baggageCollector lostandfound.BaggageCollector

			savedPipeline  db.SavedPipeline
			fakePipelineDB *dbfakes.FakePipelineDB
		)

		BeforeEach(func() {
			fakeWorkerClient = new(wfakes.FakeClient)

			workerA = new(wfakes.FakeWorker)

			workerB = new(wfakes.FakeWorker)
			workerBBaggageClaimClient = new(bcfakes.FakeClient)
			workerB.VolumeManagerReturns(workerBBaggageClaimClient, true)
			dockerVolume = new(bcfakes.FakeVolume)
			workerBBaggageClaimClient.LookupVolumeReturns(dockerVolume, true, nil)

			workerC = new(wfakes.FakeWorker)
			workerCBaggageClaimClient = new(bcfakes.FakeClient)
			workerC.VolumeManagerReturns(workerCBaggageClaimClient, true)
			crossedWiresVolume = new(bcfakes.FakeVolume)
			workerCBaggageClaimClient.LookupVolumeReturns(crossedWiresVolume, true, nil)

			workerMap := map[string]*wfakes.FakeWorker{
				"workerA": workerA,
				"workerB": workerB,
				"workerC": workerC,
			}

			fakeWorkerClient.GetWorkerStub = func(name string) (worker.Worker, error) {
				return workerMap[name], nil
Esempio n. 2
0
						}
					})

					Describe("Volumes", func() {
						It("returns all bound volumes based on properties on the container", func() {
							Expect(foundContainer.Volumes()).To(Equal([]Volume{
								expectedHandle1Volume,
								expectedHandle2Volume,
							}))
						})

						Context("when LookupVolume returns an error", func() {
							disaster := errors.New("nope")

							BeforeEach(func() {
								fakeBaggageclaimClient.LookupVolumeReturns(nil, false, disaster)
							})

							It("returns the error on lookup", func() {
								Expect(findErr).To(Equal(disaster))
							})
						})

						Context("when Build returns an error", func() {
							disaster := errors.New("nope")

							BeforeEach(func() {
								fakeVolumeFactory.BuildReturns(nil, disaster)
							})

							It("returns the error on lookup", func() {
		baggageCollector lostandfound.BaggageCollector

		savedPipeline  db.SavedPipeline
		fakePipelineDB *dbfakes.FakePipelineDB
	)

	BeforeEach(func() {
		fakeWorkerClient = new(wfakes.FakeClient)

		worker1 = new(wfakes.FakeWorker)

		worker2 = new(wfakes.FakeWorker)
		baggageClaimClient2 = new(bcfakes.FakeClient)
		worker2.VolumeManagerReturns(baggageClaimClient2, true)
		volume2 = new(bcfakes.FakeVolume)
		baggageClaimClient2.LookupVolumeReturns(volume2, true, nil)

		workerMap := map[string]*wfakes.FakeWorker{
			"worker1": worker1,
			"worker2": worker2,
		}

		fakeWorkerClient.GetWorkerStub = func(name string) (worker.Worker, error) {
			return workerMap[name], nil
		}
		baggageCollectorLogger := lagertest.NewTestLogger("test")

		fakeBaggageCollectorDB = new(fakes.FakeBaggageCollectorDB)
		fakePipelineDBFactory = new(dbfakes.FakePipelineDBFactory)

		baggageCollector = lostandfound.NewBaggageCollector(
			})

			It("removes the volume from the database", func() {
				err := baggageCollector.Collect()
				Expect(err).NotTo(HaveOccurred())

				Expect(fakeBaggageCollectorDB.ReapVolumeCallCount()).To(Equal(1))
				Expect(fakeBaggageCollectorDB.ReapVolumeArgsForCall(0)).To(Equal(returnedSavedVolume.Handle))
			})
		})

		Context("the volume is no longer found on the worker", func() {
			BeforeEach(func() {
				fakeWorkerClient.GetWorkerReturns(fakeWorker, nil)
				fakeWorker.VolumeManagerReturns(nil, false)
				fakeBaggageClaimClient.LookupVolumeReturns(nil, false, errors.New("could-not-locate-volume"))
			})

			It("removes the volume from the database", func() {
				err := baggageCollector.Collect()
				Expect(err).NotTo(HaveOccurred())

				Expect(fakeBaggageCollectorDB.ReapVolumeCallCount()).To(Equal(1))
				Expect(fakeBaggageCollectorDB.ReapVolumeArgsForCall(0)).To(Equal(returnedSavedVolume.Handle))
			})
		})

	})

})