Golang FakeStoreAdapter.SetErrInjector方法代碼示例

				Ω(metrics["StartEvacuating"]).Should(BeNumerically("==", 6))
				Ω(metrics["StopExtra"]).Should(BeNumerically("==", 2))
				Ω(metrics["StopDuplicate"]).Should(BeNumerically("==", 4))
				Ω(metrics["StopEvacuationComplete"]).Should(BeNumerically("==", 6))
			})
		})

		Context("when the store times out while getting metrics", func() {
			BeforeEach(func() {
				fakeStoreAdapter.GetErrInjector = fakestoreadapter.NewFakeStoreAdapterErrorInjector("metrics", errors.New("oops"))
			})

			It("should return an error", func() {
				err := accountant.IncrementSentMessageMetrics(starts, stops)
				Ω(err).Should(Equal(errors.New("oops")))
			})
		})

		Context("when the store times out while saving metrics", func() {
			BeforeEach(func() {
				fakeStoreAdapter.SetErrInjector = fakestoreadapter.NewFakeStoreAdapterErrorInjector("metrics", errors.New("oops"))
			})

			It("should return an error", func() {
				err := accountant.IncrementSentMessageMetrics(starts, stops)
				Ω(err).Should(Equal(errors.New("oops")))
			})
		})
	})
})

				conf.ListenerHeartbeatSyncIntervalInMilliseconds = 0
				forceHeartbeatSync()
			})

			It("should not bump the freshness", func() {
				isFresh, _ := store.IsActualStateFresh(freshByTime)
				Ω(isFresh).Should(BeFalse())
			})
		})

		Context("when the save fails", func() {
			BeforeEach(func() {
				store.BumpActualFreshness(timeProvider.Time())

				storeAdapter.SetErrInjector = fakestoreadapter.NewFakeStoreAdapterErrorInjector(app.InstanceAtIndex(0).InstanceGuid, errors.New("oops"))

				messageBus.Subscriptions["dea.heartbeat"][0].Callback(&yagnats.Message{
					Payload: heartbeat.ToJSON(),
				})

				forceHeartbeatSync()
			})

			It("logs about the failed save", func() {
				Ω(logger.LoggedSubjects).Should(ContainElement(ContainSubstring("Could not put instance heartbeats in store")))
			})

			It("does not bump the SavedHeartbeats metric", func() {
				Ω(metricsAccountant.SavedHeartbeats).Should(Equal(0))
			})

				It("should track the time taken to sync desired state", func() {
					Ω(metricsAccountant.TrackedDesiredStateSyncTime).ShouldNot(BeZero())
				})

				It("should send a succesful result down the result channel", func(done Done) {
					result := <-resultChan
					Ω(result.Success).Should(BeTrue())
					Ω(result.Message).Should(BeZero())
					Ω(result.Error).ShouldNot(HaveOccurred())
					close(done)
				}, 0.1)

				Context("and it fails to write to the store", func() {
					BeforeEach(func() {
						storeAdapter.SetErrInjector = fakestoreadapter.NewFakeStoreAdapterErrorInjector("desired", errors.New("oops!"))
					})

					assertFailure("Failed to sync desired state to the store", 2)
				})

				Context("and it fails to read from the store", func() {
					BeforeEach(func() {
						storeAdapter.ListErrInjector = fakestoreadapter.NewFakeStoreAdapterErrorInjector("apps", errors.New("oops!"))
					})

					assertFailure("Failed to sync desired state to the store", 2)
				})
			})
		})

	Context("when there are start messages", func() {
		var keepAliveTime int
		var sentOn int64
		var err error
		var pendingMessage models.PendingStartMessage
		var storeSetErrInjector *fakestoreadapter.FakeStoreAdapterErrorInjector

		JustBeforeEach(func() {
			store.SyncDesiredState(app.DesiredState(1))
			pendingMessage = models.NewPendingStartMessage(time.Unix(100, 0), 30, keepAliveTime, app.AppGuid, app.AppVersion, 0, 1.0, models.PendingStartMessageReasonInvalid)
			pendingMessage.SentOn = sentOn
			store.SavePendingStartMessages(
				pendingMessage,
			)
			storeAdapter.SetErrInjector = storeSetErrInjector
			err = sender.Send()
		})

		BeforeEach(func() {
			keepAliveTime = 0
			sentOn = 0
			err = nil
			storeSetErrInjector = nil
		})

		Context("and it is not time to send the message yet", func() {
			BeforeEach(func() {
				timeProvider.TimeToProvide = time.Unix(129, 0)
			})