Golang FakeVolume.ReleaseCallCount方法代码示例

							}))
						})

						It("saves the volume information to the database", func() {
							Expect(fakeDB.InsertVolumeCallCount()).To(Equal(1))
							Expect(fakeDB.InsertVolumeArgsForCall(0)).To(Equal(db.Volume{
								Handle:          "found-volume-handle",
								WorkerName:      "myworker",
								TTL:             time.Hour,
								ResourceVersion: atc.Version{"some": "theversion"},
								ResourceHash:    "hash",
							}))
						})

						It("releases the volume, since the container keeps it alive", func() {
							Expect(foundVolume.ReleaseCallCount()).To(Equal(1))
						})

						Describe("the cache", func() {
							Describe("IsInitialized", func() {
								Context("when the volume has the initialized property set", func() {
									BeforeEach(func() {
										foundVolume.PropertiesReturns(baggageclaim.VolumeProperties{
											"initialized": "any-value",
										}, nil)
									})

									It("returns true", func() {
										Expect(initCache.IsInitialized()).To(BeTrue())
									})
								})

				aVolume.HandleReturns("a")
				bVolume = new(bfakes.FakeVolume)
				bVolume.HandleReturns("b")
			})

			Context("with a, b order", func() {
				BeforeEach(func() {
					fakeBaggageclaimClient.ListVolumesReturns([]baggageclaim.Volume{aVolume, bVolume}, nil)
				})

				It("selects the volume based on the lowest alphabetical name", func() {
					Expect(foundVolume).To(Equal(aVolume))
					Expect(found).To(BeTrue())

					Expect(aVolume.SetTTLCallCount()).To(Equal(0))
					Expect(bVolume.ReleaseCallCount()).To(Equal(1))
					Expect(bVolume.ReleaseArgsForCall(0)).To(Equal(worker.FinalTTL(time.Minute)))
				})
			})

			Context("with b, a order", func() {
				BeforeEach(func() {
					fakeBaggageclaimClient.ListVolumesReturns([]baggageclaim.Volume{bVolume, aVolume}, nil)
				})

				It("selects the volume based on the lowest alphabetical name", func() {
					Expect(foundVolume).To(Equal(aVolume))
					Expect(found).To(BeTrue())

					Expect(aVolume.SetTTLCallCount()).To(Equal(0))
					Expect(bVolume.ReleaseCallCount()).To(Equal(1))

	It("sets the ttl of each volume used in a one-off build to at least 24 hours", func() {
		err := baggageCollector.Collect()
		Expect(err).NotTo(HaveOccurred())
		Expect(fakeBaggageCollectorDB.GetAllPipelinesCallCount()).To(Equal(1))
		Expect(fakePipelineDBFactory.BuildCallCount()).To(Equal(1))
		Expect(fakePipelineDBFactory.BuildArgsForCall(0)).To(Equal(savedPipeline))
		Expect(fakePipelineDB.GetJobFinishedAndNextBuildCallCount()).To(Equal(1))
		Expect(fakePipelineDB.GetJobFinishedAndNextBuildArgsForCall(0)).To(Equal("my-precious-job"))
		Expect(fakeBaggageCollectorDB.GetImageVolumeIdentifiersByBuildIDCallCount()).To(Equal(1))
		Expect(fakeBaggageCollectorDB.GetImageVolumeIdentifiersByBuildIDArgsForCall(0)).To(Equal(2))
		Expect(fakeBaggageCollectorDB.GetVolumesForOneOffBuildImageResourcesCallCount()).To(Equal(1))
		Expect(fakeBaggageCollectorDB.GetVolumesCallCount()).To(Equal(1))
		Expect(fakeWorkerClient.GetWorkerCallCount()).To(Equal(2))

		Expect(worker1.VolumeManagerCallCount()).To(Equal(0))
		Expect(worker2.VolumeManagerCallCount()).To(Equal(1))

		Expect(baggageClaimClient2.LookupVolumeCallCount()).To(Equal(1))
		_, handle := baggageClaimClient2.LookupVolumeArgsForCall(0)
		Expect(handle).To(Equal("volume2"))
		Expect(volume2.ReleaseCallCount()).To(Equal(1))
		Expect(volume2.ReleaseArgsForCall(0)).To(Equal(worker.FinalTTL(expectedLatestVersionTTL)))

		Expect(fakeBaggageCollectorDB.SetVolumeTTLCallCount()).To(Equal(1))
		handle, ttl := fakeBaggageCollectorDB.SetVolumeTTLArgsForCall(0)
		Expect(handle).To(Equal("volume2"))
		Expect(ttl).To(Equal(expectedLatestVersionTTL))
	})
})

			Expect(fakePipelineDB.GetJobFinishedAndNextBuildCallCount()).To(Equal(1))
			Expect(fakePipelineDB.GetJobFinishedAndNextBuildArgsForCall(0)).To(Equal("my-precious-job"))
			Expect(fakeBaggageCollectorDB.GetImageVolumeIdentifiersByBuildIDCallCount()).To(Equal(1))
			Expect(fakeBaggageCollectorDB.GetImageVolumeIdentifiersByBuildIDArgsForCall(0)).To(Equal(2))
			Expect(fakeBaggageCollectorDB.GetVolumesCallCount()).To(Equal(1))
			Expect(fakeWorkerClient.GetWorkerCallCount()).To(Equal(3))

			Expect(workerA.VolumeManagerCallCount()).To(Equal(0))
			Expect(workerB.VolumeManagerCallCount()).To(Equal(1))
			Expect(workerC.VolumeManagerCallCount()).To(Equal(1))

			var handle string
			Expect(workerBBaggageClaimClient.LookupVolumeCallCount()).To(Equal(1))
			_, handle = workerBBaggageClaimClient.LookupVolumeArgsForCall(0)
			Expect(handle).To(Equal("docker-volume-handle"))
			Expect(dockerVolume.ReleaseCallCount()).To(Equal(1))
			Expect(dockerVolume.ReleaseArgsForCall(0)).To(Equal(worker.FinalTTL(expectedLatestVersionTTL)))

			Expect(workerCBaggageClaimClient.LookupVolumeCallCount()).To(Equal(1))
			_, handle = workerCBaggageClaimClient.LookupVolumeArgsForCall(0)
			Expect(handle).To(Equal("crossed-wires-volume-handle"))
			Expect(crossedWiresVolume.ReleaseCallCount()).To(Equal(1))
			Expect(crossedWiresVolume.ReleaseArgsForCall(0)).To(Equal(worker.FinalTTL(expectedOldVersionTTL)))

			Expect(fakeBaggageCollectorDB.SetVolumeTTLCallCount()).To(Equal(2))

			type setVolumeTTLArgs struct {
				Handle string
				TTL    time.Duration
			}

										Mode:    garden.BindMountModeRW,
									},
								}))

								Expect(spec.Properties).To(HaveLen(2))
								Expect(spec.Properties["concourse:volumes"]).To(MatchJSON(
									`["cow-volume1","cow-volume2"]`,
								))

								Expect(spec.Properties["concourse:volume-mounts"]).To(MatchJSON(
									`{"cow-volume1":"/some/dst/path1","cow-volume2":"/some/dst/path2"}`,
								))
							})

							It("releases the volumes that it instantiated but not the ones that were passed in", func() {
								Expect(cowVolume1.ReleaseCallCount()).To(Equal(1))
								Expect(cowVolume2.ReleaseCallCount()).To(Equal(1))
								Expect(volume1.ReleaseCallCount()).To(BeZero())
								Expect(volume2.ReleaseCallCount()).To(BeZero())
							})

							Context("and the copy-on-write volumes fail to be created", func() {
								disaster := errors.New("par")

								BeforeEach(func() {
									fakeBaggageclaimClient.CreateVolumeReturns(nil, disaster)
								})

								It("errors", func() {
									Expect(createErr).To(Equal(disaster))
									Expect(fakeGardenClient.CreateCallCount()).To(BeZero())