fake_resource_options.go

// This file was generated by counterfeiter
package resourcefakes

import (
	"sync"

	"github.com/concourse/atc"
	"github.com/concourse/atc/resource"
)

type FakeResourceOptions struct {
	IOConfigStub        func() resource.IOConfig
	iOConfigMutex       sync.RWMutex
	iOConfigArgsForCall []struct{}
	iOConfigReturns     struct {
		result1 resource.IOConfig
	}
	iOConfigReturnsOnCall map[int]struct {
		result1 resource.IOConfig
	}
	SourceStub        func() atc.Source
	sourceMutex       sync.RWMutex
	sourceArgsForCall []struct{}
	sourceReturns     struct {
		result1 atc.Source
	}
	sourceReturnsOnCall map[int]struct {
		result1 atc.Source
	}
	ParamsStub        func() atc.Params
	paramsMutex       sync.RWMutex
	paramsArgsForCall []struct{}
	paramsReturns     struct {
		result1 atc.Params
	}
	paramsReturnsOnCall map[int]struct {
		result1 atc.Params
	}
	VersionStub        func() atc.Version
	versionMutex       sync.RWMutex
	versionArgsForCall []struct{}
	versionReturns     struct {
		result1 atc.Version
	}
	versionReturnsOnCall map[int]struct {
		result1 atc.Version
	}
	ResourceTypeStub        func() resource.ResourceType
	resourceTypeMutex       sync.RWMutex
	resourceTypeArgsForCall []struct{}
	resourceTypeReturns     struct {
		result1 resource.ResourceType
	}
	resourceTypeReturnsOnCall map[int]struct {
		result1 resource.ResourceType
	}
	LockNameStub        func(workerName string) (string, error)
	lockNameMutex       sync.RWMutex
	lockNameArgsForCall []struct {
		workerName string
	}
	lockNameReturns struct {
		result1 string
		result2 error
	}
	lockNameReturnsOnCall map[int]struct {
		result1 string
		result2 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeResourceOptions) IOConfig() resource.IOConfig {
	fake.iOConfigMutex.Lock()
	ret, specificReturn := fake.iOConfigReturnsOnCall[len(fake.iOConfigArgsForCall)]
	fake.iOConfigArgsForCall = append(fake.iOConfigArgsForCall, struct{}{})
	fake.recordInvocation("IOConfig", []interface{}{})
	fake.iOConfigMutex.Unlock()
	if fake.IOConfigStub != nil {
		return fake.IOConfigStub()
	}
	if specificReturn {
		return ret.result1
	}
	return fake.iOConfigReturns.result1
}

func (fake *FakeResourceOptions) IOConfigCallCount() int {
	fake.iOConfigMutex.RLock()
	defer fake.iOConfigMutex.RUnlock()
	return len(fake.iOConfigArgsForCall)
}

func (fake *FakeResourceOptions) IOConfigReturns(result1 resource.IOConfig) {
	fake.IOConfigStub = nil
	fake.iOConfigReturns = struct {
		result1 resource.IOConfig
	}{result1}
}

func (fake *FakeResourceOptions) IOConfigReturnsOnCall(i int, result1 resource.IOConfig) {
	fake.IOConfigStub = nil
	if fake.iOConfigReturnsOnCall == nil {
		fake.iOConfigReturnsOnCall = make(map[int]struct {
			result1 resource.IOConfig
		})
	}
	fake.iOConfigReturnsOnCall[i] = struct {
		result1 resource.IOConfig
	}{result1}
}

func (fake *FakeResourceOptions) Source() atc.Source {
	fake.sourceMutex.Lock()
	ret, specificReturn := fake.sourceReturnsOnCall[len(fake.sourceArgsForCall)]
	fake.sourceArgsForCall = append(fake.sourceArgsForCall, struct{}{})
	fake.recordInvocation("Source", []interface{}{})
	fake.sourceMutex.Unlock()
	if fake.SourceStub != nil {
		return fake.SourceStub()
	}
	if specificReturn {
		return ret.result1
	}
	return fake.sourceReturns.result1
}

func (fake *FakeResourceOptions) SourceCallCount() int {
	fake.sourceMutex.RLock()
	defer fake.sourceMutex.RUnlock()
	return len(fake.sourceArgsForCall)
}

func (fake *FakeResourceOptions) SourceReturns(result1 atc.Source) {
	fake.SourceStub = nil
	fake.sourceReturns = struct {
		result1 atc.Source
	}{result1}
}

func (fake *FakeResourceOptions) SourceReturnsOnCall(i int, result1 atc.Source) {
	fake.SourceStub = nil
	if fake.sourceReturnsOnCall == nil {
		fake.sourceReturnsOnCall = make(map[int]struct {
			result1 atc.Source
		})
	}
	fake.sourceReturnsOnCall[i] = struct {
		result1 atc.Source
	}{result1}
}

func (fake *FakeResourceOptions) Params() atc.Params {
	fake.paramsMutex.Lock()
	ret, specificReturn := fake.paramsReturnsOnCall[len(fake.paramsArgsForCall)]
	fake.paramsArgsForCall = append(fake.paramsArgsForCall, struct{}{})
	fake.recordInvocation("Params", []interface{}{})
	fake.paramsMutex.Unlock()
	if fake.ParamsStub != nil {
		return fake.ParamsStub()
	}
	if specificReturn {
		return ret.result1
	}
	return fake.paramsReturns.result1
}

func (fake *FakeResourceOptions) ParamsCallCount() int {
	fake.paramsMutex.RLock()
	defer fake.paramsMutex.RUnlock()
	return len(fake.paramsArgsForCall)
}

func (fake *FakeResourceOptions) ParamsReturns(result1 atc.Params) {
	fake.ParamsStub = nil
	fake.paramsReturns = struct {
		result1 atc.Params
	}{result1}
}

func (fake *FakeResourceOptions) ParamsReturnsOnCall(i int, result1 atc.Params) {
	fake.ParamsStub = nil
	if fake.paramsReturnsOnCall == nil {
		fake.paramsReturnsOnCall = make(map[int]struct {
			result1 atc.Params
		})
	}
	fake.paramsReturnsOnCall[i] = struct {
		result1 atc.Params
	}{result1}
}

func (fake *FakeResourceOptions) Version() atc.Version {
	fake.versionMutex.Lock()
	ret, specificReturn := fake.versionReturnsOnCall[len(fake.versionArgsForCall)]
	fake.versionArgsForCall = append(fake.versionArgsForCall, struct{}{})
	fake.recordInvocation("Version", []interface{}{})
	fake.versionMutex.Unlock()
	if fake.VersionStub != nil {
		return fake.VersionStub()
	}
	if specificReturn {
		return ret.result1
	}
	return fake.versionReturns.result1
}

func (fake *FakeResourceOptions) VersionCallCount() int {
	fake.versionMutex.RLock()
	defer fake.versionMutex.RUnlock()
	return len(fake.versionArgsForCall)
}

func (fake *FakeResourceOptions) VersionReturns(result1 atc.Version) {
	fake.VersionStub = nil
	fake.versionReturns = struct {
		result1 atc.Version
	}{result1}
}

func (fake *FakeResourceOptions) VersionReturnsOnCall(i int, result1 atc.Version) {
	fake.VersionStub = nil
	if fake.versionReturnsOnCall == nil {
		fake.versionReturnsOnCall = make(map[int]struct {
			result1 atc.Version
		})
	}
	fake.versionReturnsOnCall[i] = struct {
		result1 atc.Version
	}{result1}
}

func (fake *FakeResourceOptions) ResourceType() resource.ResourceType {
	fake.resourceTypeMutex.Lock()
	ret, specificReturn := fake.resourceTypeReturnsOnCall[len(fake.resourceTypeArgsForCall)]
	fake.resourceTypeArgsForCall = append(fake.resourceTypeArgsForCall, struct{}{})
	fake.recordInvocation("ResourceType", []interface{}{})
	fake.resourceTypeMutex.Unlock()
	if fake.ResourceTypeStub != nil {
		return fake.ResourceTypeStub()
	}
	if specificReturn {
		return ret.result1
	}
	return fake.resourceTypeReturns.result1
}

func (fake *FakeResourceOptions) ResourceTypeCallCount() int {
	fake.resourceTypeMutex.RLock()
	defer fake.resourceTypeMutex.RUnlock()
	return len(fake.resourceTypeArgsForCall)
}

func (fake *FakeResourceOptions) ResourceTypeReturns(result1 resource.ResourceType) {
	fake.ResourceTypeStub = nil
	fake.resourceTypeReturns = struct {
		result1 resource.ResourceType
	}{result1}
}

func (fake *FakeResourceOptions) ResourceTypeReturnsOnCall(i int, result1 resource.ResourceType) {
	fake.ResourceTypeStub = nil
	if fake.resourceTypeReturnsOnCall == nil {
		fake.resourceTypeReturnsOnCall = make(map[int]struct {
			result1 resource.ResourceType
		})
	}
	fake.resourceTypeReturnsOnCall[i] = struct {
		result1 resource.ResourceType
	}{result1}
}

func (fake *FakeResourceOptions) LockName(workerName string) (string, error) {
	fake.lockNameMutex.Lock()
	ret, specificReturn := fake.lockNameReturnsOnCall[len(fake.lockNameArgsForCall)]
	fake.lockNameArgsForCall = append(fake.lockNameArgsForCall, struct {
		workerName string
	}{workerName})
	fake.recordInvocation("LockName", []interface{}{workerName})
	fake.lockNameMutex.Unlock()
	if fake.LockNameStub != nil {
		return fake.LockNameStub(workerName)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.lockNameReturns.result1, fake.lockNameReturns.result2
}

func (fake *FakeResourceOptions) LockNameCallCount() int {
	fake.lockNameMutex.RLock()
	defer fake.lockNameMutex.RUnlock()
	return len(fake.lockNameArgsForCall)
}

func (fake *FakeResourceOptions) LockNameArgsForCall(i int) string {
	fake.lockNameMutex.RLock()
	defer fake.lockNameMutex.RUnlock()
	return fake.lockNameArgsForCall[i].workerName
}

func (fake *FakeResourceOptions) LockNameReturns(result1 string, result2 error) {
	fake.LockNameStub = nil
	fake.lockNameReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeResourceOptions) LockNameReturnsOnCall(i int, result1 string, result2 error) {
	fake.LockNameStub = nil
	if fake.lockNameReturnsOnCall == nil {
		fake.lockNameReturnsOnCall = make(map[int]struct {
			result1 string
			result2 error
		})
	}
	fake.lockNameReturnsOnCall[i] = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeResourceOptions) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.iOConfigMutex.RLock()
	defer fake.iOConfigMutex.RUnlock()
	fake.sourceMutex.RLock()
	defer fake.sourceMutex.RUnlock()
	fake.paramsMutex.RLock()
	defer fake.paramsMutex.RUnlock()
	fake.versionMutex.RLock()
	defer fake.versionMutex.RUnlock()
	fake.resourceTypeMutex.RLock()
	defer fake.resourceTypeMutex.RUnlock()
	fake.lockNameMutex.RLock()
	defer fake.lockNameMutex.RUnlock()
	return fake.invocations
}

func (fake *FakeResourceOptions) 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 _ resource.ResourceOptions = new(FakeResourceOptions)