fake_worker_db.go

// This file was generated by counterfeiter
package workerfakes

import (
	"sync"
	"time"

	"github.com/concourse/atc/db"
	"github.com/concourse/atc/worker"
)

type FakeWorkerDB struct {
	WorkersStub        func() ([]db.SavedWorker, error)
	workersMutex       sync.RWMutex
	workersArgsForCall []struct{}
	workersReturns     struct {
		result1 []db.SavedWorker
		result2 error
	}
	GetWorkerStub        func(string) (db.SavedWorker, bool, error)
	getWorkerMutex       sync.RWMutex
	getWorkerArgsForCall []struct {
		arg1 string
	}
	getWorkerReturns struct {
		result1 db.SavedWorker
		result2 bool
		result3 error
	}
	CreateContainerStub        func(container db.Container, ttl time.Duration, maxLifetime time.Duration, volumeHandles []string) (db.SavedContainer, error)
	createContainerMutex       sync.RWMutex
	createContainerArgsForCall []struct {
		container     db.Container
		ttl           time.Duration
		maxLifetime   time.Duration
		volumeHandles []string
	}
	createContainerReturns struct {
		result1 db.SavedContainer
		result2 error
	}
	GetContainerStub        func(string) (db.SavedContainer, bool, error)
	getContainerMutex       sync.RWMutex
	getContainerArgsForCall []struct {
		arg1 string
	}
	getContainerReturns struct {
		result1 db.SavedContainer
		result2 bool
		result3 error
	}
	FindContainerByIdentifierStub        func(db.ContainerIdentifier) (db.SavedContainer, bool, error)
	findContainerByIdentifierMutex       sync.RWMutex
	findContainerByIdentifierArgsForCall []struct {
		arg1 db.ContainerIdentifier
	}
	findContainerByIdentifierReturns struct {
		result1 db.SavedContainer
		result2 bool
		result3 error
	}
	FindWorkerCheckResourceTypeVersionStub        func(workerName string, checkType string) (string, bool, error)
	findWorkerCheckResourceTypeVersionMutex       sync.RWMutex
	findWorkerCheckResourceTypeVersionArgsForCall []struct {
		workerName string
		checkType  string
	}
	findWorkerCheckResourceTypeVersionReturns struct {
		result1 string
		result2 bool
		result3 error
	}
	UpdateExpiresAtOnContainerStub        func(handle string, ttl time.Duration) error
	updateExpiresAtOnContainerMutex       sync.RWMutex
	updateExpiresAtOnContainerArgsForCall []struct {
		handle string
		ttl    time.Duration
	}
	updateExpiresAtOnContainerReturns struct {
		result1 error
	}
	ReapContainerStub        func(handle string) error
	reapContainerMutex       sync.RWMutex
	reapContainerArgsForCall []struct {
		handle string
	}
	reapContainerReturns struct {
		result1 error
	}
	InsertVolumeStub        func(db.Volume) error
	insertVolumeMutex       sync.RWMutex
	insertVolumeArgsForCall []struct {
		arg1 db.Volume
	}
	insertVolumeReturns struct {
		result1 error
	}
	GetVolumesByIdentifierStub        func(db.VolumeIdentifier) ([]db.SavedVolume, error)
	getVolumesByIdentifierMutex       sync.RWMutex
	getVolumesByIdentifierArgsForCall []struct {
		arg1 db.VolumeIdentifier
	}
	getVolumesByIdentifierReturns struct {
		result1 []db.SavedVolume
		result2 error
	}
	GetVolumeTTLStub        func(volumeHandle string) (time.Duration, bool, error)
	getVolumeTTLMutex       sync.RWMutex
	getVolumeTTLArgsForCall []struct {
		volumeHandle string
	}
	getVolumeTTLReturns struct {
		result1 time.Duration
		result2 bool
		result3 error
	}
	ReapVolumeStub        func(handle string) error
	reapVolumeMutex       sync.RWMutex
	reapVolumeArgsForCall []struct {
		handle string
	}
	reapVolumeReturns struct {
		result1 error
	}
	SetVolumeTTLStub        func(string, time.Duration) error
	setVolumeTTLMutex       sync.RWMutex
	setVolumeTTLArgsForCall []struct {
		arg1 string
		arg2 time.Duration
	}
	setVolumeTTLReturns struct {
		result1 error
	}
	SetVolumeSizeInBytesStub        func(string, int64) error
	setVolumeSizeInBytesMutex       sync.RWMutex
	setVolumeSizeInBytesArgsForCall []struct {
		arg1 string
		arg2 int64
	}
	setVolumeSizeInBytesReturns struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeWorkerDB) Workers() ([]db.SavedWorker, error) {
	fake.workersMutex.Lock()
	fake.workersArgsForCall = append(fake.workersArgsForCall, struct{}{})
	fake.recordInvocation("Workers", []interface{}{})
	fake.workersMutex.Unlock()
	if fake.WorkersStub != nil {
		return fake.WorkersStub()
	} else {
		return fake.workersReturns.result1, fake.workersReturns.result2
	}
}

