github.com/pf-qiu/concourse/v6@v6.7.3-0.20201207032516-1f455d73275f/atc/db/dbfakes/fake_volume_repository.go

// Code generated by counterfeiter. DO NOT EDIT.
package dbfakes

import (
	"sync"
	"time"

	"github.com/pf-qiu/concourse/v6/atc/db"
)

type FakeVolumeRepository struct {
	CreateBaseResourceTypeVolumeStub        func(*db.UsedWorkerBaseResourceType) (db.CreatingVolume, error)
	createBaseResourceTypeVolumeMutex       sync.RWMutex
	createBaseResourceTypeVolumeArgsForCall []struct {
		arg1 *db.UsedWorkerBaseResourceType
	}
	createBaseResourceTypeVolumeReturns struct {
		result1 db.CreatingVolume
		result2 error
	}
	createBaseResourceTypeVolumeReturnsOnCall map[int]struct {
		result1 db.CreatingVolume
		result2 error
	}
	CreateContainerVolumeStub        func(int, string, db.CreatingContainer, string) (db.CreatingVolume, error)
	createContainerVolumeMutex       sync.RWMutex
	createContainerVolumeArgsForCall []struct {
		arg1 int
		arg2 string
		arg3 db.CreatingContainer
		arg4 string
	}
	createContainerVolumeReturns struct {
		result1 db.CreatingVolume
		result2 error
	}
	createContainerVolumeReturnsOnCall map[int]struct {
		result1 db.CreatingVolume
		result2 error
	}
	CreateResourceCertsVolumeStub        func(string, *db.UsedWorkerResourceCerts) (db.CreatingVolume, error)
	createResourceCertsVolumeMutex       sync.RWMutex
	createResourceCertsVolumeArgsForCall []struct {
		arg1 string
		arg2 *db.UsedWorkerResourceCerts
	}
	createResourceCertsVolumeReturns struct {
		result1 db.CreatingVolume
		result2 error
	}
	createResourceCertsVolumeReturnsOnCall map[int]struct {
		result1 db.CreatingVolume
		result2 error
	}
	CreateTaskCacheVolumeStub        func(int, *db.UsedWorkerTaskCache) (db.CreatingVolume, error)
	createTaskCacheVolumeMutex       sync.RWMutex
	createTaskCacheVolumeArgsForCall []struct {
		arg1 int
		arg2 *db.UsedWorkerTaskCache
	}
	createTaskCacheVolumeReturns struct {
		result1 db.CreatingVolume
		result2 error
	}
	createTaskCacheVolumeReturnsOnCall map[int]struct {
		result1 db.CreatingVolume
		result2 error
	}
	CreateVolumeStub        func(int, string, db.VolumeType) (db.CreatingVolume, error)
	createVolumeMutex       sync.RWMutex
	createVolumeArgsForCall []struct {
		arg1 int
		arg2 string
		arg3 db.VolumeType
	}
	createVolumeReturns struct {
		result1 db.CreatingVolume
		result2 error
	}
	createVolumeReturnsOnCall map[int]struct {
		result1 db.CreatingVolume
		result2 error
	}
	DestroyFailedVolumesStub        func() (int, error)
	destroyFailedVolumesMutex       sync.RWMutex
	destroyFailedVolumesArgsForCall []struct {
	}
	destroyFailedVolumesReturns struct {
		result1 int
		result2 error
	}
	destroyFailedVolumesReturnsOnCall map[int]struct {
		result1 int
		result2 error
	}
	DestroyUnknownVolumesStub        func(string, []string) (int, error)
	destroyUnknownVolumesMutex       sync.RWMutex
	destroyUnknownVolumesArgsForCall []struct {
		arg1 string
		arg2 []string
	}
	destroyUnknownVolumesReturns struct {
		result1 int
		result2 error
	}
	destroyUnknownVolumesReturnsOnCall map[int]struct {
		result1 int
		result2 error
	}
	FindBaseResourceTypeVolumeStub        func(*db.UsedWorkerBaseResourceType) (db.CreatingVolume, db.CreatedVolume, error)
	findBaseResourceTypeVolumeMutex       sync.RWMutex
	findBaseResourceTypeVolumeArgsForCall []struct {
		arg1 *db.UsedWorkerBaseResourceType
	}
	findBaseResourceTypeVolumeReturns struct {
		result1 db.CreatingVolume
		result2 db.CreatedVolume
		result3 error
	}
	findBaseResourceTypeVolumeReturnsOnCall map[int]struct {
		result1 db.CreatingVolume
		result2 db.CreatedVolume
		result3 error
	}
	FindContainerVolumeStub        func(int, string, db.CreatingContainer, string) (db.CreatingVolume, db.CreatedVolume, error)
	findContainerVolumeMutex       sync.RWMutex
	findContainerVolumeArgsForCall []struct {
		arg1 int
		arg2 string
		arg3 db.CreatingContainer
		arg4 string
	}
	findContainerVolumeReturns struct {
		result1 db.CreatingVolume
		result2 db.CreatedVolume
		result3 error
	}
	findContainerVolumeReturnsOnCall map[int]struct {
		result1 db.CreatingVolume
		result2 db.CreatedVolume
		result3 error
	}
	FindCreatedVolumeStub        func(string) (db.CreatedVolume, bool, error)
	findCreatedVolumeMutex       sync.RWMutex
	findCreatedVolumeArgsForCall []struct {
		arg1 string
	}
	findCreatedVolumeReturns struct {
		result1 db.CreatedVolume
		result2 bool
		result3 error
	}
	findCreatedVolumeReturnsOnCall map[int]struct {
		result1 db.CreatedVolume
		result2 bool
		result3 error
	}
	FindResourceCacheVolumeStub        func(string, db.UsedResourceCache) (db.CreatedVolume, bool, error)
	findResourceCacheVolumeMutex       sync.RWMutex
	findResourceCacheVolumeArgsForCall []struct {
		arg1 string
		arg2 db.UsedResourceCache
	}
	findResourceCacheVolumeReturns struct {
		result1 db.CreatedVolume
		result2 bool
		result3 error
	}
	findResourceCacheVolumeReturnsOnCall map[int]struct {
		result1 db.CreatedVolume
		result2 bool
		result3 error
	}
	FindResourceCertsVolumeStub        func(string, *db.UsedWorkerResourceCerts) (db.CreatingVolume, db.CreatedVolume, error)
	findResourceCertsVolumeMutex       sync.RWMutex
	findResourceCertsVolumeArgsForCall []struct {
		arg1 string
		arg2 *db.UsedWorkerResourceCerts
	}
	findResourceCertsVolumeReturns struct {
		result1 db.CreatingVolume
		result2 db.CreatedVolume
		result3 error
	}
	findResourceCertsVolumeReturnsOnCall map[int]struct {
		result1 db.CreatingVolume
		result2 db.CreatedVolume
		result3 error
	}
	FindTaskCacheVolumeStub        func(int, string, db.UsedTaskCache) (db.CreatedVolume, bool, error)
	findTaskCacheVolumeMutex       sync.RWMutex
	findTaskCacheVolumeArgsForCall []struct {
		arg1 int
		arg2 string
		arg3 db.UsedTaskCache
	}
	findTaskCacheVolumeReturns struct {
		result1 db.CreatedVolume
		result2 bool
		result3 error
	}
	findTaskCacheVolumeReturnsOnCall map[int]struct {
		result1 db.CreatedVolume
		result2 bool
		result3 error
	}
	FindVolumesForContainerStub        func(db.CreatedContainer) ([]db.CreatedVolume, error)
	findVolumesForContainerMutex       sync.RWMutex
	findVolumesForContainerArgsForCall []struct {
		arg1 db.CreatedContainer
	}
	findVolumesForContainerReturns struct {
		result1 []db.CreatedVolume
		result2 error
	}
	findVolumesForContainerReturnsOnCall map[int]struct {
		result1 []db.CreatedVolume
		result2 error
	}
	GetDestroyingVolumesStub        func(string) ([]string, error)
	getDestroyingVolumesMutex       sync.RWMutex
	getDestroyingVolumesArgsForCall []struct {
		arg1 string
	}
	getDestroyingVolumesReturns struct {
		result1 []string
		result2 error
	}
	getDestroyingVolumesReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetOrphanedVolumesStub        func() ([]db.CreatedVolume, error)
	getOrphanedVolumesMutex       sync.RWMutex
	getOrphanedVolumesArgsForCall []struct {
	}
	getOrphanedVolumesReturns struct {
		result1 []db.CreatedVolume
		result2 error
	}
	getOrphanedVolumesReturnsOnCall map[int]struct {
		result1 []db.CreatedVolume
		result2 error
	}
	GetTeamVolumesStub        func(int) ([]db.CreatedVolume, error)
	getTeamVolumesMutex       sync.RWMutex
	getTeamVolumesArgsForCall []struct {
		arg1 int
	}
	getTeamVolumesReturns struct {
		result1 []db.CreatedVolume
		result2 error
	}
	getTeamVolumesReturnsOnCall map[int]struct {
		result1 []db.CreatedVolume
		result2 error
	}
	RemoveDestroyingVolumesStub        func(string, []string) (int, error)
	removeDestroyingVolumesMutex       sync.RWMutex
	removeDestroyingVolumesArgsForCall []struct {
		arg1 string
		arg2 []string
	}
	removeDestroyingVolumesReturns struct {
		result1 int
		result2 error
	}
	removeDestroyingVolumesReturnsOnCall map[int]struct {
		result1 int
		result2 error
	}
	RemoveMissingVolumesStub        func(time.Duration) (int, error)
	removeMissingVolumesMutex       sync.RWMutex
	removeMissingVolumesArgsForCall []struct {
		arg1 time.Duration
	}
	removeMissingVolumesReturns struct {
		result1 int
		result2 error
	}
	removeMissingVolumesReturnsOnCall map[int]struct {
		result1 int
		result2 error
	}
	UpdateVolumesMissingSinceStub        func(string, []string) error
	updateVolumesMissingSinceMutex       sync.RWMutex
	updateVolumesMissingSinceArgsForCall []struct {
		arg1 string
		arg2 []string
	}
	updateVolumesMissingSinceReturns struct {
		result1 error
	}
	updateVolumesMissingSinceReturnsOnCall map[int]struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeVolumeRepository) CreateBaseResourceTypeVolume(arg1 *db.UsedWorkerBaseResourceType) (db.CreatingVolume, error) {
	fake.createBaseResourceTypeVolumeMutex.Lock()
	ret, specificReturn := fake.createBaseResourceTypeVolumeReturnsOnCall[len(fake.createBaseResourceTypeVolumeArgsForCall)]
	fake.createBaseResourceTypeVolumeArgsForCall = append(fake.createBaseResourceTypeVolumeArgsForCall, struct {
		arg1 *db.UsedWorkerBaseResourceType
	}{arg1})
	fake.recordInvocation("CreateBaseResourceTypeVolume", []interface{}{arg1})
	fake.createBaseResourceTypeVolumeMutex.Unlock()
	if fake.CreateBaseResourceTypeVolumeStub != nil {
		return fake.CreateBaseResourceTypeVolumeStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.createBaseResourceTypeVolumeReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeVolumeRepository) CreateBaseResourceTypeVolumeCallCount() int {
	fake.createBaseResourceTypeVolumeMutex.RLock()
	defer fake.createBaseResourceTypeVolumeMutex.RUnlock()
	return len(fake.createBaseResourceTypeVolumeArgsForCall)
}

func (fake *FakeVolumeRepository) CreateBaseResourceTypeVolumeCalls(stub func(*db.UsedWorkerBaseResourceType) (db.CreatingVolume, error)) {
	fake.createBaseResourceTypeVolumeMutex.Lock()
	defer fake.createBaseResourceTypeVolumeMutex.Unlock()
	fake.CreateBaseResourceTypeVolumeStub = stub
}

func (fake *FakeVolumeRepository) CreateBaseResourceTypeVolumeArgsForCall(i int) *db.UsedWorkerBaseResourceType {
	fake.createBaseResourceTypeVolumeMutex.RLock()
	defer fake.createBaseResourceTypeVolumeMutex.RUnlock()
	argsForCall := fake.createBaseResourceTypeVolumeArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeVolumeRepository) CreateBaseResourceTypeVolumeReturns(result1 db.CreatingVolume, result2 error) {
	fake.createBaseResourceTypeVolumeMutex.Lock()
	defer fake.createBaseResourceTypeVolumeMutex.Unlock()
	fake.CreateBaseResourceTypeVolumeStub = nil
	fake.createBaseResourceTypeVolumeReturns = struct {
		result1 db.CreatingVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) CreateBaseResourceTypeVolumeReturnsOnCall(i int, result1 db.CreatingVolume, result2 error) {
	fake.createBaseResourceTypeVolumeMutex.Lock()
	defer fake.createBaseResourceTypeVolumeMutex.Unlock()
	fake.CreateBaseResourceTypeVolumeStub = nil
	if fake.createBaseResourceTypeVolumeReturnsOnCall == nil {
		fake.createBaseResourceTypeVolumeReturnsOnCall = make(map[int]struct {
			result1 db.CreatingVolume
			result2 error
		})
	}
	fake.createBaseResourceTypeVolumeReturnsOnCall[i] = struct {
		result1 db.CreatingVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) CreateContainerVolume(arg1 int, arg2 string, arg3 db.CreatingContainer, arg4 string) (db.CreatingVolume, error) {
	fake.createContainerVolumeMutex.Lock()
	ret, specificReturn := fake.createContainerVolumeReturnsOnCall[len(fake.createContainerVolumeArgsForCall)]
	fake.createContainerVolumeArgsForCall = append(fake.createContainerVolumeArgsForCall, struct {
		arg1 int
		arg2 string
		arg3 db.CreatingContainer
		arg4 string
	}{arg1, arg2, arg3, arg4})
	fake.recordInvocation("CreateContainerVolume", []interface{}{arg1, arg2, arg3, arg4})
	fake.createContainerVolumeMutex.Unlock()
	if fake.CreateContainerVolumeStub != nil {
		return fake.CreateContainerVolumeStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.createContainerVolumeReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeVolumeRepository) CreateContainerVolumeCallCount() int {
	fake.createContainerVolumeMutex.RLock()
	defer fake.createContainerVolumeMutex.RUnlock()
	return len(fake.createContainerVolumeArgsForCall)
}

func (fake *FakeVolumeRepository) CreateContainerVolumeCalls(stub func(int, string, db.CreatingContainer, string) (db.CreatingVolume, error)) {
	fake.createContainerVolumeMutex.Lock()
	defer fake.createContainerVolumeMutex.Unlock()
	fake.CreateContainerVolumeStub = stub
}

func (fake *FakeVolumeRepository) CreateContainerVolumeArgsForCall(i int) (int, string, db.CreatingContainer, string) {
	fake.createContainerVolumeMutex.RLock()
	defer fake.createContainerVolumeMutex.RUnlock()
	argsForCall := fake.createContainerVolumeArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeVolumeRepository) CreateContainerVolumeReturns(result1 db.CreatingVolume, result2 error) {
	fake.createContainerVolumeMutex.Lock()
	defer fake.createContainerVolumeMutex.Unlock()
	fake.CreateContainerVolumeStub = nil
	fake.createContainerVolumeReturns = struct {
		result1 db.CreatingVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) CreateContainerVolumeReturnsOnCall(i int, result1 db.CreatingVolume, result2 error) {
	fake.createContainerVolumeMutex.Lock()
	defer fake.createContainerVolumeMutex.Unlock()
	fake.CreateContainerVolumeStub = nil
	if fake.createContainerVolumeReturnsOnCall == nil {
		fake.createContainerVolumeReturnsOnCall = make(map[int]struct {
			result1 db.CreatingVolume
			result2 error
		})
	}
	fake.createContainerVolumeReturnsOnCall[i] = struct {
		result1 db.CreatingVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) CreateResourceCertsVolume(arg1 string, arg2 *db.UsedWorkerResourceCerts) (db.CreatingVolume, error) {
	fake.createResourceCertsVolumeMutex.Lock()
	ret, specificReturn := fake.createResourceCertsVolumeReturnsOnCall[len(fake.createResourceCertsVolumeArgsForCall)]
	fake.createResourceCertsVolumeArgsForCall = append(fake.createResourceCertsVolumeArgsForCall, struct {
		arg1 string
		arg2 *db.UsedWorkerResourceCerts
	}{arg1, arg2})
	fake.recordInvocation("CreateResourceCertsVolume", []interface{}{arg1, arg2})
	fake.createResourceCertsVolumeMutex.Unlock()
	if fake.CreateResourceCertsVolumeStub != nil {
		return fake.CreateResourceCertsVolumeStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.createResourceCertsVolumeReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeVolumeRepository) CreateResourceCertsVolumeCallCount() int {
	fake.createResourceCertsVolumeMutex.RLock()
	defer fake.createResourceCertsVolumeMutex.RUnlock()
	return len(fake.createResourceCertsVolumeArgsForCall)
}

func (fake *FakeVolumeRepository) CreateResourceCertsVolumeCalls(stub func(string, *db.UsedWorkerResourceCerts) (db.CreatingVolume, error)) {
	fake.createResourceCertsVolumeMutex.Lock()
	defer fake.createResourceCertsVolumeMutex.Unlock()
	fake.CreateResourceCertsVolumeStub = stub
}

func (fake *FakeVolumeRepository) CreateResourceCertsVolumeArgsForCall(i int) (string, *db.UsedWorkerResourceCerts) {
	fake.createResourceCertsVolumeMutex.RLock()
	defer fake.createResourceCertsVolumeMutex.RUnlock()
	argsForCall := fake.createResourceCertsVolumeArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeVolumeRepository) CreateResourceCertsVolumeReturns(result1 db.CreatingVolume, result2 error) {
	fake.createResourceCertsVolumeMutex.Lock()
	defer fake.createResourceCertsVolumeMutex.Unlock()
	fake.CreateResourceCertsVolumeStub = nil
	fake.createResourceCertsVolumeReturns = struct {
		result1 db.CreatingVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) CreateResourceCertsVolumeReturnsOnCall(i int, result1 db.CreatingVolume, result2 error) {
	fake.createResourceCertsVolumeMutex.Lock()
	defer fake.createResourceCertsVolumeMutex.Unlock()
	fake.CreateResourceCertsVolumeStub = nil
	if fake.createResourceCertsVolumeReturnsOnCall == nil {
		fake.createResourceCertsVolumeReturnsOnCall = make(map[int]struct {
			result1 db.CreatingVolume
			result2 error
		})
	}
	fake.createResourceCertsVolumeReturnsOnCall[i] = struct {
		result1 db.CreatingVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) CreateTaskCacheVolume(arg1 int, arg2 *db.UsedWorkerTaskCache) (db.CreatingVolume, error) {
	fake.createTaskCacheVolumeMutex.Lock()
	ret, specificReturn := fake.createTaskCacheVolumeReturnsOnCall[len(fake.createTaskCacheVolumeArgsForCall)]
	fake.createTaskCacheVolumeArgsForCall = append(fake.createTaskCacheVolumeArgsForCall, struct {
		arg1 int
		arg2 *db.UsedWorkerTaskCache
	}{arg1, arg2})
	fake.recordInvocation("CreateTaskCacheVolume", []interface{}{arg1, arg2})
	fake.createTaskCacheVolumeMutex.Unlock()
	if fake.CreateTaskCacheVolumeStub != nil {
		return fake.CreateTaskCacheVolumeStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.createTaskCacheVolumeReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeVolumeRepository) CreateTaskCacheVolumeCallCount() int {
	fake.createTaskCacheVolumeMutex.RLock()
	defer fake.createTaskCacheVolumeMutex.RUnlock()
	return len(fake.createTaskCacheVolumeArgsForCall)
}

func (fake *FakeVolumeRepository) CreateTaskCacheVolumeCalls(stub func(int, *db.UsedWorkerTaskCache) (db.CreatingVolume, error)) {
	fake.createTaskCacheVolumeMutex.Lock()
	defer fake.createTaskCacheVolumeMutex.Unlock()
	fake.CreateTaskCacheVolumeStub = stub
}

func (fake *FakeVolumeRepository) CreateTaskCacheVolumeArgsForCall(i int) (int, *db.UsedWorkerTaskCache) {
	fake.createTaskCacheVolumeMutex.RLock()
	defer fake.createTaskCacheVolumeMutex.RUnlock()
	argsForCall := fake.createTaskCacheVolumeArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeVolumeRepository) CreateTaskCacheVolumeReturns(result1 db.CreatingVolume, result2 error) {
	fake.createTaskCacheVolumeMutex.Lock()
	defer fake.createTaskCacheVolumeMutex.Unlock()
	fake.CreateTaskCacheVolumeStub = nil
	fake.createTaskCacheVolumeReturns = struct {
		result1 db.CreatingVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) CreateTaskCacheVolumeReturnsOnCall(i int, result1 db.CreatingVolume, result2 error) {
	fake.createTaskCacheVolumeMutex.Lock()
	defer fake.createTaskCacheVolumeMutex.Unlock()
	fake.CreateTaskCacheVolumeStub = nil
	if fake.createTaskCacheVolumeReturnsOnCall == nil {
		fake.createTaskCacheVolumeReturnsOnCall = make(map[int]struct {
			result1 db.CreatingVolume
			result2 error
		})
	}
	fake.createTaskCacheVolumeReturnsOnCall[i] = struct {
		result1 db.CreatingVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) CreateVolume(arg1 int, arg2 string, arg3 db.VolumeType) (db.CreatingVolume, error) {
	fake.createVolumeMutex.Lock()
	ret, specificReturn := fake.createVolumeReturnsOnCall[len(fake.createVolumeArgsForCall)]
	fake.createVolumeArgsForCall = append(fake.createVolumeArgsForCall, struct {
		arg1 int
		arg2 string
		arg3 db.VolumeType
	}{arg1, arg2, arg3})
	fake.recordInvocation("CreateVolume", []interface{}{arg1, arg2, arg3})
	fake.createVolumeMutex.Unlock()
	if fake.CreateVolumeStub != nil {
		return fake.CreateVolumeStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.createVolumeReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeVolumeRepository) CreateVolumeCallCount() int {
	fake.createVolumeMutex.RLock()
	defer fake.createVolumeMutex.RUnlock()
	return len(fake.createVolumeArgsForCall)
}

func (fake *FakeVolumeRepository) CreateVolumeCalls(stub func(int, string, db.VolumeType) (db.CreatingVolume, error)) {
	fake.createVolumeMutex.Lock()
	defer fake.createVolumeMutex.Unlock()
	fake.CreateVolumeStub = stub
}

func (fake *FakeVolumeRepository) CreateVolumeArgsForCall(i int) (int, string, db.VolumeType) {
	fake.createVolumeMutex.RLock()
	defer fake.createVolumeMutex.RUnlock()
	argsForCall := fake.createVolumeArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeVolumeRepository) CreateVolumeReturns(result1 db.CreatingVolume, result2 error) {
	fake.createVolumeMutex.Lock()
	defer fake.createVolumeMutex.Unlock()
	fake.CreateVolumeStub = nil
	fake.createVolumeReturns = struct {
		result1 db.CreatingVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) CreateVolumeReturnsOnCall(i int, result1 db.CreatingVolume, result2 error) {
	fake.createVolumeMutex.Lock()
	defer fake.createVolumeMutex.Unlock()
	fake.CreateVolumeStub = nil
	if fake.createVolumeReturnsOnCall == nil {
		fake.createVolumeReturnsOnCall = make(map[int]struct {
			result1 db.CreatingVolume
			result2 error
		})
	}
	fake.createVolumeReturnsOnCall[i] = struct {
		result1 db.CreatingVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) DestroyFailedVolumes() (int, error) {
	fake.destroyFailedVolumesMutex.Lock()
	ret, specificReturn := fake.destroyFailedVolumesReturnsOnCall[len(fake.destroyFailedVolumesArgsForCall)]
	fake.destroyFailedVolumesArgsForCall = append(fake.destroyFailedVolumesArgsForCall, struct {
	}{})
	fake.recordInvocation("DestroyFailedVolumes", []interface{}{})
	fake.destroyFailedVolumesMutex.Unlock()
	if fake.DestroyFailedVolumesStub != nil {
		return fake.DestroyFailedVolumesStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.destroyFailedVolumesReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeVolumeRepository) DestroyFailedVolumesCallCount() int {
	fake.destroyFailedVolumesMutex.RLock()
	defer fake.destroyFailedVolumesMutex.RUnlock()
	return len(fake.destroyFailedVolumesArgsForCall)
}

func (fake *FakeVolumeRepository) DestroyFailedVolumesCalls(stub func() (int, error)) {
	fake.destroyFailedVolumesMutex.Lock()
	defer fake.destroyFailedVolumesMutex.Unlock()
	fake.DestroyFailedVolumesStub = stub
}

func (fake *FakeVolumeRepository) DestroyFailedVolumesReturns(result1 int, result2 error) {
	fake.destroyFailedVolumesMutex.Lock()
	defer fake.destroyFailedVolumesMutex.Unlock()
	fake.DestroyFailedVolumesStub = nil
	fake.destroyFailedVolumesReturns = struct {
		result1 int
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) DestroyFailedVolumesReturnsOnCall(i int, result1 int, result2 error) {
	fake.destroyFailedVolumesMutex.Lock()
	defer fake.destroyFailedVolumesMutex.Unlock()
	fake.DestroyFailedVolumesStub = nil
	if fake.destroyFailedVolumesReturnsOnCall == nil {
		fake.destroyFailedVolumesReturnsOnCall = make(map[int]struct {
			result1 int
			result2 error
		})
	}
	fake.destroyFailedVolumesReturnsOnCall[i] = struct {
		result1 int
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) DestroyUnknownVolumes(arg1 string, arg2 []string) (int, error) {
	var arg2Copy []string
	if arg2 != nil {
		arg2Copy = make([]string, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.destroyUnknownVolumesMutex.Lock()
	ret, specificReturn := fake.destroyUnknownVolumesReturnsOnCall[len(fake.destroyUnknownVolumesArgsForCall)]
	fake.destroyUnknownVolumesArgsForCall = append(fake.destroyUnknownVolumesArgsForCall, struct {
		arg1 string
		arg2 []string
	}{arg1, arg2Copy})
	fake.recordInvocation("DestroyUnknownVolumes", []interface{}{arg1, arg2Copy})
	fake.destroyUnknownVolumesMutex.Unlock()
	if fake.DestroyUnknownVolumesStub != nil {
		return fake.DestroyUnknownVolumesStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.destroyUnknownVolumesReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeVolumeRepository) DestroyUnknownVolumesCallCount() int {
	fake.destroyUnknownVolumesMutex.RLock()
	defer fake.destroyUnknownVolumesMutex.RUnlock()
	return len(fake.destroyUnknownVolumesArgsForCall)
}

func (fake *FakeVolumeRepository) DestroyUnknownVolumesCalls(stub func(string, []string) (int, error)) {
	fake.destroyUnknownVolumesMutex.Lock()
	defer fake.destroyUnknownVolumesMutex.Unlock()
	fake.DestroyUnknownVolumesStub = stub
}

func (fake *FakeVolumeRepository) DestroyUnknownVolumesArgsForCall(i int) (string, []string) {
	fake.destroyUnknownVolumesMutex.RLock()
	defer fake.destroyUnknownVolumesMutex.RUnlock()
	argsForCall := fake.destroyUnknownVolumesArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeVolumeRepository) DestroyUnknownVolumesReturns(result1 int, result2 error) {
	fake.destroyUnknownVolumesMutex.Lock()
	defer fake.destroyUnknownVolumesMutex.Unlock()
	fake.DestroyUnknownVolumesStub = nil
	fake.destroyUnknownVolumesReturns = struct {
		result1 int
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) DestroyUnknownVolumesReturnsOnCall(i int, result1 int, result2 error) {
	fake.destroyUnknownVolumesMutex.Lock()
	defer fake.destroyUnknownVolumesMutex.Unlock()
	fake.DestroyUnknownVolumesStub = nil
	if fake.destroyUnknownVolumesReturnsOnCall == nil {
		fake.destroyUnknownVolumesReturnsOnCall = make(map[int]struct {
			result1 int
			result2 error
		})
	}
	fake.destroyUnknownVolumesReturnsOnCall[i] = struct {
		result1 int
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) FindBaseResourceTypeVolume(arg1 *db.UsedWorkerBaseResourceType) (db.CreatingVolume, db.CreatedVolume, error) {
	fake.findBaseResourceTypeVolumeMutex.Lock()
	ret, specificReturn := fake.findBaseResourceTypeVolumeReturnsOnCall[len(fake.findBaseResourceTypeVolumeArgsForCall)]
	fake.findBaseResourceTypeVolumeArgsForCall = append(fake.findBaseResourceTypeVolumeArgsForCall, struct {
		arg1 *db.UsedWorkerBaseResourceType
	}{arg1})
	fake.recordInvocation("FindBaseResourceTypeVolume", []interface{}{arg1})
	fake.findBaseResourceTypeVolumeMutex.Unlock()
	if fake.FindBaseResourceTypeVolumeStub != nil {
		return fake.FindBaseResourceTypeVolumeStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.findBaseResourceTypeVolumeReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeVolumeRepository) FindBaseResourceTypeVolumeCallCount() int {
	fake.findBaseResourceTypeVolumeMutex.RLock()
	defer fake.findBaseResourceTypeVolumeMutex.RUnlock()
	return len(fake.findBaseResourceTypeVolumeArgsForCall)
}

func (fake *FakeVolumeRepository) FindBaseResourceTypeVolumeCalls(stub func(*db.UsedWorkerBaseResourceType) (db.CreatingVolume, db.CreatedVolume, error)) {
	fake.findBaseResourceTypeVolumeMutex.Lock()
	defer fake.findBaseResourceTypeVolumeMutex.Unlock()
	fake.FindBaseResourceTypeVolumeStub = stub
}

func (fake *FakeVolumeRepository) FindBaseResourceTypeVolumeArgsForCall(i int) *db.UsedWorkerBaseResourceType {
	fake.findBaseResourceTypeVolumeMutex.RLock()
	defer fake.findBaseResourceTypeVolumeMutex.RUnlock()
	argsForCall := fake.findBaseResourceTypeVolumeArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeVolumeRepository) FindBaseResourceTypeVolumeReturns(result1 db.CreatingVolume, result2 db.CreatedVolume, result3 error) {
	fake.findBaseResourceTypeVolumeMutex.Lock()
	defer fake.findBaseResourceTypeVolumeMutex.Unlock()
	fake.FindBaseResourceTypeVolumeStub = nil
	fake.findBaseResourceTypeVolumeReturns = struct {
		result1 db.CreatingVolume
		result2 db.CreatedVolume
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeVolumeRepository) FindBaseResourceTypeVolumeReturnsOnCall(i int, result1 db.CreatingVolume, result2 db.CreatedVolume, result3 error) {
	fake.findBaseResourceTypeVolumeMutex.Lock()
	defer fake.findBaseResourceTypeVolumeMutex.Unlock()
	fake.FindBaseResourceTypeVolumeStub = nil
	if fake.findBaseResourceTypeVolumeReturnsOnCall == nil {
		fake.findBaseResourceTypeVolumeReturnsOnCall = make(map[int]struct {
			result1 db.CreatingVolume
			result2 db.CreatedVolume
			result3 error
		})
	}
	fake.findBaseResourceTypeVolumeReturnsOnCall[i] = struct {
		result1 db.CreatingVolume
		result2 db.CreatedVolume
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeVolumeRepository) FindContainerVolume(arg1 int, arg2 string, arg3 db.CreatingContainer, arg4 string) (db.CreatingVolume, db.CreatedVolume, error) {
	fake.findContainerVolumeMutex.Lock()
	ret, specificReturn := fake.findContainerVolumeReturnsOnCall[len(fake.findContainerVolumeArgsForCall)]
	fake.findContainerVolumeArgsForCall = append(fake.findContainerVolumeArgsForCall, struct {
		arg1 int
		arg2 string
		arg3 db.CreatingContainer
		arg4 string
	}{arg1, arg2, arg3, arg4})
	fake.recordInvocation("FindContainerVolume", []interface{}{arg1, arg2, arg3, arg4})
	fake.findContainerVolumeMutex.Unlock()
	if fake.FindContainerVolumeStub != nil {
		return fake.FindContainerVolumeStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.findContainerVolumeReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeVolumeRepository) FindContainerVolumeCallCount() int {
	fake.findContainerVolumeMutex.RLock()
	defer fake.findContainerVolumeMutex.RUnlock()
	return len(fake.findContainerVolumeArgsForCall)
}

func (fake *FakeVolumeRepository) FindContainerVolumeCalls(stub func(int, string, db.CreatingContainer, string) (db.CreatingVolume, db.CreatedVolume, error)) {
	fake.findContainerVolumeMutex.Lock()
	defer fake.findContainerVolumeMutex.Unlock()
	fake.FindContainerVolumeStub = stub
}

func (fake *FakeVolumeRepository) FindContainerVolumeArgsForCall(i int) (int, string, db.CreatingContainer, string) {
	fake.findContainerVolumeMutex.RLock()
	defer fake.findContainerVolumeMutex.RUnlock()
	argsForCall := fake.findContainerVolumeArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeVolumeRepository) FindContainerVolumeReturns(result1 db.CreatingVolume, result2 db.CreatedVolume, result3 error) {
	fake.findContainerVolumeMutex.Lock()
	defer fake.findContainerVolumeMutex.Unlock()
	fake.FindContainerVolumeStub = nil
	fake.findContainerVolumeReturns = struct {
		result1 db.CreatingVolume
		result2 db.CreatedVolume
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeVolumeRepository) FindContainerVolumeReturnsOnCall(i int, result1 db.CreatingVolume, result2 db.CreatedVolume, result3 error) {
	fake.findContainerVolumeMutex.Lock()
	defer fake.findContainerVolumeMutex.Unlock()
	fake.FindContainerVolumeStub = nil
	if fake.findContainerVolumeReturnsOnCall == nil {
		fake.findContainerVolumeReturnsOnCall = make(map[int]struct {
			result1 db.CreatingVolume
			result2 db.CreatedVolume
			result3 error
		})
	}
	fake.findContainerVolumeReturnsOnCall[i] = struct {
		result1 db.CreatingVolume
		result2 db.CreatedVolume
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeVolumeRepository) FindCreatedVolume(arg1 string) (db.CreatedVolume, bool, error) {
	fake.findCreatedVolumeMutex.Lock()
	ret, specificReturn := fake.findCreatedVolumeReturnsOnCall[len(fake.findCreatedVolumeArgsForCall)]
	fake.findCreatedVolumeArgsForCall = append(fake.findCreatedVolumeArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("FindCreatedVolume", []interface{}{arg1})
	fake.findCreatedVolumeMutex.Unlock()
	if fake.FindCreatedVolumeStub != nil {
		return fake.FindCreatedVolumeStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.findCreatedVolumeReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeVolumeRepository) FindCreatedVolumeCallCount() int {
	fake.findCreatedVolumeMutex.RLock()
	defer fake.findCreatedVolumeMutex.RUnlock()
	return len(fake.findCreatedVolumeArgsForCall)
}

func (fake *FakeVolumeRepository) FindCreatedVolumeCalls(stub func(string) (db.CreatedVolume, bool, error)) {
	fake.findCreatedVolumeMutex.Lock()
	defer fake.findCreatedVolumeMutex.Unlock()
	fake.FindCreatedVolumeStub = stub
}

func (fake *FakeVolumeRepository) FindCreatedVolumeArgsForCall(i int) string {
	fake.findCreatedVolumeMutex.RLock()
	defer fake.findCreatedVolumeMutex.RUnlock()
	argsForCall := fake.findCreatedVolumeArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeVolumeRepository) FindCreatedVolumeReturns(result1 db.CreatedVolume, result2 bool, result3 error) {
	fake.findCreatedVolumeMutex.Lock()
	defer fake.findCreatedVolumeMutex.Unlock()
	fake.FindCreatedVolumeStub = nil
	fake.findCreatedVolumeReturns = struct {
		result1 db.CreatedVolume
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeVolumeRepository) FindCreatedVolumeReturnsOnCall(i int, result1 db.CreatedVolume, result2 bool, result3 error) {
	fake.findCreatedVolumeMutex.Lock()
	defer fake.findCreatedVolumeMutex.Unlock()
	fake.FindCreatedVolumeStub = nil
	if fake.findCreatedVolumeReturnsOnCall == nil {
		fake.findCreatedVolumeReturnsOnCall = make(map[int]struct {
			result1 db.CreatedVolume
			result2 bool
			result3 error
		})
	}
	fake.findCreatedVolumeReturnsOnCall[i] = struct {
		result1 db.CreatedVolume
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeVolumeRepository) FindResourceCacheVolume(arg1 string, arg2 db.UsedResourceCache) (db.CreatedVolume, bool, error) {
	fake.findResourceCacheVolumeMutex.Lock()
	ret, specificReturn := fake.findResourceCacheVolumeReturnsOnCall[len(fake.findResourceCacheVolumeArgsForCall)]
	fake.findResourceCacheVolumeArgsForCall = append(fake.findResourceCacheVolumeArgsForCall, struct {
		arg1 string
		arg2 db.UsedResourceCache
	}{arg1, arg2})
	fake.recordInvocation("FindResourceCacheVolume", []interface{}{arg1, arg2})
	fake.findResourceCacheVolumeMutex.Unlock()
	if fake.FindResourceCacheVolumeStub != nil {
		return fake.FindResourceCacheVolumeStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.findResourceCacheVolumeReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeVolumeRepository) FindResourceCacheVolumeCallCount() int {
	fake.findResourceCacheVolumeMutex.RLock()
	defer fake.findResourceCacheVolumeMutex.RUnlock()
	return len(fake.findResourceCacheVolumeArgsForCall)
}

func (fake *FakeVolumeRepository) FindResourceCacheVolumeCalls(stub func(string, db.UsedResourceCache) (db.CreatedVolume, bool, error)) {
	fake.findResourceCacheVolumeMutex.Lock()
	defer fake.findResourceCacheVolumeMutex.Unlock()
	fake.FindResourceCacheVolumeStub = stub
}

func (fake *FakeVolumeRepository) FindResourceCacheVolumeArgsForCall(i int) (string, db.UsedResourceCache) {
	fake.findResourceCacheVolumeMutex.RLock()
	defer fake.findResourceCacheVolumeMutex.RUnlock()
	argsForCall := fake.findResourceCacheVolumeArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeVolumeRepository) FindResourceCacheVolumeReturns(result1 db.CreatedVolume, result2 bool, result3 error) {
	fake.findResourceCacheVolumeMutex.Lock()
	defer fake.findResourceCacheVolumeMutex.Unlock()
	fake.FindResourceCacheVolumeStub = nil
	fake.findResourceCacheVolumeReturns = struct {
		result1 db.CreatedVolume
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeVolumeRepository) FindResourceCacheVolumeReturnsOnCall(i int, result1 db.CreatedVolume, result2 bool, result3 error) {
	fake.findResourceCacheVolumeMutex.Lock()
	defer fake.findResourceCacheVolumeMutex.Unlock()
	fake.FindResourceCacheVolumeStub = nil
	if fake.findResourceCacheVolumeReturnsOnCall == nil {
		fake.findResourceCacheVolumeReturnsOnCall = make(map[int]struct {
			result1 db.CreatedVolume
			result2 bool
			result3 error
		})
	}
	fake.findResourceCacheVolumeReturnsOnCall[i] = struct {
		result1 db.CreatedVolume
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeVolumeRepository) FindResourceCertsVolume(arg1 string, arg2 *db.UsedWorkerResourceCerts) (db.CreatingVolume, db.CreatedVolume, error) {
	fake.findResourceCertsVolumeMutex.Lock()
	ret, specificReturn := fake.findResourceCertsVolumeReturnsOnCall[len(fake.findResourceCertsVolumeArgsForCall)]
	fake.findResourceCertsVolumeArgsForCall = append(fake.findResourceCertsVolumeArgsForCall, struct {
		arg1 string
		arg2 *db.UsedWorkerResourceCerts
	}{arg1, arg2})
	fake.recordInvocation("FindResourceCertsVolume", []interface{}{arg1, arg2})
	fake.findResourceCertsVolumeMutex.Unlock()
	if fake.FindResourceCertsVolumeStub != nil {
		return fake.FindResourceCertsVolumeStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.findResourceCertsVolumeReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeVolumeRepository) FindResourceCertsVolumeCallCount() int {
	fake.findResourceCertsVolumeMutex.RLock()
	defer fake.findResourceCertsVolumeMutex.RUnlock()
	return len(fake.findResourceCertsVolumeArgsForCall)
}

func (fake *FakeVolumeRepository) FindResourceCertsVolumeCalls(stub func(string, *db.UsedWorkerResourceCerts) (db.CreatingVolume, db.CreatedVolume, error)) {
	fake.findResourceCertsVolumeMutex.Lock()
	defer fake.findResourceCertsVolumeMutex.Unlock()
	fake.FindResourceCertsVolumeStub = stub
}

func (fake *FakeVolumeRepository) FindResourceCertsVolumeArgsForCall(i int) (string, *db.UsedWorkerResourceCerts) {
	fake.findResourceCertsVolumeMutex.RLock()
	defer fake.findResourceCertsVolumeMutex.RUnlock()
	argsForCall := fake.findResourceCertsVolumeArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeVolumeRepository) FindResourceCertsVolumeReturns(result1 db.CreatingVolume, result2 db.CreatedVolume, result3 error) {
	fake.findResourceCertsVolumeMutex.Lock()
	defer fake.findResourceCertsVolumeMutex.Unlock()
	fake.FindResourceCertsVolumeStub = nil
	fake.findResourceCertsVolumeReturns = struct {
		result1 db.CreatingVolume
		result2 db.CreatedVolume
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeVolumeRepository) FindResourceCertsVolumeReturnsOnCall(i int, result1 db.CreatingVolume, result2 db.CreatedVolume, result3 error) {
	fake.findResourceCertsVolumeMutex.Lock()
	defer fake.findResourceCertsVolumeMutex.Unlock()
	fake.FindResourceCertsVolumeStub = nil
	if fake.findResourceCertsVolumeReturnsOnCall == nil {
		fake.findResourceCertsVolumeReturnsOnCall = make(map[int]struct {
			result1 db.CreatingVolume
			result2 db.CreatedVolume
			result3 error
		})
	}
	fake.findResourceCertsVolumeReturnsOnCall[i] = struct {
		result1 db.CreatingVolume
		result2 db.CreatedVolume
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeVolumeRepository) FindTaskCacheVolume(arg1 int, arg2 string, arg3 db.UsedTaskCache) (db.CreatedVolume, bool, error) {
	fake.findTaskCacheVolumeMutex.Lock()
	ret, specificReturn := fake.findTaskCacheVolumeReturnsOnCall[len(fake.findTaskCacheVolumeArgsForCall)]
	fake.findTaskCacheVolumeArgsForCall = append(fake.findTaskCacheVolumeArgsForCall, struct {
		arg1 int
		arg2 string
		arg3 db.UsedTaskCache
	}{arg1, arg2, arg3})
	fake.recordInvocation("FindTaskCacheVolume", []interface{}{arg1, arg2, arg3})
	fake.findTaskCacheVolumeMutex.Unlock()
	if fake.FindTaskCacheVolumeStub != nil {
		return fake.FindTaskCacheVolumeStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.findTaskCacheVolumeReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeVolumeRepository) FindTaskCacheVolumeCallCount() int {
	fake.findTaskCacheVolumeMutex.RLock()
	defer fake.findTaskCacheVolumeMutex.RUnlock()
	return len(fake.findTaskCacheVolumeArgsForCall)
}

func (fake *FakeVolumeRepository) FindTaskCacheVolumeCalls(stub func(int, string, db.UsedTaskCache) (db.CreatedVolume, bool, error)) {
	fake.findTaskCacheVolumeMutex.Lock()
	defer fake.findTaskCacheVolumeMutex.Unlock()
	fake.FindTaskCacheVolumeStub = stub
}

func (fake *FakeVolumeRepository) FindTaskCacheVolumeArgsForCall(i int) (int, string, db.UsedTaskCache) {
	fake.findTaskCacheVolumeMutex.RLock()
	defer fake.findTaskCacheVolumeMutex.RUnlock()
	argsForCall := fake.findTaskCacheVolumeArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeVolumeRepository) FindTaskCacheVolumeReturns(result1 db.CreatedVolume, result2 bool, result3 error) {
	fake.findTaskCacheVolumeMutex.Lock()
	defer fake.findTaskCacheVolumeMutex.Unlock()
	fake.FindTaskCacheVolumeStub = nil
	fake.findTaskCacheVolumeReturns = struct {
		result1 db.CreatedVolume
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeVolumeRepository) FindTaskCacheVolumeReturnsOnCall(i int, result1 db.CreatedVolume, result2 bool, result3 error) {
	fake.findTaskCacheVolumeMutex.Lock()
	defer fake.findTaskCacheVolumeMutex.Unlock()
	fake.FindTaskCacheVolumeStub = nil
	if fake.findTaskCacheVolumeReturnsOnCall == nil {
		fake.findTaskCacheVolumeReturnsOnCall = make(map[int]struct {
			result1 db.CreatedVolume
			result2 bool
			result3 error
		})
	}
	fake.findTaskCacheVolumeReturnsOnCall[i] = struct {
		result1 db.CreatedVolume
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeVolumeRepository) FindVolumesForContainer(arg1 db.CreatedContainer) ([]db.CreatedVolume, error) {
	fake.findVolumesForContainerMutex.Lock()
	ret, specificReturn := fake.findVolumesForContainerReturnsOnCall[len(fake.findVolumesForContainerArgsForCall)]
	fake.findVolumesForContainerArgsForCall = append(fake.findVolumesForContainerArgsForCall, struct {
		arg1 db.CreatedContainer
	}{arg1})
	fake.recordInvocation("FindVolumesForContainer", []interface{}{arg1})
	fake.findVolumesForContainerMutex.Unlock()
	if fake.FindVolumesForContainerStub != nil {
		return fake.FindVolumesForContainerStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.findVolumesForContainerReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeVolumeRepository) FindVolumesForContainerCallCount() int {
	fake.findVolumesForContainerMutex.RLock()
	defer fake.findVolumesForContainerMutex.RUnlock()
	return len(fake.findVolumesForContainerArgsForCall)
}

func (fake *FakeVolumeRepository) FindVolumesForContainerCalls(stub func(db.CreatedContainer) ([]db.CreatedVolume, error)) {
	fake.findVolumesForContainerMutex.Lock()
	defer fake.findVolumesForContainerMutex.Unlock()
	fake.FindVolumesForContainerStub = stub
}

func (fake *FakeVolumeRepository) FindVolumesForContainerArgsForCall(i int) db.CreatedContainer {
	fake.findVolumesForContainerMutex.RLock()
	defer fake.findVolumesForContainerMutex.RUnlock()
	argsForCall := fake.findVolumesForContainerArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeVolumeRepository) FindVolumesForContainerReturns(result1 []db.CreatedVolume, result2 error) {
	fake.findVolumesForContainerMutex.Lock()
	defer fake.findVolumesForContainerMutex.Unlock()
	fake.FindVolumesForContainerStub = nil
	fake.findVolumesForContainerReturns = struct {
		result1 []db.CreatedVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) FindVolumesForContainerReturnsOnCall(i int, result1 []db.CreatedVolume, result2 error) {
	fake.findVolumesForContainerMutex.Lock()
	defer fake.findVolumesForContainerMutex.Unlock()
	fake.FindVolumesForContainerStub = nil
	if fake.findVolumesForContainerReturnsOnCall == nil {
		fake.findVolumesForContainerReturnsOnCall = make(map[int]struct {
			result1 []db.CreatedVolume
			result2 error
		})
	}
	fake.findVolumesForContainerReturnsOnCall[i] = struct {
		result1 []db.CreatedVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) GetDestroyingVolumes(arg1 string) ([]string, error) {
	fake.getDestroyingVolumesMutex.Lock()
	ret, specificReturn := fake.getDestroyingVolumesReturnsOnCall[len(fake.getDestroyingVolumesArgsForCall)]
	fake.getDestroyingVolumesArgsForCall = append(fake.getDestroyingVolumesArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetDestroyingVolumes", []interface{}{arg1})
	fake.getDestroyingVolumesMutex.Unlock()
	if fake.GetDestroyingVolumesStub != nil {
		return fake.GetDestroyingVolumesStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getDestroyingVolumesReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeVolumeRepository) GetDestroyingVolumesCallCount() int {
	fake.getDestroyingVolumesMutex.RLock()
	defer fake.getDestroyingVolumesMutex.RUnlock()
	return len(fake.getDestroyingVolumesArgsForCall)
}

func (fake *FakeVolumeRepository) GetDestroyingVolumesCalls(stub func(string) ([]string, error)) {
	fake.getDestroyingVolumesMutex.Lock()
	defer fake.getDestroyingVolumesMutex.Unlock()
	fake.GetDestroyingVolumesStub = stub
}

func (fake *FakeVolumeRepository) GetDestroyingVolumesArgsForCall(i int) string {
	fake.getDestroyingVolumesMutex.RLock()
	defer fake.getDestroyingVolumesMutex.RUnlock()
	argsForCall := fake.getDestroyingVolumesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeVolumeRepository) GetDestroyingVolumesReturns(result1 []string, result2 error) {
	fake.getDestroyingVolumesMutex.Lock()
	defer fake.getDestroyingVolumesMutex.Unlock()
	fake.GetDestroyingVolumesStub = nil
	fake.getDestroyingVolumesReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) GetDestroyingVolumesReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getDestroyingVolumesMutex.Lock()
	defer fake.getDestroyingVolumesMutex.Unlock()
	fake.GetDestroyingVolumesStub = nil
	if fake.getDestroyingVolumesReturnsOnCall == nil {
		fake.getDestroyingVolumesReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getDestroyingVolumesReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) GetOrphanedVolumes() ([]db.CreatedVolume, error) {
	fake.getOrphanedVolumesMutex.Lock()
	ret, specificReturn := fake.getOrphanedVolumesReturnsOnCall[len(fake.getOrphanedVolumesArgsForCall)]
	fake.getOrphanedVolumesArgsForCall = append(fake.getOrphanedVolumesArgsForCall, struct {
	}{})
	fake.recordInvocation("GetOrphanedVolumes", []interface{}{})
	fake.getOrphanedVolumesMutex.Unlock()
	if fake.GetOrphanedVolumesStub != nil {
		return fake.GetOrphanedVolumesStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getOrphanedVolumesReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeVolumeRepository) GetOrphanedVolumesCallCount() int {
	fake.getOrphanedVolumesMutex.RLock()
	defer fake.getOrphanedVolumesMutex.RUnlock()
	return len(fake.getOrphanedVolumesArgsForCall)
}

func (fake *FakeVolumeRepository) GetOrphanedVolumesCalls(stub func() ([]db.CreatedVolume, error)) {
	fake.getOrphanedVolumesMutex.Lock()
	defer fake.getOrphanedVolumesMutex.Unlock()
	fake.GetOrphanedVolumesStub = stub
}

func (fake *FakeVolumeRepository) GetOrphanedVolumesReturns(result1 []db.CreatedVolume, result2 error) {
	fake.getOrphanedVolumesMutex.Lock()
	defer fake.getOrphanedVolumesMutex.Unlock()
	fake.GetOrphanedVolumesStub = nil
	fake.getOrphanedVolumesReturns = struct {
		result1 []db.CreatedVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) GetOrphanedVolumesReturnsOnCall(i int, result1 []db.CreatedVolume, result2 error) {
	fake.getOrphanedVolumesMutex.Lock()
	defer fake.getOrphanedVolumesMutex.Unlock()
	fake.GetOrphanedVolumesStub = nil
	if fake.getOrphanedVolumesReturnsOnCall == nil {
		fake.getOrphanedVolumesReturnsOnCall = make(map[int]struct {
			result1 []db.CreatedVolume
			result2 error
		})
	}
	fake.getOrphanedVolumesReturnsOnCall[i] = struct {
		result1 []db.CreatedVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) GetTeamVolumes(arg1 int) ([]db.CreatedVolume, error) {
	fake.getTeamVolumesMutex.Lock()
	ret, specificReturn := fake.getTeamVolumesReturnsOnCall[len(fake.getTeamVolumesArgsForCall)]
	fake.getTeamVolumesArgsForCall = append(fake.getTeamVolumesArgsForCall, struct {
		arg1 int
	}{arg1})
	fake.recordInvocation("GetTeamVolumes", []interface{}{arg1})
	fake.getTeamVolumesMutex.Unlock()
	if fake.GetTeamVolumesStub != nil {
		return fake.GetTeamVolumesStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getTeamVolumesReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeVolumeRepository) GetTeamVolumesCallCount() int {
	fake.getTeamVolumesMutex.RLock()
	defer fake.getTeamVolumesMutex.RUnlock()
	return len(fake.getTeamVolumesArgsForCall)
}

func (fake *FakeVolumeRepository) GetTeamVolumesCalls(stub func(int) ([]db.CreatedVolume, error)) {
	fake.getTeamVolumesMutex.Lock()
	defer fake.getTeamVolumesMutex.Unlock()
	fake.GetTeamVolumesStub = stub
}

func (fake *FakeVolumeRepository) GetTeamVolumesArgsForCall(i int) int {
	fake.getTeamVolumesMutex.RLock()
	defer fake.getTeamVolumesMutex.RUnlock()
	argsForCall := fake.getTeamVolumesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeVolumeRepository) GetTeamVolumesReturns(result1 []db.CreatedVolume, result2 error) {
	fake.getTeamVolumesMutex.Lock()
	defer fake.getTeamVolumesMutex.Unlock()
	fake.GetTeamVolumesStub = nil
	fake.getTeamVolumesReturns = struct {
		result1 []db.CreatedVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) GetTeamVolumesReturnsOnCall(i int, result1 []db.CreatedVolume, result2 error) {
	fake.getTeamVolumesMutex.Lock()
	defer fake.getTeamVolumesMutex.Unlock()
	fake.GetTeamVolumesStub = nil
	if fake.getTeamVolumesReturnsOnCall == nil {
		fake.getTeamVolumesReturnsOnCall = make(map[int]struct {
			result1 []db.CreatedVolume
			result2 error
		})
	}
	fake.getTeamVolumesReturnsOnCall[i] = struct {
		result1 []db.CreatedVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) RemoveDestroyingVolumes(arg1 string, arg2 []string) (int, error) {
	var arg2Copy []string
	if arg2 != nil {
		arg2Copy = make([]string, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.removeDestroyingVolumesMutex.Lock()
	ret, specificReturn := fake.removeDestroyingVolumesReturnsOnCall[len(fake.removeDestroyingVolumesArgsForCall)]
	fake.removeDestroyingVolumesArgsForCall = append(fake.removeDestroyingVolumesArgsForCall, struct {
		arg1 string
		arg2 []string
	}{arg1, arg2Copy})
	fake.recordInvocation("RemoveDestroyingVolumes", []interface{}{arg1, arg2Copy})
	fake.removeDestroyingVolumesMutex.Unlock()
	if fake.RemoveDestroyingVolumesStub != nil {
		return fake.RemoveDestroyingVolumesStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.removeDestroyingVolumesReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeVolumeRepository) RemoveDestroyingVolumesCallCount() int {
	fake.removeDestroyingVolumesMutex.RLock()
	defer fake.removeDestroyingVolumesMutex.RUnlock()
	return len(fake.removeDestroyingVolumesArgsForCall)
}

func (fake *FakeVolumeRepository) RemoveDestroyingVolumesCalls(stub func(string, []string) (int, error)) {
	fake.removeDestroyingVolumesMutex.Lock()
	defer fake.removeDestroyingVolumesMutex.Unlock()
	fake.RemoveDestroyingVolumesStub = stub
}

func (fake *FakeVolumeRepository) RemoveDestroyingVolumesArgsForCall(i int) (string, []string) {
	fake.removeDestroyingVolumesMutex.RLock()
	defer fake.removeDestroyingVolumesMutex.RUnlock()
	argsForCall := fake.removeDestroyingVolumesArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeVolumeRepository) RemoveDestroyingVolumesReturns(result1 int, result2 error) {
	fake.removeDestroyingVolumesMutex.Lock()
	defer fake.removeDestroyingVolumesMutex.Unlock()
	fake.RemoveDestroyingVolumesStub = nil
	fake.removeDestroyingVolumesReturns = struct {
		result1 int
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) RemoveDestroyingVolumesReturnsOnCall(i int, result1 int, result2 error) {
	fake.removeDestroyingVolumesMutex.Lock()
	defer fake.removeDestroyingVolumesMutex.Unlock()
	fake.RemoveDestroyingVolumesStub = nil
	if fake.removeDestroyingVolumesReturnsOnCall == nil {
		fake.removeDestroyingVolumesReturnsOnCall = make(map[int]struct {
			result1 int
			result2 error
		})
	}
	fake.removeDestroyingVolumesReturnsOnCall[i] = struct {
		result1 int
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) RemoveMissingVolumes(arg1 time.Duration) (int, error) {
	fake.removeMissingVolumesMutex.Lock()
	ret, specificReturn := fake.removeMissingVolumesReturnsOnCall[len(fake.removeMissingVolumesArgsForCall)]
	fake.removeMissingVolumesArgsForCall = append(fake.removeMissingVolumesArgsForCall, struct {
		arg1 time.Duration
	}{arg1})
	fake.recordInvocation("RemoveMissingVolumes", []interface{}{arg1})
	fake.removeMissingVolumesMutex.Unlock()
	if fake.RemoveMissingVolumesStub != nil {
		return fake.RemoveMissingVolumesStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.removeMissingVolumesReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeVolumeRepository) RemoveMissingVolumesCallCount() int {
	fake.removeMissingVolumesMutex.RLock()
	defer fake.removeMissingVolumesMutex.RUnlock()
	return len(fake.removeMissingVolumesArgsForCall)
}

func (fake *FakeVolumeRepository) RemoveMissingVolumesCalls(stub func(time.Duration) (int, error)) {
	fake.removeMissingVolumesMutex.Lock()
	defer fake.removeMissingVolumesMutex.Unlock()
	fake.RemoveMissingVolumesStub = stub
}

func (fake *FakeVolumeRepository) RemoveMissingVolumesArgsForCall(i int) time.Duration {
	fake.removeMissingVolumesMutex.RLock()
	defer fake.removeMissingVolumesMutex.RUnlock()
	argsForCall := fake.removeMissingVolumesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeVolumeRepository) RemoveMissingVolumesReturns(result1 int, result2 error) {
	fake.removeMissingVolumesMutex.Lock()
	defer fake.removeMissingVolumesMutex.Unlock()
	fake.RemoveMissingVolumesStub = nil
	fake.removeMissingVolumesReturns = struct {
		result1 int
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) RemoveMissingVolumesReturnsOnCall(i int, result1 int, result2 error) {
	fake.removeMissingVolumesMutex.Lock()
	defer fake.removeMissingVolumesMutex.Unlock()
	fake.RemoveMissingVolumesStub = nil
	if fake.removeMissingVolumesReturnsOnCall == nil {
		fake.removeMissingVolumesReturnsOnCall = make(map[int]struct {
			result1 int
			result2 error
		})
	}
	fake.removeMissingVolumesReturnsOnCall[i] = struct {
		result1 int
		result2 error
	}{result1, result2}
}

func (fake *FakeVolumeRepository) UpdateVolumesMissingSince(arg1 string, arg2 []string) error {
	var arg2Copy []string
	if arg2 != nil {
		arg2Copy = make([]string, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.updateVolumesMissingSinceMutex.Lock()
	ret, specificReturn := fake.updateVolumesMissingSinceReturnsOnCall[len(fake.updateVolumesMissingSinceArgsForCall)]
	fake.updateVolumesMissingSinceArgsForCall = append(fake.updateVolumesMissingSinceArgsForCall, struct {
		arg1 string
		arg2 []string
	}{arg1, arg2Copy})
	fake.recordInvocation("UpdateVolumesMissingSince", []interface{}{arg1, arg2Copy})
	fake.updateVolumesMissingSinceMutex.Unlock()
	if fake.UpdateVolumesMissingSinceStub != nil {
		return fake.UpdateVolumesMissingSinceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.updateVolumesMissingSinceReturns
	return fakeReturns.result1
}

func (fake *FakeVolumeRepository) UpdateVolumesMissingSinceCallCount() int {
	fake.updateVolumesMissingSinceMutex.RLock()
	defer fake.updateVolumesMissingSinceMutex.RUnlock()
	return len(fake.updateVolumesMissingSinceArgsForCall)
}

func (fake *FakeVolumeRepository) UpdateVolumesMissingSinceCalls(stub func(string, []string) error) {
	fake.updateVolumesMissingSinceMutex.Lock()
	defer fake.updateVolumesMissingSinceMutex.Unlock()
	fake.UpdateVolumesMissingSinceStub = stub
}

func (fake *FakeVolumeRepository) UpdateVolumesMissingSinceArgsForCall(i int) (string, []string) {
	fake.updateVolumesMissingSinceMutex.RLock()
	defer fake.updateVolumesMissingSinceMutex.RUnlock()
	argsForCall := fake.updateVolumesMissingSinceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeVolumeRepository) UpdateVolumesMissingSinceReturns(result1 error) {
	fake.updateVolumesMissingSinceMutex.Lock()
	defer fake.updateVolumesMissingSinceMutex.Unlock()
	fake.UpdateVolumesMissingSinceStub = nil
	fake.updateVolumesMissingSinceReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeVolumeRepository) UpdateVolumesMissingSinceReturnsOnCall(i int, result1 error) {
	fake.updateVolumesMissingSinceMutex.Lock()
	defer fake.updateVolumesMissingSinceMutex.Unlock()
	fake.UpdateVolumesMissingSinceStub = nil
	if fake.updateVolumesMissingSinceReturnsOnCall == nil {
		fake.updateVolumesMissingSinceReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateVolumesMissingSinceReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeVolumeRepository) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.createBaseResourceTypeVolumeMutex.RLock()
	defer fake.createBaseResourceTypeVolumeMutex.RUnlock()
	fake.createContainerVolumeMutex.RLock()
	defer fake.createContainerVolumeMutex.RUnlock()
	fake.createResourceCertsVolumeMutex.RLock()
	defer fake.createResourceCertsVolumeMutex.RUnlock()
	fake.createTaskCacheVolumeMutex.RLock()
	defer fake.createTaskCacheVolumeMutex.RUnlock()
	fake.createVolumeMutex.RLock()
	defer fake.createVolumeMutex.RUnlock()
	fake.destroyFailedVolumesMutex.RLock()
	defer fake.destroyFailedVolumesMutex.RUnlock()
	fake.destroyUnknownVolumesMutex.RLock()
	defer fake.destroyUnknownVolumesMutex.RUnlock()
	fake.findBaseResourceTypeVolumeMutex.RLock()
	defer fake.findBaseResourceTypeVolumeMutex.RUnlock()
	fake.findContainerVolumeMutex.RLock()
	defer fake.findContainerVolumeMutex.RUnlock()
	fake.findCreatedVolumeMutex.RLock()
	defer fake.findCreatedVolumeMutex.RUnlock()
	fake.findResourceCacheVolumeMutex.RLock()
	defer fake.findResourceCacheVolumeMutex.RUnlock()
	fake.findResourceCertsVolumeMutex.RLock()
	defer fake.findResourceCertsVolumeMutex.RUnlock()
	fake.findTaskCacheVolumeMutex.RLock()
	defer fake.findTaskCacheVolumeMutex.RUnlock()
	fake.findVolumesForContainerMutex.RLock()
	defer fake.findVolumesForContainerMutex.RUnlock()
	fake.getDestroyingVolumesMutex.RLock()
	defer fake.getDestroyingVolumesMutex.RUnlock()
	fake.getOrphanedVolumesMutex.RLock()
	defer fake.getOrphanedVolumesMutex.RUnlock()
	fake.getTeamVolumesMutex.RLock()
	defer fake.getTeamVolumesMutex.RUnlock()
	fake.removeDestroyingVolumesMutex.RLock()
	defer fake.removeDestroyingVolumesMutex.RUnlock()
	fake.removeMissingVolumesMutex.RLock()
	defer fake.removeMissingVolumesMutex.RUnlock()
	fake.updateVolumesMissingSinceMutex.RLock()
	defer fake.updateVolumesMissingSinceMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeVolumeRepository) recordInvocation(key string, args []interface{}) {
	fake.invocationsMutex.Lock()
	defer fake.invocationsMutex.Unlock()
	if fake.invocations == nil {
		fake.invocations = map[string][][]interface{}{}
	}
	if fake.invocations[key] == nil {
		fake.invocations[key] = [][]interface{}{}
	}
	fake.invocations[key] = append(fake.invocations[key], args)
}

var _ db.VolumeRepository = new(FakeVolumeRepository)