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

import (
	"sync"

	"github.com/ehsaniara/joblet/internal/joblet/domain"
	"github.com/ehsaniara/joblet/internal/joblet/interfaces"
)

type FakeVolumeStore struct {
	CreateVolumeStub        func(*domain.Volume) error
	createVolumeMutex       sync.RWMutex
	createVolumeArgsForCall []struct {
		arg1 *domain.Volume
	}
	createVolumeReturns struct {
		result1 error
	}
	createVolumeReturnsOnCall map[int]struct {
		result1 error
	}
	DecrementJobCountStub        func(string) error
	decrementJobCountMutex       sync.RWMutex
	decrementJobCountArgsForCall []struct {
		arg1 string
	}
	decrementJobCountReturns struct {
		result1 error
	}
	decrementJobCountReturnsOnCall map[int]struct {
		result1 error
	}
	GetVolumeStub        func(string) (*domain.Volume, bool)
	getVolumeMutex       sync.RWMutex
	getVolumeArgsForCall []struct {
		arg1 string
	}
	getVolumeReturns struct {
		result1 *domain.Volume
		result2 bool
	}
	getVolumeReturnsOnCall map[int]struct {
		result1 *domain.Volume
		result2 bool
	}
	IncrementJobCountStub        func(string) error
	incrementJobCountMutex       sync.RWMutex
	incrementJobCountArgsForCall []struct {
		arg1 string
	}
	incrementJobCountReturns struct {
		result1 error
	}
	incrementJobCountReturnsOnCall map[int]struct {
		result1 error
	}
	ListVolumesStub        func() []*domain.Volume
	listVolumesMutex       sync.RWMutex
	listVolumesArgsForCall []struct {
	}
	listVolumesReturns struct {
		result1 []*domain.Volume
	}
	listVolumesReturnsOnCall map[int]struct {
		result1 []*domain.Volume
	}
	RemoveVolumeStub        func(string) error
	removeVolumeMutex       sync.RWMutex
	removeVolumeArgsForCall []struct {
		arg1 string
	}
	removeVolumeReturns struct {
		result1 error
	}
	removeVolumeReturnsOnCall map[int]struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeVolumeStore) CreateVolume(arg1 *domain.Volume) error {
	fake.createVolumeMutex.Lock()
	ret, specificReturn := fake.createVolumeReturnsOnCall[len(fake.createVolumeArgsForCall)]
	fake.createVolumeArgsForCall = append(fake.createVolumeArgsForCall, struct {
		arg1 *domain.Volume
	}{arg1})
	stub := fake.CreateVolumeStub
	fakeReturns := fake.createVolumeReturns
	fake.recordInvocation("CreateVolume", []interface{}{arg1})
	fake.createVolumeMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

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

func (fake *FakeVolumeStore) CreateVolumeCalls(stub func(*domain.Volume) error) {
	fake.createVolumeMutex.Lock()
	defer fake.createVolumeMutex.Unlock()
	fake.CreateVolumeStub = stub
}

func (fake *FakeVolumeStore) CreateVolumeArgsForCall(i int) *domain.Volume {
	fake.createVolumeMutex.RLock()
	defer fake.createVolumeMutex.RUnlock()
	argsForCall := fake.createVolumeArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeVolumeStore) CreateVolumeReturns(result1 error) {
	fake.createVolumeMutex.Lock()
	defer fake.createVolumeMutex.Unlock()
	fake.CreateVolumeStub = nil
	fake.createVolumeReturns = struct {
		result1 error
	}{result1}
}

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

func (fake *FakeVolumeStore) DecrementJobCount(arg1 string) error {
	fake.decrementJobCountMutex.Lock()
	ret, specificReturn := fake.decrementJobCountReturnsOnCall[len(fake.decrementJobCountArgsForCall)]
	fake.decrementJobCountArgsForCall = append(fake.decrementJobCountArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DecrementJobCountStub
	fakeReturns := fake.decrementJobCountReturns
	fake.recordInvocation("DecrementJobCount", []interface{}{arg1})
	fake.decrementJobCountMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeVolumeStore) DecrementJobCountCallCount() int {
	fake.decrementJobCountMutex.RLock()
	defer fake.decrementJobCountMutex.RUnlock()
	return len(fake.decrementJobCountArgsForCall)
}

func (fake *FakeVolumeStore) DecrementJobCountCalls(stub func(string) error) {
	fake.decrementJobCountMutex.Lock()
	defer fake.decrementJobCountMutex.Unlock()
	fake.DecrementJobCountStub = stub
}

func (fake *FakeVolumeStore) DecrementJobCountArgsForCall(i int) string {
	fake.decrementJobCountMutex.RLock()
	defer fake.decrementJobCountMutex.RUnlock()
	argsForCall := fake.decrementJobCountArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeVolumeStore) DecrementJobCountReturns(result1 error) {
	fake.decrementJobCountMutex.Lock()
	defer fake.decrementJobCountMutex.Unlock()
	fake.DecrementJobCountStub = nil
	fake.decrementJobCountReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeVolumeStore) DecrementJobCountReturnsOnCall(i int, result1 error) {
	fake.decrementJobCountMutex.Lock()
	defer fake.decrementJobCountMutex.Unlock()
	fake.DecrementJobCountStub = nil
	if fake.decrementJobCountReturnsOnCall == nil {
		fake.decrementJobCountReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.decrementJobCountReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeVolumeStore) GetVolume(arg1 string) (*domain.Volume, bool) {
	fake.getVolumeMutex.Lock()
	ret, specificReturn := fake.getVolumeReturnsOnCall[len(fake.getVolumeArgsForCall)]
	fake.getVolumeArgsForCall = append(fake.getVolumeArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetVolumeStub
	fakeReturns := fake.getVolumeReturns
	fake.recordInvocation("GetVolume", []interface{}{arg1})
	fake.getVolumeMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeVolumeStore) GetVolumeCallCount() int {
	fake.getVolumeMutex.RLock()
	defer fake.getVolumeMutex.RUnlock()
	return len(fake.getVolumeArgsForCall)
}

func (fake *FakeVolumeStore) GetVolumeCalls(stub func(string) (*domain.Volume, bool)) {
	fake.getVolumeMutex.Lock()
	defer fake.getVolumeMutex.Unlock()
	fake.GetVolumeStub = stub
}

func (fake *FakeVolumeStore) GetVolumeArgsForCall(i int) string {
	fake.getVolumeMutex.RLock()
	defer fake.getVolumeMutex.RUnlock()
	argsForCall := fake.getVolumeArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeVolumeStore) GetVolumeReturns(result1 *domain.Volume, result2 bool) {
	fake.getVolumeMutex.Lock()
	defer fake.getVolumeMutex.Unlock()
	fake.GetVolumeStub = nil
	fake.getVolumeReturns = struct {
		result1 *domain.Volume
		result2 bool
	}{result1, result2}
}

func (fake *FakeVolumeStore) GetVolumeReturnsOnCall(i int, result1 *domain.Volume, result2 bool) {
	fake.getVolumeMutex.Lock()
	defer fake.getVolumeMutex.Unlock()
	fake.GetVolumeStub = nil
	if fake.getVolumeReturnsOnCall == nil {
		fake.getVolumeReturnsOnCall = make(map[int]struct {
			result1 *domain.Volume
			result2 bool
		})
	}
	fake.getVolumeReturnsOnCall[i] = struct {
		result1 *domain.Volume
		result2 bool
	}{result1, result2}
}

func (fake *FakeVolumeStore) IncrementJobCount(arg1 string) error {
	fake.incrementJobCountMutex.Lock()
	ret, specificReturn := fake.incrementJobCountReturnsOnCall[len(fake.incrementJobCountArgsForCall)]
	fake.incrementJobCountArgsForCall = append(fake.incrementJobCountArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.IncrementJobCountStub
	fakeReturns := fake.incrementJobCountReturns
	fake.recordInvocation("IncrementJobCount", []interface{}{arg1})
	fake.incrementJobCountMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeVolumeStore) IncrementJobCountCallCount() int {
	fake.incrementJobCountMutex.RLock()
	defer fake.incrementJobCountMutex.RUnlock()
	return len(fake.incrementJobCountArgsForCall)
}

func (fake *FakeVolumeStore) IncrementJobCountCalls(stub func(string) error) {
	fake.incrementJobCountMutex.Lock()
	defer fake.incrementJobCountMutex.Unlock()
	fake.IncrementJobCountStub = stub
}

func (fake *FakeVolumeStore) IncrementJobCountArgsForCall(i int) string {
	fake.incrementJobCountMutex.RLock()
	defer fake.incrementJobCountMutex.RUnlock()
	argsForCall := fake.incrementJobCountArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeVolumeStore) IncrementJobCountReturns(result1 error) {
	fake.incrementJobCountMutex.Lock()
	defer fake.incrementJobCountMutex.Unlock()
	fake.IncrementJobCountStub = nil
	fake.incrementJobCountReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeVolumeStore) IncrementJobCountReturnsOnCall(i int, result1 error) {
	fake.incrementJobCountMutex.Lock()
	defer fake.incrementJobCountMutex.Unlock()
	fake.IncrementJobCountStub = nil
	if fake.incrementJobCountReturnsOnCall == nil {
		fake.incrementJobCountReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.incrementJobCountReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeVolumeStore) ListVolumes() []*domain.Volume {
	fake.listVolumesMutex.Lock()
	ret, specificReturn := fake.listVolumesReturnsOnCall[len(fake.listVolumesArgsForCall)]
	fake.listVolumesArgsForCall = append(fake.listVolumesArgsForCall, struct {
	}{})
	stub := fake.ListVolumesStub
	fakeReturns := fake.listVolumesReturns
	fake.recordInvocation("ListVolumes", []interface{}{})
	fake.listVolumesMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeVolumeStore) ListVolumesCallCount() int {
	fake.listVolumesMutex.RLock()
	defer fake.listVolumesMutex.RUnlock()
	return len(fake.listVolumesArgsForCall)
}

func (fake *FakeVolumeStore) ListVolumesCalls(stub func() []*domain.Volume) {
	fake.listVolumesMutex.Lock()
	defer fake.listVolumesMutex.Unlock()
	fake.ListVolumesStub = stub
}

func (fake *FakeVolumeStore) ListVolumesReturns(result1 []*domain.Volume) {
	fake.listVolumesMutex.Lock()
	defer fake.listVolumesMutex.Unlock()
	fake.ListVolumesStub = nil
	fake.listVolumesReturns = struct {
		result1 []*domain.Volume
	}{result1}
}

func (fake *FakeVolumeStore) ListVolumesReturnsOnCall(i int, result1 []*domain.Volume) {
	fake.listVolumesMutex.Lock()
	defer fake.listVolumesMutex.Unlock()
	fake.ListVolumesStub = nil
	if fake.listVolumesReturnsOnCall == nil {
		fake.listVolumesReturnsOnCall = make(map[int]struct {
			result1 []*domain.Volume
		})
	}
	fake.listVolumesReturnsOnCall[i] = struct {
		result1 []*domain.Volume
	}{result1}
}

func (fake *FakeVolumeStore) RemoveVolume(arg1 string) error {
	fake.removeVolumeMutex.Lock()
	ret, specificReturn := fake.removeVolumeReturnsOnCall[len(fake.removeVolumeArgsForCall)]
	fake.removeVolumeArgsForCall = append(fake.removeVolumeArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.RemoveVolumeStub
	fakeReturns := fake.removeVolumeReturns
	fake.recordInvocation("RemoveVolume", []interface{}{arg1})
	fake.removeVolumeMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeVolumeStore) RemoveVolumeCallCount() int {
	fake.removeVolumeMutex.RLock()
	defer fake.removeVolumeMutex.RUnlock()
	return len(fake.removeVolumeArgsForCall)
}

func (fake *FakeVolumeStore) RemoveVolumeCalls(stub func(string) error) {
	fake.removeVolumeMutex.Lock()
	defer fake.removeVolumeMutex.Unlock()
	fake.RemoveVolumeStub = stub
}

func (fake *FakeVolumeStore) RemoveVolumeArgsForCall(i int) string {
	fake.removeVolumeMutex.RLock()
	defer fake.removeVolumeMutex.RUnlock()
	argsForCall := fake.removeVolumeArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeVolumeStore) RemoveVolumeReturns(result1 error) {
	fake.removeVolumeMutex.Lock()
	defer fake.removeVolumeMutex.Unlock()
	fake.RemoveVolumeStub = nil
	fake.removeVolumeReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeVolumeStore) RemoveVolumeReturnsOnCall(i int, result1 error) {
	fake.removeVolumeMutex.Lock()
	defer fake.removeVolumeMutex.Unlock()
	fake.RemoveVolumeStub = nil
	if fake.removeVolumeReturnsOnCall == nil {
		fake.removeVolumeReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.removeVolumeReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeVolumeStore) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeVolumeStore) 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 _ interfaces.VolumeStore = new(FakeVolumeStore)