func (fake *FakeWorkerDB) WorkersCallCount() int {
	fake.workersMutex.RLock()
	defer fake.workersMutex.RUnlock()
	return len(fake.workersArgsForCall)
}

func (fake *FakeWorkerDB) WorkersReturns(result1 []db.SavedWorker, result2 error) {
	fake.WorkersStub = nil
	fake.workersReturns = struct {
		result1 []db.SavedWorker
		result2 error
	}{result1, result2}
}

func (fake *FakeWorkerDB) GetWorker(arg1 string) (db.SavedWorker, bool, error) {
	fake.getWorkerMutex.Lock()
	fake.getWorkerArgsForCall = append(fake.getWorkerArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetWorker", []interface{}{arg1})
	fake.getWorkerMutex.Unlock()
	if fake.GetWorkerStub != nil {
		return fake.GetWorkerStub(arg1)
	} else {
		return fake.getWorkerReturns.result1, fake.getWorkerReturns.result2, fake.getWorkerReturns.result3
	}
}

func (fake *FakeWorkerDB) GetWorkerCallCount() int {
	fake.getWorkerMutex.RLock()
	defer fake.getWorkerMutex.RUnlock()
	return len(fake.getWorkerArgsForCall)
}

func (fake *FakeWorkerDB) GetWorkerArgsForCall(i int) string {
	fake.getWorkerMutex.RLock()
	defer fake.getWorkerMutex.RUnlock()
	return fake.getWorkerArgsForCall[i].arg1
}

func (fake *FakeWorkerDB) GetWorkerReturns(result1 db.SavedWorker, result2 bool, result3 error) {
	fake.GetWorkerStub = nil
	fake.getWorkerReturns = struct {
		result1 db.SavedWorker
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeWorkerDB) CreateContainer(container db.Container, ttl time.Duration, maxLifetime time.Duration, volumeHandles []string) (db.SavedContainer, error) {
	var volumeHandlesCopy []string
	if volumeHandles != nil {
		volumeHandlesCopy = make([]string, len(volumeHandles))
		copy(volumeHandlesCopy, volumeHandles)
	}
	fake.createContainerMutex.Lock()
	fake.createContainerArgsForCall = append(fake.createContainerArgsForCall, struct {
		container     db.Container
		ttl           time.Duration
		maxLifetime   time.Duration
		volumeHandles []string
	}{container, ttl, maxLifetime, volumeHandlesCopy})
	fake.recordInvocation("CreateContainer", []interface{}{container, ttl, maxLifetime, volumeHandlesCopy})
	fake.createContainerMutex.Unlock()
	if fake.CreateContainerStub != nil {
		return fake.CreateContainerStub(container, ttl, maxLifetime, volumeHandles)
	} else {
		return fake.createContainerReturns.result1, fake.createContainerReturns.result2
	}
}

func (fake *FakeWorkerDB) CreateContainerCallCount() int {
	fake.createContainerMutex.RLock()
	defer fake.createContainerMutex.RUnlock()
	return len(fake.createContainerArgsForCall)
}

func (fake *FakeWorkerDB) CreateContainerArgsForCall(i int) (db.Container, time.Duration, time.Duration, []string) {
	fake.createContainerMutex.RLock()
	defer fake.createContainerMutex.RUnlock()
	return fake.createContainerArgsForCall[i].container, fake.createContainerArgsForCall[i].ttl, fake.createContainerArgsForCall[i].maxLifetime, fake.createContainerArgsForCall[i].volumeHandles
}

func (fake *FakeWorkerDB) CreateContainerReturns(result1 db.SavedContainer, result2 error) {
	fake.CreateContainerStub = nil
	fake.createContainerReturns = struct {
		result1 db.SavedContainer
		result2 error
	}{result1, result2}
}

func (fake *FakeWorkerDB) GetContainer(arg1 string) (db.SavedContainer, bool, error) {
	fake.getContainerMutex.Lock()
	fake.getContainerArgsForCall = append(fake.getContainerArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetContainer", []interface{}{arg1})
	fake.getContainerMutex.Unlock()
	if fake.GetContainerStub != nil {
		return fake.GetContainerStub(arg1)
	} else {
		return fake.getContainerReturns.result1, fake.getContainerReturns.result2, fake.getContainerReturns.result3
	}
}

func (fake *FakeWorkerDB) GetContainerCallCount() int {
	fake.getContainerMutex.RLock()
	defer fake.getContainerMutex.RUnlock()
	return len(fake.getContainerArgsForCall)
}

func (fake *FakeWorkerDB) GetContainerArgsForCall(i int) string {
	fake.getContainerMutex.RLock()
	defer fake.getContainerMutex.RUnlock()
	return fake.getContainerArgsForCall[i].arg1
}

func (fake *FakeWorkerDB) GetContainerReturns(result1 db.SavedContainer, result2 bool, result3 error) {
	fake.GetContainerStub = nil
	fake.getContainerReturns = struct {
		result1 db.SavedContainer
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeWorkerDB) FindContainerByIdentifier(arg1 db.ContainerIdentifier) (db.SavedContainer, bool, error) {
	fake.findContainerByIdentifierMutex.Lock()
	fake.findContainerByIdentifierArgsForCall = append(fake.findContainerByIdentifierArgsForCall, struct {
		arg1 db.ContainerIdentifier
	}{arg1})
	fake.recordInvocation("FindContainerByIdentifier", []interface{}{arg1})
	fake.findContainerByIdentifierMutex.Unlock()
	if fake.FindContainerByIdentifierStub != nil {
		return fake.FindContainerByIdentifierStub(arg1)
	} else {
		return fake.findContainerByIdentifierReturns.result1, fake.findContainerByIdentifierReturns.result2, fake.findContainerByIdentifierReturns.result3
	}
}

func (fake *FakeWorkerDB) FindContainerByIdentifierCallCount() int {
	fake.findContainerByIdentifierMutex.RLock()
	defer fake.findContainerByIdentifierMutex.RUnlock()
	return len(fake.findContainerByIdentifierArgsForCall)
}

func (fake *FakeWorkerDB) FindContainerByIdentifierArgsForCall(i int) db.ContainerIdentifier {
	fake.findContainerByIdentifierMutex.RLock()
	defer fake.findContainerByIdentifierMutex.RUnlock()
	return fake.findContainerByIdentifierArgsForCall[i].arg1
}

func (fake *FakeWorkerDB) FindContainerByIdentifierReturns(result1 db.SavedContainer, result2 bool, result3 error) {
	fake.FindContainerByIdentifierStub = nil
	fake.findContainerByIdentifierReturns = struct {
		result1 db.SavedContainer
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeWorkerDB) FindWorkerCheckResourceTypeVersion(workerName string, checkType string) (string, bool, error) {
	fake.findWorkerCheckResourceTypeVersionMutex.Lock()
	fake.findWorkerCheckResourceTypeVersionArgsForCall = append(fake.findWorkerCheckResourceTypeVersionArgsForCall, struct {
		workerName string
		checkType  string
	}{workerName, checkType})
	fake.recordInvocation("FindWorkerCheckResourceTypeVersion", []interface{}{workerName, checkType})
	fake.findWorkerCheckResourceTypeVersionMutex.Unlock()
	if fake.FindWorkerCheckResourceTypeVersionStub != nil {
		return fake.FindWorkerCheckResourceTypeVersionStub(workerName, checkType)
	} else {
		return fake.findWorkerCheckResourceTypeVersionReturns.result1, fake.findWorkerCheckResourceTypeVersionReturns.result2, fake.findWorkerCheckResourceTypeVersionReturns.result3
	}
}

func (fake *FakeWorkerDB) FindWorkerCheckResourceTypeVersionCallCount() int {
	fake.findWorkerCheckResourceTypeVersionMutex.RLock()
	defer fake.findWorkerCheckResourceTypeVersionMutex.RUnlock()
	return len(fake.findWorkerCheckResourceTypeVersionArgsForCall)
}

func (fake *FakeWorkerDB) FindWorkerCheckResourceTypeVersionArgsForCall(i int) (string, string) {
	fake.findWorkerCheckResourceTypeVersionMutex.RLock()
	defer fake.findWorkerCheckResourceTypeVersionMutex.RUnlock()
	return fake.findWorkerCheckResourceTypeVersionArgsForCall[i].workerName, fake.findWorkerCheckResourceTypeVersionArgsForCall[i].checkType
}

func (fake *FakeWorkerDB) FindWorkerCheckResourceTypeVersionReturns(result1 string, result2 bool, result3 error) {
	fake.FindWorkerCheckResourceTypeVersionStub = nil
	fake.findWorkerCheckResourceTypeVersionReturns = struct {
		result1 string
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeWorkerDB) UpdateExpiresAtOnContainer(handle string, ttl time.Duration) error {
	fake.updateExpiresAtOnContainerMutex.Lock()
	fake.updateExpiresAtOnContainerArgsForCall = append(fake.updateExpiresAtOnContainerArgsForCall, struct {
		handle string
		ttl    time.Duration
	}{handle, ttl})
	fake.recordInvocation("UpdateExpiresAtOnContainer", []interface{}{handle, ttl})
	fake.updateExpiresAtOnContainerMutex.Unlock()
	if fake.UpdateExpiresAtOnContainerStub != nil {
		return fake.UpdateExpiresAtOnContainerStub(handle, ttl)
	} else {
		return fake.updateExpiresAtOnContainerReturns.result1
	}
}

func (fake *FakeWorkerDB) UpdateExpiresAtOnContainerCallCount() int {
	fake.updateExpiresAtOnContainerMutex.RLock()
	defer fake.updateExpiresAtOnContainerMutex.RUnlock()
	return len(fake.updateExpiresAtOnContainerArgsForCall)
}

func (fake *FakeWorkerDB) UpdateExpiresAtOnContainerArgsForCall(i int) (string, time.Duration) {
	fake.updateExpiresAtOnContainerMutex.RLock()
	defer fake.updateExpiresAtOnContainerMutex.RUnlock()
	return fake.updateExpiresAtOnContainerArgsForCall[i].handle, fake.updateExpiresAtOnContainerArgsForCall[i].ttl
}

func (fake *FakeWorkerDB) UpdateExpiresAtOnContainerReturns(result1 error) {
	fake.UpdateExpiresAtOnContainerStub = nil
	fake.updateExpiresAtOnContainerReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeWorkerDB) ReapContainer(handle string) error {
	fake.reapContainerMutex.Lock()
	fake.reapContainerArgsForCall = append(fake.reapContainerArgsForCall, struct {
		handle string
	}{handle})
	fake.recordInvocation("ReapContainer", []interface{}{handle})
	fake.reapContainerMutex.Unlock()
	if fake.ReapContainerStub != nil {
		return fake.ReapContainerStub(handle)
	} else {
		return fake.reapContainerReturns.result1
	}
}

func (fake *FakeWorkerDB) ReapContainerCallCount() int {
	fake.reapContainerMutex.RLock()
	defer fake.reapContainerMutex.RUnlock()
	return len(fake.reapContainerArgsForCall)
}

func (fake *FakeWorkerDB) ReapContainerArgsForCall(i int) string {
	fake.reapContainerMutex.RLock()
	defer fake.reapContainerMutex.RUnlock()
	return fake.reapContainerArgsForCall[i].handle
}

func (fake *FakeWorkerDB) ReapContainerReturns(result1 error) {
	fake.ReapContainerStub = nil
	fake.reapContainerReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeWorkerDB) InsertVolume(arg1 db.Volume) error {
	fake.insertVolumeMutex.Lock()
	fake.insertVolumeArgsForCall = append(fake.insertVolumeArgsForCall, struct {
		arg1 db.Volume
	}{arg1})
	fake.recordInvocation("InsertVolume", []interface{}{arg1})
	fake.insertVolumeMutex.Unlock()
	if fake.InsertVolumeStub != nil {
		return fake.InsertVolumeStub(arg1)
	} else {
		return fake.insertVolumeReturns.result1
	}
}

func (fake *FakeWorkerDB) InsertVolumeCallCount() int {
	fake.insertVolumeMutex.RLock()
	defer fake.insertVolumeMutex.RUnlock()
	return len(fake.insertVolumeArgsForCall)
}

func (fake *FakeWorkerDB) InsertVolumeArgsForCall(i int) db.Volume {
	fake.insertVolumeMutex.RLock()
	defer fake.insertVolumeMutex.RUnlock()
	return fake.insertVolumeArgsForCall[i].arg1
}

func (fake *FakeWorkerDB) InsertVolumeReturns(result1 error) {
	fake.InsertVolumeStub = nil
	fake.insertVolumeReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeWorkerDB) GetVolumesByIdentifier(arg1 db.VolumeIdentifier) ([]db.SavedVolume, error) {
	fake.getVolumesByIdentifierMutex.Lock()
	fake.getVolumesByIdentifierArgsForCall = append(fake.getVolumesByIdentifierArgsForCall, struct {
		arg1 db.VolumeIdentifier
	}{arg1})
	fake.recordInvocation("GetVolumesByIdentifier", []interface{}{arg1})
	fake.getVolumesByIdentifierMutex.Unlock()
	if fake.GetVolumesByIdentifierStub != nil {
		return fake.GetVolumesByIdentifierStub(arg1)
	} else {
		return fake.getVolumesByIdentifierReturns.result1, fake.getVolumesByIdentifierReturns.result2
	}
}

func (fake *FakeWorkerDB) GetVolumesByIdentifierCallCount() int {
	fake.getVolumesByIdentifierMutex.RLock()
	defer fake.getVolumesByIdentifierMutex.RUnlock()
	return len(fake.getVolumesByIdentifierArgsForCall)
}

func (fake *FakeWorkerDB) GetVolumesByIdentifierArgsForCall(i int) db.VolumeIdentifier {
	fake.getVolumesByIdentifierMutex.RLock()
	defer fake.getVolumesByIdentifierMutex.RUnlock()
	return fake.getVolumesByIdentifierArgsForCall[i].arg1
}

func (fake *FakeWorkerDB) GetVolumesByIdentifierReturns(result1 []db.SavedVolume, result2 error) {
	fake.GetVolumesByIdentifierStub = nil
	fake.getVolumesByIdentifierReturns = struct {
		result1 []db.SavedVolume
		result2 error
	}{result1, result2}
}

func (fake *FakeWorkerDB) GetVolumeTTL(volumeHandle string) (time.Duration, bool, error) {
	fake.getVolumeTTLMutex.Lock()
	fake.getVolumeTTLArgsForCall = append(fake.getVolumeTTLArgsForCall, struct {
		volumeHandle string
	}{volumeHandle})
	fake.recordInvocation("GetVolumeTTL", []interface{}{volumeHandle})
	fake.getVolumeTTLMutex.Unlock()
	if fake.GetVolumeTTLStub != nil {
		return fake.GetVolumeTTLStub(volumeHandle)
	} else {
		return fake.getVolumeTTLReturns.result1, fake.getVolumeTTLReturns.result2, fake.getVolumeTTLReturns.result3
	}
}

func (fake *FakeWorkerDB) GetVolumeTTLCallCount() int {
	fake.getVolumeTTLMutex.RLock()
	defer fake.getVolumeTTLMutex.RUnlock()
	return len(fake.getVolumeTTLArgsForCall)
}

func (fake *FakeWorkerDB) GetVolumeTTLArgsForCall(i int) string {
	fake.getVolumeTTLMutex.RLock()
	defer fake.getVolumeTTLMutex.RUnlock()
	return fake.getVolumeTTLArgsForCall[i].volumeHandle
}

func (fake *FakeWorkerDB) GetVolumeTTLReturns(result1 time.Duration, result2 bool, result3 error) {
	fake.GetVolumeTTLStub = nil
	fake.getVolumeTTLReturns = struct {
		result1 time.Duration
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeWorkerDB) ReapVolume(handle string) error {
	fake.reapVolumeMutex.Lock()
	fake.reapVolumeArgsForCall = append(fake.reapVolumeArgsForCall, struct {
		handle string
	}{handle})
	fake.recordInvocation("ReapVolume", []interface{}{handle})
	fake.reapVolumeMutex.Unlock()
	if fake.ReapVolumeStub != nil {
		return fake.ReapVolumeStub(handle)
	} else {
		return fake.reapVolumeReturns.result1
	}
}

func (fake *FakeWorkerDB) ReapVolumeCallCount() int {
	fake.reapVolumeMutex.RLock()
	defer fake.reapVolumeMutex.RUnlock()
	return len(fake.reapVolumeArgsForCall)
}

func (fake *FakeWorkerDB) ReapVolumeArgsForCall(i int) string {
	fake.reapVolumeMutex.RLock()
	defer fake.reapVolumeMutex.RUnlock()
	return fake.reapVolumeArgsForCall[i].handle
}

func (fake *FakeWorkerDB) ReapVolumeReturns(result1 error) {
	fake.ReapVolumeStub = nil
	fake.reapVolumeReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeWorkerDB) SetVolumeTTL(arg1 string, arg2 time.Duration) error {
	fake.setVolumeTTLMutex.Lock()
	fake.setVolumeTTLArgsForCall = append(fake.setVolumeTTLArgsForCall, struct {
		arg1 string
		arg2 time.Duration
	}{arg1, arg2})
	fake.recordInvocation("SetVolumeTTL", []interface{}{arg1, arg2})
	fake.setVolumeTTLMutex.Unlock()
	if fake.SetVolumeTTLStub != nil {
		return fake.SetVolumeTTLStub(arg1, arg2)
	} else {
		return fake.setVolumeTTLReturns.result1
	}
}

func (fake *FakeWorkerDB) SetVolumeTTLCallCount() int {
	fake.setVolumeTTLMutex.RLock()
	defer fake.setVolumeTTLMutex.RUnlock()
	return len(fake.setVolumeTTLArgsForCall)
}

func (fake *FakeWorkerDB) SetVolumeTTLArgsForCall(i int) (string, time.Duration) {
	fake.setVolumeTTLMutex.RLock()
	defer fake.setVolumeTTLMutex.RUnlock()
	return fake.setVolumeTTLArgsForCall[i].arg1, fake.setVolumeTTLArgsForCall[i].arg2
}

func (fake *FakeWorkerDB) SetVolumeTTLReturns(result1 error) {
	fake.SetVolumeTTLStub = nil
	fake.setVolumeTTLReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeWorkerDB) SetVolumeSizeInBytes(arg1 string, arg2 int64) error {
	fake.setVolumeSizeInBytesMutex.Lock()
	fake.setVolumeSizeInBytesArgsForCall = append(fake.setVolumeSizeInBytesArgsForCall, struct {
		arg1 string
		arg2 int64
	}{arg1, arg2})
	fake.recordInvocation("SetVolumeSizeInBytes", []interface{}{arg1, arg2})
	fake.setVolumeSizeInBytesMutex.Unlock()
	if fake.SetVolumeSizeInBytesStub != nil {
		return fake.SetVolumeSizeInBytesStub(arg1, arg2)
	} else {
		return fake.setVolumeSizeInBytesReturns.result1
	}
}

func (fake *FakeWorkerDB) SetVolumeSizeInBytesCallCount() int {
	fake.setVolumeSizeInBytesMutex.RLock()
	defer fake.setVolumeSizeInBytesMutex.RUnlock()
	return len(fake.setVolumeSizeInBytesArgsForCall)
}

func (fake *FakeWorkerDB) SetVolumeSizeInBytesArgsForCall(i int) (string, int64) {
	fake.setVolumeSizeInBytesMutex.RLock()
	defer fake.setVolumeSizeInBytesMutex.RUnlock()
	return fake.setVolumeSizeInBytesArgsForCall[i].arg1, fake.setVolumeSizeInBytesArgsForCall[i].arg2
}

func (fake *FakeWorkerDB) SetVolumeSizeInBytesReturns(result1 error) {
	fake.SetVolumeSizeInBytesStub = nil
	fake.setVolumeSizeInBytesReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeWorkerDB) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.workersMutex.RLock()
	defer fake.workersMutex.RUnlock()
	fake.getWorkerMutex.RLock()
	defer fake.getWorkerMutex.RUnlock()
	fake.createContainerMutex.RLock()
	defer fake.createContainerMutex.RUnlock()
	fake.getContainerMutex.RLock()
	defer fake.getContainerMutex.RUnlock()
	fake.findContainerByIdentifierMutex.RLock()
	defer fake.findContainerByIdentifierMutex.RUnlock()
	fake.findWorkerCheckResourceTypeVersionMutex.RLock()
	defer fake.findWorkerCheckResourceTypeVersionMutex.RUnlock()
	fake.updateExpiresAtOnContainerMutex.RLock()
	defer fake.updateExpiresAtOnContainerMutex.RUnlock()
	fake.reapContainerMutex.RLock()
	defer fake.reapContainerMutex.RUnlock()
	fake.insertVolumeMutex.RLock()
	defer fake.insertVolumeMutex.RUnlock()
	fake.getVolumesByIdentifierMutex.RLock()
	defer fake.getVolumesByIdentifierMutex.RUnlock()
	fake.getVolumeTTLMutex.RLock()
	defer fake.getVolumeTTLMutex.RUnlock()
	fake.reapVolumeMutex.RLock()
	defer fake.reapVolumeMutex.RUnlock()
	fake.setVolumeTTLMutex.RLock()
	defer fake.setVolumeTTLMutex.RUnlock()
	fake.setVolumeSizeInBytesMutex.RLock()
	defer fake.setVolumeSizeInBytesMutex.RUnlock()
	return fake.invocations
}

func (fake *FakeWorkerDB) 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 _ worker.WorkerDB = new(FakeWorkerDB)