JustBeforeEach(func() {
					syncEvents.Sync <- struct{}{}
				})

				Describe("bbs events", func() {
					var ready chan struct{}
					var count int32

					BeforeEach(func() {
						ready = make(chan struct{})
						count = 0

						bbsClient.ActualLRPGroupsStub = func(filter models.ActualLRPFilter) ([]*models.ActualLRPGroup, error) {
							defer GinkgoRecover()

							atomic.AddInt32(&count, 1)
							ready <- struct{}{}
							Eventually(ready).Should(Receive())
							return nil, nil
						}
					})

					JustBeforeEach(func() {
						Eventually(ready).Should(Receive())
					})

					It("caches events", func() {
						sendEvent()
						Consistently(table.RemoveEndpointCallCount).Should(Equal(0))
						ready <- struct{}{}
					})
			State: oldmodels.ActualLRPStateClaimed,
			Since: 4444,
		}

		oldEvacuatingLRP2 = oldActualLRP2
		oldEvacuatingLRP2.State = oldmodels.ActualLRPStateRunning
		oldEvacuatingLRP2.Since = 3417
	})

	Describe("GetAll", func() {
		Context("when reading LRPs from BBS succeeds", func() {
			BeforeEach(func() {
				fakeBBS.ActualLRPGroupsStub = func(filter models.ActualLRPFilter) ([]*models.ActualLRPGroup, error) {
					groups := []*models.ActualLRPGroup{}
					if filter.Domain == "" {
						groups = append(groups, &models.ActualLRPGroup{Instance: &actualLRP1})
					}
					groups = append(groups, &models.ActualLRPGroup{Instance: &actualLRP2, Evacuating: &evacuatingLRP2})
					return groups, nil
				}
			})

			It("calls the BBS to retrieve the actual LRP groups", func() {
				handler.GetAll(responseRecorder, newTestRequest(""))
				Expect(fakeBBS.ActualLRPGroupsCallCount()).To(Equal(1))
			})

			It("responds with 200 Status OK", func() {
				handler.GetAll(responseRecorder, newTestRequest(""))
				Expect(responseRecorder.Code).To(Equal(http.StatusOK))
			})
				Expect(t2.Sub(t1)).To(BeNumerically("~", 2*time.Second, 200*time.Millisecond))
			})
		})

		Context("if it never hears anything from a router anywhere", func() {
			It("should still be able to shutdown", func() {
				process.Signal(os.Interrupt)
				Eventually(process.Wait()).Should(Receive(BeNil()))
			})
		})
	})

	Describe("syncing", func() {
		BeforeEach(func() {
			bbsClient.ActualLRPGroupsStub = func(f models.ActualLRPFilter) ([]*models.ActualLRPGroup, error) {
				return nil, nil
			}
			syncInterval = 500 * time.Millisecond

			clockStep = 250 * time.Millisecond
		})

		JustBeforeEach(func() {
			//we set the emit interval real high to avoid colliding with our sync interval
			routerStartMessages <- &nats.Msg{
				Data: []byte(`{"minimumRegisterIntervalInSeconds":10, "pruneThresholdInSeconds": 20}`),
			}
		})

		Context("after the router greets", func() {
			BeforeEach(func() {