concourse/atc/db/dbfakes/fake_resource.go

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

import (
	"sync"
	"time"

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

type FakeResource struct {
	APIPinnedVersionStub        func() atc.Version
	aPIPinnedVersionMutex       sync.RWMutex
	aPIPinnedVersionArgsForCall []struct {
	}
	aPIPinnedVersionReturns struct {
		result1 atc.Version
	}
	aPIPinnedVersionReturnsOnCall map[int]struct {
		result1 atc.Version
	}
	CheckErrorStub        func() error
	checkErrorMutex       sync.RWMutex
	checkErrorArgsForCall []struct {
	}
	checkErrorReturns struct {
		result1 error
	}
	checkErrorReturnsOnCall map[int]struct {
		result1 error
	}
	CheckEveryStub        func() string
	checkEveryMutex       sync.RWMutex
	checkEveryArgsForCall []struct {
	}
	checkEveryReturns struct {
		result1 string
	}
	checkEveryReturnsOnCall map[int]struct {
		result1 string
	}
	CheckSetupErrorStub        func() error
	checkSetupErrorMutex       sync.RWMutex
	checkSetupErrorArgsForCall []struct {
	}
	checkSetupErrorReturns struct {
		result1 error
	}
	checkSetupErrorReturnsOnCall map[int]struct {
		result1 error
	}
	CheckTimeoutStub        func() string
	checkTimeoutMutex       sync.RWMutex
	checkTimeoutArgsForCall []struct {
	}
	checkTimeoutReturns struct {
		result1 string
	}
	checkTimeoutReturnsOnCall map[int]struct {
		result1 string
	}
	ConfigPinnedVersionStub        func() atc.Version
	configPinnedVersionMutex       sync.RWMutex
	configPinnedVersionArgsForCall []struct {
	}
	configPinnedVersionReturns struct {
		result1 atc.Version
	}
	configPinnedVersionReturnsOnCall map[int]struct {
		result1 atc.Version
	}
	CurrentPinnedVersionStub        func() atc.Version
	currentPinnedVersionMutex       sync.RWMutex
	currentPinnedVersionArgsForCall []struct {
	}
	currentPinnedVersionReturns struct {
		result1 atc.Version
	}
	currentPinnedVersionReturnsOnCall map[int]struct {
		result1 atc.Version
	}
	DisableVersionStub        func(int) error
	disableVersionMutex       sync.RWMutex
	disableVersionArgsForCall []struct {
		arg1 int
	}
	disableVersionReturns struct {
		result1 error
	}
	disableVersionReturnsOnCall map[int]struct {
		result1 error
	}
	EnableVersionStub        func(int) error
	enableVersionMutex       sync.RWMutex
	enableVersionArgsForCall []struct {
		arg1 int
	}
	enableVersionReturns struct {
		result1 error
	}
	enableVersionReturnsOnCall map[int]struct {
		result1 error
	}
	IDStub        func() int
	iDMutex       sync.RWMutex
	iDArgsForCall []struct {
	}
	iDReturns struct {
		result1 int
	}
	iDReturnsOnCall map[int]struct {
		result1 int
	}
	IconStub        func() string
	iconMutex       sync.RWMutex
	iconArgsForCall []struct {
	}
	iconReturns struct {
		result1 string
	}
	iconReturnsOnCall map[int]struct {
		result1 string
	}
	LastCheckEndTimeStub        func() time.Time
	lastCheckEndTimeMutex       sync.RWMutex
	lastCheckEndTimeArgsForCall []struct {
	}
	lastCheckEndTimeReturns struct {
		result1 time.Time
	}
	lastCheckEndTimeReturnsOnCall map[int]struct {
		result1 time.Time
	}
	LastCheckStartTimeStub        func() time.Time
	lastCheckStartTimeMutex       sync.RWMutex
	lastCheckStartTimeArgsForCall []struct {
	}
	lastCheckStartTimeReturns struct {
		result1 time.Time
	}
	lastCheckStartTimeReturnsOnCall map[int]struct {
		result1 time.Time
	}
	NameStub        func() string
	nameMutex       sync.RWMutex
	nameArgsForCall []struct {
	}
	nameReturns struct {
		result1 string
	}
	nameReturnsOnCall map[int]struct {
		result1 string
	}
	NotifyScanStub        func() error
	notifyScanMutex       sync.RWMutex
	notifyScanArgsForCall []struct {
	}
	notifyScanReturns struct {
		result1 error
	}
	notifyScanReturnsOnCall map[int]struct {
		result1 error
	}
	PinCommentStub        func() string
	pinCommentMutex       sync.RWMutex
	pinCommentArgsForCall []struct {
	}
	pinCommentReturns struct {
		result1 string
	}
	pinCommentReturnsOnCall map[int]struct {
		result1 string
	}
	PinVersionStub        func(int) error
	pinVersionMutex       sync.RWMutex
	pinVersionArgsForCall []struct {
		arg1 int
	}
	pinVersionReturns struct {
		result1 error
	}
	pinVersionReturnsOnCall map[int]struct {
		result1 error
	}
	PipelineIDStub        func() int
	pipelineIDMutex       sync.RWMutex
	pipelineIDArgsForCall []struct {
	}
	pipelineIDReturns struct {
		result1 int
	}
	pipelineIDReturnsOnCall map[int]struct {
		result1 int
	}
	PipelineNameStub        func() string
	pipelineNameMutex       sync.RWMutex
	pipelineNameArgsForCall []struct {
	}
	pipelineNameReturns struct {
		result1 string
	}
	pipelineNameReturnsOnCall map[int]struct {
		result1 string
	}
	PublicStub        func() bool
	publicMutex       sync.RWMutex
	publicArgsForCall []struct {
	}
	publicReturns struct {
		result1 bool
	}
	publicReturnsOnCall map[int]struct {
		result1 bool
	}
	ReloadStub        func() (bool, error)
	reloadMutex       sync.RWMutex
	reloadArgsForCall []struct {
	}
	reloadReturns struct {
		result1 bool
		result2 error
	}
	reloadReturnsOnCall map[int]struct {
		result1 bool
		result2 error
	}
	ResourceConfigIDStub        func() int
	resourceConfigIDMutex       sync.RWMutex
	resourceConfigIDArgsForCall []struct {
	}
	resourceConfigIDReturns struct {
		result1 int
	}
	resourceConfigIDReturnsOnCall map[int]struct {
		result1 int
	}
	ResourceConfigScopeIDStub        func() int
	resourceConfigScopeIDMutex       sync.RWMutex
	resourceConfigScopeIDArgsForCall []struct {
	}
	resourceConfigScopeIDReturns struct {
		result1 int
	}
	resourceConfigScopeIDReturnsOnCall map[int]struct {
		result1 int
	}
	ResourceConfigVersionIDStub        func(atc.Version) (int, bool, error)
	resourceConfigVersionIDMutex       sync.RWMutex
	resourceConfigVersionIDArgsForCall []struct {
		arg1 atc.Version
	}
	resourceConfigVersionIDReturns struct {
		result1 int
		result2 bool
		result3 error
	}
	resourceConfigVersionIDReturnsOnCall map[int]struct {
		result1 int
		result2 bool
		result3 error
	}
	SaveUncheckedVersionStub        func(atc.Version, db.ResourceConfigMetadataFields, db.ResourceConfig, atc.VersionedResourceTypes) (bool, error)
	saveUncheckedVersionMutex       sync.RWMutex
	saveUncheckedVersionArgsForCall []struct {
		arg1 atc.Version
		arg2 db.ResourceConfigMetadataFields
		arg3 db.ResourceConfig
		arg4 atc.VersionedResourceTypes
	}
	saveUncheckedVersionReturns struct {
		result1 bool
		result2 error
	}
	saveUncheckedVersionReturnsOnCall map[int]struct {
		result1 bool
		result2 error
	}
	SetCheckSetupErrorStub        func(error) error
	setCheckSetupErrorMutex       sync.RWMutex
	setCheckSetupErrorArgsForCall []struct {
		arg1 error
	}
	setCheckSetupErrorReturns struct {
		result1 error
	}
	setCheckSetupErrorReturnsOnCall map[int]struct {
		result1 error
	}
	SetPinCommentStub        func(string) error
	setPinCommentMutex       sync.RWMutex
	setPinCommentArgsForCall []struct {
		arg1 string
	}
	setPinCommentReturns struct {
		result1 error
	}
	setPinCommentReturnsOnCall map[int]struct {
		result1 error
	}
	SetResourceConfigStub        func(atc.Source, atc.VersionedResourceTypes) (db.ResourceConfigScope, error)
	setResourceConfigMutex       sync.RWMutex
	setResourceConfigArgsForCall []struct {
		arg1 atc.Source
		arg2 atc.VersionedResourceTypes
	}
	setResourceConfigReturns struct {
		result1 db.ResourceConfigScope
		result2 error
	}
	setResourceConfigReturnsOnCall map[int]struct {
		result1 db.ResourceConfigScope
		result2 error
	}
	SourceStub        func() atc.Source
	sourceMutex       sync.RWMutex
	sourceArgsForCall []struct {
	}
	sourceReturns struct {
		result1 atc.Source
	}
	sourceReturnsOnCall map[int]struct {
		result1 atc.Source
	}
	TagsStub        func() atc.Tags
	tagsMutex       sync.RWMutex
	tagsArgsForCall []struct {
	}
	tagsReturns struct {
		result1 atc.Tags
	}
	tagsReturnsOnCall map[int]struct {
		result1 atc.Tags
	}
	TeamNameStub        func() string
	teamNameMutex       sync.RWMutex
	teamNameArgsForCall []struct {
	}
	teamNameReturns struct {
		result1 string
	}
	teamNameReturnsOnCall map[int]struct {
		result1 string
	}
	TypeStub        func() string
	typeMutex       sync.RWMutex
	typeArgsForCall []struct {
	}
	typeReturns struct {
		result1 string
	}
	typeReturnsOnCall map[int]struct {
		result1 string
	}
	UnpinVersionStub        func() error
	unpinVersionMutex       sync.RWMutex
	unpinVersionArgsForCall []struct {
	}
	unpinVersionReturns struct {
		result1 error
	}
	unpinVersionReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateMetadataStub        func(atc.Version, db.ResourceConfigMetadataFields) (bool, error)
	updateMetadataMutex       sync.RWMutex
	updateMetadataArgsForCall []struct {
		arg1 atc.Version
		arg2 db.ResourceConfigMetadataFields
	}
	updateMetadataReturns struct {
		result1 bool
		result2 error
	}
	updateMetadataReturnsOnCall map[int]struct {
		result1 bool
		result2 error
	}
	VersionsStub        func(db.Page) ([]atc.ResourceVersion, db.Pagination, bool, error)
	versionsMutex       sync.RWMutex
	versionsArgsForCall []struct {
		arg1 db.Page
	}
	versionsReturns struct {
		result1 []atc.ResourceVersion
		result2 db.Pagination
		result3 bool
		result4 error
	}
	versionsReturnsOnCall map[int]struct {
		result1 []atc.ResourceVersion
		result2 db.Pagination
		result3 bool
		result4 error
	}
	WebhookTokenStub        func() string
	webhookTokenMutex       sync.RWMutex
	webhookTokenArgsForCall []struct {
	}
	webhookTokenReturns struct {
		result1 string
	}
	webhookTokenReturnsOnCall map[int]struct {
		result1 string
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeResource) APIPinnedVersion() atc.Version {
	fake.aPIPinnedVersionMutex.Lock()
	ret, specificReturn := fake.aPIPinnedVersionReturnsOnCall[len(fake.aPIPinnedVersionArgsForCall)]
	fake.aPIPinnedVersionArgsForCall = append(fake.aPIPinnedVersionArgsForCall, struct {
	}{})
	fake.recordInvocation("APIPinnedVersion", []interface{}{})
	fake.aPIPinnedVersionMutex.Unlock()
	if fake.APIPinnedVersionStub != nil {
		return fake.APIPinnedVersionStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.aPIPinnedVersionReturns
	return fakeReturns.result1
}

func (fake *FakeResource) APIPinnedVersionCallCount() int {
	fake.aPIPinnedVersionMutex.RLock()
	defer fake.aPIPinnedVersionMutex.RUnlock()
	return len(fake.aPIPinnedVersionArgsForCall)
}

func (fake *FakeResource) APIPinnedVersionCalls(stub func() atc.Version) {
	fake.aPIPinnedVersionMutex.Lock()
	defer fake.aPIPinnedVersionMutex.Unlock()
	fake.APIPinnedVersionStub = stub
}

func (fake *FakeResource) APIPinnedVersionReturns(result1 atc.Version) {
	fake.aPIPinnedVersionMutex.Lock()
	defer fake.aPIPinnedVersionMutex.Unlock()
	fake.APIPinnedVersionStub = nil
	fake.aPIPinnedVersionReturns = struct {
		result1 atc.Version
	}{result1}
}

func (fake *FakeResource) APIPinnedVersionReturnsOnCall(i int, result1 atc.Version) {
	fake.aPIPinnedVersionMutex.Lock()
	defer fake.aPIPinnedVersionMutex.Unlock()
	fake.APIPinnedVersionStub = nil
	if fake.aPIPinnedVersionReturnsOnCall == nil {
		fake.aPIPinnedVersionReturnsOnCall = make(map[int]struct {
			result1 atc.Version
		})
	}
	fake.aPIPinnedVersionReturnsOnCall[i] = struct {
		result1 atc.Version
	}{result1}
}

func (fake *FakeResource) CheckError() error {
	fake.checkErrorMutex.Lock()
	ret, specificReturn := fake.checkErrorReturnsOnCall[len(fake.checkErrorArgsForCall)]
	fake.checkErrorArgsForCall = append(fake.checkErrorArgsForCall, struct {
	}{})
	fake.recordInvocation("CheckError", []interface{}{})
	fake.checkErrorMutex.Unlock()
	if fake.CheckErrorStub != nil {
		return fake.CheckErrorStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.checkErrorReturns
	return fakeReturns.result1
}

func (fake *FakeResource) CheckErrorCallCount() int {
	fake.checkErrorMutex.RLock()
	defer fake.checkErrorMutex.RUnlock()
	return len(fake.checkErrorArgsForCall)
}

func (fake *FakeResource) CheckErrorCalls(stub func() error) {
	fake.checkErrorMutex.Lock()
	defer fake.checkErrorMutex.Unlock()
	fake.CheckErrorStub = stub
}

func (fake *FakeResource) CheckErrorReturns(result1 error) {
	fake.checkErrorMutex.Lock()
	defer fake.checkErrorMutex.Unlock()
	fake.CheckErrorStub = nil
	fake.checkErrorReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeResource) CheckErrorReturnsOnCall(i int, result1 error) {
	fake.checkErrorMutex.Lock()
	defer fake.checkErrorMutex.Unlock()
	fake.CheckErrorStub = nil
	if fake.checkErrorReturnsOnCall == nil {
		fake.checkErrorReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.checkErrorReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeResource) CheckEvery() string {
	fake.checkEveryMutex.Lock()
	ret, specificReturn := fake.checkEveryReturnsOnCall[len(fake.checkEveryArgsForCall)]
	fake.checkEveryArgsForCall = append(fake.checkEveryArgsForCall, struct {
	}{})
	fake.recordInvocation("CheckEvery", []interface{}{})
	fake.checkEveryMutex.Unlock()
	if fake.CheckEveryStub != nil {
		return fake.CheckEveryStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.checkEveryReturns
	return fakeReturns.result1
}

func (fake *FakeResource) CheckEveryCallCount() int {
	fake.checkEveryMutex.RLock()
	defer fake.checkEveryMutex.RUnlock()
	return len(fake.checkEveryArgsForCall)
}

func (fake *FakeResource) CheckEveryCalls(stub func() string) {
	fake.checkEveryMutex.Lock()
	defer fake.checkEveryMutex.Unlock()
	fake.CheckEveryStub = stub
}

func (fake *FakeResource) CheckEveryReturns(result1 string) {
	fake.checkEveryMutex.Lock()
	defer fake.checkEveryMutex.Unlock()
	fake.CheckEveryStub = nil
	fake.checkEveryReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeResource) CheckEveryReturnsOnCall(i int, result1 string) {
	fake.checkEveryMutex.Lock()
	defer fake.checkEveryMutex.Unlock()
	fake.CheckEveryStub = nil
	if fake.checkEveryReturnsOnCall == nil {
		fake.checkEveryReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.checkEveryReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeResource) CheckSetupError() error {
	fake.checkSetupErrorMutex.Lock()
	ret, specificReturn := fake.checkSetupErrorReturnsOnCall[len(fake.checkSetupErrorArgsForCall)]
	fake.checkSetupErrorArgsForCall = append(fake.checkSetupErrorArgsForCall, struct {
	}{})
	fake.recordInvocation("CheckSetupError", []interface{}{})
	fake.checkSetupErrorMutex.Unlock()
	if fake.CheckSetupErrorStub != nil {
		return fake.CheckSetupErrorStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.checkSetupErrorReturns
	return fakeReturns.result1
}

func (fake *FakeResource) CheckSetupErrorCallCount() int {
	fake.checkSetupErrorMutex.RLock()
	defer fake.checkSetupErrorMutex.RUnlock()
	return len(fake.checkSetupErrorArgsForCall)
}

func (fake *FakeResource) CheckSetupErrorCalls(stub func() error) {
	fake.checkSetupErrorMutex.Lock()
	defer fake.checkSetupErrorMutex.Unlock()
	fake.CheckSetupErrorStub = stub
}

func (fake *FakeResource) CheckSetupErrorReturns(result1 error) {
	fake.checkSetupErrorMutex.Lock()
	defer fake.checkSetupErrorMutex.Unlock()
	fake.CheckSetupErrorStub = nil
	fake.checkSetupErrorReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeResource) CheckSetupErrorReturnsOnCall(i int, result1 error) {
	fake.checkSetupErrorMutex.Lock()
	defer fake.checkSetupErrorMutex.Unlock()
	fake.CheckSetupErrorStub = nil
	if fake.checkSetupErrorReturnsOnCall == nil {
		fake.checkSetupErrorReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.checkSetupErrorReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeResource) CheckTimeout() string {
	fake.checkTimeoutMutex.Lock()
	ret, specificReturn := fake.checkTimeoutReturnsOnCall[len(fake.checkTimeoutArgsForCall)]
	fake.checkTimeoutArgsForCall = append(fake.checkTimeoutArgsForCall, struct {
	}{})
	fake.recordInvocation("CheckTimeout", []interface{}{})
	fake.checkTimeoutMutex.Unlock()
	if fake.CheckTimeoutStub != nil {
		return fake.CheckTimeoutStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.checkTimeoutReturns
	return fakeReturns.result1
}

func (fake *FakeResource) CheckTimeoutCallCount() int {
	fake.checkTimeoutMutex.RLock()
	defer fake.checkTimeoutMutex.RUnlock()
	return len(fake.checkTimeoutArgsForCall)
}

func (fake *FakeResource) CheckTimeoutCalls(stub func() string) {
	fake.checkTimeoutMutex.Lock()
	defer fake.checkTimeoutMutex.Unlock()
	fake.CheckTimeoutStub = stub
}

func (fake *FakeResource) CheckTimeoutReturns(result1 string) {
	fake.checkTimeoutMutex.Lock()
	defer fake.checkTimeoutMutex.Unlock()
	fake.CheckTimeoutStub = nil
	fake.checkTimeoutReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeResource) CheckTimeoutReturnsOnCall(i int, result1 string) {
	fake.checkTimeoutMutex.Lock()
	defer fake.checkTimeoutMutex.Unlock()
	fake.CheckTimeoutStub = nil
	if fake.checkTimeoutReturnsOnCall == nil {
		fake.checkTimeoutReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.checkTimeoutReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeResource) ConfigPinnedVersion() atc.Version {
	fake.configPinnedVersionMutex.Lock()
	ret, specificReturn := fake.configPinnedVersionReturnsOnCall[len(fake.configPinnedVersionArgsForCall)]
	fake.configPinnedVersionArgsForCall = append(fake.configPinnedVersionArgsForCall, struct {
	}{})
	fake.recordInvocation("ConfigPinnedVersion", []interface{}{})
	fake.configPinnedVersionMutex.Unlock()
	if fake.ConfigPinnedVersionStub != nil {
		return fake.ConfigPinnedVersionStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.configPinnedVersionReturns
	return fakeReturns.result1
}

func (fake *FakeResource) ConfigPinnedVersionCallCount() int {
	fake.configPinnedVersionMutex.RLock()
	defer fake.configPinnedVersionMutex.RUnlock()
	return len(fake.configPinnedVersionArgsForCall)
}

func (fake *FakeResource) ConfigPinnedVersionCalls(stub func() atc.Version) {
	fake.configPinnedVersionMutex.Lock()
	defer fake.configPinnedVersionMutex.Unlock()
	fake.ConfigPinnedVersionStub = stub
}

func (fake *FakeResource) ConfigPinnedVersionReturns(result1 atc.Version) {
	fake.configPinnedVersionMutex.Lock()
	defer fake.configPinnedVersionMutex.Unlock()
	fake.ConfigPinnedVersionStub = nil
	fake.configPinnedVersionReturns = struct {
		result1 atc.Version
	}{result1}
}

func (fake *FakeResource) ConfigPinnedVersionReturnsOnCall(i int, result1 atc.Version) {
	fake.configPinnedVersionMutex.Lock()
	defer fake.configPinnedVersionMutex.Unlock()
	fake.ConfigPinnedVersionStub = nil
	if fake.configPinnedVersionReturnsOnCall == nil {
		fake.configPinnedVersionReturnsOnCall = make(map[int]struct {
			result1 atc.Version
		})
	}
	fake.configPinnedVersionReturnsOnCall[i] = struct {
		result1 atc.Version
	}{result1}
}

func (fake *FakeResource) CurrentPinnedVersion() atc.Version {
	fake.currentPinnedVersionMutex.Lock()
	ret, specificReturn := fake.currentPinnedVersionReturnsOnCall[len(fake.currentPinnedVersionArgsForCall)]
	fake.currentPinnedVersionArgsForCall = append(fake.currentPinnedVersionArgsForCall, struct {
	}{})
	fake.recordInvocation("CurrentPinnedVersion", []interface{}{})
	fake.currentPinnedVersionMutex.Unlock()
	if fake.CurrentPinnedVersionStub != nil {
		return fake.CurrentPinnedVersionStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.currentPinnedVersionReturns
	return fakeReturns.result1
}

func (fake *FakeResource) CurrentPinnedVersionCallCount() int {
	fake.currentPinnedVersionMutex.RLock()
	defer fake.currentPinnedVersionMutex.RUnlock()
	return len(fake.currentPinnedVersionArgsForCall)
}

func (fake *FakeResource) CurrentPinnedVersionCalls(stub func() atc.Version) {
	fake.currentPinnedVersionMutex.Lock()
	defer fake.currentPinnedVersionMutex.Unlock()
	fake.CurrentPinnedVersionStub = stub
}

func (fake *FakeResource) CurrentPinnedVersionReturns(result1 atc.Version) {
	fake.currentPinnedVersionMutex.Lock()
	defer fake.currentPinnedVersionMutex.Unlock()
	fake.CurrentPinnedVersionStub = nil
	fake.currentPinnedVersionReturns = struct {
		result1 atc.Version
	}{result1}
}

func (fake *FakeResource) CurrentPinnedVersionReturnsOnCall(i int, result1 atc.Version) {
	fake.currentPinnedVersionMutex.Lock()
	defer fake.currentPinnedVersionMutex.Unlock()
	fake.CurrentPinnedVersionStub = nil
	if fake.currentPinnedVersionReturnsOnCall == nil {
		fake.currentPinnedVersionReturnsOnCall = make(map[int]struct {
			result1 atc.Version
		})
	}
	fake.currentPinnedVersionReturnsOnCall[i] = struct {
		result1 atc.Version
	}{result1}
}

func (fake *FakeResource) DisableVersion(arg1 int) error {
	fake.disableVersionMutex.Lock()
	ret, specificReturn := fake.disableVersionReturnsOnCall[len(fake.disableVersionArgsForCall)]
	fake.disableVersionArgsForCall = append(fake.disableVersionArgsForCall, struct {
		arg1 int
	}{arg1})
	fake.recordInvocation("DisableVersion", []interface{}{arg1})
	fake.disableVersionMutex.Unlock()
	if fake.DisableVersionStub != nil {
		return fake.DisableVersionStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.disableVersionReturns
	return fakeReturns.result1
}

func (fake *FakeResource) DisableVersionCallCount() int {
	fake.disableVersionMutex.RLock()
	defer fake.disableVersionMutex.RUnlock()
	return len(fake.disableVersionArgsForCall)
}

func (fake *FakeResource) DisableVersionCalls(stub func(int) error) {
	fake.disableVersionMutex.Lock()
	defer fake.disableVersionMutex.Unlock()
	fake.DisableVersionStub = stub
}

func (fake *FakeResource) DisableVersionArgsForCall(i int) int {
	fake.disableVersionMutex.RLock()
	defer fake.disableVersionMutex.RUnlock()
	argsForCall := fake.disableVersionArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeResource) DisableVersionReturns(result1 error) {
	fake.disableVersionMutex.Lock()
	defer fake.disableVersionMutex.Unlock()
	fake.DisableVersionStub = nil
	fake.disableVersionReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeResource) DisableVersionReturnsOnCall(i int, result1 error) {
	fake.disableVersionMutex.Lock()
	defer fake.disableVersionMutex.Unlock()
	fake.DisableVersionStub = nil
	if fake.disableVersionReturnsOnCall == nil {
		fake.disableVersionReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.disableVersionReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeResource) EnableVersion(arg1 int) error {
	fake.enableVersionMutex.Lock()
	ret, specificReturn := fake.enableVersionReturnsOnCall[len(fake.enableVersionArgsForCall)]
	fake.enableVersionArgsForCall = append(fake.enableVersionArgsForCall, struct {
		arg1 int
	}{arg1})
	fake.recordInvocation("EnableVersion", []interface{}{arg1})
	fake.enableVersionMutex.Unlock()
	if fake.EnableVersionStub != nil {
		return fake.EnableVersionStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.enableVersionReturns
	return fakeReturns.result1
}

func (fake *FakeResource) EnableVersionCallCount() int {
	fake.enableVersionMutex.RLock()
	defer fake.enableVersionMutex.RUnlock()
	return len(fake.enableVersionArgsForCall)
}

func (fake *FakeResource) EnableVersionCalls(stub func(int) error) {
	fake.enableVersionMutex.Lock()
	defer fake.enableVersionMutex.Unlock()
	fake.EnableVersionStub = stub
}

func (fake *FakeResource) EnableVersionArgsForCall(i int) int {
	fake.enableVersionMutex.RLock()
	defer fake.enableVersionMutex.RUnlock()
	argsForCall := fake.enableVersionArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeResource) EnableVersionReturns(result1 error) {
	fake.enableVersionMutex.Lock()
	defer fake.enableVersionMutex.Unlock()
	fake.EnableVersionStub = nil
	fake.enableVersionReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeResource) EnableVersionReturnsOnCall(i int, result1 error) {
	fake.enableVersionMutex.Lock()
	defer fake.enableVersionMutex.Unlock()
	fake.EnableVersionStub = nil
	if fake.enableVersionReturnsOnCall == nil {
		fake.enableVersionReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.enableVersionReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeResource) ID() int {
	fake.iDMutex.Lock()
	ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)]
	fake.iDArgsForCall = append(fake.iDArgsForCall, struct {
	}{})
	fake.recordInvocation("ID", []interface{}{})
	fake.iDMutex.Unlock()
	if fake.IDStub != nil {
		return fake.IDStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.iDReturns
	return fakeReturns.result1
}

func (fake *FakeResource) IDCallCount() int {
	fake.iDMutex.RLock()
	defer fake.iDMutex.RUnlock()
	return len(fake.iDArgsForCall)
}

func (fake *FakeResource) IDCalls(stub func() int) {
	fake.iDMutex.Lock()
	defer fake.iDMutex.Unlock()
	fake.IDStub = stub
}

func (fake *FakeResource) IDReturns(result1 int) {
	fake.iDMutex.Lock()
	defer fake.iDMutex.Unlock()
	fake.IDStub = nil
	fake.iDReturns = struct {
		result1 int
	}{result1}
}

func (fake *FakeResource) IDReturnsOnCall(i int, result1 int) {
	fake.iDMutex.Lock()
	defer fake.iDMutex.Unlock()
	fake.IDStub = nil
	if fake.iDReturnsOnCall == nil {
		fake.iDReturnsOnCall = make(map[int]struct {
			result1 int
		})
	}
	fake.iDReturnsOnCall[i] = struct {
		result1 int
	}{result1}
}

func (fake *FakeResource) Icon() string {
	fake.iconMutex.Lock()
	ret, specificReturn := fake.iconReturnsOnCall[len(fake.iconArgsForCall)]
	fake.iconArgsForCall = append(fake.iconArgsForCall, struct {
	}{})
	fake.recordInvocation("Icon", []interface{}{})
	fake.iconMutex.Unlock()
	if fake.IconStub != nil {
		return fake.IconStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.iconReturns
	return fakeReturns.result1
}

func (fake *FakeResource) IconCallCount() int {
	fake.iconMutex.RLock()
	defer fake.iconMutex.RUnlock()
	return len(fake.iconArgsForCall)
}

func (fake *FakeResource) IconCalls(stub func() string) {
	fake.iconMutex.Lock()
	defer fake.iconMutex.Unlock()
	fake.IconStub = stub
}

func (fake *FakeResource) IconReturns(result1 string) {
	fake.iconMutex.Lock()
	defer fake.iconMutex.Unlock()
	fake.IconStub = nil
	fake.iconReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeResource) IconReturnsOnCall(i int, result1 string) {
	fake.iconMutex.Lock()
	defer fake.iconMutex.Unlock()
	fake.IconStub = nil
	if fake.iconReturnsOnCall == nil {
		fake.iconReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.iconReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeResource) LastCheckEndTime() time.Time {
	fake.lastCheckEndTimeMutex.Lock()
	ret, specificReturn := fake.lastCheckEndTimeReturnsOnCall[len(fake.lastCheckEndTimeArgsForCall)]
	fake.lastCheckEndTimeArgsForCall = append(fake.lastCheckEndTimeArgsForCall, struct {
	}{})
	fake.recordInvocation("LastCheckEndTime", []interface{}{})
	fake.lastCheckEndTimeMutex.Unlock()
	if fake.LastCheckEndTimeStub != nil {
		return fake.LastCheckEndTimeStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.lastCheckEndTimeReturns
	return fakeReturns.result1
}

func (fake *FakeResource) LastCheckEndTimeCallCount() int {
	fake.lastCheckEndTimeMutex.RLock()
	defer fake.lastCheckEndTimeMutex.RUnlock()
	return len(fake.lastCheckEndTimeArgsForCall)
}

func (fake *FakeResource) LastCheckEndTimeCalls(stub func() time.Time) {
	fake.lastCheckEndTimeMutex.Lock()
	defer fake.lastCheckEndTimeMutex.Unlock()
	fake.LastCheckEndTimeStub = stub
}

func (fake *FakeResource) LastCheckEndTimeReturns(result1 time.Time) {
	fake.lastCheckEndTimeMutex.Lock()
	defer fake.lastCheckEndTimeMutex.Unlock()
	fake.LastCheckEndTimeStub = nil
	fake.lastCheckEndTimeReturns = struct {
		result1 time.Time
	}{result1}
}

func (fake *FakeResource) LastCheckEndTimeReturnsOnCall(i int, result1 time.Time) {
	fake.lastCheckEndTimeMutex.Lock()
	defer fake.lastCheckEndTimeMutex.Unlock()
	fake.LastCheckEndTimeStub = nil
	if fake.lastCheckEndTimeReturnsOnCall == nil {
		fake.lastCheckEndTimeReturnsOnCall = make(map[int]struct {
			result1 time.Time
		})
	}
	fake.lastCheckEndTimeReturnsOnCall[i] = struct {
		result1 time.Time
	}{result1}
}

func (fake *FakeResource) LastCheckStartTime() time.Time {
	fake.lastCheckStartTimeMutex.Lock()
	ret, specificReturn := fake.lastCheckStartTimeReturnsOnCall[len(fake.lastCheckStartTimeArgsForCall)]
	fake.lastCheckStartTimeArgsForCall = append(fake.lastCheckStartTimeArgsForCall, struct {
	}{})
	fake.recordInvocation("LastCheckStartTime", []interface{}{})
	fake.lastCheckStartTimeMutex.Unlock()
	if fake.LastCheckStartTimeStub != nil {
		return fake.LastCheckStartTimeStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.lastCheckStartTimeReturns
	return fakeReturns.result1
}

func (fake *FakeResource) LastCheckStartTimeCallCount() int {
	fake.lastCheckStartTimeMutex.RLock()
	defer fake.lastCheckStartTimeMutex.RUnlock()
	return len(fake.lastCheckStartTimeArgsForCall)
}

func (fake *FakeResource) LastCheckStartTimeCalls(stub func() time.Time) {
	fake.lastCheckStartTimeMutex.Lock()
	defer fake.lastCheckStartTimeMutex.Unlock()
	fake.LastCheckStartTimeStub = stub
}

func (fake *FakeResource) LastCheckStartTimeReturns(result1 time.Time) {
	fake.lastCheckStartTimeMutex.Lock()
	defer fake.lastCheckStartTimeMutex.Unlock()
	fake.LastCheckStartTimeStub = nil
	fake.lastCheckStartTimeReturns = struct {
		result1 time.Time
	}{result1}
}

func (fake *FakeResource) LastCheckStartTimeReturnsOnCall(i int, result1 time.Time) {
	fake.lastCheckStartTimeMutex.Lock()
	defer fake.lastCheckStartTimeMutex.Unlock()
	fake.LastCheckStartTimeStub = nil
	if fake.lastCheckStartTimeReturnsOnCall == nil {
		fake.lastCheckStartTimeReturnsOnCall = make(map[int]struct {
			result1 time.Time
		})
	}
	fake.lastCheckStartTimeReturnsOnCall[i] = struct {
		result1 time.Time
	}{result1}
}

func (fake *FakeResource) Name() string {
	fake.nameMutex.Lock()
	ret, specificReturn := fake.nameReturnsOnCall[len(fake.nameArgsForCall)]
	fake.nameArgsForCall = append(fake.nameArgsForCall, struct {
	}{})
	fake.recordInvocation("Name", []interface{}{})
	fake.nameMutex.Unlock()
	if fake.NameStub != nil {
		return fake.NameStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.nameReturns
	return fakeReturns.result1
}

func (fake *FakeResource) NameCallCount() int {
	fake.nameMutex.RLock()
	defer fake.nameMutex.RUnlock()
	return len(fake.nameArgsForCall)
}

func (fake *FakeResource) NameCalls(stub func() string) {
	fake.nameMutex.Lock()
	defer fake.nameMutex.Unlock()
	fake.NameStub = stub
}

func (fake *FakeResource) NameReturns(result1 string) {
	fake.nameMutex.Lock()
	defer fake.nameMutex.Unlock()
	fake.NameStub = nil
	fake.nameReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeResource) NameReturnsOnCall(i int, result1 string) {
	fake.nameMutex.Lock()
	defer fake.nameMutex.Unlock()
	fake.NameStub = nil
	if fake.nameReturnsOnCall == nil {
		fake.nameReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.nameReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeResource) NotifyScan() error {
	fake.notifyScanMutex.Lock()
	ret, specificReturn := fake.notifyScanReturnsOnCall[len(fake.notifyScanArgsForCall)]
	fake.notifyScanArgsForCall = append(fake.notifyScanArgsForCall, struct {
	}{})
	fake.recordInvocation("NotifyScan", []interface{}{})
	fake.notifyScanMutex.Unlock()
	if fake.NotifyScanStub != nil {
		return fake.NotifyScanStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.notifyScanReturns
	return fakeReturns.result1
}

func (fake *FakeResource) NotifyScanCallCount() int {
	fake.notifyScanMutex.RLock()
	defer fake.notifyScanMutex.RUnlock()
	return len(fake.notifyScanArgsForCall)
}

func (fake *FakeResource) NotifyScanCalls(stub func() error) {
	fake.notifyScanMutex.Lock()
	defer fake.notifyScanMutex.Unlock()
	fake.NotifyScanStub = stub
}

func (fake *FakeResource) NotifyScanReturns(result1 error) {
	fake.notifyScanMutex.Lock()
	defer fake.notifyScanMutex.Unlock()
	fake.NotifyScanStub = nil
	fake.notifyScanReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeResource) NotifyScanReturnsOnCall(i int, result1 error) {
	fake.notifyScanMutex.Lock()
	defer fake.notifyScanMutex.Unlock()
	fake.NotifyScanStub = nil
	if fake.notifyScanReturnsOnCall == nil {
		fake.notifyScanReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.notifyScanReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeResource) PinComment() string {
	fake.pinCommentMutex.Lock()
	ret, specificReturn := fake.pinCommentReturnsOnCall[len(fake.pinCommentArgsForCall)]
	fake.pinCommentArgsForCall = append(fake.pinCommentArgsForCall, struct {
	}{})
	fake.recordInvocation("PinComment", []interface{}{})
	fake.pinCommentMutex.Unlock()
	if fake.PinCommentStub != nil {
		return fake.PinCommentStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.pinCommentReturns
	return fakeReturns.result1
}

func (fake *FakeResource) PinCommentCallCount() int {
	fake.pinCommentMutex.RLock()
	defer fake.pinCommentMutex.RUnlock()
	return len(fake.pinCommentArgsForCall)
}

func (fake *FakeResource) PinCommentCalls(stub func() string) {
	fake.pinCommentMutex.Lock()
	defer fake.pinCommentMutex.Unlock()
	fake.PinCommentStub = stub
}

func (fake *FakeResource) PinCommentReturns(result1 string) {
	fake.pinCommentMutex.Lock()
	defer fake.pinCommentMutex.Unlock()
	fake.PinCommentStub = nil
	fake.pinCommentReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeResource) PinCommentReturnsOnCall(i int, result1 string) {
	fake.pinCommentMutex.Lock()
	defer fake.pinCommentMutex.Unlock()
	fake.PinCommentStub = nil
	if fake.pinCommentReturnsOnCall == nil {
		fake.pinCommentReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.pinCommentReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeResource) PinVersion(arg1 int) error {
	fake.pinVersionMutex.Lock()
	ret, specificReturn := fake.pinVersionReturnsOnCall[len(fake.pinVersionArgsForCall)]
	fake.pinVersionArgsForCall = append(fake.pinVersionArgsForCall, struct {
		arg1 int
	}{arg1})
	fake.recordInvocation("PinVersion", []interface{}{arg1})
	fake.pinVersionMutex.Unlock()
	if fake.PinVersionStub != nil {
		return fake.PinVersionStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.pinVersionReturns
	return fakeReturns.result1
}

func (fake *FakeResource) PinVersionCallCount() int {
	fake.pinVersionMutex.RLock()
	defer fake.pinVersionMutex.RUnlock()
	return len(fake.pinVersionArgsForCall)
}

func (fake *FakeResource) PinVersionCalls(stub func(int) error) {
	fake.pinVersionMutex.Lock()
	defer fake.pinVersionMutex.Unlock()
	fake.PinVersionStub = stub
}

func (fake *FakeResource) PinVersionArgsForCall(i int) int {
	fake.pinVersionMutex.RLock()
	defer fake.pinVersionMutex.RUnlock()
	argsForCall := fake.pinVersionArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeResource) PinVersionReturns(result1 error) {
	fake.pinVersionMutex.Lock()
	defer fake.pinVersionMutex.Unlock()
	fake.PinVersionStub = nil
	fake.pinVersionReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeResource) PinVersionReturnsOnCall(i int, result1 error) {
	fake.pinVersionMutex.Lock()
	defer fake.pinVersionMutex.Unlock()
	fake.PinVersionStub = nil
	if fake.pinVersionReturnsOnCall == nil {
		fake.pinVersionReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.pinVersionReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeResource) PipelineID() int {
	fake.pipelineIDMutex.Lock()
	ret, specificReturn := fake.pipelineIDReturnsOnCall[len(fake.pipelineIDArgsForCall)]
	fake.pipelineIDArgsForCall = append(fake.pipelineIDArgsForCall, struct {
	}{})
	fake.recordInvocation("PipelineID", []interface{}{})
	fake.pipelineIDMutex.Unlock()
	if fake.PipelineIDStub != nil {
		return fake.PipelineIDStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.pipelineIDReturns
	return fakeReturns.result1
}

func (fake *FakeResource) PipelineIDCallCount() int {
	fake.pipelineIDMutex.RLock()
	defer fake.pipelineIDMutex.RUnlock()
	return len(fake.pipelineIDArgsForCall)
}

func (fake *FakeResource) PipelineIDCalls(stub func() int) {
	fake.pipelineIDMutex.Lock()
	defer fake.pipelineIDMutex.Unlock()
	fake.PipelineIDStub = stub
}

func (fake *FakeResource) PipelineIDReturns(result1 int) {
	fake.pipelineIDMutex.Lock()
	defer fake.pipelineIDMutex.Unlock()
	fake.PipelineIDStub = nil
	fake.pipelineIDReturns = struct {
		result1 int
	}{result1}
}

func (fake *FakeResource) PipelineIDReturnsOnCall(i int, result1 int) {
	fake.pipelineIDMutex.Lock()
	defer fake.pipelineIDMutex.Unlock()
	fake.PipelineIDStub = nil
	if fake.pipelineIDReturnsOnCall == nil {
		fake.pipelineIDReturnsOnCall = make(map[int]struct {
			result1 int
		})
	}
	fake.pipelineIDReturnsOnCall[i] = struct {
		result1 int
	}{result1}
}

func (fake *FakeResource) PipelineName() string {
	fake.pipelineNameMutex.Lock()
	ret, specificReturn := fake.pipelineNameReturnsOnCall[len(fake.pipelineNameArgsForCall)]
	fake.pipelineNameArgsForCall = append(fake.pipelineNameArgsForCall, struct {
	}{})
	fake.recordInvocation("PipelineName", []interface{}{})
	fake.pipelineNameMutex.Unlock()
	if fake.PipelineNameStub != nil {
		return fake.PipelineNameStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.pipelineNameReturns
	return fakeReturns.result1
}

func (fake *FakeResource) PipelineNameCallCount() int {
	fake.pipelineNameMutex.RLock()
	defer fake.pipelineNameMutex.RUnlock()
	return len(fake.pipelineNameArgsForCall)
}

func (fake *FakeResource) PipelineNameCalls(stub func() string) {
	fake.pipelineNameMutex.Lock()
	defer fake.pipelineNameMutex.Unlock()
	fake.PipelineNameStub = stub
}

func (fake *FakeResource) PipelineNameReturns(result1 string) {
	fake.pipelineNameMutex.Lock()
	defer fake.pipelineNameMutex.Unlock()
	fake.PipelineNameStub = nil
	fake.pipelineNameReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeResource) PipelineNameReturnsOnCall(i int, result1 string) {
	fake.pipelineNameMutex.Lock()
	defer fake.pipelineNameMutex.Unlock()
	fake.PipelineNameStub = nil
	if fake.pipelineNameReturnsOnCall == nil {
		fake.pipelineNameReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.pipelineNameReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeResource) Public() bool {
	fake.publicMutex.Lock()
	ret, specificReturn := fake.publicReturnsOnCall[len(fake.publicArgsForCall)]
	fake.publicArgsForCall = append(fake.publicArgsForCall, struct {
	}{})
	fake.recordInvocation("Public", []interface{}{})
	fake.publicMutex.Unlock()
	if fake.PublicStub != nil {
		return fake.PublicStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.publicReturns
	return fakeReturns.result1
}

func (fake *FakeResource) PublicCallCount() int {
	fake.publicMutex.RLock()
	defer fake.publicMutex.RUnlock()
	return len(fake.publicArgsForCall)
}

func (fake *FakeResource) PublicCalls(stub func() bool) {
	fake.publicMutex.Lock()
	defer fake.publicMutex.Unlock()
	fake.PublicStub = stub
}

func (fake *FakeResource) PublicReturns(result1 bool) {
	fake.publicMutex.Lock()
	defer fake.publicMutex.Unlock()
	fake.PublicStub = nil
	fake.publicReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeResource) PublicReturnsOnCall(i int, result1 bool) {
	fake.publicMutex.Lock()
	defer fake.publicMutex.Unlock()
	fake.PublicStub = nil
	if fake.publicReturnsOnCall == nil {
		fake.publicReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.publicReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeResource) Reload() (bool, error) {
	fake.reloadMutex.Lock()
	ret, specificReturn := fake.reloadReturnsOnCall[len(fake.reloadArgsForCall)]
	fake.reloadArgsForCall = append(fake.reloadArgsForCall, struct {
	}{})
	fake.recordInvocation("Reload", []interface{}{})
	fake.reloadMutex.Unlock()
	if fake.ReloadStub != nil {
		return fake.ReloadStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.reloadReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeResource) ReloadCallCount() int {
	fake.reloadMutex.RLock()
	defer fake.reloadMutex.RUnlock()
	return len(fake.reloadArgsForCall)
}

func (fake *FakeResource) ReloadCalls(stub func() (bool, error)) {
	fake.reloadMutex.Lock()
	defer fake.reloadMutex.Unlock()
	fake.ReloadStub = stub
}

func (fake *FakeResource) ReloadReturns(result1 bool, result2 error) {
	fake.reloadMutex.Lock()
	defer fake.reloadMutex.Unlock()
	fake.ReloadStub = nil
	fake.reloadReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeResource) ReloadReturnsOnCall(i int, result1 bool, result2 error) {
	fake.reloadMutex.Lock()
	defer fake.reloadMutex.Unlock()
	fake.ReloadStub = nil
	if fake.reloadReturnsOnCall == nil {
		fake.reloadReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 error
		})
	}
	fake.reloadReturnsOnCall[i] = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeResource) ResourceConfigID() int {
	fake.resourceConfigIDMutex.Lock()
	ret, specificReturn := fake.resourceConfigIDReturnsOnCall[len(fake.resourceConfigIDArgsForCall)]
	fake.resourceConfigIDArgsForCall = append(fake.resourceConfigIDArgsForCall, struct {
	}{})
	fake.recordInvocation("ResourceConfigID", []interface{}{})
	fake.resourceConfigIDMutex.Unlock()
	if fake.ResourceConfigIDStub != nil {
		return fake.ResourceConfigIDStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.resourceConfigIDReturns
	return fakeReturns.result1
}

func (fake *FakeResource) ResourceConfigIDCallCount() int {
	fake.resourceConfigIDMutex.RLock()
	defer fake.resourceConfigIDMutex.RUnlock()
	return len(fake.resourceConfigIDArgsForCall)
}

func (fake *FakeResource) ResourceConfigIDCalls(stub func() int) {
	fake.resourceConfigIDMutex.Lock()
	defer fake.resourceConfigIDMutex.Unlock()
	fake.ResourceConfigIDStub = stub
}

func (fake *FakeResource) ResourceConfigIDReturns(result1 int) {
	fake.resourceConfigIDMutex.Lock()
	defer fake.resourceConfigIDMutex.Unlock()
	fake.ResourceConfigIDStub = nil
	fake.resourceConfigIDReturns = struct {
		result1 int
	}{result1}
}

func (fake *FakeResource) ResourceConfigIDReturnsOnCall(i int, result1 int) {
	fake.resourceConfigIDMutex.Lock()
	defer fake.resourceConfigIDMutex.Unlock()
	fake.ResourceConfigIDStub = nil
	if fake.resourceConfigIDReturnsOnCall == nil {
		fake.resourceConfigIDReturnsOnCall = make(map[int]struct {
			result1 int
		})
	}
	fake.resourceConfigIDReturnsOnCall[i] = struct {
		result1 int
	}{result1}
}

func (fake *FakeResource) ResourceConfigScopeID() int {
	fake.resourceConfigScopeIDMutex.Lock()
	ret, specificReturn := fake.resourceConfigScopeIDReturnsOnCall[len(fake.resourceConfigScopeIDArgsForCall)]
	fake.resourceConfigScopeIDArgsForCall = append(fake.resourceConfigScopeIDArgsForCall, struct {
	}{})
	fake.recordInvocation("ResourceConfigScopeID", []interface{}{})
	fake.resourceConfigScopeIDMutex.Unlock()
	if fake.ResourceConfigScopeIDStub != nil {
		return fake.ResourceConfigScopeIDStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.resourceConfigScopeIDReturns
	return fakeReturns.result1
}

func (fake *FakeResource) ResourceConfigScopeIDCallCount() int {
	fake.resourceConfigScopeIDMutex.RLock()
	defer fake.resourceConfigScopeIDMutex.RUnlock()
	return len(fake.resourceConfigScopeIDArgsForCall)
}

func (fake *FakeResource) ResourceConfigScopeIDCalls(stub func() int) {
	fake.resourceConfigScopeIDMutex.Lock()
	defer fake.resourceConfigScopeIDMutex.Unlock()
	fake.ResourceConfigScopeIDStub = stub
}

func (fake *FakeResource) ResourceConfigScopeIDReturns(result1 int) {
	fake.resourceConfigScopeIDMutex.Lock()
	defer fake.resourceConfigScopeIDMutex.Unlock()
	fake.ResourceConfigScopeIDStub = nil
	fake.resourceConfigScopeIDReturns = struct {
		result1 int
	}{result1}
}

func (fake *FakeResource) ResourceConfigScopeIDReturnsOnCall(i int, result1 int) {
	fake.resourceConfigScopeIDMutex.Lock()
	defer fake.resourceConfigScopeIDMutex.Unlock()
	fake.ResourceConfigScopeIDStub = nil
	if fake.resourceConfigScopeIDReturnsOnCall == nil {
		fake.resourceConfigScopeIDReturnsOnCall = make(map[int]struct {
			result1 int
		})
	}
	fake.resourceConfigScopeIDReturnsOnCall[i] = struct {
		result1 int
	}{result1}
}

func (fake *FakeResource) ResourceConfigVersionID(arg1 atc.Version) (int, bool, error) {
	fake.resourceConfigVersionIDMutex.Lock()
	ret, specificReturn := fake.resourceConfigVersionIDReturnsOnCall[len(fake.resourceConfigVersionIDArgsForCall)]
	fake.resourceConfigVersionIDArgsForCall = append(fake.resourceConfigVersionIDArgsForCall, struct {
		arg1 atc.Version
	}{arg1})
	fake.recordInvocation("ResourceConfigVersionID", []interface{}{arg1})
	fake.resourceConfigVersionIDMutex.Unlock()
	if fake.ResourceConfigVersionIDStub != nil {
		return fake.ResourceConfigVersionIDStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.resourceConfigVersionIDReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeResource) ResourceConfigVersionIDCallCount() int {
	fake.resourceConfigVersionIDMutex.RLock()
	defer fake.resourceConfigVersionIDMutex.RUnlock()
	return len(fake.resourceConfigVersionIDArgsForCall)
}

func (fake *FakeResource) ResourceConfigVersionIDCalls(stub func(atc.Version) (int, bool, error)) {
	fake.resourceConfigVersionIDMutex.Lock()
	defer fake.resourceConfigVersionIDMutex.Unlock()
	fake.ResourceConfigVersionIDStub = stub
}

func (fake *FakeResource) ResourceConfigVersionIDArgsForCall(i int) atc.Version {
	fake.resourceConfigVersionIDMutex.RLock()
	defer fake.resourceConfigVersionIDMutex.RUnlock()
	argsForCall := fake.resourceConfigVersionIDArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeResource) ResourceConfigVersionIDReturns(result1 int, result2 bool, result3 error) {
	fake.resourceConfigVersionIDMutex.Lock()
	defer fake.resourceConfigVersionIDMutex.Unlock()
	fake.ResourceConfigVersionIDStub = nil
	fake.resourceConfigVersionIDReturns = struct {
		result1 int
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeResource) ResourceConfigVersionIDReturnsOnCall(i int, result1 int, result2 bool, result3 error) {
	fake.resourceConfigVersionIDMutex.Lock()
	defer fake.resourceConfigVersionIDMutex.Unlock()
	fake.ResourceConfigVersionIDStub = nil
	if fake.resourceConfigVersionIDReturnsOnCall == nil {
		fake.resourceConfigVersionIDReturnsOnCall = make(map[int]struct {
			result1 int
			result2 bool
			result3 error
		})
	}
	fake.resourceConfigVersionIDReturnsOnCall[i] = struct {
		result1 int
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeResource) SaveUncheckedVersion(arg1 atc.Version, arg2 db.ResourceConfigMetadataFields, arg3 db.ResourceConfig, arg4 atc.VersionedResourceTypes) (bool, error) {
	fake.saveUncheckedVersionMutex.Lock()
	ret, specificReturn := fake.saveUncheckedVersionReturnsOnCall[len(fake.saveUncheckedVersionArgsForCall)]
	fake.saveUncheckedVersionArgsForCall = append(fake.saveUncheckedVersionArgsForCall, struct {
		arg1 atc.Version
		arg2 db.ResourceConfigMetadataFields
		arg3 db.ResourceConfig
		arg4 atc.VersionedResourceTypes
	}{arg1, arg2, arg3, arg4})
	fake.recordInvocation("SaveUncheckedVersion", []interface{}{arg1, arg2, arg3, arg4})
	fake.saveUncheckedVersionMutex.Unlock()
	if fake.SaveUncheckedVersionStub != nil {
		return fake.SaveUncheckedVersionStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.saveUncheckedVersionReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeResource) SaveUncheckedVersionCallCount() int {
	fake.saveUncheckedVersionMutex.RLock()
	defer fake.saveUncheckedVersionMutex.RUnlock()
	return len(fake.saveUncheckedVersionArgsForCall)
}

func (fake *FakeResource) SaveUncheckedVersionCalls(stub func(atc.Version, db.ResourceConfigMetadataFields, db.ResourceConfig, atc.VersionedResourceTypes) (bool, error)) {
	fake.saveUncheckedVersionMutex.Lock()
	defer fake.saveUncheckedVersionMutex.Unlock()
	fake.SaveUncheckedVersionStub = stub
}

func (fake *FakeResource) SaveUncheckedVersionArgsForCall(i int) (atc.Version, db.ResourceConfigMetadataFields, db.ResourceConfig, atc.VersionedResourceTypes) {
	fake.saveUncheckedVersionMutex.RLock()
	defer fake.saveUncheckedVersionMutex.RUnlock()
	argsForCall := fake.saveUncheckedVersionArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeResource) SaveUncheckedVersionReturns(result1 bool, result2 error) {
	fake.saveUncheckedVersionMutex.Lock()
	defer fake.saveUncheckedVersionMutex.Unlock()
	fake.SaveUncheckedVersionStub = nil
	fake.saveUncheckedVersionReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeResource) SaveUncheckedVersionReturnsOnCall(i int, result1 bool, result2 error) {
	fake.saveUncheckedVersionMutex.Lock()
	defer fake.saveUncheckedVersionMutex.Unlock()
	fake.SaveUncheckedVersionStub = nil
	if fake.saveUncheckedVersionReturnsOnCall == nil {
		fake.saveUncheckedVersionReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 error
		})
	}
	fake.saveUncheckedVersionReturnsOnCall[i] = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeResource) SetCheckSetupError(arg1 error) error {
	fake.setCheckSetupErrorMutex.Lock()
	ret, specificReturn := fake.setCheckSetupErrorReturnsOnCall[len(fake.setCheckSetupErrorArgsForCall)]
	fake.setCheckSetupErrorArgsForCall = append(fake.setCheckSetupErrorArgsForCall, struct {
		arg1 error
	}{arg1})
	fake.recordInvocation("SetCheckSetupError", []interface{}{arg1})
	fake.setCheckSetupErrorMutex.Unlock()
	if fake.SetCheckSetupErrorStub != nil {
		return fake.SetCheckSetupErrorStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.setCheckSetupErrorReturns
	return fakeReturns.result1
}

func (fake *FakeResource) SetCheckSetupErrorCallCount() int {
	fake.setCheckSetupErrorMutex.RLock()
	defer fake.setCheckSetupErrorMutex.RUnlock()
	return len(fake.setCheckSetupErrorArgsForCall)
}

func (fake *FakeResource) SetCheckSetupErrorCalls(stub func(error) error) {
	fake.setCheckSetupErrorMutex.Lock()
	defer fake.setCheckSetupErrorMutex.Unlock()
	fake.SetCheckSetupErrorStub = stub
}

func (fake *FakeResource) SetCheckSetupErrorArgsForCall(i int) error {
	fake.setCheckSetupErrorMutex.RLock()
	defer fake.setCheckSetupErrorMutex.RUnlock()
	argsForCall := fake.setCheckSetupErrorArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeResource) SetCheckSetupErrorReturns(result1 error) {
	fake.setCheckSetupErrorMutex.Lock()
	defer fake.setCheckSetupErrorMutex.Unlock()
	fake.SetCheckSetupErrorStub = nil
	fake.setCheckSetupErrorReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeResource) SetCheckSetupErrorReturnsOnCall(i int, result1 error) {
	fake.setCheckSetupErrorMutex.Lock()
	defer fake.setCheckSetupErrorMutex.Unlock()
	fake.SetCheckSetupErrorStub = nil
	if fake.setCheckSetupErrorReturnsOnCall == nil {
		fake.setCheckSetupErrorReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.setCheckSetupErrorReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeResource) SetPinComment(arg1 string) error {
	fake.setPinCommentMutex.Lock()
	ret, specificReturn := fake.setPinCommentReturnsOnCall[len(fake.setPinCommentArgsForCall)]
	fake.setPinCommentArgsForCall = append(fake.setPinCommentArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("SetPinComment", []interface{}{arg1})
	fake.setPinCommentMutex.Unlock()
	if fake.SetPinCommentStub != nil {
		return fake.SetPinCommentStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.setPinCommentReturns
	return fakeReturns.result1
}

func (fake *FakeResource) SetPinCommentCallCount() int {
	fake.setPinCommentMutex.RLock()
	defer fake.setPinCommentMutex.RUnlock()
	return len(fake.setPinCommentArgsForCall)
}

func (fake *FakeResource) SetPinCommentCalls(stub func(string) error) {
	fake.setPinCommentMutex.Lock()
	defer fake.setPinCommentMutex.Unlock()
	fake.SetPinCommentStub = stub
}

func (fake *FakeResource) SetPinCommentArgsForCall(i int) string {
	fake.setPinCommentMutex.RLock()
	defer fake.setPinCommentMutex.RUnlock()
	argsForCall := fake.setPinCommentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeResource) SetPinCommentReturns(result1 error) {
	fake.setPinCommentMutex.Lock()
	defer fake.setPinCommentMutex.Unlock()
	fake.SetPinCommentStub = nil
	fake.setPinCommentReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeResource) SetPinCommentReturnsOnCall(i int, result1 error) {
	fake.setPinCommentMutex.Lock()
	defer fake.setPinCommentMutex.Unlock()
	fake.SetPinCommentStub = nil
	if fake.setPinCommentReturnsOnCall == nil {
		fake.setPinCommentReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.setPinCommentReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeResource) SetResourceConfig(arg1 atc.Source, arg2 atc.VersionedResourceTypes) (db.ResourceConfigScope, error) {
	fake.setResourceConfigMutex.Lock()
	ret, specificReturn := fake.setResourceConfigReturnsOnCall[len(fake.setResourceConfigArgsForCall)]
	fake.setResourceConfigArgsForCall = append(fake.setResourceConfigArgsForCall, struct {
		arg1 atc.Source
		arg2 atc.VersionedResourceTypes
	}{arg1, arg2})
	fake.recordInvocation("SetResourceConfig", []interface{}{arg1, arg2})
	fake.setResourceConfigMutex.Unlock()
	if fake.SetResourceConfigStub != nil {
		return fake.SetResourceConfigStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.setResourceConfigReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeResource) SetResourceConfigCallCount() int {
	fake.setResourceConfigMutex.RLock()
	defer fake.setResourceConfigMutex.RUnlock()
	return len(fake.setResourceConfigArgsForCall)
}

func (fake *FakeResource) SetResourceConfigCalls(stub func(atc.Source, atc.VersionedResourceTypes) (db.ResourceConfigScope, error)) {
	fake.setResourceConfigMutex.Lock()
	defer fake.setResourceConfigMutex.Unlock()
	fake.SetResourceConfigStub = stub
}

func (fake *FakeResource) SetResourceConfigArgsForCall(i int) (atc.Source, atc.VersionedResourceTypes) {
	fake.setResourceConfigMutex.RLock()
	defer fake.setResourceConfigMutex.RUnlock()
	argsForCall := fake.setResourceConfigArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeResource) SetResourceConfigReturns(result1 db.ResourceConfigScope, result2 error) {
	fake.setResourceConfigMutex.Lock()
	defer fake.setResourceConfigMutex.Unlock()
	fake.SetResourceConfigStub = nil
	fake.setResourceConfigReturns = struct {
		result1 db.ResourceConfigScope
		result2 error
	}{result1, result2}
}

func (fake *FakeResource) SetResourceConfigReturnsOnCall(i int, result1 db.ResourceConfigScope, result2 error) {
	fake.setResourceConfigMutex.Lock()
	defer fake.setResourceConfigMutex.Unlock()
	fake.SetResourceConfigStub = nil
	if fake.setResourceConfigReturnsOnCall == nil {
		fake.setResourceConfigReturnsOnCall = make(map[int]struct {
			result1 db.ResourceConfigScope
			result2 error
		})
	}
	fake.setResourceConfigReturnsOnCall[i] = struct {
		result1 db.ResourceConfigScope
		result2 error
	}{result1, result2}
}

func (fake *FakeResource) 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
	}
	fakeReturns := fake.sourceReturns
	return fakeReturns.result1
}

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

func (fake *FakeResource) SourceCalls(stub func() atc.Source) {
	fake.sourceMutex.Lock()
	defer fake.sourceMutex.Unlock()
	fake.SourceStub = stub
}

func (fake *FakeResource) SourceReturns(result1 atc.Source) {
	fake.sourceMutex.Lock()
	defer fake.sourceMutex.Unlock()
	fake.SourceStub = nil
	fake.sourceReturns = struct {
		result1 atc.Source
	}{result1}
}

func (fake *FakeResource) SourceReturnsOnCall(i int, result1 atc.Source) {
	fake.sourceMutex.Lock()
	defer fake.sourceMutex.Unlock()
	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 *FakeResource) Tags() atc.Tags {
	fake.tagsMutex.Lock()
	ret, specificReturn := fake.tagsReturnsOnCall[len(fake.tagsArgsForCall)]
	fake.tagsArgsForCall = append(fake.tagsArgsForCall, struct {
	}{})
	fake.recordInvocation("Tags", []interface{}{})
	fake.tagsMutex.Unlock()
	if fake.TagsStub != nil {
		return fake.TagsStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.tagsReturns
	return fakeReturns.result1
}

func (fake *FakeResource) TagsCallCount() int {
	fake.tagsMutex.RLock()
	defer fake.tagsMutex.RUnlock()
	return len(fake.tagsArgsForCall)
}

func (fake *FakeResource) TagsCalls(stub func() atc.Tags) {
	fake.tagsMutex.Lock()
	defer fake.tagsMutex.Unlock()
	fake.TagsStub = stub
}

func (fake *FakeResource) TagsReturns(result1 atc.Tags) {
	fake.tagsMutex.Lock()
	defer fake.tagsMutex.Unlock()
	fake.TagsStub = nil
	fake.tagsReturns = struct {
		result1 atc.Tags
	}{result1}
}

func (fake *FakeResource) TagsReturnsOnCall(i int, result1 atc.Tags) {
	fake.tagsMutex.Lock()
	defer fake.tagsMutex.Unlock()
	fake.TagsStub = nil
	if fake.tagsReturnsOnCall == nil {
		fake.tagsReturnsOnCall = make(map[int]struct {
			result1 atc.Tags
		})
	}
	fake.tagsReturnsOnCall[i] = struct {
		result1 atc.Tags
	}{result1}
}

func (fake *FakeResource) TeamName() string {
	fake.teamNameMutex.Lock()
	ret, specificReturn := fake.teamNameReturnsOnCall[len(fake.teamNameArgsForCall)]
	fake.teamNameArgsForCall = append(fake.teamNameArgsForCall, struct {
	}{})
	fake.recordInvocation("TeamName", []interface{}{})
	fake.teamNameMutex.Unlock()
	if fake.TeamNameStub != nil {
		return fake.TeamNameStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.teamNameReturns
	return fakeReturns.result1
}

func (fake *FakeResource) TeamNameCallCount() int {
	fake.teamNameMutex.RLock()
	defer fake.teamNameMutex.RUnlock()
	return len(fake.teamNameArgsForCall)
}

func (fake *FakeResource) TeamNameCalls(stub func() string) {
	fake.teamNameMutex.Lock()
	defer fake.teamNameMutex.Unlock()
	fake.TeamNameStub = stub
}

func (fake *FakeResource) TeamNameReturns(result1 string) {
	fake.teamNameMutex.Lock()
	defer fake.teamNameMutex.Unlock()
	fake.TeamNameStub = nil
	fake.teamNameReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeResource) TeamNameReturnsOnCall(i int, result1 string) {
	fake.teamNameMutex.Lock()
	defer fake.teamNameMutex.Unlock()
	fake.TeamNameStub = nil
	if fake.teamNameReturnsOnCall == nil {
		fake.teamNameReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.teamNameReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeResource) Type() string {
	fake.typeMutex.Lock()
	ret, specificReturn := fake.typeReturnsOnCall[len(fake.typeArgsForCall)]
	fake.typeArgsForCall = append(fake.typeArgsForCall, struct {
	}{})
	fake.recordInvocation("Type", []interface{}{})
	fake.typeMutex.Unlock()
	if fake.TypeStub != nil {
		return fake.TypeStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.typeReturns
	return fakeReturns.result1
}

func (fake *FakeResource) TypeCallCount() int {
	fake.typeMutex.RLock()
	defer fake.typeMutex.RUnlock()
	return len(fake.typeArgsForCall)
}

func (fake *FakeResource) TypeCalls(stub func() string) {
	fake.typeMutex.Lock()
	defer fake.typeMutex.Unlock()
	fake.TypeStub = stub
}

func (fake *FakeResource) TypeReturns(result1 string) {
	fake.typeMutex.Lock()
	defer fake.typeMutex.Unlock()
	fake.TypeStub = nil
	fake.typeReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeResource) TypeReturnsOnCall(i int, result1 string) {
	fake.typeMutex.Lock()
	defer fake.typeMutex.Unlock()
	fake.TypeStub = nil
	if fake.typeReturnsOnCall == nil {
		fake.typeReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.typeReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeResource) UnpinVersion() error {
	fake.unpinVersionMutex.Lock()
	ret, specificReturn := fake.unpinVersionReturnsOnCall[len(fake.unpinVersionArgsForCall)]
	fake.unpinVersionArgsForCall = append(fake.unpinVersionArgsForCall, struct {
	}{})
	fake.recordInvocation("UnpinVersion", []interface{}{})
	fake.unpinVersionMutex.Unlock()
	if fake.UnpinVersionStub != nil {
		return fake.UnpinVersionStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.unpinVersionReturns
	return fakeReturns.result1
}

func (fake *FakeResource) UnpinVersionCallCount() int {
	fake.unpinVersionMutex.RLock()
	defer fake.unpinVersionMutex.RUnlock()
	return len(fake.unpinVersionArgsForCall)
}

func (fake *FakeResource) UnpinVersionCalls(stub func() error) {
	fake.unpinVersionMutex.Lock()
	defer fake.unpinVersionMutex.Unlock()
	fake.UnpinVersionStub = stub
}

func (fake *FakeResource) UnpinVersionReturns(result1 error) {
	fake.unpinVersionMutex.Lock()
	defer fake.unpinVersionMutex.Unlock()
	fake.UnpinVersionStub = nil
	fake.unpinVersionReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeResource) UnpinVersionReturnsOnCall(i int, result1 error) {
	fake.unpinVersionMutex.Lock()
	defer fake.unpinVersionMutex.Unlock()
	fake.UnpinVersionStub = nil
	if fake.unpinVersionReturnsOnCall == nil {
		fake.unpinVersionReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.unpinVersionReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeResource) UpdateMetadata(arg1 atc.Version, arg2 db.ResourceConfigMetadataFields) (bool, error) {
	fake.updateMetadataMutex.Lock()
	ret, specificReturn := fake.updateMetadataReturnsOnCall[len(fake.updateMetadataArgsForCall)]
	fake.updateMetadataArgsForCall = append(fake.updateMetadataArgsForCall, struct {
		arg1 atc.Version
		arg2 db.ResourceConfigMetadataFields
	}{arg1, arg2})
	fake.recordInvocation("UpdateMetadata", []interface{}{arg1, arg2})
	fake.updateMetadataMutex.Unlock()
	if fake.UpdateMetadataStub != nil {
		return fake.UpdateMetadataStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateMetadataReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeResource) UpdateMetadataCallCount() int {
	fake.updateMetadataMutex.RLock()
	defer fake.updateMetadataMutex.RUnlock()
	return len(fake.updateMetadataArgsForCall)
}

func (fake *FakeResource) UpdateMetadataCalls(stub func(atc.Version, db.ResourceConfigMetadataFields) (bool, error)) {
	fake.updateMetadataMutex.Lock()
	defer fake.updateMetadataMutex.Unlock()
	fake.UpdateMetadataStub = stub
}

func (fake *FakeResource) UpdateMetadataArgsForCall(i int) (atc.Version, db.ResourceConfigMetadataFields) {
	fake.updateMetadataMutex.RLock()
	defer fake.updateMetadataMutex.RUnlock()
	argsForCall := fake.updateMetadataArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeResource) UpdateMetadataReturns(result1 bool, result2 error) {
	fake.updateMetadataMutex.Lock()
	defer fake.updateMetadataMutex.Unlock()
	fake.UpdateMetadataStub = nil
	fake.updateMetadataReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeResource) UpdateMetadataReturnsOnCall(i int, result1 bool, result2 error) {
	fake.updateMetadataMutex.Lock()
	defer fake.updateMetadataMutex.Unlock()
	fake.UpdateMetadataStub = nil
	if fake.updateMetadataReturnsOnCall == nil {
		fake.updateMetadataReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 error
		})
	}
	fake.updateMetadataReturnsOnCall[i] = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeResource) Versions(arg1 db.Page) ([]atc.ResourceVersion, db.Pagination, bool, error) {
	fake.versionsMutex.Lock()
	ret, specificReturn := fake.versionsReturnsOnCall[len(fake.versionsArgsForCall)]
	fake.versionsArgsForCall = append(fake.versionsArgsForCall, struct {
		arg1 db.Page
	}{arg1})
	fake.recordInvocation("Versions", []interface{}{arg1})
	fake.versionsMutex.Unlock()
	if fake.VersionsStub != nil {
		return fake.VersionsStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3, ret.result4
	}
	fakeReturns := fake.versionsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4
}

func (fake *FakeResource) VersionsCallCount() int {
	fake.versionsMutex.RLock()
	defer fake.versionsMutex.RUnlock()
	return len(fake.versionsArgsForCall)
}

func (fake *FakeResource) VersionsCalls(stub func(db.Page) ([]atc.ResourceVersion, db.Pagination, bool, error)) {
	fake.versionsMutex.Lock()
	defer fake.versionsMutex.Unlock()
	fake.VersionsStub = stub
}

func (fake *FakeResource) VersionsArgsForCall(i int) db.Page {
	fake.versionsMutex.RLock()
	defer fake.versionsMutex.RUnlock()
	argsForCall := fake.versionsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeResource) VersionsReturns(result1 []atc.ResourceVersion, result2 db.Pagination, result3 bool, result4 error) {
	fake.versionsMutex.Lock()
	defer fake.versionsMutex.Unlock()
	fake.VersionsStub = nil
	fake.versionsReturns = struct {
		result1 []atc.ResourceVersion
		result2 db.Pagination
		result3 bool
		result4 error
	}{result1, result2, result3, result4}
}

func (fake *FakeResource) VersionsReturnsOnCall(i int, result1 []atc.ResourceVersion, result2 db.Pagination, result3 bool, result4 error) {
	fake.versionsMutex.Lock()
	defer fake.versionsMutex.Unlock()
	fake.VersionsStub = nil
	if fake.versionsReturnsOnCall == nil {
		fake.versionsReturnsOnCall = make(map[int]struct {
			result1 []atc.ResourceVersion
			result2 db.Pagination
			result3 bool
			result4 error
		})
	}
	fake.versionsReturnsOnCall[i] = struct {
		result1 []atc.ResourceVersion
		result2 db.Pagination
		result3 bool
		result4 error
	}{result1, result2, result3, result4}
}

func (fake *FakeResource) WebhookToken() string {
	fake.webhookTokenMutex.Lock()
	ret, specificReturn := fake.webhookTokenReturnsOnCall[len(fake.webhookTokenArgsForCall)]
	fake.webhookTokenArgsForCall = append(fake.webhookTokenArgsForCall, struct {
	}{})
	fake.recordInvocation("WebhookToken", []interface{}{})
	fake.webhookTokenMutex.Unlock()
	if fake.WebhookTokenStub != nil {
		return fake.WebhookTokenStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.webhookTokenReturns
	return fakeReturns.result1
}

func (fake *FakeResource) WebhookTokenCallCount() int {
	fake.webhookTokenMutex.RLock()
	defer fake.webhookTokenMutex.RUnlock()
	return len(fake.webhookTokenArgsForCall)
}

func (fake *FakeResource) WebhookTokenCalls(stub func() string) {
	fake.webhookTokenMutex.Lock()
	defer fake.webhookTokenMutex.Unlock()
	fake.WebhookTokenStub = stub
}

func (fake *FakeResource) WebhookTokenReturns(result1 string) {
	fake.webhookTokenMutex.Lock()
	defer fake.webhookTokenMutex.Unlock()
	fake.WebhookTokenStub = nil
	fake.webhookTokenReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeResource) WebhookTokenReturnsOnCall(i int, result1 string) {
	fake.webhookTokenMutex.Lock()
	defer fake.webhookTokenMutex.Unlock()
	fake.WebhookTokenStub = nil
	if fake.webhookTokenReturnsOnCall == nil {
		fake.webhookTokenReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.webhookTokenReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeResource) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.aPIPinnedVersionMutex.RLock()
	defer fake.aPIPinnedVersionMutex.RUnlock()
	fake.checkErrorMutex.RLock()
	defer fake.checkErrorMutex.RUnlock()
	fake.checkEveryMutex.RLock()
	defer fake.checkEveryMutex.RUnlock()
	fake.checkSetupErrorMutex.RLock()
	defer fake.checkSetupErrorMutex.RUnlock()
	fake.checkTimeoutMutex.RLock()
	defer fake.checkTimeoutMutex.RUnlock()
	fake.configPinnedVersionMutex.RLock()
	defer fake.configPinnedVersionMutex.RUnlock()
	fake.currentPinnedVersionMutex.RLock()
	defer fake.currentPinnedVersionMutex.RUnlock()
	fake.disableVersionMutex.RLock()
	defer fake.disableVersionMutex.RUnlock()
	fake.enableVersionMutex.RLock()
	defer fake.enableVersionMutex.RUnlock()
	fake.iDMutex.RLock()
	defer fake.iDMutex.RUnlock()
	fake.iconMutex.RLock()
	defer fake.iconMutex.RUnlock()
	fake.lastCheckEndTimeMutex.RLock()
	defer fake.lastCheckEndTimeMutex.RUnlock()
	fake.lastCheckStartTimeMutex.RLock()
	defer fake.lastCheckStartTimeMutex.RUnlock()
	fake.nameMutex.RLock()
	defer fake.nameMutex.RUnlock()
	fake.notifyScanMutex.RLock()
	defer fake.notifyScanMutex.RUnlock()
	fake.pinCommentMutex.RLock()
	defer fake.pinCommentMutex.RUnlock()
	fake.pinVersionMutex.RLock()
	defer fake.pinVersionMutex.RUnlock()
	fake.pipelineIDMutex.RLock()
	defer fake.pipelineIDMutex.RUnlock()
	fake.pipelineNameMutex.RLock()
	defer fake.pipelineNameMutex.RUnlock()
	fake.publicMutex.RLock()
	defer fake.publicMutex.RUnlock()
	fake.reloadMutex.RLock()
	defer fake.reloadMutex.RUnlock()
	fake.resourceConfigIDMutex.RLock()
	defer fake.resourceConfigIDMutex.RUnlock()
	fake.resourceConfigScopeIDMutex.RLock()
	defer fake.resourceConfigScopeIDMutex.RUnlock()
	fake.resourceConfigVersionIDMutex.RLock()
	defer fake.resourceConfigVersionIDMutex.RUnlock()
	fake.saveUncheckedVersionMutex.RLock()
	defer fake.saveUncheckedVersionMutex.RUnlock()
	fake.setCheckSetupErrorMutex.RLock()
	defer fake.setCheckSetupErrorMutex.RUnlock()
	fake.setPinCommentMutex.RLock()
	defer fake.setPinCommentMutex.RUnlock()
	fake.setResourceConfigMutex.RLock()
	defer fake.setResourceConfigMutex.RUnlock()
	fake.sourceMutex.RLock()
	defer fake.sourceMutex.RUnlock()
	fake.tagsMutex.RLock()
	defer fake.tagsMutex.RUnlock()
	fake.teamNameMutex.RLock()
	defer fake.teamNameMutex.RUnlock()
	fake.typeMutex.RLock()
	defer fake.typeMutex.RUnlock()
	fake.unpinVersionMutex.RLock()
	defer fake.unpinVersionMutex.RUnlock()
	fake.updateMetadataMutex.RLock()
	defer fake.updateMetadataMutex.RUnlock()
	fake.versionsMutex.RLock()
	defer fake.versionsMutex.RUnlock()
	fake.webhookTokenMutex.RLock()
	defer fake.webhookTokenMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

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