fetcher.StartEventCycle()

				Eventually(func() string {
					if len(sink.Records()) > 0 {
						return sink.Records()[0].Message
					} else {
						return ""
					}
				}).Should(Equal("failed to get the token"))
				Eventually(tokenFetcher.FetchTokenCallCount).Should(BeNumerically(">=", 2))
			})
		})

		Context("and the event source successfully subscribes", func() {
			It("responds to events", func() {
				eventSource := fake_routing_api.FakeEventSource{}
				client.SubscribeToEventsReturns(&eventSource, nil)

				eventSource.NextStub = func() (routing_api.Event, error) {
					event := routing_api.Event{
						Action: "Delete",
						Route: db.Route{
							Route:           "z.a.k",
							Port:            63,
							IP:              "42.42.42.42",
							TTL:             1,
							LogGuid:         "Tomato",
							RouteServiceUrl: "route-service-url",
						}}
					return event, nil
				}

		cfg = config.DefaultConfig()
		cfg.PruneStaleDropletsInterval = 2 * time.Second

		retryInterval := 0
		uaaClient = &testUaaClient.FakeClient{}
		registry = &testRegistry.FakeRegistryInterface{}

		token = &schema.Token{
			AccessToken: "access_token",
			ExpiresIn:   5,
		}
		client = &fake_routing_api.FakeClient{}

		eventChannel = make(chan routing_api.Event)
		errorChannel = make(chan error)
		eventSource := fake_routing_api.FakeEventSource{}
		client.SubscribeToEventsWithMaxRetriesReturns(&eventSource, nil)

		localEventChannel := eventChannel
		localErrorChannel := errorChannel

		eventSource.NextStub = func() (routing_api.Event, error) {
			select {
			case e := <-localErrorChannel:
				return routing_api.Event{}, e
			case event := <-localEventChannel:
				return event, nil
			}
		}

		clock = fakeclock.NewFakeClock(time.Now())

					return nil, errors.New("failed to get the token")
				}
				fetcher.StartEventCycle()

				Eventually(received).Should(Receive())
				Eventually(received).Should(Receive())

				Expect(sink.Records()).ToNot(BeNil())
				Expect(sink.Records()[0].Message).To(Equal("failed to get the token"))
				Expect(tokenFetcher.FetchTokenCallCount()).To(Equal(2))
			})
		})

		Context("and the event source successfully subscribes", func() {
			It("responds to events", func() {
				eventSource := fake_routing_api.FakeEventSource{}
				client.SubscribeToEventsReturns(&eventSource, nil)

				received := make(chan struct{})

				eventSource.NextStub = func() (routing_api.Event, error) {
					received <- struct{}{}
					event := routing_api.Event{
						Action: "Delete",
						Route: db.Route{
							Route:   "z.a.k",
							Port:    63,
							IP:      "42.42.42.42",
							TTL:     1,
							LogGuid: "Tomato",
						}}