AfterEach(func() {
process.Signal(os.Interrupt)
Eventually(process.Wait(), 5*time.Second).Should(Receive())
})
It("subscribes for events", func() {
Eventually(client.SubscribeToEventsWithMaxRetriesCallCount).Should(Equal(1))
})
Context("on specified interval", func() {
BeforeEach(func() {
client.SubscribeToEventsWithMaxRetriesReturns(&fake_routing_api.FakeEventSource{}, errors.New("not used"))
})
It("fetches routes", func() {
clock.Increment(cfg.PruneStaleDropletsInterval + 100*time.Millisecond)
Eventually(client.RoutesCallCount, 2*time.Second, 50*time.Millisecond).Should(Equal(1))
clock.Increment(cfg.PruneStaleDropletsInterval + 100*time.Millisecond)
Eventually(client.RoutesCallCount, 2*time.Second, 50*time.Millisecond).Should(Equal(2))
})
It("uses cache when fetching token from uaa", func() {
clock.Increment(cfg.PruneStaleDropletsInterval + 100*time.Millisecond)
Eventually(client.RoutesCallCount, 2*time.Second, 50*time.Millisecond).Should(Equal(1))
Expect(uaaClient.FetchTokenArgsForCall(0)).To(Equal(false))
})
})
Context("when token fetcher returns error", func() {
BeforeEach(func() {
uaaClient.FetchTokenReturns(nil, errors.New("Unauthorized"))
It("should have fake driver in registry map", func() {
drivers := registry.Drivers()
Expect(len(drivers)).To(Equal(1))
Expect(fakeDriverFactory.DriverCallCount()).To(Equal(1))
Expect(fakeDriver.ActivateCallCount()).To(Equal(1))
})
Context("when drivers are added", func() {
BeforeEach(func() {
err := voldriver.WriteDriverSpec(logger, defaultPluginsDirectory, "anotherfakedriver", "spec", []byte("http://0.0.0.0:8080"))
Expect(err).NotTo(HaveOccurred())
})
It("should find them!", func() {
fakeClock.Increment(scanInterval * 2)
Eventually(registry.Drivers).Should(HaveLen(2))
Expect(fakeDriverFactory.DriverCallCount()).To(Equal(3))
Expect(fakeDriver.ActivateCallCount()).To(Equal(3))
})
})
Context("when drivers are not responding", func() {
BeforeEach(func() {
fakeDriver.ActivateReturns(voldriver.ActivateResponse{
Err: "some err",
})
})
It("should find no drivers", func() {
fakeClock.Increment(scanInterval * 2)
Eventually(registry.Drivers).Should(HaveLen(0))
}).Should(Equal(numSessions))
}
Context("When consul is running", func() {
Context("an error occurs while acquiring the lock", func() {
BeforeEach(func() {
lockKey = ""
})
It("continues to retry", func() {
lockProcess = ifrit.Background(lockRunner)
shouldEventuallyHaveNumSessions(1)
Consistently(lockProcess.Ready()).ShouldNot(BeClosed())
Consistently(lockProcess.Wait()).ShouldNot(Receive())
clock.Increment(retryInterval)
Eventually(logger).Should(Say("acquire-lock-failed"))
Eventually(logger).Should(Say("retrying-acquiring-lock"))
Expect(sender.GetValue(lockHeldMetricName).Value).To(Equal(float64(0)))
})
})
Context("and the lock is available", func() {
It("acquires the lock", func() {
lockProcess = ifrit.Background(lockRunner)
Eventually(lockProcess.Ready()).Should(BeClosed())
Expect(sender.GetValue(lockUptimeMetricName).Value).Should(Equal(float64(0)))
Expect(getLockValue()).To(Equal(lockValue))
Expect(sender.GetValue(lockHeldMetricName).Value).To(Equal(float64(1)))
})
}
var verifyFetchWithRetries = func(client uaa_go_client.Client, server *ghttp.Server, numRetries int, expectedErrorMsg string) {
var err error
wg := sync.WaitGroup{}
wg.Add(1)
go func(wg *sync.WaitGroup) {
defer GinkgoRecover()
defer wg.Done()
_, err = client.FetchToken(forceUpdate)
Expect(err).To(HaveOccurred())
}(&wg)
for i := 0; i < numRetries; i++ {
Eventually(server.ReceivedRequests, 7*time.Second, 1*time.Second).Should(HaveLen(i + 1))
clock.Increment(DefaultRetryInterval + 10*time.Second)
}
wg.Wait()
Expect(err.Error()).To(ContainSubstring(expectedErrorMsg))
}
var getRegisterOauthClientHandlerFunc = func(status int, token *schema.Token, oauthClient *schema.OauthClient) http.HandlerFunc {
oauthClientString, err := json.Marshal(oauthClient)
var responseBody string
if status == http.StatusOK {
responseBody = string(oauthClientString)
} else {
responseBody = ""
}
BeforeEach(func() {
schedDone = make(chan struct{})
})
JustBeforeEach(func() {
go func(sched *scheduler.Scheduler, c chan struct{}) {
defer GinkgoRecover()
Expect(sched.Run).NotTo(Panic())
close(c)
}(sched, schedDone)
clk.WaitForWatcherAndIncrement(csSleep)
})
AfterEach(func() {
Expect(sched.Stop()).To(Succeed())
clk.Increment(csSleep)
Eventually(schedDone).Should(BeClosed())
})
Context("when there are no tasks", func() {
It("should not call the task selector", func() {
Expect(taskSelector.SelectTaskCallCount()).To(Equal(0))
})
})
Context("when there are tasks", func() {
var (
taskA, taskB *fakes.FakeTask
)
BeforeEach(func() {