github.com/pf-qiu/concourse/v6@v6.7.3-0.20201207032516-1f455d73275f/atc/db/dbfakes/fake_resource.go

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

import (
	"context"
	"sync"
	"time"

	"github.com/pf-qiu/concourse/v6/atc"
	"github.com/pf-qiu/concourse/v6/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
	}
	BuildSummaryStub        func() *atc.BuildSummary
	buildSummaryMutex       sync.RWMutex
	buildSummaryArgsForCall []struct {
	}
	buildSummaryReturns struct {
		result1 *atc.BuildSummary
	}
	buildSummaryReturnsOnCall map[int]struct {
		result1 *atc.BuildSummary
	}
	CheckEveryStub        func() string
	checkEveryMutex       sync.RWMutex
	checkEveryArgsForCall []struct {
	}
	checkEveryReturns struct {
		result1 string
	}
	checkEveryReturnsOnCall map[int]struct {
		result1 string
	}
	CheckPlanStub        func(atc.Version, time.Duration, db.ResourceTypes, atc.Source) atc.CheckPlan
	checkPlanMutex       sync.RWMutex
	checkPlanArgsForCall []struct {
		arg1 atc.Version
		arg2 time.Duration
		arg3 db.ResourceTypes
		arg4 atc.Source
	}
	checkPlanReturns struct {
		result1 atc.CheckPlan
	}
	checkPlanReturnsOnCall map[int]struct {
		result1 atc.CheckPlan
	}
	CheckTimeoutStub        func() string
	checkTimeoutMutex       sync.RWMutex
	checkTimeoutArgsForCall []struct {
	}
	checkTimeoutReturns struct {
		result1 string
	}
	checkTimeoutReturnsOnCall map[int]struct {
		result1 string
	}
	ConfigStub        func() atc.ResourceConfig
	configMutex       sync.RWMutex
	configArgsForCall []struct {
	}
	configReturns struct {
		result1 atc.ResourceConfig
	}
	configReturnsOnCall map[int]struct {
		result1 atc.ResourceConfig
	}
	ConfigPinnedVersionStub        func() atc.Version
	configPinnedVersionMutex       sync.RWMutex
	configPinnedVersionArgsForCall []struct {
	}
	configPinnedVersionReturns struct {
		result1 atc.Version
	}
	configPinnedVersionReturnsOnCall map[int]struct {
		result1 atc.Version
	}
	CreateBuildStub        func(context.Context, bool, atc.Plan) (db.Build, bool, error)
	createBuildMutex       sync.RWMutex
	createBuildArgsForCall []struct {
		arg1 context.Context
		arg2 bool
		arg3 atc.Plan
	}
	createBuildReturns struct {
		result1 db.Build
		result2 bool
		result3 error
	}
	createBuildReturnsOnCall map[int]struct {
		result1 db.Build
		result2 bool
		result3 error
	}
	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
	}
	FindVersionStub        func(atc.Version) (db.ResourceConfigVersion, bool, error)
	findVersionMutex       sync.RWMutex
	findVersionArgsForCall []struct {
		arg1 atc.Version
	}
	findVersionReturns struct {
		result1 db.ResourceConfigVersion
		result2 bool
		result3 error
	}
	findVersionReturnsOnCall map[int]struct {
		result1 db.ResourceConfigVersion
		result2 bool
		result3 error
	}
	HasWebhookStub        func() bool
	hasWebhookMutex       sync.RWMutex
	hasWebhookArgsForCall []struct {
	}
	hasWebhookReturns struct {
		result1 bool
	}
	hasWebhookReturnsOnCall map[int]struct {
		result1 bool
	}
	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) (bool, error)
	pinVersionMutex       sync.RWMutex
	pinVersionArgsForCall []struct {
		arg1 int
	}
	pinVersionReturns struct {
		result1 bool
		result2 error
	}
	pinVersionReturnsOnCall map[int]struct {
		result1 bool
		result2 error
	}
	PipelineStub        func() (db.Pipeline, bool, error)
	pipelineMutex       sync.RWMutex
	pipelineArgsForCall []struct {
	}
	pipelineReturns struct {
		result1 db.Pipeline
		result2 bool
		result3 error
	}
	pipelineReturnsOnCall map[int]struct {
		result1 db.Pipeline
		result2 bool
		result3 error
	}
	PipelineIDStub        func() int
	pipelineIDMutex       sync.RWMutex
	pipelineIDArgsForCall []struct {
	}
	pipelineIDReturns struct {
		result1 int
	}
	pipelineIDReturnsOnCall map[int]struct {
		result1 int
	}
	PipelineInstanceVarsStub        func() atc.InstanceVars
	pipelineInstanceVarsMutex       sync.RWMutex
	pipelineInstanceVarsArgsForCall []struct {
	}
	pipelineInstanceVarsReturns struct {
		result1 atc.InstanceVars
	}
	pipelineInstanceVarsReturnsOnCall map[int]struct {
		result1 atc.InstanceVars
	}
	PipelineNameStub        func() string
	pipelineNameMutex       sync.RWMutex
	pipelineNameArgsForCall []struct {
	}
	pipelineNameReturns struct {
		result1 string
	}
	pipelineNameReturnsOnCall map[int]struct {
		result1 string
	}
	PipelineRefStub        func() atc.PipelineRef
	pipelineRefMutex       sync.RWMutex
	pipelineRefArgsForCall []struct {
	}
	pipelineRefReturns struct {
		result1 atc.PipelineRef
	}
	pipelineRefReturnsOnCall map[int]struct {
		result1 atc.PipelineRef
	}
	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
	}
	SaveUncheckedVersionStub        func(atc.Version, db.ResourceConfigMetadataFields, db.ResourceConfig) (bool, error)
	saveUncheckedVersionMutex       sync.RWMutex
	saveUncheckedVersionArgsForCall []struct {
		arg1 atc.Version
		arg2 db.ResourceConfigMetadataFields
		arg3 db.ResourceConfig
	}
	saveUncheckedVersionReturns struct {
		result1 bool
		result2 error
	}
	saveUncheckedVersionReturnsOnCall map[int]struct {
		result1 bool
		result2 error
	}
	SetPinCommentStub        func(string) error
	setPinCommentMutex       sync.RWMutex
	setPinCommentArgsForCall []struct {
		arg1 string
	}
	setPinCommentReturns struct {
		result1 error
	}
	setPinCommentReturnsOnCall map[int]struct {
		result1 error
	}
	SetResourceConfigScopeStub        func(db.ResourceConfigScope) error
	setResourceConfigScopeMutex       sync.RWMutex
	setResourceConfigScopeArgsForCall []struct {
		arg1 db.ResourceConfigScope
	}
	setResourceConfigScopeReturns struct {
		result1 error
	}
	setResourceConfigScopeReturnsOnCall map[int]struct {
		result1 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
	}
	TeamIDStub        func() int
	teamIDMutex       sync.RWMutex
	teamIDArgsForCall []struct {
	}
	teamIDReturns struct {
		result1 int
	}
	teamIDReturnsOnCall map[int]struct {
		result1 int
	}
	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.Version) ([]atc.ResourceVersion, db.Pagination, bool, error)
	versionsMutex       sync.RWMutex
	versionsArgsForCall []struct {
		arg1 db.Page
		arg2 atc.Version
	}
	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) BuildSummary() *atc.BuildSummary {
	fake.buildSummaryMutex.Lock()
	ret, specificReturn := fake.buildSummaryReturnsOnCall[len(fake.buildSummaryArgsForCall)]
	fake.buildSummaryArgsForCall = append(fake.buildSummaryArgsForCall, struct {
	}{})
	fake.recordInvocation("BuildSummary", []interface{}{})
	fake.buildSummaryMutex.Unlock()
	if fake.BuildSummaryStub != nil {
		return fake.BuildSummaryStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.buildSummaryReturns
	return fakeReturns.result1
}

func (fake *FakeResource) BuildSummaryCallCount() int {
	fake.buildSummaryMutex.RLock()
	defer fake.buildSummaryMutex.RUnlock()
	return len(fake.buildSummaryArgsForCall)
}

func (fake *FakeResource) BuildSummaryCalls(stub func() *atc.BuildSummary) {
	fake.buildSummaryMutex.Lock()
	defer fake.buildSummaryMutex.Unlock()
	fake.BuildSummaryStub = stub
}

func (fake *FakeResource) BuildSummaryReturns(result1 *atc.BuildSummary) {
	fake.buildSummaryMutex.Lock()
	defer fake.buildSummaryMutex.Unlock()
	fake.BuildSummaryStub = nil
	fake.buildSummaryReturns = struct {
		result1 *atc.BuildSummary
	}{result1}
}

func (fake *FakeResource) BuildSummaryReturnsOnCall(i int, result1 *atc.BuildSummary) {
	fake.buildSummaryMutex.Lock()
	defer fake.buildSummaryMutex.Unlock()
	fake.BuildSummaryStub = nil
	if fake.buildSummaryReturnsOnCall == nil {
		fake.buildSummaryReturnsOnCall = make(map[int]struct {
			result1 *atc.BuildSummary
		})
	}
	fake.buildSummaryReturnsOnCall[i] = struct {
		result1 *atc.BuildSummary
	}{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) CheckPlan(arg1 atc.Version, arg2 time.Duration, arg3 db.ResourceTypes, arg4 atc.Source) atc.CheckPlan {
	fake.checkPlanMutex.Lock()
	ret, specificReturn := fake.checkPlanReturnsOnCall[len(fake.checkPlanArgsForCall)]
	fake.checkPlanArgsForCall = append(fake.checkPlanArgsForCall, struct {
		arg1 atc.Version
		arg2 time.Duration
		arg3 db.ResourceTypes
		arg4 atc.Source
	}{arg1, arg2, arg3, arg4})
	fake.recordInvocation("CheckPlan", []interface{}{arg1, arg2, arg3, arg4})
	fake.checkPlanMutex.Unlock()
	if fake.CheckPlanStub != nil {
		return fake.CheckPlanStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.checkPlanReturns
	return fakeReturns.result1
}

func (fake *FakeResource) CheckPlanCallCount() int {
	fake.checkPlanMutex.RLock()
	defer fake.checkPlanMutex.RUnlock()
	return len(fake.checkPlanArgsForCall)
}

func (fake *FakeResource) CheckPlanCalls(stub func(atc.Version, time.Duration, db.ResourceTypes, atc.Source) atc.CheckPlan) {
	fake.checkPlanMutex.Lock()
	defer fake.checkPlanMutex.Unlock()
	fake.CheckPlanStub = stub
}

func (fake *FakeResource) CheckPlanArgsForCall(i int) (atc.Version, time.Duration, db.ResourceTypes, atc.Source) {
	fake.checkPlanMutex.RLock()
	defer fake.checkPlanMutex.RUnlock()
	argsForCall := fake.checkPlanArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeResource) CheckPlanReturns(result1 atc.CheckPlan) {
	fake.checkPlanMutex.Lock()
	defer fake.checkPlanMutex.Unlock()
	fake.CheckPlanStub = nil
	fake.checkPlanReturns = struct {
		result1 atc.CheckPlan
	}{result1}
}

func (fake *FakeResource) CheckPlanReturnsOnCall(i int, result1 atc.CheckPlan) {
	fake.checkPlanMutex.Lock()
	defer fake.checkPlanMutex.Unlock()
	fake.CheckPlanStub = nil
	if fake.checkPlanReturnsOnCall == nil {
		fake.checkPlanReturnsOnCall = make(map[int]struct {
			result1 atc.CheckPlan
		})
	}
	fake.checkPlanReturnsOnCall[i] = struct {
		result1 atc.CheckPlan
	}{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) Config() atc.ResourceConfig {
	fake.configMutex.Lock()
	ret, specificReturn := fake.configReturnsOnCall[len(fake.configArgsForCall)]
	fake.configArgsForCall = append(fake.configArgsForCall, struct {
	}{})
	fake.recordInvocation("Config", []interface{}{})
	fake.configMutex.Unlock()
	if fake.ConfigStub != nil {
		return fake.ConfigStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.configReturns
	return fakeReturns.result1
}

func (fake *FakeResource) ConfigCallCount() int {
	fake.configMutex.RLock()
	defer fake.configMutex.RUnlock()
	return len(fake.configArgsForCall)
}

func (fake *FakeResource) ConfigCalls(stub func() atc.ResourceConfig) {
	fake.configMutex.Lock()
	defer fake.configMutex.Unlock()
	fake.ConfigStub = stub
}

func (fake *FakeResource) ConfigReturns(result1 atc.ResourceConfig) {
	fake.configMutex.Lock()
	defer fake.configMutex.Unlock()
	fake.ConfigStub = nil
	fake.configReturns = struct {
		result1 atc.ResourceConfig
	}{result1}
}

func (fake *FakeResource) ConfigReturnsOnCall(i int, result1 atc.ResourceConfig) {
	fake.configMutex.Lock()
	defer fake.configMutex.Unlock()
	fake.ConfigStub = nil
	if fake.configReturnsOnCall == nil {
		fake.configReturnsOnCall = make(map[int]struct {
			result1 atc.ResourceConfig
		})
	}
	fake.configReturnsOnCall[i] = struct {
		result1 atc.ResourceConfig
	}{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) CreateBuild(arg1 context.Context, arg2 bool, arg3 atc.Plan) (db.Build, bool, error) {
	fake.createBuildMutex.Lock()
	ret, specificReturn := fake.createBuildReturnsOnCall[len(fake.createBuildArgsForCall)]
	fake.createBuildArgsForCall = append(fake.createBuildArgsForCall, struct {
		arg1 context.Context
		arg2 bool
		arg3 atc.Plan
	}{arg1, arg2, arg3})
	fake.recordInvocation("CreateBuild", []interface{}{arg1, arg2, arg3})
	fake.createBuildMutex.Unlock()
	if fake.CreateBuildStub != nil {
		return fake.CreateBuildStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createBuildReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeResource) CreateBuildCallCount() int {
	fake.createBuildMutex.RLock()
	defer fake.createBuildMutex.RUnlock()
	return len(fake.createBuildArgsForCall)
}

func (fake *FakeResource) CreateBuildCalls(stub func(context.Context, bool, atc.Plan) (db.Build, bool, error)) {
	fake.createBuildMutex.Lock()
	defer fake.createBuildMutex.Unlock()
	fake.CreateBuildStub = stub
}

func (fake *FakeResource) CreateBuildArgsForCall(i int) (context.Context, bool, atc.Plan) {
	fake.createBuildMutex.RLock()
	defer fake.createBuildMutex.RUnlock()
	argsForCall := fake.createBuildArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeResource) CreateBuildReturns(result1 db.Build, result2 bool, result3 error) {
	fake.createBuildMutex.Lock()
	defer fake.createBuildMutex.Unlock()
	fake.CreateBuildStub = nil
	fake.createBuildReturns = struct {
		result1 db.Build
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeResource) CreateBuildReturnsOnCall(i int, result1 db.Build, result2 bool, result3 error) {
	fake.createBuildMutex.Lock()
	defer fake.createBuildMutex.Unlock()
	fake.CreateBuildStub = nil
	if fake.createBuildReturnsOnCall == nil {
		fake.createBuildReturnsOnCall = make(map[int]struct {
			result1 db.Build
			result2 bool
			result3 error
		})
	}
	fake.createBuildReturnsOnCall[i] = struct {
		result1 db.Build
		result2 bool
		result3 error
	}{result1, result2, result3}
}

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) FindVersion(arg1 atc.Version) (db.ResourceConfigVersion, bool, error) {
	fake.findVersionMutex.Lock()
	ret, specificReturn := fake.findVersionReturnsOnCall[len(fake.findVersionArgsForCall)]
	fake.findVersionArgsForCall = append(fake.findVersionArgsForCall, struct {
		arg1 atc.Version
	}{arg1})
	fake.recordInvocation("FindVersion", []interface{}{arg1})
	fake.findVersionMutex.Unlock()
	if fake.FindVersionStub != nil {
		return fake.FindVersionStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.findVersionReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeResource) FindVersionCallCount() int {
	fake.findVersionMutex.RLock()
	defer fake.findVersionMutex.RUnlock()
	return len(fake.findVersionArgsForCall)
}

func (fake *FakeResource) FindVersionCalls(stub func(atc.Version) (db.ResourceConfigVersion, bool, error)) {
	fake.findVersionMutex.Lock()
	defer fake.findVersionMutex.Unlock()
	fake.FindVersionStub = stub
}

func (fake *FakeResource) FindVersionArgsForCall(i int) atc.Version {
	fake.findVersionMutex.RLock()
	defer fake.findVersionMutex.RUnlock()
	argsForCall := fake.findVersionArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeResource) FindVersionReturns(result1 db.ResourceConfigVersion, result2 bool, result3 error) {
	fake.findVersionMutex.Lock()
	defer fake.findVersionMutex.Unlock()
	fake.FindVersionStub = nil
	fake.findVersionReturns = struct {
		result1 db.ResourceConfigVersion
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeResource) FindVersionReturnsOnCall(i int, result1 db.ResourceConfigVersion, result2 bool, result3 error) {
	fake.findVersionMutex.Lock()
	defer fake.findVersionMutex.Unlock()
	fake.FindVersionStub = nil
	if fake.findVersionReturnsOnCall == nil {
		fake.findVersionReturnsOnCall = make(map[int]struct {
			result1 db.ResourceConfigVersion
			result2 bool
			result3 error
		})
	}
	fake.findVersionReturnsOnCall[i] = struct {
		result1 db.ResourceConfigVersion
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeResource) HasWebhook() bool {
	fake.hasWebhookMutex.Lock()
	ret, specificReturn := fake.hasWebhookReturnsOnCall[len(fake.hasWebhookArgsForCall)]
	fake.hasWebhookArgsForCall = append(fake.hasWebhookArgsForCall, struct {
	}{})
	fake.recordInvocation("HasWebhook", []interface{}{})
	fake.hasWebhookMutex.Unlock()
	if fake.HasWebhookStub != nil {
		return fake.HasWebhookStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.hasWebhookReturns
	return fakeReturns.result1
}

func (fake *FakeResource) HasWebhookCallCount() int {
	fake.hasWebhookMutex.RLock()
	defer fake.hasWebhookMutex.RUnlock()
	return len(fake.hasWebhookArgsForCall)
}

func (fake *FakeResource) HasWebhookCalls(stub func() bool) {
	fake.hasWebhookMutex.Lock()
	defer fake.hasWebhookMutex.Unlock()
	fake.HasWebhookStub = stub
}

func (fake *FakeResource) HasWebhookReturns(result1 bool) {
	fake.hasWebhookMutex.Lock()
	defer fake.hasWebhookMutex.Unlock()
	fake.HasWebhookStub = nil
	fake.hasWebhookReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeResource) HasWebhookReturnsOnCall(i int, result1 bool) {
	fake.hasWebhookMutex.Lock()
	defer fake.hasWebhookMutex.Unlock()
	fake.HasWebhookStub = nil
	if fake.hasWebhookReturnsOnCall == nil {
		fake.hasWebhookReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.hasWebhookReturnsOnCall[i] = struct {
		result1 bool
	}{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) (bool, 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, ret.result2
	}
	fakeReturns := fake.pinVersionReturns
	return fakeReturns.result1, fakeReturns.result2
}

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

func (fake *FakeResource) PinVersionCalls(stub func(int) (bool, 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 bool, result2 error) {
	fake.pinVersionMutex.Lock()
	defer fake.pinVersionMutex.Unlock()
	fake.PinVersionStub = nil
	fake.pinVersionReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

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

func (fake *FakeResource) Pipeline() (db.Pipeline, bool, error) {
	fake.pipelineMutex.Lock()
	ret, specificReturn := fake.pipelineReturnsOnCall[len(fake.pipelineArgsForCall)]
	fake.pipelineArgsForCall = append(fake.pipelineArgsForCall, struct {
	}{})
	fake.recordInvocation("Pipeline", []interface{}{})
	fake.pipelineMutex.Unlock()
	if fake.PipelineStub != nil {
		return fake.PipelineStub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.pipelineReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeResource) PipelineCallCount() int {
	fake.pipelineMutex.RLock()
	defer fake.pipelineMutex.RUnlock()
	return len(fake.pipelineArgsForCall)
}

func (fake *FakeResource) PipelineCalls(stub func() (db.Pipeline, bool, error)) {
	fake.pipelineMutex.Lock()
	defer fake.pipelineMutex.Unlock()
	fake.PipelineStub = stub
}

func (fake *FakeResource) PipelineReturns(result1 db.Pipeline, result2 bool, result3 error) {
	fake.pipelineMutex.Lock()
	defer fake.pipelineMutex.Unlock()
	fake.PipelineStub = nil
	fake.pipelineReturns = struct {
		result1 db.Pipeline
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeResource) PipelineReturnsOnCall(i int, result1 db.Pipeline, result2 bool, result3 error) {
	fake.pipelineMutex.Lock()
	defer fake.pipelineMutex.Unlock()
	fake.PipelineStub = nil
	if fake.pipelineReturnsOnCall == nil {
		fake.pipelineReturnsOnCall = make(map[int]struct {
			result1 db.Pipeline
			result2 bool
			result3 error
		})
	}
	fake.pipelineReturnsOnCall[i] = struct {
		result1 db.Pipeline
		result2 bool
		result3 error
	}{result1, result2, result3}
}

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) PipelineInstanceVars() atc.InstanceVars {
	fake.pipelineInstanceVarsMutex.Lock()
	ret, specificReturn := fake.pipelineInstanceVarsReturnsOnCall[len(fake.pipelineInstanceVarsArgsForCall)]
	fake.pipelineInstanceVarsArgsForCall = append(fake.pipelineInstanceVarsArgsForCall, struct {
	}{})
	fake.recordInvocation("PipelineInstanceVars", []interface{}{})
	fake.pipelineInstanceVarsMutex.Unlock()
	if fake.PipelineInstanceVarsStub != nil {
		return fake.PipelineInstanceVarsStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.pipelineInstanceVarsReturns
	return fakeReturns.result1
}

func (fake *FakeResource) PipelineInstanceVarsCallCount() int {
	fake.pipelineInstanceVarsMutex.RLock()
	defer fake.pipelineInstanceVarsMutex.RUnlock()
	return len(fake.pipelineInstanceVarsArgsForCall)
}

func (fake *FakeResource) PipelineInstanceVarsCalls(stub func() atc.InstanceVars) {
	fake.pipelineInstanceVarsMutex.Lock()
	defer fake.pipelineInstanceVarsMutex.Unlock()
	fake.PipelineInstanceVarsStub = stub
}

func (fake *FakeResource) PipelineInstanceVarsReturns(result1 atc.InstanceVars) {
	fake.pipelineInstanceVarsMutex.Lock()
	defer fake.pipelineInstanceVarsMutex.Unlock()
	fake.PipelineInstanceVarsStub = nil
	fake.pipelineInstanceVarsReturns = struct {
		result1 atc.InstanceVars
	}{result1}
}

func (fake *FakeResource) PipelineInstanceVarsReturnsOnCall(i int, result1 atc.InstanceVars) {
	fake.pipelineInstanceVarsMutex.Lock()
	defer fake.pipelineInstanceVarsMutex.Unlock()
	fake.PipelineInstanceVarsStub = nil
	if fake.pipelineInstanceVarsReturnsOnCall == nil {
		fake.pipelineInstanceVarsReturnsOnCall = make(map[int]struct {
			result1 atc.InstanceVars
		})
	}
	fake.pipelineInstanceVarsReturnsOnCall[i] = struct {
		result1 atc.InstanceVars
	}{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) PipelineRef() atc.PipelineRef {
	fake.pipelineRefMutex.Lock()
	ret, specificReturn := fake.pipelineRefReturnsOnCall[len(fake.pipelineRefArgsForCall)]
	fake.pipelineRefArgsForCall = append(fake.pipelineRefArgsForCall, struct {
	}{})
	fake.recordInvocation("PipelineRef", []interface{}{})
	fake.pipelineRefMutex.Unlock()
	if fake.PipelineRefStub != nil {
		return fake.PipelineRefStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.pipelineRefReturns
	return fakeReturns.result1
}

func (fake *FakeResource) PipelineRefCallCount() int {
	fake.pipelineRefMutex.RLock()
	defer fake.pipelineRefMutex.RUnlock()
	return len(fake.pipelineRefArgsForCall)
}

func (fake *FakeResource) PipelineRefCalls(stub func() atc.PipelineRef) {
	fake.pipelineRefMutex.Lock()
	defer fake.pipelineRefMutex.Unlock()
	fake.PipelineRefStub = stub
}

func (fake *FakeResource) PipelineRefReturns(result1 atc.PipelineRef) {
	fake.pipelineRefMutex.Lock()
	defer fake.pipelineRefMutex.Unlock()
	fake.PipelineRefStub = nil
	fake.pipelineRefReturns = struct {
		result1 atc.PipelineRef
	}{result1}
}

func (fake *FakeResource) PipelineRefReturnsOnCall(i int, result1 atc.PipelineRef) {
	fake.pipelineRefMutex.Lock()
	defer fake.pipelineRefMutex.Unlock()
	fake.PipelineRefStub = nil
	if fake.pipelineRefReturnsOnCall == nil {
		fake.pipelineRefReturnsOnCall = make(map[int]struct {
			result1 atc.PipelineRef
		})
	}
	fake.pipelineRefReturnsOnCall[i] = struct {
		result1 atc.PipelineRef
	}{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) SaveUncheckedVersion(arg1 atc.Version, arg2 db.ResourceConfigMetadataFields, arg3 db.ResourceConfig) (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
	}{arg1, arg2, arg3})
	fake.recordInvocation("SaveUncheckedVersion", []interface{}{arg1, arg2, arg3})
	fake.saveUncheckedVersionMutex.Unlock()
	if fake.SaveUncheckedVersionStub != nil {
		return fake.SaveUncheckedVersionStub(arg1, arg2, arg3)
	}
	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) (bool, error)) {
	fake.saveUncheckedVersionMutex.Lock()
	defer fake.saveUncheckedVersionMutex.Unlock()
	fake.SaveUncheckedVersionStub = stub
}

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

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) 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) SetResourceConfigScope(arg1 db.ResourceConfigScope) error {
	fake.setResourceConfigScopeMutex.Lock()
	ret, specificReturn := fake.setResourceConfigScopeReturnsOnCall[len(fake.setResourceConfigScopeArgsForCall)]
	fake.setResourceConfigScopeArgsForCall = append(fake.setResourceConfigScopeArgsForCall, struct {
		arg1 db.ResourceConfigScope
	}{arg1})
	fake.recordInvocation("SetResourceConfigScope", []interface{}{arg1})
	fake.setResourceConfigScopeMutex.Unlock()
	if fake.SetResourceConfigScopeStub != nil {
		return fake.SetResourceConfigScopeStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.setResourceConfigScopeReturns
	return fakeReturns.result1
}

func (fake *FakeResource) SetResourceConfigScopeCallCount() int {
	fake.setResourceConfigScopeMutex.RLock()
	defer fake.setResourceConfigScopeMutex.RUnlock()
	return len(fake.setResourceConfigScopeArgsForCall)
}

func (fake *FakeResource) SetResourceConfigScopeCalls(stub func(db.ResourceConfigScope) error) {
	fake.setResourceConfigScopeMutex.Lock()
	defer fake.setResourceConfigScopeMutex.Unlock()
	fake.SetResourceConfigScopeStub = stub
}

func (fake *FakeResource) SetResourceConfigScopeArgsForCall(i int) db.ResourceConfigScope {
	fake.setResourceConfigScopeMutex.RLock()
	defer fake.setResourceConfigScopeMutex.RUnlock()
	argsForCall := fake.setResourceConfigScopeArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeResource) SetResourceConfigScopeReturns(result1 error) {
	fake.setResourceConfigScopeMutex.Lock()
	defer fake.setResourceConfigScopeMutex.Unlock()
	fake.SetResourceConfigScopeStub = nil
	fake.setResourceConfigScopeReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeResource) SetResourceConfigScopeReturnsOnCall(i int, result1 error) {
	fake.setResourceConfigScopeMutex.Lock()
	defer fake.setResourceConfigScopeMutex.Unlock()
	fake.SetResourceConfigScopeStub = nil
	if fake.setResourceConfigScopeReturnsOnCall == nil {
		fake.setResourceConfigScopeReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.setResourceConfigScopeReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

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) TeamID() int {
	fake.teamIDMutex.Lock()
	ret, specificReturn := fake.teamIDReturnsOnCall[len(fake.teamIDArgsForCall)]
	fake.teamIDArgsForCall = append(fake.teamIDArgsForCall, struct {
	}{})
	fake.recordInvocation("TeamID", []interface{}{})
	fake.teamIDMutex.Unlock()
	if fake.TeamIDStub != nil {
		return fake.TeamIDStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.teamIDReturns
	return fakeReturns.result1
}

func (fake *FakeResource) TeamIDCallCount() int {
	fake.teamIDMutex.RLock()
	defer fake.teamIDMutex.RUnlock()
	return len(fake.teamIDArgsForCall)
}

func (fake *FakeResource) TeamIDCalls(stub func() int) {
	fake.teamIDMutex.Lock()
	defer fake.teamIDMutex.Unlock()
	fake.TeamIDStub = stub
}

func (fake *FakeResource) TeamIDReturns(result1 int) {
	fake.teamIDMutex.Lock()
	defer fake.teamIDMutex.Unlock()
	fake.TeamIDStub = nil
	fake.teamIDReturns = struct {
		result1 int
	}{result1}
}

func (fake *FakeResource) TeamIDReturnsOnCall(i int, result1 int) {
	fake.teamIDMutex.Lock()
	defer fake.teamIDMutex.Unlock()
	fake.TeamIDStub = nil
	if fake.teamIDReturnsOnCall == nil {
		fake.teamIDReturnsOnCall = make(map[int]struct {
			result1 int
		})
	}
	fake.teamIDReturnsOnCall[i] = struct {
		result1 int
	}{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, arg2 atc.Version) ([]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
		arg2 atc.Version
	}{arg1, arg2})
	fake.recordInvocation("Versions", []interface{}{arg1, arg2})
	fake.versionsMutex.Unlock()
	if fake.VersionsStub != nil {
		return fake.VersionsStub(arg1, arg2)
	}
	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.Version) ([]atc.ResourceVersion, db.Pagination, bool, error)) {
	fake.versionsMutex.Lock()
	defer fake.versionsMutex.Unlock()
	fake.VersionsStub = stub
}

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

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.buildSummaryMutex.RLock()
	defer fake.buildSummaryMutex.RUnlock()
	fake.checkEveryMutex.RLock()
	defer fake.checkEveryMutex.RUnlock()
	fake.checkPlanMutex.RLock()
	defer fake.checkPlanMutex.RUnlock()
	fake.checkTimeoutMutex.RLock()
	defer fake.checkTimeoutMutex.RUnlock()
	fake.configMutex.RLock()
	defer fake.configMutex.RUnlock()
	fake.configPinnedVersionMutex.RLock()
	defer fake.configPinnedVersionMutex.RUnlock()
	fake.createBuildMutex.RLock()
	defer fake.createBuildMutex.RUnlock()
	fake.currentPinnedVersionMutex.RLock()
	defer fake.currentPinnedVersionMutex.RUnlock()
	fake.disableVersionMutex.RLock()
	defer fake.disableVersionMutex.RUnlock()
	fake.enableVersionMutex.RLock()
	defer fake.enableVersionMutex.RUnlock()
	fake.findVersionMutex.RLock()
	defer fake.findVersionMutex.RUnlock()
	fake.hasWebhookMutex.RLock()
	defer fake.hasWebhookMutex.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.pipelineMutex.RLock()
	defer fake.pipelineMutex.RUnlock()
	fake.pipelineIDMutex.RLock()
	defer fake.pipelineIDMutex.RUnlock()
	fake.pipelineInstanceVarsMutex.RLock()
	defer fake.pipelineInstanceVarsMutex.RUnlock()
	fake.pipelineNameMutex.RLock()
	defer fake.pipelineNameMutex.RUnlock()
	fake.pipelineRefMutex.RLock()
	defer fake.pipelineRefMutex.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.saveUncheckedVersionMutex.RLock()
	defer fake.saveUncheckedVersionMutex.RUnlock()
	fake.setPinCommentMutex.RLock()
	defer fake.setPinCommentMutex.RUnlock()
	fake.setResourceConfigScopeMutex.RLock()
	defer fake.setResourceConfigScopeMutex.RUnlock()
	fake.sourceMutex.RLock()
	defer fake.sourceMutex.RUnlock()
	fake.tagsMutex.RLock()
	defer fake.tagsMutex.RUnlock()
	fake.teamIDMutex.RLock()
	defer fake.teamIDMutex.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)