satisfyingWorker = new(wfakes.FakeWorker)
					workerClient.SatisfyingReturns(satisfyingWorker, nil)

					satisfyingWorker.CreateContainerReturns(fakeContainer, nil)
				})

				Context("when the worker supports volume management", func() {
					var fakeBaggageclaimClient *bfakes.FakeClient

					BeforeEach(func() {
						fakeBaggageclaimClient = new(bfakes.FakeClient)
						satisfyingWorker.VolumeManagerReturns(fakeBaggageclaimClient, true)
					})

					Context("when the cache is already present", func() {
						var foundVolume *bfakes.FakeVolume

						BeforeEach(func() {
							foundVolume = new(bfakes.FakeVolume)
							foundVolume.HandleReturns("found-volume-handle")
							cacheIdentifier.FindOnReturns(foundVolume, true, nil)

							cacheIdentifier.ResourceVersionReturns(atc.Version{"some": "theversion"})
							cacheIdentifier.ResourceHashReturns("hash")
							satisfyingWorker.NameReturns("myworker")
							foundVolume.ExpirationReturns(time.Hour, time.Now(), nil)
						})

						It("does not error and returns a resource", func() {
							Expect(initErr).NotTo(HaveOccurred())
							Expect(initResource).NotTo(BeNil())

			Source:  atc.Source{"some": "source"},
			Params:  atc.Params{"some": "params"},
		}
	})

	Describe("FindOn", func() {
		var foundVolume baggageclaim.Volume
		var found bool
		var findErr error

		JustBeforeEach(func() {
			foundVolume, found, findErr = cacheIdentifier.FindOn(logger, fakeBaggageclaimClient)
		})

		Context("when one cache volume is present", func() {
			var workerVolume *bfakes.FakeVolume

			BeforeEach(func() {
				workerVolume = new(bfakes.FakeVolume)
				workerVolume.HandleReturns("found-volume-handle")
				fakeBaggageclaimClient.ListVolumesReturns([]baggageclaim.Volume{workerVolume}, nil)
			})

			It("returns the volume and true", func() {
				Expect(foundVolume).To(Equal(workerVolume))
				Expect(found).To(BeTrue())
			})

			It("found it by querying for the correct properties", func() {
				_, spec := fakeBaggageclaimClient.ListVolumesArgsForCall(0)
				Expect(spec).To(Equal(baggageclaim.VolumeProperties{

)

var _ = Describe("Baggage-collecting image resource volumes", func() {
	Context("when there is a single job", func() {
		var (
			fakeWorkerClient *wfakes.FakeClient
			workerA          *wfakes.FakeWorker

			workerB                   *wfakes.FakeWorker
			workerBBaggageClaimClient *bcfakes.FakeClient
			dockerVolume              *bcfakes.FakeVolume

			workerC                   *wfakes.FakeWorker
			workerCBaggageClaimClient *bcfakes.FakeClient
			crossedWiresVolume        *bcfakes.FakeVolume

			fakeBaggageCollectorDB *fakes.FakeBaggageCollectorDB
			fakePipelineDBFactory  *dbfakes.FakePipelineDBFactory

			expectedOldVersionTTL    = 4 * time.Minute
			expectedLatestVersionTTL = time.Duration(0)
			expectedOneOffTTL        = 5 * time.Hour

			baggageCollector lostandfound.BaggageCollector

			savedPipeline  db.SavedPipeline
			fakePipelineDB *dbfakes.FakePipelineDB
		)

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

	wfakes "github.com/concourse/atc/worker/fakes"
	bcfakes "github.com/concourse/baggageclaim/fakes"
)

var _ = Describe("Baggage-collecting image resource volumes created by one-off builds", func() {

	var (
		fakeWorkerClient *wfakes.FakeClient
		worker1          *wfakes.FakeWorker

		worker2             *wfakes.FakeWorker
		baggageClaimClient2 *bcfakes.FakeClient
		volume2             *bcfakes.FakeVolume

		fakeBaggageCollectorDB *fakes.FakeBaggageCollectorDB
		fakePipelineDBFactory  *dbfakes.FakePipelineDBFactory

		expectedOldVersionTTL    = 4 * time.Minute
		expectedLatestVersionTTL = time.Duration(0)
		expectedOneOffTTL        = 5 * time.Hour

		baggageCollector lostandfound.BaggageCollector

		savedPipeline  db.SavedPipeline
		fakePipelineDB *dbfakes.FakePipelineDB
	)

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

		worker1 = new(wfakes.FakeWorker)

	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"

	"github.com/concourse/atc/worker"
	"github.com/concourse/atc/worker/fakes"
	"github.com/concourse/baggageclaim"
	bfakes "github.com/concourse/baggageclaim/fakes"
	"github.com/pivotal-golang/clock/fakeclock"
	"github.com/pivotal-golang/lager/lagertest"
)

var _ = Describe("Volumes", func() {
	var (
		volumeFactory worker.VolumeFactory
		fakeVolume    *bfakes.FakeVolume
		fakeDB        *fakes.FakeVolumeFactoryDB
		fakeClock     *fakeclock.FakeClock
		logger        *lagertest.TestLogger
	)

	BeforeEach(func() {
		fakeVolume = new(bfakes.FakeVolume)
		fakeDB = new(fakes.FakeVolumeFactoryDB)
		fakeClock = fakeclock.NewFakeClock(time.Unix(123, 456))
		logger = lagertest.NewTestLogger("test")

		volumeFactory = worker.NewVolumeFactory(fakeDB, fakeClock)
	})

	Context("VolumeFactory", func() {
		Describe("Build", func() {

						It("creates the container with the given env vars", func() {
							Expect(fakeGardenClient.CreateCallCount()).To(Equal(1))
							Expect(fakeGardenClient.CreateArgsForCall(0)).To(Equal(garden.ContainerSpec{
								RootFSPath: "some-resource-image",
								Privileged: true,
								Env:        []string{"a=1", "b=2"},
								Properties: garden.Properties{},
							}))

						})
					})

					Context("when a volume mount is provided", func() {
						var (
							volume1 *bfakes.FakeVolume
							volume2 *bfakes.FakeVolume
						)

						BeforeEach(func() {
							volume1 = new(bfakes.FakeVolume)
							volume1.HandleReturns("some-volume1")
							volume1.PathReturns("/some/src/path1")

							volume2 = new(bfakes.FakeVolume)
							volume2.HandleReturns("some-volume2")
							volume2.PathReturns("/some/src/path2")
						})

						Context("when copy-on-write is specified", func() {
							var (
								cowVolume1 *bfakes.FakeVolume