fake_garden_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 FakeGardenWorkerDB struct {
	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(handle string) (db.SavedContainer, bool, error)
	getContainerMutex       sync.RWMutex
	getContainerArgsForCall []struct {
		handle string
	}
	getContainerReturns struct {
		result1 db.SavedContainer
		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(string) error
	reapContainerMutex       sync.RWMutex
	reapContainerArgsForCall []struct {
		arg1 string
	}
	reapContainerReturns struct {
		result1 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
	}
	InsertVolumeStub        func(db.Volume) error
	insertVolumeMutex       sync.RWMutex
	insertVolumeArgsForCall []struct {
		arg1 db.Volume
	}
	insertVolumeReturns struct {
		result1 error
	}
	SetVolumeTTLStub        func(string, time.Duration) error
	setVolumeTTLMutex       sync.RWMutex
	setVolumeTTLArgsForCall []struct {
		arg1 string
		arg2 time.Duration
	}
	setVolumeTTLReturns struct {
		result1 error
	}
	GetVolumeTTLStub        func(string) (time.Duration, bool, error)
	getVolumeTTLMutex       sync.RWMutex
	getVolumeTTLArgsForCall []struct {
		arg1 string
	}
	getVolumeTTLReturns struct {
		result1 time.Duration
		result2 bool
		result3 error
	}
	GetVolumesByIdentifierStub        func(db.VolumeIdentifier) ([]db.SavedVolume, error)
	getVolumesByIdentifierMutex       sync.RWMutex
	getVolumesByIdentifierArgsForCall []struct {
		arg1 db.VolumeIdentifier
	}
	getVolumesByIdentifierReturns struct {
		result1 []db.SavedVolume
		result2 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeGardenWorkerDB) 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 *FakeGardenWorkerDB) CreateContainerCallCount() int {
	fake.createContainerMutex.RLock()
	defer fake.createContainerMutex.RUnlock()
	return len(fake.createContainerArgsForCall)
}

func (fake *FakeGardenWorkerDB) 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 *FakeGardenWorkerDB) CreateContainerReturns(result1 db.SavedContainer, result2 error) {
	fake.CreateContainerStub = nil
	fake.createContainerReturns = struct {
		result1 db.SavedContainer
		result2 error
	}{result1, result2}
}

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

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

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

func (fake *FakeGardenWorkerDB) 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 *FakeGardenWorkerDB) 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 *FakeGardenWorkerDB) UpdateExpiresAtOnContainerCallCount() int {
	fake.updateExpiresAtOnContainerMutex.RLock()
	defer fake.updateExpiresAtOnContainerMutex.RUnlock()
	return len(fake.updateExpiresAtOnContainerArgsForCall)
}

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

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

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

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

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

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

func (fake *FakeGardenWorkerDB) 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 *FakeGardenWorkerDB) FindWorkerCheckResourceTypeVersionCallCount() int {
	fake.findWorkerCheckResourceTypeVersionMutex.RLock()
	defer fake.findWorkerCheckResourceTypeVersionMutex.RUnlock()
	return len(fake.findWorkerCheckResourceTypeVersionArgsForCall)
}

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

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

func (fake *FakeGardenWorkerDB) 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 *FakeGardenWorkerDB) InsertVolumeCallCount() int {
	fake.insertVolumeMutex.RLock()
	defer fake.insertVolumeMutex.RUnlock()
	return len(fake.insertVolumeArgsForCall)
}

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

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

func (fake *FakeGardenWorkerDB) 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 *FakeGardenWorkerDB) SetVolumeTTLCallCount() int {
	fake.setVolumeTTLMutex.RLock()
	defer fake.setVolumeTTLMutex.RUnlock()
	return len(fake.setVolumeTTLArgsForCall)
}

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

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

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

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

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

func (fake *FakeGardenWorkerDB) 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 *FakeGardenWorkerDB) 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 *FakeGardenWorkerDB) GetVolumesByIdentifierCallCount() int {
	fake.getVolumesByIdentifierMutex.RLock()
	defer fake.getVolumesByIdentifierMutex.RUnlock()
	return len(fake.getVolumesByIdentifierArgsForCall)
}

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

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

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

func (fake *FakeGardenWorkerDB) 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.GardenWorkerDB = new(FakeGardenWorkerDB)