2362 lines
70 KiB
Go
2362 lines
70 KiB
Go
// Code generated by counterfeiter. DO NOT EDIT.
|
|
package dbfakes
|
|
|
|
import (
|
|
"sync"
|
|
"time"
|
|
|
|
"code.cloudfoundry.org/lager"
|
|
"github.com/concourse/concourse/atc"
|
|
"github.com/concourse/concourse/atc/creds"
|
|
"github.com/concourse/concourse/atc/db"
|
|
)
|
|
|
|
type FakeTeam struct {
|
|
AdminStub func() bool
|
|
adminMutex sync.RWMutex
|
|
adminArgsForCall []struct {
|
|
}
|
|
adminReturns struct {
|
|
result1 bool
|
|
}
|
|
adminReturnsOnCall map[int]struct {
|
|
result1 bool
|
|
}
|
|
AuthStub func() atc.TeamAuth
|
|
authMutex sync.RWMutex
|
|
authArgsForCall []struct {
|
|
}
|
|
authReturns struct {
|
|
result1 atc.TeamAuth
|
|
}
|
|
authReturnsOnCall map[int]struct {
|
|
result1 atc.TeamAuth
|
|
}
|
|
BuildsStub func(db.Page) ([]db.Build, db.Pagination, error)
|
|
buildsMutex sync.RWMutex
|
|
buildsArgsForCall []struct {
|
|
arg1 db.Page
|
|
}
|
|
buildsReturns struct {
|
|
result1 []db.Build
|
|
result2 db.Pagination
|
|
result3 error
|
|
}
|
|
buildsReturnsOnCall map[int]struct {
|
|
result1 []db.Build
|
|
result2 db.Pagination
|
|
result3 error
|
|
}
|
|
BuildsWithTimeStub func(db.Page) ([]db.Build, db.Pagination, error)
|
|
buildsWithTimeMutex sync.RWMutex
|
|
buildsWithTimeArgsForCall []struct {
|
|
arg1 db.Page
|
|
}
|
|
buildsWithTimeReturns struct {
|
|
result1 []db.Build
|
|
result2 db.Pagination
|
|
result3 error
|
|
}
|
|
buildsWithTimeReturnsOnCall map[int]struct {
|
|
result1 []db.Build
|
|
result2 db.Pagination
|
|
result3 error
|
|
}
|
|
ContainersStub func() ([]db.Container, error)
|
|
containersMutex sync.RWMutex
|
|
containersArgsForCall []struct {
|
|
}
|
|
containersReturns struct {
|
|
result1 []db.Container
|
|
result2 error
|
|
}
|
|
containersReturnsOnCall map[int]struct {
|
|
result1 []db.Container
|
|
result2 error
|
|
}
|
|
CreateOneOffBuildStub func() (db.Build, error)
|
|
createOneOffBuildMutex sync.RWMutex
|
|
createOneOffBuildArgsForCall []struct {
|
|
}
|
|
createOneOffBuildReturns struct {
|
|
result1 db.Build
|
|
result2 error
|
|
}
|
|
createOneOffBuildReturnsOnCall map[int]struct {
|
|
result1 db.Build
|
|
result2 error
|
|
}
|
|
CreateStartedBuildStub func(atc.Plan) (db.Build, error)
|
|
createStartedBuildMutex sync.RWMutex
|
|
createStartedBuildArgsForCall []struct {
|
|
arg1 atc.Plan
|
|
}
|
|
createStartedBuildReturns struct {
|
|
result1 db.Build
|
|
result2 error
|
|
}
|
|
createStartedBuildReturnsOnCall map[int]struct {
|
|
result1 db.Build
|
|
result2 error
|
|
}
|
|
DeleteStub func() error
|
|
deleteMutex sync.RWMutex
|
|
deleteArgsForCall []struct {
|
|
}
|
|
deleteReturns struct {
|
|
result1 error
|
|
}
|
|
deleteReturnsOnCall map[int]struct {
|
|
result1 error
|
|
}
|
|
FindCheckContainersStub func(lager.Logger, atc.PipelineRef, string, creds.Secrets, creds.VarSourcePool) ([]db.Container, map[int]time.Time, error)
|
|
findCheckContainersMutex sync.RWMutex
|
|
findCheckContainersArgsForCall []struct {
|
|
arg1 lager.Logger
|
|
arg2 atc.PipelineRef
|
|
arg3 string
|
|
arg4 creds.Secrets
|
|
arg5 creds.VarSourcePool
|
|
}
|
|
findCheckContainersReturns struct {
|
|
result1 []db.Container
|
|
result2 map[int]time.Time
|
|
result3 error
|
|
}
|
|
findCheckContainersReturnsOnCall map[int]struct {
|
|
result1 []db.Container
|
|
result2 map[int]time.Time
|
|
result3 error
|
|
}
|
|
FindContainerByHandleStub func(string) (db.Container, bool, error)
|
|
findContainerByHandleMutex sync.RWMutex
|
|
findContainerByHandleArgsForCall []struct {
|
|
arg1 string
|
|
}
|
|
findContainerByHandleReturns struct {
|
|
result1 db.Container
|
|
result2 bool
|
|
result3 error
|
|
}
|
|
findContainerByHandleReturnsOnCall map[int]struct {
|
|
result1 db.Container
|
|
result2 bool
|
|
result3 error
|
|
}
|
|
FindContainersByMetadataStub func(db.ContainerMetadata) ([]db.Container, error)
|
|
findContainersByMetadataMutex sync.RWMutex
|
|
findContainersByMetadataArgsForCall []struct {
|
|
arg1 db.ContainerMetadata
|
|
}
|
|
findContainersByMetadataReturns struct {
|
|
result1 []db.Container
|
|
result2 error
|
|
}
|
|
findContainersByMetadataReturnsOnCall map[int]struct {
|
|
result1 []db.Container
|
|
result2 error
|
|
}
|
|
FindCreatedContainerByHandleStub func(string) (db.CreatedContainer, bool, error)
|
|
findCreatedContainerByHandleMutex sync.RWMutex
|
|
findCreatedContainerByHandleArgsForCall []struct {
|
|
arg1 string
|
|
}
|
|
findCreatedContainerByHandleReturns struct {
|
|
result1 db.CreatedContainer
|
|
result2 bool
|
|
result3 error
|
|
}
|
|
findCreatedContainerByHandleReturnsOnCall map[int]struct {
|
|
result1 db.CreatedContainer
|
|
result2 bool
|
|
result3 error
|
|
}
|
|
FindVolumeForWorkerArtifactStub func(int) (db.CreatedVolume, bool, error)
|
|
findVolumeForWorkerArtifactMutex sync.RWMutex
|
|
findVolumeForWorkerArtifactArgsForCall []struct {
|
|
arg1 int
|
|
}
|
|
findVolumeForWorkerArtifactReturns struct {
|
|
result1 db.CreatedVolume
|
|
result2 bool
|
|
result3 error
|
|
}
|
|
findVolumeForWorkerArtifactReturnsOnCall map[int]struct {
|
|
result1 db.CreatedVolume
|
|
result2 bool
|
|
result3 error
|
|
}
|
|
FindWorkerForContainerStub func(string) (db.Worker, bool, error)
|
|
findWorkerForContainerMutex sync.RWMutex
|
|
findWorkerForContainerArgsForCall []struct {
|
|
arg1 string
|
|
}
|
|
findWorkerForContainerReturns struct {
|
|
result1 db.Worker
|
|
result2 bool
|
|
result3 error
|
|
}
|
|
findWorkerForContainerReturnsOnCall map[int]struct {
|
|
result1 db.Worker
|
|
result2 bool
|
|
result3 error
|
|
}
|
|
FindWorkerForVolumeStub func(string) (db.Worker, bool, error)
|
|
findWorkerForVolumeMutex sync.RWMutex
|
|
findWorkerForVolumeArgsForCall []struct {
|
|
arg1 string
|
|
}
|
|
findWorkerForVolumeReturns struct {
|
|
result1 db.Worker
|
|
result2 bool
|
|
result3 error
|
|
}
|
|
findWorkerForVolumeReturnsOnCall map[int]struct {
|
|
result1 db.Worker
|
|
result2 bool
|
|
result3 error
|
|
}
|
|
IDStub func() int
|
|
iDMutex sync.RWMutex
|
|
iDArgsForCall []struct {
|
|
}
|
|
iDReturns struct {
|
|
result1 int
|
|
}
|
|
iDReturnsOnCall map[int]struct {
|
|
result1 int
|
|
}
|
|
IsCheckContainerStub func(string) (bool, error)
|
|
isCheckContainerMutex sync.RWMutex
|
|
isCheckContainerArgsForCall []struct {
|
|
arg1 string
|
|
}
|
|
isCheckContainerReturns struct {
|
|
result1 bool
|
|
result2 error
|
|
}
|
|
isCheckContainerReturnsOnCall map[int]struct {
|
|
result1 bool
|
|
result2 error
|
|
}
|
|
IsContainerWithinTeamStub func(string, bool) (bool, error)
|
|
isContainerWithinTeamMutex sync.RWMutex
|
|
isContainerWithinTeamArgsForCall []struct {
|
|
arg1 string
|
|
arg2 bool
|
|
}
|
|
isContainerWithinTeamReturns struct {
|
|
result1 bool
|
|
result2 error
|
|
}
|
|
isContainerWithinTeamReturnsOnCall map[int]struct {
|
|
result1 bool
|
|
result2 error
|
|
}
|
|
NameStub func() string
|
|
nameMutex sync.RWMutex
|
|
nameArgsForCall []struct {
|
|
}
|
|
nameReturns struct {
|
|
result1 string
|
|
}
|
|
nameReturnsOnCall map[int]struct {
|
|
result1 string
|
|
}
|
|
OrderPipelinesStub func([]string) error
|
|
orderPipelinesMutex sync.RWMutex
|
|
orderPipelinesArgsForCall []struct {
|
|
arg1 []string
|
|
}
|
|
orderPipelinesReturns struct {
|
|
result1 error
|
|
}
|
|
orderPipelinesReturnsOnCall map[int]struct {
|
|
result1 error
|
|
}
|
|
PipelineStub func(atc.PipelineRef) (db.Pipeline, bool, error)
|
|
pipelineMutex sync.RWMutex
|
|
pipelineArgsForCall []struct {
|
|
arg1 atc.PipelineRef
|
|
}
|
|
pipelineReturns struct {
|
|
result1 db.Pipeline
|
|
result2 bool
|
|
result3 error
|
|
}
|
|
pipelineReturnsOnCall map[int]struct {
|
|
result1 db.Pipeline
|
|
result2 bool
|
|
result3 error
|
|
}
|
|
PipelinesStub func() ([]db.Pipeline, error)
|
|
pipelinesMutex sync.RWMutex
|
|
pipelinesArgsForCall []struct {
|
|
}
|
|
pipelinesReturns struct {
|
|
result1 []db.Pipeline
|
|
result2 error
|
|
}
|
|
pipelinesReturnsOnCall map[int]struct {
|
|
result1 []db.Pipeline
|
|
result2 error
|
|
}
|
|
PrivateAndPublicBuildsStub func(db.Page) ([]db.Build, db.Pagination, error)
|
|
privateAndPublicBuildsMutex sync.RWMutex
|
|
privateAndPublicBuildsArgsForCall []struct {
|
|
arg1 db.Page
|
|
}
|
|
privateAndPublicBuildsReturns struct {
|
|
result1 []db.Build
|
|
result2 db.Pagination
|
|
result3 error
|
|
}
|
|
privateAndPublicBuildsReturnsOnCall map[int]struct {
|
|
result1 []db.Build
|
|
result2 db.Pagination
|
|
result3 error
|
|
}
|
|
PublicPipelinesStub func() ([]db.Pipeline, error)
|
|
publicPipelinesMutex sync.RWMutex
|
|
publicPipelinesArgsForCall []struct {
|
|
}
|
|
publicPipelinesReturns struct {
|
|
result1 []db.Pipeline
|
|
result2 error
|
|
}
|
|
publicPipelinesReturnsOnCall map[int]struct {
|
|
result1 []db.Pipeline
|
|
result2 error
|
|
}
|
|
RenameStub func(string) error
|
|
renameMutex sync.RWMutex
|
|
renameArgsForCall []struct {
|
|
arg1 string
|
|
}
|
|
renameReturns struct {
|
|
result1 error
|
|
}
|
|
renameReturnsOnCall map[int]struct {
|
|
result1 error
|
|
}
|
|
RenamePipelineStub func(string, string) (bool, error)
|
|
renamePipelineMutex sync.RWMutex
|
|
renamePipelineArgsForCall []struct {
|
|
arg1 string
|
|
arg2 string
|
|
}
|
|
renamePipelineReturns struct {
|
|
result1 bool
|
|
result2 error
|
|
}
|
|
renamePipelineReturnsOnCall map[int]struct {
|
|
result1 bool
|
|
result2 error
|
|
}
|
|
SavePipelineStub func(atc.PipelineRef, atc.Config, db.ConfigVersion, bool) (db.Pipeline, bool, error)
|
|
savePipelineMutex sync.RWMutex
|
|
savePipelineArgsForCall []struct {
|
|
arg1 atc.PipelineRef
|
|
arg2 atc.Config
|
|
arg3 db.ConfigVersion
|
|
arg4 bool
|
|
}
|
|
savePipelineReturns struct {
|
|
result1 db.Pipeline
|
|
result2 bool
|
|
result3 error
|
|
}
|
|
savePipelineReturnsOnCall map[int]struct {
|
|
result1 db.Pipeline
|
|
result2 bool
|
|
result3 error
|
|
}
|
|
SaveWorkerStub func(atc.Worker, time.Duration) (db.Worker, error)
|
|
saveWorkerMutex sync.RWMutex
|
|
saveWorkerArgsForCall []struct {
|
|
arg1 atc.Worker
|
|
arg2 time.Duration
|
|
}
|
|
saveWorkerReturns struct {
|
|
result1 db.Worker
|
|
result2 error
|
|
}
|
|
saveWorkerReturnsOnCall map[int]struct {
|
|
result1 db.Worker
|
|
result2 error
|
|
}
|
|
UpdateProviderAuthStub func(atc.TeamAuth) error
|
|
updateProviderAuthMutex sync.RWMutex
|
|
updateProviderAuthArgsForCall []struct {
|
|
arg1 atc.TeamAuth
|
|
}
|
|
updateProviderAuthReturns struct {
|
|
result1 error
|
|
}
|
|
updateProviderAuthReturnsOnCall map[int]struct {
|
|
result1 error
|
|
}
|
|
WorkersStub func() ([]db.Worker, error)
|
|
workersMutex sync.RWMutex
|
|
workersArgsForCall []struct {
|
|
}
|
|
workersReturns struct {
|
|
result1 []db.Worker
|
|
result2 error
|
|
}
|
|
workersReturnsOnCall map[int]struct {
|
|
result1 []db.Worker
|
|
result2 error
|
|
}
|
|
invocations map[string][][]interface{}
|
|
invocationsMutex sync.RWMutex
|
|
}
|
|
|
|
func (fake *FakeTeam) Admin() bool {
|
|
fake.adminMutex.Lock()
|
|
ret, specificReturn := fake.adminReturnsOnCall[len(fake.adminArgsForCall)]
|
|
fake.adminArgsForCall = append(fake.adminArgsForCall, struct {
|
|
}{})
|
|
stub := fake.AdminStub
|
|
fakeReturns := fake.adminReturns
|
|
fake.recordInvocation("Admin", []interface{}{})
|
|
fake.adminMutex.Unlock()
|
|
if stub != nil {
|
|
return stub()
|
|
}
|
|
if specificReturn {
|
|
return ret.result1
|
|
}
|
|
return fakeReturns.result1
|
|
}
|
|
|
|
func (fake *FakeTeam) AdminCallCount() int {
|
|
fake.adminMutex.RLock()
|
|
defer fake.adminMutex.RUnlock()
|
|
return len(fake.adminArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) AdminCalls(stub func() bool) {
|
|
fake.adminMutex.Lock()
|
|
defer fake.adminMutex.Unlock()
|
|
fake.AdminStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) AdminReturns(result1 bool) {
|
|
fake.adminMutex.Lock()
|
|
defer fake.adminMutex.Unlock()
|
|
fake.AdminStub = nil
|
|
fake.adminReturns = struct {
|
|
result1 bool
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *FakeTeam) AdminReturnsOnCall(i int, result1 bool) {
|
|
fake.adminMutex.Lock()
|
|
defer fake.adminMutex.Unlock()
|
|
fake.AdminStub = nil
|
|
if fake.adminReturnsOnCall == nil {
|
|
fake.adminReturnsOnCall = make(map[int]struct {
|
|
result1 bool
|
|
})
|
|
}
|
|
fake.adminReturnsOnCall[i] = struct {
|
|
result1 bool
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *FakeTeam) Auth() atc.TeamAuth {
|
|
fake.authMutex.Lock()
|
|
ret, specificReturn := fake.authReturnsOnCall[len(fake.authArgsForCall)]
|
|
fake.authArgsForCall = append(fake.authArgsForCall, struct {
|
|
}{})
|
|
stub := fake.AuthStub
|
|
fakeReturns := fake.authReturns
|
|
fake.recordInvocation("Auth", []interface{}{})
|
|
fake.authMutex.Unlock()
|
|
if stub != nil {
|
|
return stub()
|
|
}
|
|
if specificReturn {
|
|
return ret.result1
|
|
}
|
|
return fakeReturns.result1
|
|
}
|
|
|
|
func (fake *FakeTeam) AuthCallCount() int {
|
|
fake.authMutex.RLock()
|
|
defer fake.authMutex.RUnlock()
|
|
return len(fake.authArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) AuthCalls(stub func() atc.TeamAuth) {
|
|
fake.authMutex.Lock()
|
|
defer fake.authMutex.Unlock()
|
|
fake.AuthStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) AuthReturns(result1 atc.TeamAuth) {
|
|
fake.authMutex.Lock()
|
|
defer fake.authMutex.Unlock()
|
|
fake.AuthStub = nil
|
|
fake.authReturns = struct {
|
|
result1 atc.TeamAuth
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *FakeTeam) AuthReturnsOnCall(i int, result1 atc.TeamAuth) {
|
|
fake.authMutex.Lock()
|
|
defer fake.authMutex.Unlock()
|
|
fake.AuthStub = nil
|
|
if fake.authReturnsOnCall == nil {
|
|
fake.authReturnsOnCall = make(map[int]struct {
|
|
result1 atc.TeamAuth
|
|
})
|
|
}
|
|
fake.authReturnsOnCall[i] = struct {
|
|
result1 atc.TeamAuth
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *FakeTeam) Builds(arg1 db.Page) ([]db.Build, db.Pagination, error) {
|
|
fake.buildsMutex.Lock()
|
|
ret, specificReturn := fake.buildsReturnsOnCall[len(fake.buildsArgsForCall)]
|
|
fake.buildsArgsForCall = append(fake.buildsArgsForCall, struct {
|
|
arg1 db.Page
|
|
}{arg1})
|
|
stub := fake.BuildsStub
|
|
fakeReturns := fake.buildsReturns
|
|
fake.recordInvocation("Builds", []interface{}{arg1})
|
|
fake.buildsMutex.Unlock()
|
|
if stub != nil {
|
|
return stub(arg1)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2, ret.result3
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
|
|
}
|
|
|
|
func (fake *FakeTeam) BuildsCallCount() int {
|
|
fake.buildsMutex.RLock()
|
|
defer fake.buildsMutex.RUnlock()
|
|
return len(fake.buildsArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) BuildsCalls(stub func(db.Page) ([]db.Build, db.Pagination, error)) {
|
|
fake.buildsMutex.Lock()
|
|
defer fake.buildsMutex.Unlock()
|
|
fake.BuildsStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) BuildsArgsForCall(i int) db.Page {
|
|
fake.buildsMutex.RLock()
|
|
defer fake.buildsMutex.RUnlock()
|
|
argsForCall := fake.buildsArgsForCall[i]
|
|
return argsForCall.arg1
|
|
}
|
|
|
|
func (fake *FakeTeam) BuildsReturns(result1 []db.Build, result2 db.Pagination, result3 error) {
|
|
fake.buildsMutex.Lock()
|
|
defer fake.buildsMutex.Unlock()
|
|
fake.BuildsStub = nil
|
|
fake.buildsReturns = struct {
|
|
result1 []db.Build
|
|
result2 db.Pagination
|
|
result3 error
|
|
}{result1, result2, result3}
|
|
}
|
|
|
|
func (fake *FakeTeam) BuildsReturnsOnCall(i int, result1 []db.Build, result2 db.Pagination, result3 error) {
|
|
fake.buildsMutex.Lock()
|
|
defer fake.buildsMutex.Unlock()
|
|
fake.BuildsStub = nil
|
|
if fake.buildsReturnsOnCall == nil {
|
|
fake.buildsReturnsOnCall = make(map[int]struct {
|
|
result1 []db.Build
|
|
result2 db.Pagination
|
|
result3 error
|
|
})
|
|
}
|
|
fake.buildsReturnsOnCall[i] = struct {
|
|
result1 []db.Build
|
|
result2 db.Pagination
|
|
result3 error
|
|
}{result1, result2, result3}
|
|
}
|
|
|
|
func (fake *FakeTeam) BuildsWithTime(arg1 db.Page) ([]db.Build, db.Pagination, error) {
|
|
fake.buildsWithTimeMutex.Lock()
|
|
ret, specificReturn := fake.buildsWithTimeReturnsOnCall[len(fake.buildsWithTimeArgsForCall)]
|
|
fake.buildsWithTimeArgsForCall = append(fake.buildsWithTimeArgsForCall, struct {
|
|
arg1 db.Page
|
|
}{arg1})
|
|
stub := fake.BuildsWithTimeStub
|
|
fakeReturns := fake.buildsWithTimeReturns
|
|
fake.recordInvocation("BuildsWithTime", []interface{}{arg1})
|
|
fake.buildsWithTimeMutex.Unlock()
|
|
if stub != nil {
|
|
return stub(arg1)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2, ret.result3
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
|
|
}
|
|
|
|
func (fake *FakeTeam) BuildsWithTimeCallCount() int {
|
|
fake.buildsWithTimeMutex.RLock()
|
|
defer fake.buildsWithTimeMutex.RUnlock()
|
|
return len(fake.buildsWithTimeArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) BuildsWithTimeCalls(stub func(db.Page) ([]db.Build, db.Pagination, error)) {
|
|
fake.buildsWithTimeMutex.Lock()
|
|
defer fake.buildsWithTimeMutex.Unlock()
|
|
fake.BuildsWithTimeStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) BuildsWithTimeArgsForCall(i int) db.Page {
|
|
fake.buildsWithTimeMutex.RLock()
|
|
defer fake.buildsWithTimeMutex.RUnlock()
|
|
argsForCall := fake.buildsWithTimeArgsForCall[i]
|
|
return argsForCall.arg1
|
|
}
|
|
|
|
func (fake *FakeTeam) BuildsWithTimeReturns(result1 []db.Build, result2 db.Pagination, result3 error) {
|
|
fake.buildsWithTimeMutex.Lock()
|
|
defer fake.buildsWithTimeMutex.Unlock()
|
|
fake.BuildsWithTimeStub = nil
|
|
fake.buildsWithTimeReturns = struct {
|
|
result1 []db.Build
|
|
result2 db.Pagination
|
|
result3 error
|
|
}{result1, result2, result3}
|
|
}
|
|
|
|
func (fake *FakeTeam) BuildsWithTimeReturnsOnCall(i int, result1 []db.Build, result2 db.Pagination, result3 error) {
|
|
fake.buildsWithTimeMutex.Lock()
|
|
defer fake.buildsWithTimeMutex.Unlock()
|
|
fake.BuildsWithTimeStub = nil
|
|
if fake.buildsWithTimeReturnsOnCall == nil {
|
|
fake.buildsWithTimeReturnsOnCall = make(map[int]struct {
|
|
result1 []db.Build
|
|
result2 db.Pagination
|
|
result3 error
|
|
})
|
|
}
|
|
fake.buildsWithTimeReturnsOnCall[i] = struct {
|
|
result1 []db.Build
|
|
result2 db.Pagination
|
|
result3 error
|
|
}{result1, result2, result3}
|
|
}
|
|
|
|
func (fake *FakeTeam) Containers() ([]db.Container, error) {
|
|
fake.containersMutex.Lock()
|
|
ret, specificReturn := fake.containersReturnsOnCall[len(fake.containersArgsForCall)]
|
|
fake.containersArgsForCall = append(fake.containersArgsForCall, struct {
|
|
}{})
|
|
stub := fake.ContainersStub
|
|
fakeReturns := fake.containersReturns
|
|
fake.recordInvocation("Containers", []interface{}{})
|
|
fake.containersMutex.Unlock()
|
|
if stub != nil {
|
|
return stub()
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2
|
|
}
|
|
|
|
func (fake *FakeTeam) ContainersCallCount() int {
|
|
fake.containersMutex.RLock()
|
|
defer fake.containersMutex.RUnlock()
|
|
return len(fake.containersArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) ContainersCalls(stub func() ([]db.Container, error)) {
|
|
fake.containersMutex.Lock()
|
|
defer fake.containersMutex.Unlock()
|
|
fake.ContainersStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) ContainersReturns(result1 []db.Container, result2 error) {
|
|
fake.containersMutex.Lock()
|
|
defer fake.containersMutex.Unlock()
|
|
fake.ContainersStub = nil
|
|
fake.containersReturns = struct {
|
|
result1 []db.Container
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeTeam) ContainersReturnsOnCall(i int, result1 []db.Container, result2 error) {
|
|
fake.containersMutex.Lock()
|
|
defer fake.containersMutex.Unlock()
|
|
fake.ContainersStub = nil
|
|
if fake.containersReturnsOnCall == nil {
|
|
fake.containersReturnsOnCall = make(map[int]struct {
|
|
result1 []db.Container
|
|
result2 error
|
|
})
|
|
}
|
|
fake.containersReturnsOnCall[i] = struct {
|
|
result1 []db.Container
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeTeam) CreateOneOffBuild() (db.Build, error) {
|
|
fake.createOneOffBuildMutex.Lock()
|
|
ret, specificReturn := fake.createOneOffBuildReturnsOnCall[len(fake.createOneOffBuildArgsForCall)]
|
|
fake.createOneOffBuildArgsForCall = append(fake.createOneOffBuildArgsForCall, struct {
|
|
}{})
|
|
stub := fake.CreateOneOffBuildStub
|
|
fakeReturns := fake.createOneOffBuildReturns
|
|
fake.recordInvocation("CreateOneOffBuild", []interface{}{})
|
|
fake.createOneOffBuildMutex.Unlock()
|
|
if stub != nil {
|
|
return stub()
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2
|
|
}
|
|
|
|
func (fake *FakeTeam) CreateOneOffBuildCallCount() int {
|
|
fake.createOneOffBuildMutex.RLock()
|
|
defer fake.createOneOffBuildMutex.RUnlock()
|
|
return len(fake.createOneOffBuildArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) CreateOneOffBuildCalls(stub func() (db.Build, error)) {
|
|
fake.createOneOffBuildMutex.Lock()
|
|
defer fake.createOneOffBuildMutex.Unlock()
|
|
fake.CreateOneOffBuildStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) CreateOneOffBuildReturns(result1 db.Build, result2 error) {
|
|
fake.createOneOffBuildMutex.Lock()
|
|
defer fake.createOneOffBuildMutex.Unlock()
|
|
fake.CreateOneOffBuildStub = nil
|
|
fake.createOneOffBuildReturns = struct {
|
|
result1 db.Build
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeTeam) CreateOneOffBuildReturnsOnCall(i int, result1 db.Build, result2 error) {
|
|
fake.createOneOffBuildMutex.Lock()
|
|
defer fake.createOneOffBuildMutex.Unlock()
|
|
fake.CreateOneOffBuildStub = nil
|
|
if fake.createOneOffBuildReturnsOnCall == nil {
|
|
fake.createOneOffBuildReturnsOnCall = make(map[int]struct {
|
|
result1 db.Build
|
|
result2 error
|
|
})
|
|
}
|
|
fake.createOneOffBuildReturnsOnCall[i] = struct {
|
|
result1 db.Build
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeTeam) CreateStartedBuild(arg1 atc.Plan) (db.Build, error) {
|
|
fake.createStartedBuildMutex.Lock()
|
|
ret, specificReturn := fake.createStartedBuildReturnsOnCall[len(fake.createStartedBuildArgsForCall)]
|
|
fake.createStartedBuildArgsForCall = append(fake.createStartedBuildArgsForCall, struct {
|
|
arg1 atc.Plan
|
|
}{arg1})
|
|
stub := fake.CreateStartedBuildStub
|
|
fakeReturns := fake.createStartedBuildReturns
|
|
fake.recordInvocation("CreateStartedBuild", []interface{}{arg1})
|
|
fake.createStartedBuildMutex.Unlock()
|
|
if stub != nil {
|
|
return stub(arg1)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2
|
|
}
|
|
|
|
func (fake *FakeTeam) CreateStartedBuildCallCount() int {
|
|
fake.createStartedBuildMutex.RLock()
|
|
defer fake.createStartedBuildMutex.RUnlock()
|
|
return len(fake.createStartedBuildArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) CreateStartedBuildCalls(stub func(atc.Plan) (db.Build, error)) {
|
|
fake.createStartedBuildMutex.Lock()
|
|
defer fake.createStartedBuildMutex.Unlock()
|
|
fake.CreateStartedBuildStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) CreateStartedBuildArgsForCall(i int) atc.Plan {
|
|
fake.createStartedBuildMutex.RLock()
|
|
defer fake.createStartedBuildMutex.RUnlock()
|
|
argsForCall := fake.createStartedBuildArgsForCall[i]
|
|
return argsForCall.arg1
|
|
}
|
|
|
|
func (fake *FakeTeam) CreateStartedBuildReturns(result1 db.Build, result2 error) {
|
|
fake.createStartedBuildMutex.Lock()
|
|
defer fake.createStartedBuildMutex.Unlock()
|
|
fake.CreateStartedBuildStub = nil
|
|
fake.createStartedBuildReturns = struct {
|
|
result1 db.Build
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeTeam) CreateStartedBuildReturnsOnCall(i int, result1 db.Build, result2 error) {
|
|
fake.createStartedBuildMutex.Lock()
|
|
defer fake.createStartedBuildMutex.Unlock()
|
|
fake.CreateStartedBuildStub = nil
|
|
if fake.createStartedBuildReturnsOnCall == nil {
|
|
fake.createStartedBuildReturnsOnCall = make(map[int]struct {
|
|
result1 db.Build
|
|
result2 error
|
|
})
|
|
}
|
|
fake.createStartedBuildReturnsOnCall[i] = struct {
|
|
result1 db.Build
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeTeam) Delete() error {
|
|
fake.deleteMutex.Lock()
|
|
ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)]
|
|
fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct {
|
|
}{})
|
|
stub := fake.DeleteStub
|
|
fakeReturns := fake.deleteReturns
|
|
fake.recordInvocation("Delete", []interface{}{})
|
|
fake.deleteMutex.Unlock()
|
|
if stub != nil {
|
|
return stub()
|
|
}
|
|
if specificReturn {
|
|
return ret.result1
|
|
}
|
|
return fakeReturns.result1
|
|
}
|
|
|
|
func (fake *FakeTeam) DeleteCallCount() int {
|
|
fake.deleteMutex.RLock()
|
|
defer fake.deleteMutex.RUnlock()
|
|
return len(fake.deleteArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) DeleteCalls(stub func() error) {
|
|
fake.deleteMutex.Lock()
|
|
defer fake.deleteMutex.Unlock()
|
|
fake.DeleteStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) DeleteReturns(result1 error) {
|
|
fake.deleteMutex.Lock()
|
|
defer fake.deleteMutex.Unlock()
|
|
fake.DeleteStub = nil
|
|
fake.deleteReturns = struct {
|
|
result1 error
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *FakeTeam) DeleteReturnsOnCall(i int, result1 error) {
|
|
fake.deleteMutex.Lock()
|
|
defer fake.deleteMutex.Unlock()
|
|
fake.DeleteStub = nil
|
|
if fake.deleteReturnsOnCall == nil {
|
|
fake.deleteReturnsOnCall = make(map[int]struct {
|
|
result1 error
|
|
})
|
|
}
|
|
fake.deleteReturnsOnCall[i] = struct {
|
|
result1 error
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *FakeTeam) FindCheckContainers(arg1 lager.Logger, arg2 atc.PipelineRef, arg3 string, arg4 creds.Secrets, arg5 creds.VarSourcePool) ([]db.Container, map[int]time.Time, error) {
|
|
fake.findCheckContainersMutex.Lock()
|
|
ret, specificReturn := fake.findCheckContainersReturnsOnCall[len(fake.findCheckContainersArgsForCall)]
|
|
fake.findCheckContainersArgsForCall = append(fake.findCheckContainersArgsForCall, struct {
|
|
arg1 lager.Logger
|
|
arg2 atc.PipelineRef
|
|
arg3 string
|
|
arg4 creds.Secrets
|
|
arg5 creds.VarSourcePool
|
|
}{arg1, arg2, arg3, arg4, arg5})
|
|
stub := fake.FindCheckContainersStub
|
|
fakeReturns := fake.findCheckContainersReturns
|
|
fake.recordInvocation("FindCheckContainers", []interface{}{arg1, arg2, arg3, arg4, arg5})
|
|
fake.findCheckContainersMutex.Unlock()
|
|
if stub != nil {
|
|
return stub(arg1, arg2, arg3, arg4, arg5)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2, ret.result3
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
|
|
}
|
|
|
|
func (fake *FakeTeam) FindCheckContainersCallCount() int {
|
|
fake.findCheckContainersMutex.RLock()
|
|
defer fake.findCheckContainersMutex.RUnlock()
|
|
return len(fake.findCheckContainersArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) FindCheckContainersCalls(stub func(lager.Logger, atc.PipelineRef, string, creds.Secrets, creds.VarSourcePool) ([]db.Container, map[int]time.Time, error)) {
|
|
fake.findCheckContainersMutex.Lock()
|
|
defer fake.findCheckContainersMutex.Unlock()
|
|
fake.FindCheckContainersStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) FindCheckContainersArgsForCall(i int) (lager.Logger, atc.PipelineRef, string, creds.Secrets, creds.VarSourcePool) {
|
|
fake.findCheckContainersMutex.RLock()
|
|
defer fake.findCheckContainersMutex.RUnlock()
|
|
argsForCall := fake.findCheckContainersArgsForCall[i]
|
|
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
|
|
}
|
|
|
|
func (fake *FakeTeam) FindCheckContainersReturns(result1 []db.Container, result2 map[int]time.Time, result3 error) {
|
|
fake.findCheckContainersMutex.Lock()
|
|
defer fake.findCheckContainersMutex.Unlock()
|
|
fake.FindCheckContainersStub = nil
|
|
fake.findCheckContainersReturns = struct {
|
|
result1 []db.Container
|
|
result2 map[int]time.Time
|
|
result3 error
|
|
}{result1, result2, result3}
|
|
}
|
|
|
|
func (fake *FakeTeam) FindCheckContainersReturnsOnCall(i int, result1 []db.Container, result2 map[int]time.Time, result3 error) {
|
|
fake.findCheckContainersMutex.Lock()
|
|
defer fake.findCheckContainersMutex.Unlock()
|
|
fake.FindCheckContainersStub = nil
|
|
if fake.findCheckContainersReturnsOnCall == nil {
|
|
fake.findCheckContainersReturnsOnCall = make(map[int]struct {
|
|
result1 []db.Container
|
|
result2 map[int]time.Time
|
|
result3 error
|
|
})
|
|
}
|
|
fake.findCheckContainersReturnsOnCall[i] = struct {
|
|
result1 []db.Container
|
|
result2 map[int]time.Time
|
|
result3 error
|
|
}{result1, result2, result3}
|
|
}
|
|
|
|
func (fake *FakeTeam) FindContainerByHandle(arg1 string) (db.Container, bool, error) {
|
|
fake.findContainerByHandleMutex.Lock()
|
|
ret, specificReturn := fake.findContainerByHandleReturnsOnCall[len(fake.findContainerByHandleArgsForCall)]
|
|
fake.findContainerByHandleArgsForCall = append(fake.findContainerByHandleArgsForCall, struct {
|
|
arg1 string
|
|
}{arg1})
|
|
stub := fake.FindContainerByHandleStub
|
|
fakeReturns := fake.findContainerByHandleReturns
|
|
fake.recordInvocation("FindContainerByHandle", []interface{}{arg1})
|
|
fake.findContainerByHandleMutex.Unlock()
|
|
if stub != nil {
|
|
return stub(arg1)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2, ret.result3
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
|
|
}
|
|
|
|
func (fake *FakeTeam) FindContainerByHandleCallCount() int {
|
|
fake.findContainerByHandleMutex.RLock()
|
|
defer fake.findContainerByHandleMutex.RUnlock()
|
|
return len(fake.findContainerByHandleArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) FindContainerByHandleCalls(stub func(string) (db.Container, bool, error)) {
|
|
fake.findContainerByHandleMutex.Lock()
|
|
defer fake.findContainerByHandleMutex.Unlock()
|
|
fake.FindContainerByHandleStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) FindContainerByHandleArgsForCall(i int) string {
|
|
fake.findContainerByHandleMutex.RLock()
|
|
defer fake.findContainerByHandleMutex.RUnlock()
|
|
argsForCall := fake.findContainerByHandleArgsForCall[i]
|
|
return argsForCall.arg1
|
|
}
|
|
|
|
func (fake *FakeTeam) FindContainerByHandleReturns(result1 db.Container, result2 bool, result3 error) {
|
|
fake.findContainerByHandleMutex.Lock()
|
|
defer fake.findContainerByHandleMutex.Unlock()
|
|
fake.FindContainerByHandleStub = nil
|
|
fake.findContainerByHandleReturns = struct {
|
|
result1 db.Container
|
|
result2 bool
|
|
result3 error
|
|
}{result1, result2, result3}
|
|
}
|
|
|
|
func (fake *FakeTeam) FindContainerByHandleReturnsOnCall(i int, result1 db.Container, result2 bool, result3 error) {
|
|
fake.findContainerByHandleMutex.Lock()
|
|
defer fake.findContainerByHandleMutex.Unlock()
|
|
fake.FindContainerByHandleStub = nil
|
|
if fake.findContainerByHandleReturnsOnCall == nil {
|
|
fake.findContainerByHandleReturnsOnCall = make(map[int]struct {
|
|
result1 db.Container
|
|
result2 bool
|
|
result3 error
|
|
})
|
|
}
|
|
fake.findContainerByHandleReturnsOnCall[i] = struct {
|
|
result1 db.Container
|
|
result2 bool
|
|
result3 error
|
|
}{result1, result2, result3}
|
|
}
|
|
|
|
func (fake *FakeTeam) FindContainersByMetadata(arg1 db.ContainerMetadata) ([]db.Container, error) {
|
|
fake.findContainersByMetadataMutex.Lock()
|
|
ret, specificReturn := fake.findContainersByMetadataReturnsOnCall[len(fake.findContainersByMetadataArgsForCall)]
|
|
fake.findContainersByMetadataArgsForCall = append(fake.findContainersByMetadataArgsForCall, struct {
|
|
arg1 db.ContainerMetadata
|
|
}{arg1})
|
|
stub := fake.FindContainersByMetadataStub
|
|
fakeReturns := fake.findContainersByMetadataReturns
|
|
fake.recordInvocation("FindContainersByMetadata", []interface{}{arg1})
|
|
fake.findContainersByMetadataMutex.Unlock()
|
|
if stub != nil {
|
|
return stub(arg1)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2
|
|
}
|
|
|
|
func (fake *FakeTeam) FindContainersByMetadataCallCount() int {
|
|
fake.findContainersByMetadataMutex.RLock()
|
|
defer fake.findContainersByMetadataMutex.RUnlock()
|
|
return len(fake.findContainersByMetadataArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) FindContainersByMetadataCalls(stub func(db.ContainerMetadata) ([]db.Container, error)) {
|
|
fake.findContainersByMetadataMutex.Lock()
|
|
defer fake.findContainersByMetadataMutex.Unlock()
|
|
fake.FindContainersByMetadataStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) FindContainersByMetadataArgsForCall(i int) db.ContainerMetadata {
|
|
fake.findContainersByMetadataMutex.RLock()
|
|
defer fake.findContainersByMetadataMutex.RUnlock()
|
|
argsForCall := fake.findContainersByMetadataArgsForCall[i]
|
|
return argsForCall.arg1
|
|
}
|
|
|
|
func (fake *FakeTeam) FindContainersByMetadataReturns(result1 []db.Container, result2 error) {
|
|
fake.findContainersByMetadataMutex.Lock()
|
|
defer fake.findContainersByMetadataMutex.Unlock()
|
|
fake.FindContainersByMetadataStub = nil
|
|
fake.findContainersByMetadataReturns = struct {
|
|
result1 []db.Container
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeTeam) FindContainersByMetadataReturnsOnCall(i int, result1 []db.Container, result2 error) {
|
|
fake.findContainersByMetadataMutex.Lock()
|
|
defer fake.findContainersByMetadataMutex.Unlock()
|
|
fake.FindContainersByMetadataStub = nil
|
|
if fake.findContainersByMetadataReturnsOnCall == nil {
|
|
fake.findContainersByMetadataReturnsOnCall = make(map[int]struct {
|
|
result1 []db.Container
|
|
result2 error
|
|
})
|
|
}
|
|
fake.findContainersByMetadataReturnsOnCall[i] = struct {
|
|
result1 []db.Container
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeTeam) FindCreatedContainerByHandle(arg1 string) (db.CreatedContainer, bool, error) {
|
|
fake.findCreatedContainerByHandleMutex.Lock()
|
|
ret, specificReturn := fake.findCreatedContainerByHandleReturnsOnCall[len(fake.findCreatedContainerByHandleArgsForCall)]
|
|
fake.findCreatedContainerByHandleArgsForCall = append(fake.findCreatedContainerByHandleArgsForCall, struct {
|
|
arg1 string
|
|
}{arg1})
|
|
stub := fake.FindCreatedContainerByHandleStub
|
|
fakeReturns := fake.findCreatedContainerByHandleReturns
|
|
fake.recordInvocation("FindCreatedContainerByHandle", []interface{}{arg1})
|
|
fake.findCreatedContainerByHandleMutex.Unlock()
|
|
if stub != nil {
|
|
return stub(arg1)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2, ret.result3
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
|
|
}
|
|
|
|
func (fake *FakeTeam) FindCreatedContainerByHandleCallCount() int {
|
|
fake.findCreatedContainerByHandleMutex.RLock()
|
|
defer fake.findCreatedContainerByHandleMutex.RUnlock()
|
|
return len(fake.findCreatedContainerByHandleArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) FindCreatedContainerByHandleCalls(stub func(string) (db.CreatedContainer, bool, error)) {
|
|
fake.findCreatedContainerByHandleMutex.Lock()
|
|
defer fake.findCreatedContainerByHandleMutex.Unlock()
|
|
fake.FindCreatedContainerByHandleStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) FindCreatedContainerByHandleArgsForCall(i int) string {
|
|
fake.findCreatedContainerByHandleMutex.RLock()
|
|
defer fake.findCreatedContainerByHandleMutex.RUnlock()
|
|
argsForCall := fake.findCreatedContainerByHandleArgsForCall[i]
|
|
return argsForCall.arg1
|
|
}
|
|
|
|
func (fake *FakeTeam) FindCreatedContainerByHandleReturns(result1 db.CreatedContainer, result2 bool, result3 error) {
|
|
fake.findCreatedContainerByHandleMutex.Lock()
|
|
defer fake.findCreatedContainerByHandleMutex.Unlock()
|
|
fake.FindCreatedContainerByHandleStub = nil
|
|
fake.findCreatedContainerByHandleReturns = struct {
|
|
result1 db.CreatedContainer
|
|
result2 bool
|
|
result3 error
|
|
}{result1, result2, result3}
|
|
}
|
|
|
|
func (fake *FakeTeam) FindCreatedContainerByHandleReturnsOnCall(i int, result1 db.CreatedContainer, result2 bool, result3 error) {
|
|
fake.findCreatedContainerByHandleMutex.Lock()
|
|
defer fake.findCreatedContainerByHandleMutex.Unlock()
|
|
fake.FindCreatedContainerByHandleStub = nil
|
|
if fake.findCreatedContainerByHandleReturnsOnCall == nil {
|
|
fake.findCreatedContainerByHandleReturnsOnCall = make(map[int]struct {
|
|
result1 db.CreatedContainer
|
|
result2 bool
|
|
result3 error
|
|
})
|
|
}
|
|
fake.findCreatedContainerByHandleReturnsOnCall[i] = struct {
|
|
result1 db.CreatedContainer
|
|
result2 bool
|
|
result3 error
|
|
}{result1, result2, result3}
|
|
}
|
|
|
|
func (fake *FakeTeam) FindVolumeForWorkerArtifact(arg1 int) (db.CreatedVolume, bool, error) {
|
|
fake.findVolumeForWorkerArtifactMutex.Lock()
|
|
ret, specificReturn := fake.findVolumeForWorkerArtifactReturnsOnCall[len(fake.findVolumeForWorkerArtifactArgsForCall)]
|
|
fake.findVolumeForWorkerArtifactArgsForCall = append(fake.findVolumeForWorkerArtifactArgsForCall, struct {
|
|
arg1 int
|
|
}{arg1})
|
|
stub := fake.FindVolumeForWorkerArtifactStub
|
|
fakeReturns := fake.findVolumeForWorkerArtifactReturns
|
|
fake.recordInvocation("FindVolumeForWorkerArtifact", []interface{}{arg1})
|
|
fake.findVolumeForWorkerArtifactMutex.Unlock()
|
|
if stub != nil {
|
|
return stub(arg1)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2, ret.result3
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
|
|
}
|
|
|
|
func (fake *FakeTeam) FindVolumeForWorkerArtifactCallCount() int {
|
|
fake.findVolumeForWorkerArtifactMutex.RLock()
|
|
defer fake.findVolumeForWorkerArtifactMutex.RUnlock()
|
|
return len(fake.findVolumeForWorkerArtifactArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) FindVolumeForWorkerArtifactCalls(stub func(int) (db.CreatedVolume, bool, error)) {
|
|
fake.findVolumeForWorkerArtifactMutex.Lock()
|
|
defer fake.findVolumeForWorkerArtifactMutex.Unlock()
|
|
fake.FindVolumeForWorkerArtifactStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) FindVolumeForWorkerArtifactArgsForCall(i int) int {
|
|
fake.findVolumeForWorkerArtifactMutex.RLock()
|
|
defer fake.findVolumeForWorkerArtifactMutex.RUnlock()
|
|
argsForCall := fake.findVolumeForWorkerArtifactArgsForCall[i]
|
|
return argsForCall.arg1
|
|
}
|
|
|
|
func (fake *FakeTeam) FindVolumeForWorkerArtifactReturns(result1 db.CreatedVolume, result2 bool, result3 error) {
|
|
fake.findVolumeForWorkerArtifactMutex.Lock()
|
|
defer fake.findVolumeForWorkerArtifactMutex.Unlock()
|
|
fake.FindVolumeForWorkerArtifactStub = nil
|
|
fake.findVolumeForWorkerArtifactReturns = struct {
|
|
result1 db.CreatedVolume
|
|
result2 bool
|
|
result3 error
|
|
}{result1, result2, result3}
|
|
}
|
|
|
|
func (fake *FakeTeam) FindVolumeForWorkerArtifactReturnsOnCall(i int, result1 db.CreatedVolume, result2 bool, result3 error) {
|
|
fake.findVolumeForWorkerArtifactMutex.Lock()
|
|
defer fake.findVolumeForWorkerArtifactMutex.Unlock()
|
|
fake.FindVolumeForWorkerArtifactStub = nil
|
|
if fake.findVolumeForWorkerArtifactReturnsOnCall == nil {
|
|
fake.findVolumeForWorkerArtifactReturnsOnCall = make(map[int]struct {
|
|
result1 db.CreatedVolume
|
|
result2 bool
|
|
result3 error
|
|
})
|
|
}
|
|
fake.findVolumeForWorkerArtifactReturnsOnCall[i] = struct {
|
|
result1 db.CreatedVolume
|
|
result2 bool
|
|
result3 error
|
|
}{result1, result2, result3}
|
|
}
|
|
|
|
func (fake *FakeTeam) FindWorkerForContainer(arg1 string) (db.Worker, bool, error) {
|
|
fake.findWorkerForContainerMutex.Lock()
|
|
ret, specificReturn := fake.findWorkerForContainerReturnsOnCall[len(fake.findWorkerForContainerArgsForCall)]
|
|
fake.findWorkerForContainerArgsForCall = append(fake.findWorkerForContainerArgsForCall, struct {
|
|
arg1 string
|
|
}{arg1})
|
|
stub := fake.FindWorkerForContainerStub
|
|
fakeReturns := fake.findWorkerForContainerReturns
|
|
fake.recordInvocation("FindWorkerForContainer", []interface{}{arg1})
|
|
fake.findWorkerForContainerMutex.Unlock()
|
|
if stub != nil {
|
|
return stub(arg1)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2, ret.result3
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
|
|
}
|
|
|
|
func (fake *FakeTeam) FindWorkerForContainerCallCount() int {
|
|
fake.findWorkerForContainerMutex.RLock()
|
|
defer fake.findWorkerForContainerMutex.RUnlock()
|
|
return len(fake.findWorkerForContainerArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) FindWorkerForContainerCalls(stub func(string) (db.Worker, bool, error)) {
|
|
fake.findWorkerForContainerMutex.Lock()
|
|
defer fake.findWorkerForContainerMutex.Unlock()
|
|
fake.FindWorkerForContainerStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) FindWorkerForContainerArgsForCall(i int) string {
|
|
fake.findWorkerForContainerMutex.RLock()
|
|
defer fake.findWorkerForContainerMutex.RUnlock()
|
|
argsForCall := fake.findWorkerForContainerArgsForCall[i]
|
|
return argsForCall.arg1
|
|
}
|
|
|
|
func (fake *FakeTeam) FindWorkerForContainerReturns(result1 db.Worker, result2 bool, result3 error) {
|
|
fake.findWorkerForContainerMutex.Lock()
|
|
defer fake.findWorkerForContainerMutex.Unlock()
|
|
fake.FindWorkerForContainerStub = nil
|
|
fake.findWorkerForContainerReturns = struct {
|
|
result1 db.Worker
|
|
result2 bool
|
|
result3 error
|
|
}{result1, result2, result3}
|
|
}
|
|
|
|
func (fake *FakeTeam) FindWorkerForContainerReturnsOnCall(i int, result1 db.Worker, result2 bool, result3 error) {
|
|
fake.findWorkerForContainerMutex.Lock()
|
|
defer fake.findWorkerForContainerMutex.Unlock()
|
|
fake.FindWorkerForContainerStub = nil
|
|
if fake.findWorkerForContainerReturnsOnCall == nil {
|
|
fake.findWorkerForContainerReturnsOnCall = make(map[int]struct {
|
|
result1 db.Worker
|
|
result2 bool
|
|
result3 error
|
|
})
|
|
}
|
|
fake.findWorkerForContainerReturnsOnCall[i] = struct {
|
|
result1 db.Worker
|
|
result2 bool
|
|
result3 error
|
|
}{result1, result2, result3}
|
|
}
|
|
|
|
func (fake *FakeTeam) FindWorkerForVolume(arg1 string) (db.Worker, bool, error) {
|
|
fake.findWorkerForVolumeMutex.Lock()
|
|
ret, specificReturn := fake.findWorkerForVolumeReturnsOnCall[len(fake.findWorkerForVolumeArgsForCall)]
|
|
fake.findWorkerForVolumeArgsForCall = append(fake.findWorkerForVolumeArgsForCall, struct {
|
|
arg1 string
|
|
}{arg1})
|
|
stub := fake.FindWorkerForVolumeStub
|
|
fakeReturns := fake.findWorkerForVolumeReturns
|
|
fake.recordInvocation("FindWorkerForVolume", []interface{}{arg1})
|
|
fake.findWorkerForVolumeMutex.Unlock()
|
|
if stub != nil {
|
|
return stub(arg1)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2, ret.result3
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
|
|
}
|
|
|
|
func (fake *FakeTeam) FindWorkerForVolumeCallCount() int {
|
|
fake.findWorkerForVolumeMutex.RLock()
|
|
defer fake.findWorkerForVolumeMutex.RUnlock()
|
|
return len(fake.findWorkerForVolumeArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) FindWorkerForVolumeCalls(stub func(string) (db.Worker, bool, error)) {
|
|
fake.findWorkerForVolumeMutex.Lock()
|
|
defer fake.findWorkerForVolumeMutex.Unlock()
|
|
fake.FindWorkerForVolumeStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) FindWorkerForVolumeArgsForCall(i int) string {
|
|
fake.findWorkerForVolumeMutex.RLock()
|
|
defer fake.findWorkerForVolumeMutex.RUnlock()
|
|
argsForCall := fake.findWorkerForVolumeArgsForCall[i]
|
|
return argsForCall.arg1
|
|
}
|
|
|
|
func (fake *FakeTeam) FindWorkerForVolumeReturns(result1 db.Worker, result2 bool, result3 error) {
|
|
fake.findWorkerForVolumeMutex.Lock()
|
|
defer fake.findWorkerForVolumeMutex.Unlock()
|
|
fake.FindWorkerForVolumeStub = nil
|
|
fake.findWorkerForVolumeReturns = struct {
|
|
result1 db.Worker
|
|
result2 bool
|
|
result3 error
|
|
}{result1, result2, result3}
|
|
}
|
|
|
|
func (fake *FakeTeam) FindWorkerForVolumeReturnsOnCall(i int, result1 db.Worker, result2 bool, result3 error) {
|
|
fake.findWorkerForVolumeMutex.Lock()
|
|
defer fake.findWorkerForVolumeMutex.Unlock()
|
|
fake.FindWorkerForVolumeStub = nil
|
|
if fake.findWorkerForVolumeReturnsOnCall == nil {
|
|
fake.findWorkerForVolumeReturnsOnCall = make(map[int]struct {
|
|
result1 db.Worker
|
|
result2 bool
|
|
result3 error
|
|
})
|
|
}
|
|
fake.findWorkerForVolumeReturnsOnCall[i] = struct {
|
|
result1 db.Worker
|
|
result2 bool
|
|
result3 error
|
|
}{result1, result2, result3}
|
|
}
|
|
|
|
func (fake *FakeTeam) ID() int {
|
|
fake.iDMutex.Lock()
|
|
ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)]
|
|
fake.iDArgsForCall = append(fake.iDArgsForCall, struct {
|
|
}{})
|
|
stub := fake.IDStub
|
|
fakeReturns := fake.iDReturns
|
|
fake.recordInvocation("ID", []interface{}{})
|
|
fake.iDMutex.Unlock()
|
|
if stub != nil {
|
|
return stub()
|
|
}
|
|
if specificReturn {
|
|
return ret.result1
|
|
}
|
|
return fakeReturns.result1
|
|
}
|
|
|
|
func (fake *FakeTeam) IDCallCount() int {
|
|
fake.iDMutex.RLock()
|
|
defer fake.iDMutex.RUnlock()
|
|
return len(fake.iDArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) IDCalls(stub func() int) {
|
|
fake.iDMutex.Lock()
|
|
defer fake.iDMutex.Unlock()
|
|
fake.IDStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) IDReturns(result1 int) {
|
|
fake.iDMutex.Lock()
|
|
defer fake.iDMutex.Unlock()
|
|
fake.IDStub = nil
|
|
fake.iDReturns = struct {
|
|
result1 int
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *FakeTeam) 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 *FakeTeam) IsCheckContainer(arg1 string) (bool, error) {
|
|
fake.isCheckContainerMutex.Lock()
|
|
ret, specificReturn := fake.isCheckContainerReturnsOnCall[len(fake.isCheckContainerArgsForCall)]
|
|
fake.isCheckContainerArgsForCall = append(fake.isCheckContainerArgsForCall, struct {
|
|
arg1 string
|
|
}{arg1})
|
|
stub := fake.IsCheckContainerStub
|
|
fakeReturns := fake.isCheckContainerReturns
|
|
fake.recordInvocation("IsCheckContainer", []interface{}{arg1})
|
|
fake.isCheckContainerMutex.Unlock()
|
|
if stub != nil {
|
|
return stub(arg1)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2
|
|
}
|
|
|
|
func (fake *FakeTeam) IsCheckContainerCallCount() int {
|
|
fake.isCheckContainerMutex.RLock()
|
|
defer fake.isCheckContainerMutex.RUnlock()
|
|
return len(fake.isCheckContainerArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) IsCheckContainerCalls(stub func(string) (bool, error)) {
|
|
fake.isCheckContainerMutex.Lock()
|
|
defer fake.isCheckContainerMutex.Unlock()
|
|
fake.IsCheckContainerStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) IsCheckContainerArgsForCall(i int) string {
|
|
fake.isCheckContainerMutex.RLock()
|
|
defer fake.isCheckContainerMutex.RUnlock()
|
|
argsForCall := fake.isCheckContainerArgsForCall[i]
|
|
return argsForCall.arg1
|
|
}
|
|
|
|
func (fake *FakeTeam) IsCheckContainerReturns(result1 bool, result2 error) {
|
|
fake.isCheckContainerMutex.Lock()
|
|
defer fake.isCheckContainerMutex.Unlock()
|
|
fake.IsCheckContainerStub = nil
|
|
fake.isCheckContainerReturns = struct {
|
|
result1 bool
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeTeam) IsCheckContainerReturnsOnCall(i int, result1 bool, result2 error) {
|
|
fake.isCheckContainerMutex.Lock()
|
|
defer fake.isCheckContainerMutex.Unlock()
|
|
fake.IsCheckContainerStub = nil
|
|
if fake.isCheckContainerReturnsOnCall == nil {
|
|
fake.isCheckContainerReturnsOnCall = make(map[int]struct {
|
|
result1 bool
|
|
result2 error
|
|
})
|
|
}
|
|
fake.isCheckContainerReturnsOnCall[i] = struct {
|
|
result1 bool
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeTeam) IsContainerWithinTeam(arg1 string, arg2 bool) (bool, error) {
|
|
fake.isContainerWithinTeamMutex.Lock()
|
|
ret, specificReturn := fake.isContainerWithinTeamReturnsOnCall[len(fake.isContainerWithinTeamArgsForCall)]
|
|
fake.isContainerWithinTeamArgsForCall = append(fake.isContainerWithinTeamArgsForCall, struct {
|
|
arg1 string
|
|
arg2 bool
|
|
}{arg1, arg2})
|
|
stub := fake.IsContainerWithinTeamStub
|
|
fakeReturns := fake.isContainerWithinTeamReturns
|
|
fake.recordInvocation("IsContainerWithinTeam", []interface{}{arg1, arg2})
|
|
fake.isContainerWithinTeamMutex.Unlock()
|
|
if stub != nil {
|
|
return stub(arg1, arg2)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2
|
|
}
|
|
|
|
func (fake *FakeTeam) IsContainerWithinTeamCallCount() int {
|
|
fake.isContainerWithinTeamMutex.RLock()
|
|
defer fake.isContainerWithinTeamMutex.RUnlock()
|
|
return len(fake.isContainerWithinTeamArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) IsContainerWithinTeamCalls(stub func(string, bool) (bool, error)) {
|
|
fake.isContainerWithinTeamMutex.Lock()
|
|
defer fake.isContainerWithinTeamMutex.Unlock()
|
|
fake.IsContainerWithinTeamStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) IsContainerWithinTeamArgsForCall(i int) (string, bool) {
|
|
fake.isContainerWithinTeamMutex.RLock()
|
|
defer fake.isContainerWithinTeamMutex.RUnlock()
|
|
argsForCall := fake.isContainerWithinTeamArgsForCall[i]
|
|
return argsForCall.arg1, argsForCall.arg2
|
|
}
|
|
|
|
func (fake *FakeTeam) IsContainerWithinTeamReturns(result1 bool, result2 error) {
|
|
fake.isContainerWithinTeamMutex.Lock()
|
|
defer fake.isContainerWithinTeamMutex.Unlock()
|
|
fake.IsContainerWithinTeamStub = nil
|
|
fake.isContainerWithinTeamReturns = struct {
|
|
result1 bool
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeTeam) IsContainerWithinTeamReturnsOnCall(i int, result1 bool, result2 error) {
|
|
fake.isContainerWithinTeamMutex.Lock()
|
|
defer fake.isContainerWithinTeamMutex.Unlock()
|
|
fake.IsContainerWithinTeamStub = nil
|
|
if fake.isContainerWithinTeamReturnsOnCall == nil {
|
|
fake.isContainerWithinTeamReturnsOnCall = make(map[int]struct {
|
|
result1 bool
|
|
result2 error
|
|
})
|
|
}
|
|
fake.isContainerWithinTeamReturnsOnCall[i] = struct {
|
|
result1 bool
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeTeam) Name() string {
|
|
fake.nameMutex.Lock()
|
|
ret, specificReturn := fake.nameReturnsOnCall[len(fake.nameArgsForCall)]
|
|
fake.nameArgsForCall = append(fake.nameArgsForCall, struct {
|
|
}{})
|
|
stub := fake.NameStub
|
|
fakeReturns := fake.nameReturns
|
|
fake.recordInvocation("Name", []interface{}{})
|
|
fake.nameMutex.Unlock()
|
|
if stub != nil {
|
|
return stub()
|
|
}
|
|
if specificReturn {
|
|
return ret.result1
|
|
}
|
|
return fakeReturns.result1
|
|
}
|
|
|
|
func (fake *FakeTeam) NameCallCount() int {
|
|
fake.nameMutex.RLock()
|
|
defer fake.nameMutex.RUnlock()
|
|
return len(fake.nameArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) NameCalls(stub func() string) {
|
|
fake.nameMutex.Lock()
|
|
defer fake.nameMutex.Unlock()
|
|
fake.NameStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) NameReturns(result1 string) {
|
|
fake.nameMutex.Lock()
|
|
defer fake.nameMutex.Unlock()
|
|
fake.NameStub = nil
|
|
fake.nameReturns = struct {
|
|
result1 string
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *FakeTeam) 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 *FakeTeam) OrderPipelines(arg1 []string) error {
|
|
var arg1Copy []string
|
|
if arg1 != nil {
|
|
arg1Copy = make([]string, len(arg1))
|
|
copy(arg1Copy, arg1)
|
|
}
|
|
fake.orderPipelinesMutex.Lock()
|
|
ret, specificReturn := fake.orderPipelinesReturnsOnCall[len(fake.orderPipelinesArgsForCall)]
|
|
fake.orderPipelinesArgsForCall = append(fake.orderPipelinesArgsForCall, struct {
|
|
arg1 []string
|
|
}{arg1Copy})
|
|
stub := fake.OrderPipelinesStub
|
|
fakeReturns := fake.orderPipelinesReturns
|
|
fake.recordInvocation("OrderPipelines", []interface{}{arg1Copy})
|
|
fake.orderPipelinesMutex.Unlock()
|
|
if stub != nil {
|
|
return stub(arg1)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1
|
|
}
|
|
return fakeReturns.result1
|
|
}
|
|
|
|
func (fake *FakeTeam) OrderPipelinesCallCount() int {
|
|
fake.orderPipelinesMutex.RLock()
|
|
defer fake.orderPipelinesMutex.RUnlock()
|
|
return len(fake.orderPipelinesArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) OrderPipelinesCalls(stub func([]string) error) {
|
|
fake.orderPipelinesMutex.Lock()
|
|
defer fake.orderPipelinesMutex.Unlock()
|
|
fake.OrderPipelinesStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) OrderPipelinesArgsForCall(i int) []string {
|
|
fake.orderPipelinesMutex.RLock()
|
|
defer fake.orderPipelinesMutex.RUnlock()
|
|
argsForCall := fake.orderPipelinesArgsForCall[i]
|
|
return argsForCall.arg1
|
|
}
|
|
|
|
func (fake *FakeTeam) OrderPipelinesReturns(result1 error) {
|
|
fake.orderPipelinesMutex.Lock()
|
|
defer fake.orderPipelinesMutex.Unlock()
|
|
fake.OrderPipelinesStub = nil
|
|
fake.orderPipelinesReturns = struct {
|
|
result1 error
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *FakeTeam) OrderPipelinesReturnsOnCall(i int, result1 error) {
|
|
fake.orderPipelinesMutex.Lock()
|
|
defer fake.orderPipelinesMutex.Unlock()
|
|
fake.OrderPipelinesStub = nil
|
|
if fake.orderPipelinesReturnsOnCall == nil {
|
|
fake.orderPipelinesReturnsOnCall = make(map[int]struct {
|
|
result1 error
|
|
})
|
|
}
|
|
fake.orderPipelinesReturnsOnCall[i] = struct {
|
|
result1 error
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *FakeTeam) Pipeline(arg1 atc.PipelineRef) (db.Pipeline, bool, error) {
|
|
fake.pipelineMutex.Lock()
|
|
ret, specificReturn := fake.pipelineReturnsOnCall[len(fake.pipelineArgsForCall)]
|
|
fake.pipelineArgsForCall = append(fake.pipelineArgsForCall, struct {
|
|
arg1 atc.PipelineRef
|
|
}{arg1})
|
|
stub := fake.PipelineStub
|
|
fakeReturns := fake.pipelineReturns
|
|
fake.recordInvocation("Pipeline", []interface{}{arg1})
|
|
fake.pipelineMutex.Unlock()
|
|
if stub != nil {
|
|
return stub(arg1)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2, ret.result3
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
|
|
}
|
|
|
|
func (fake *FakeTeam) PipelineCallCount() int {
|
|
fake.pipelineMutex.RLock()
|
|
defer fake.pipelineMutex.RUnlock()
|
|
return len(fake.pipelineArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) PipelineCalls(stub func(atc.PipelineRef) (db.Pipeline, bool, error)) {
|
|
fake.pipelineMutex.Lock()
|
|
defer fake.pipelineMutex.Unlock()
|
|
fake.PipelineStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) PipelineArgsForCall(i int) atc.PipelineRef {
|
|
fake.pipelineMutex.RLock()
|
|
defer fake.pipelineMutex.RUnlock()
|
|
argsForCall := fake.pipelineArgsForCall[i]
|
|
return argsForCall.arg1
|
|
}
|
|
|
|
func (fake *FakeTeam) 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 *FakeTeam) 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 *FakeTeam) Pipelines() ([]db.Pipeline, error) {
|
|
fake.pipelinesMutex.Lock()
|
|
ret, specificReturn := fake.pipelinesReturnsOnCall[len(fake.pipelinesArgsForCall)]
|
|
fake.pipelinesArgsForCall = append(fake.pipelinesArgsForCall, struct {
|
|
}{})
|
|
stub := fake.PipelinesStub
|
|
fakeReturns := fake.pipelinesReturns
|
|
fake.recordInvocation("Pipelines", []interface{}{})
|
|
fake.pipelinesMutex.Unlock()
|
|
if stub != nil {
|
|
return stub()
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2
|
|
}
|
|
|
|
func (fake *FakeTeam) PipelinesCallCount() int {
|
|
fake.pipelinesMutex.RLock()
|
|
defer fake.pipelinesMutex.RUnlock()
|
|
return len(fake.pipelinesArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) PipelinesCalls(stub func() ([]db.Pipeline, error)) {
|
|
fake.pipelinesMutex.Lock()
|
|
defer fake.pipelinesMutex.Unlock()
|
|
fake.PipelinesStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) PipelinesReturns(result1 []db.Pipeline, result2 error) {
|
|
fake.pipelinesMutex.Lock()
|
|
defer fake.pipelinesMutex.Unlock()
|
|
fake.PipelinesStub = nil
|
|
fake.pipelinesReturns = struct {
|
|
result1 []db.Pipeline
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeTeam) PipelinesReturnsOnCall(i int, result1 []db.Pipeline, result2 error) {
|
|
fake.pipelinesMutex.Lock()
|
|
defer fake.pipelinesMutex.Unlock()
|
|
fake.PipelinesStub = nil
|
|
if fake.pipelinesReturnsOnCall == nil {
|
|
fake.pipelinesReturnsOnCall = make(map[int]struct {
|
|
result1 []db.Pipeline
|
|
result2 error
|
|
})
|
|
}
|
|
fake.pipelinesReturnsOnCall[i] = struct {
|
|
result1 []db.Pipeline
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeTeam) PrivateAndPublicBuilds(arg1 db.Page) ([]db.Build, db.Pagination, error) {
|
|
fake.privateAndPublicBuildsMutex.Lock()
|
|
ret, specificReturn := fake.privateAndPublicBuildsReturnsOnCall[len(fake.privateAndPublicBuildsArgsForCall)]
|
|
fake.privateAndPublicBuildsArgsForCall = append(fake.privateAndPublicBuildsArgsForCall, struct {
|
|
arg1 db.Page
|
|
}{arg1})
|
|
stub := fake.PrivateAndPublicBuildsStub
|
|
fakeReturns := fake.privateAndPublicBuildsReturns
|
|
fake.recordInvocation("PrivateAndPublicBuilds", []interface{}{arg1})
|
|
fake.privateAndPublicBuildsMutex.Unlock()
|
|
if stub != nil {
|
|
return stub(arg1)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2, ret.result3
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
|
|
}
|
|
|
|
func (fake *FakeTeam) PrivateAndPublicBuildsCallCount() int {
|
|
fake.privateAndPublicBuildsMutex.RLock()
|
|
defer fake.privateAndPublicBuildsMutex.RUnlock()
|
|
return len(fake.privateAndPublicBuildsArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) PrivateAndPublicBuildsCalls(stub func(db.Page) ([]db.Build, db.Pagination, error)) {
|
|
fake.privateAndPublicBuildsMutex.Lock()
|
|
defer fake.privateAndPublicBuildsMutex.Unlock()
|
|
fake.PrivateAndPublicBuildsStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) PrivateAndPublicBuildsArgsForCall(i int) db.Page {
|
|
fake.privateAndPublicBuildsMutex.RLock()
|
|
defer fake.privateAndPublicBuildsMutex.RUnlock()
|
|
argsForCall := fake.privateAndPublicBuildsArgsForCall[i]
|
|
return argsForCall.arg1
|
|
}
|
|
|
|
func (fake *FakeTeam) PrivateAndPublicBuildsReturns(result1 []db.Build, result2 db.Pagination, result3 error) {
|
|
fake.privateAndPublicBuildsMutex.Lock()
|
|
defer fake.privateAndPublicBuildsMutex.Unlock()
|
|
fake.PrivateAndPublicBuildsStub = nil
|
|
fake.privateAndPublicBuildsReturns = struct {
|
|
result1 []db.Build
|
|
result2 db.Pagination
|
|
result3 error
|
|
}{result1, result2, result3}
|
|
}
|
|
|
|
func (fake *FakeTeam) PrivateAndPublicBuildsReturnsOnCall(i int, result1 []db.Build, result2 db.Pagination, result3 error) {
|
|
fake.privateAndPublicBuildsMutex.Lock()
|
|
defer fake.privateAndPublicBuildsMutex.Unlock()
|
|
fake.PrivateAndPublicBuildsStub = nil
|
|
if fake.privateAndPublicBuildsReturnsOnCall == nil {
|
|
fake.privateAndPublicBuildsReturnsOnCall = make(map[int]struct {
|
|
result1 []db.Build
|
|
result2 db.Pagination
|
|
result3 error
|
|
})
|
|
}
|
|
fake.privateAndPublicBuildsReturnsOnCall[i] = struct {
|
|
result1 []db.Build
|
|
result2 db.Pagination
|
|
result3 error
|
|
}{result1, result2, result3}
|
|
}
|
|
|
|
func (fake *FakeTeam) PublicPipelines() ([]db.Pipeline, error) {
|
|
fake.publicPipelinesMutex.Lock()
|
|
ret, specificReturn := fake.publicPipelinesReturnsOnCall[len(fake.publicPipelinesArgsForCall)]
|
|
fake.publicPipelinesArgsForCall = append(fake.publicPipelinesArgsForCall, struct {
|
|
}{})
|
|
stub := fake.PublicPipelinesStub
|
|
fakeReturns := fake.publicPipelinesReturns
|
|
fake.recordInvocation("PublicPipelines", []interface{}{})
|
|
fake.publicPipelinesMutex.Unlock()
|
|
if stub != nil {
|
|
return stub()
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2
|
|
}
|
|
|
|
func (fake *FakeTeam) PublicPipelinesCallCount() int {
|
|
fake.publicPipelinesMutex.RLock()
|
|
defer fake.publicPipelinesMutex.RUnlock()
|
|
return len(fake.publicPipelinesArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) PublicPipelinesCalls(stub func() ([]db.Pipeline, error)) {
|
|
fake.publicPipelinesMutex.Lock()
|
|
defer fake.publicPipelinesMutex.Unlock()
|
|
fake.PublicPipelinesStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) PublicPipelinesReturns(result1 []db.Pipeline, result2 error) {
|
|
fake.publicPipelinesMutex.Lock()
|
|
defer fake.publicPipelinesMutex.Unlock()
|
|
fake.PublicPipelinesStub = nil
|
|
fake.publicPipelinesReturns = struct {
|
|
result1 []db.Pipeline
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeTeam) PublicPipelinesReturnsOnCall(i int, result1 []db.Pipeline, result2 error) {
|
|
fake.publicPipelinesMutex.Lock()
|
|
defer fake.publicPipelinesMutex.Unlock()
|
|
fake.PublicPipelinesStub = nil
|
|
if fake.publicPipelinesReturnsOnCall == nil {
|
|
fake.publicPipelinesReturnsOnCall = make(map[int]struct {
|
|
result1 []db.Pipeline
|
|
result2 error
|
|
})
|
|
}
|
|
fake.publicPipelinesReturnsOnCall[i] = struct {
|
|
result1 []db.Pipeline
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeTeam) Rename(arg1 string) error {
|
|
fake.renameMutex.Lock()
|
|
ret, specificReturn := fake.renameReturnsOnCall[len(fake.renameArgsForCall)]
|
|
fake.renameArgsForCall = append(fake.renameArgsForCall, struct {
|
|
arg1 string
|
|
}{arg1})
|
|
stub := fake.RenameStub
|
|
fakeReturns := fake.renameReturns
|
|
fake.recordInvocation("Rename", []interface{}{arg1})
|
|
fake.renameMutex.Unlock()
|
|
if stub != nil {
|
|
return stub(arg1)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1
|
|
}
|
|
return fakeReturns.result1
|
|
}
|
|
|
|
func (fake *FakeTeam) RenameCallCount() int {
|
|
fake.renameMutex.RLock()
|
|
defer fake.renameMutex.RUnlock()
|
|
return len(fake.renameArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) RenameCalls(stub func(string) error) {
|
|
fake.renameMutex.Lock()
|
|
defer fake.renameMutex.Unlock()
|
|
fake.RenameStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) RenameArgsForCall(i int) string {
|
|
fake.renameMutex.RLock()
|
|
defer fake.renameMutex.RUnlock()
|
|
argsForCall := fake.renameArgsForCall[i]
|
|
return argsForCall.arg1
|
|
}
|
|
|
|
func (fake *FakeTeam) RenameReturns(result1 error) {
|
|
fake.renameMutex.Lock()
|
|
defer fake.renameMutex.Unlock()
|
|
fake.RenameStub = nil
|
|
fake.renameReturns = struct {
|
|
result1 error
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *FakeTeam) RenameReturnsOnCall(i int, result1 error) {
|
|
fake.renameMutex.Lock()
|
|
defer fake.renameMutex.Unlock()
|
|
fake.RenameStub = nil
|
|
if fake.renameReturnsOnCall == nil {
|
|
fake.renameReturnsOnCall = make(map[int]struct {
|
|
result1 error
|
|
})
|
|
}
|
|
fake.renameReturnsOnCall[i] = struct {
|
|
result1 error
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *FakeTeam) RenamePipeline(arg1 string, arg2 string) (bool, error) {
|
|
fake.renamePipelineMutex.Lock()
|
|
ret, specificReturn := fake.renamePipelineReturnsOnCall[len(fake.renamePipelineArgsForCall)]
|
|
fake.renamePipelineArgsForCall = append(fake.renamePipelineArgsForCall, struct {
|
|
arg1 string
|
|
arg2 string
|
|
}{arg1, arg2})
|
|
stub := fake.RenamePipelineStub
|
|
fakeReturns := fake.renamePipelineReturns
|
|
fake.recordInvocation("RenamePipeline", []interface{}{arg1, arg2})
|
|
fake.renamePipelineMutex.Unlock()
|
|
if stub != nil {
|
|
return stub(arg1, arg2)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2
|
|
}
|
|
|
|
func (fake *FakeTeam) RenamePipelineCallCount() int {
|
|
fake.renamePipelineMutex.RLock()
|
|
defer fake.renamePipelineMutex.RUnlock()
|
|
return len(fake.renamePipelineArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) RenamePipelineCalls(stub func(string, string) (bool, error)) {
|
|
fake.renamePipelineMutex.Lock()
|
|
defer fake.renamePipelineMutex.Unlock()
|
|
fake.RenamePipelineStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) RenamePipelineArgsForCall(i int) (string, string) {
|
|
fake.renamePipelineMutex.RLock()
|
|
defer fake.renamePipelineMutex.RUnlock()
|
|
argsForCall := fake.renamePipelineArgsForCall[i]
|
|
return argsForCall.arg1, argsForCall.arg2
|
|
}
|
|
|
|
func (fake *FakeTeam) RenamePipelineReturns(result1 bool, result2 error) {
|
|
fake.renamePipelineMutex.Lock()
|
|
defer fake.renamePipelineMutex.Unlock()
|
|
fake.RenamePipelineStub = nil
|
|
fake.renamePipelineReturns = struct {
|
|
result1 bool
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeTeam) RenamePipelineReturnsOnCall(i int, result1 bool, result2 error) {
|
|
fake.renamePipelineMutex.Lock()
|
|
defer fake.renamePipelineMutex.Unlock()
|
|
fake.RenamePipelineStub = nil
|
|
if fake.renamePipelineReturnsOnCall == nil {
|
|
fake.renamePipelineReturnsOnCall = make(map[int]struct {
|
|
result1 bool
|
|
result2 error
|
|
})
|
|
}
|
|
fake.renamePipelineReturnsOnCall[i] = struct {
|
|
result1 bool
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeTeam) SavePipeline(arg1 atc.PipelineRef, arg2 atc.Config, arg3 db.ConfigVersion, arg4 bool) (db.Pipeline, bool, error) {
|
|
fake.savePipelineMutex.Lock()
|
|
ret, specificReturn := fake.savePipelineReturnsOnCall[len(fake.savePipelineArgsForCall)]
|
|
fake.savePipelineArgsForCall = append(fake.savePipelineArgsForCall, struct {
|
|
arg1 atc.PipelineRef
|
|
arg2 atc.Config
|
|
arg3 db.ConfigVersion
|
|
arg4 bool
|
|
}{arg1, arg2, arg3, arg4})
|
|
stub := fake.SavePipelineStub
|
|
fakeReturns := fake.savePipelineReturns
|
|
fake.recordInvocation("SavePipeline", []interface{}{arg1, arg2, arg3, arg4})
|
|
fake.savePipelineMutex.Unlock()
|
|
if stub != nil {
|
|
return stub(arg1, arg2, arg3, arg4)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2, ret.result3
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
|
|
}
|
|
|
|
func (fake *FakeTeam) SavePipelineCallCount() int {
|
|
fake.savePipelineMutex.RLock()
|
|
defer fake.savePipelineMutex.RUnlock()
|
|
return len(fake.savePipelineArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) SavePipelineCalls(stub func(atc.PipelineRef, atc.Config, db.ConfigVersion, bool) (db.Pipeline, bool, error)) {
|
|
fake.savePipelineMutex.Lock()
|
|
defer fake.savePipelineMutex.Unlock()
|
|
fake.SavePipelineStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) SavePipelineArgsForCall(i int) (atc.PipelineRef, atc.Config, db.ConfigVersion, bool) {
|
|
fake.savePipelineMutex.RLock()
|
|
defer fake.savePipelineMutex.RUnlock()
|
|
argsForCall := fake.savePipelineArgsForCall[i]
|
|
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
|
|
}
|
|
|
|
func (fake *FakeTeam) SavePipelineReturns(result1 db.Pipeline, result2 bool, result3 error) {
|
|
fake.savePipelineMutex.Lock()
|
|
defer fake.savePipelineMutex.Unlock()
|
|
fake.SavePipelineStub = nil
|
|
fake.savePipelineReturns = struct {
|
|
result1 db.Pipeline
|
|
result2 bool
|
|
result3 error
|
|
}{result1, result2, result3}
|
|
}
|
|
|
|
func (fake *FakeTeam) SavePipelineReturnsOnCall(i int, result1 db.Pipeline, result2 bool, result3 error) {
|
|
fake.savePipelineMutex.Lock()
|
|
defer fake.savePipelineMutex.Unlock()
|
|
fake.SavePipelineStub = nil
|
|
if fake.savePipelineReturnsOnCall == nil {
|
|
fake.savePipelineReturnsOnCall = make(map[int]struct {
|
|
result1 db.Pipeline
|
|
result2 bool
|
|
result3 error
|
|
})
|
|
}
|
|
fake.savePipelineReturnsOnCall[i] = struct {
|
|
result1 db.Pipeline
|
|
result2 bool
|
|
result3 error
|
|
}{result1, result2, result3}
|
|
}
|
|
|
|
func (fake *FakeTeam) SaveWorker(arg1 atc.Worker, arg2 time.Duration) (db.Worker, error) {
|
|
fake.saveWorkerMutex.Lock()
|
|
ret, specificReturn := fake.saveWorkerReturnsOnCall[len(fake.saveWorkerArgsForCall)]
|
|
fake.saveWorkerArgsForCall = append(fake.saveWorkerArgsForCall, struct {
|
|
arg1 atc.Worker
|
|
arg2 time.Duration
|
|
}{arg1, arg2})
|
|
stub := fake.SaveWorkerStub
|
|
fakeReturns := fake.saveWorkerReturns
|
|
fake.recordInvocation("SaveWorker", []interface{}{arg1, arg2})
|
|
fake.saveWorkerMutex.Unlock()
|
|
if stub != nil {
|
|
return stub(arg1, arg2)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2
|
|
}
|
|
|
|
func (fake *FakeTeam) SaveWorkerCallCount() int {
|
|
fake.saveWorkerMutex.RLock()
|
|
defer fake.saveWorkerMutex.RUnlock()
|
|
return len(fake.saveWorkerArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) SaveWorkerCalls(stub func(atc.Worker, time.Duration) (db.Worker, error)) {
|
|
fake.saveWorkerMutex.Lock()
|
|
defer fake.saveWorkerMutex.Unlock()
|
|
fake.SaveWorkerStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) SaveWorkerArgsForCall(i int) (atc.Worker, time.Duration) {
|
|
fake.saveWorkerMutex.RLock()
|
|
defer fake.saveWorkerMutex.RUnlock()
|
|
argsForCall := fake.saveWorkerArgsForCall[i]
|
|
return argsForCall.arg1, argsForCall.arg2
|
|
}
|
|
|
|
func (fake *FakeTeam) SaveWorkerReturns(result1 db.Worker, result2 error) {
|
|
fake.saveWorkerMutex.Lock()
|
|
defer fake.saveWorkerMutex.Unlock()
|
|
fake.SaveWorkerStub = nil
|
|
fake.saveWorkerReturns = struct {
|
|
result1 db.Worker
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeTeam) SaveWorkerReturnsOnCall(i int, result1 db.Worker, result2 error) {
|
|
fake.saveWorkerMutex.Lock()
|
|
defer fake.saveWorkerMutex.Unlock()
|
|
fake.SaveWorkerStub = nil
|
|
if fake.saveWorkerReturnsOnCall == nil {
|
|
fake.saveWorkerReturnsOnCall = make(map[int]struct {
|
|
result1 db.Worker
|
|
result2 error
|
|
})
|
|
}
|
|
fake.saveWorkerReturnsOnCall[i] = struct {
|
|
result1 db.Worker
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeTeam) UpdateProviderAuth(arg1 atc.TeamAuth) error {
|
|
fake.updateProviderAuthMutex.Lock()
|
|
ret, specificReturn := fake.updateProviderAuthReturnsOnCall[len(fake.updateProviderAuthArgsForCall)]
|
|
fake.updateProviderAuthArgsForCall = append(fake.updateProviderAuthArgsForCall, struct {
|
|
arg1 atc.TeamAuth
|
|
}{arg1})
|
|
stub := fake.UpdateProviderAuthStub
|
|
fakeReturns := fake.updateProviderAuthReturns
|
|
fake.recordInvocation("UpdateProviderAuth", []interface{}{arg1})
|
|
fake.updateProviderAuthMutex.Unlock()
|
|
if stub != nil {
|
|
return stub(arg1)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1
|
|
}
|
|
return fakeReturns.result1
|
|
}
|
|
|
|
func (fake *FakeTeam) UpdateProviderAuthCallCount() int {
|
|
fake.updateProviderAuthMutex.RLock()
|
|
defer fake.updateProviderAuthMutex.RUnlock()
|
|
return len(fake.updateProviderAuthArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) UpdateProviderAuthCalls(stub func(atc.TeamAuth) error) {
|
|
fake.updateProviderAuthMutex.Lock()
|
|
defer fake.updateProviderAuthMutex.Unlock()
|
|
fake.UpdateProviderAuthStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) UpdateProviderAuthArgsForCall(i int) atc.TeamAuth {
|
|
fake.updateProviderAuthMutex.RLock()
|
|
defer fake.updateProviderAuthMutex.RUnlock()
|
|
argsForCall := fake.updateProviderAuthArgsForCall[i]
|
|
return argsForCall.arg1
|
|
}
|
|
|
|
func (fake *FakeTeam) UpdateProviderAuthReturns(result1 error) {
|
|
fake.updateProviderAuthMutex.Lock()
|
|
defer fake.updateProviderAuthMutex.Unlock()
|
|
fake.UpdateProviderAuthStub = nil
|
|
fake.updateProviderAuthReturns = struct {
|
|
result1 error
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *FakeTeam) UpdateProviderAuthReturnsOnCall(i int, result1 error) {
|
|
fake.updateProviderAuthMutex.Lock()
|
|
defer fake.updateProviderAuthMutex.Unlock()
|
|
fake.UpdateProviderAuthStub = nil
|
|
if fake.updateProviderAuthReturnsOnCall == nil {
|
|
fake.updateProviderAuthReturnsOnCall = make(map[int]struct {
|
|
result1 error
|
|
})
|
|
}
|
|
fake.updateProviderAuthReturnsOnCall[i] = struct {
|
|
result1 error
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *FakeTeam) Workers() ([]db.Worker, error) {
|
|
fake.workersMutex.Lock()
|
|
ret, specificReturn := fake.workersReturnsOnCall[len(fake.workersArgsForCall)]
|
|
fake.workersArgsForCall = append(fake.workersArgsForCall, struct {
|
|
}{})
|
|
stub := fake.WorkersStub
|
|
fakeReturns := fake.workersReturns
|
|
fake.recordInvocation("Workers", []interface{}{})
|
|
fake.workersMutex.Unlock()
|
|
if stub != nil {
|
|
return stub()
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2
|
|
}
|
|
|
|
func (fake *FakeTeam) WorkersCallCount() int {
|
|
fake.workersMutex.RLock()
|
|
defer fake.workersMutex.RUnlock()
|
|
return len(fake.workersArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeTeam) WorkersCalls(stub func() ([]db.Worker, error)) {
|
|
fake.workersMutex.Lock()
|
|
defer fake.workersMutex.Unlock()
|
|
fake.WorkersStub = stub
|
|
}
|
|
|
|
func (fake *FakeTeam) WorkersReturns(result1 []db.Worker, result2 error) {
|
|
fake.workersMutex.Lock()
|
|
defer fake.workersMutex.Unlock()
|
|
fake.WorkersStub = nil
|
|
fake.workersReturns = struct {
|
|
result1 []db.Worker
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeTeam) WorkersReturnsOnCall(i int, result1 []db.Worker, result2 error) {
|
|
fake.workersMutex.Lock()
|
|
defer fake.workersMutex.Unlock()
|
|
fake.WorkersStub = nil
|
|
if fake.workersReturnsOnCall == nil {
|
|
fake.workersReturnsOnCall = make(map[int]struct {
|
|
result1 []db.Worker
|
|
result2 error
|
|
})
|
|
}
|
|
fake.workersReturnsOnCall[i] = struct {
|
|
result1 []db.Worker
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeTeam) Invocations() map[string][][]interface{} {
|
|
fake.invocationsMutex.RLock()
|
|
defer fake.invocationsMutex.RUnlock()
|
|
fake.adminMutex.RLock()
|
|
defer fake.adminMutex.RUnlock()
|
|
fake.authMutex.RLock()
|
|
defer fake.authMutex.RUnlock()
|
|
fake.buildsMutex.RLock()
|
|
defer fake.buildsMutex.RUnlock()
|
|
fake.buildsWithTimeMutex.RLock()
|
|
defer fake.buildsWithTimeMutex.RUnlock()
|
|
fake.containersMutex.RLock()
|
|
defer fake.containersMutex.RUnlock()
|
|
fake.createOneOffBuildMutex.RLock()
|
|
defer fake.createOneOffBuildMutex.RUnlock()
|
|
fake.createStartedBuildMutex.RLock()
|
|
defer fake.createStartedBuildMutex.RUnlock()
|
|
fake.deleteMutex.RLock()
|
|
defer fake.deleteMutex.RUnlock()
|
|
fake.findCheckContainersMutex.RLock()
|
|
defer fake.findCheckContainersMutex.RUnlock()
|
|
fake.findContainerByHandleMutex.RLock()
|
|
defer fake.findContainerByHandleMutex.RUnlock()
|
|
fake.findContainersByMetadataMutex.RLock()
|
|
defer fake.findContainersByMetadataMutex.RUnlock()
|
|
fake.findCreatedContainerByHandleMutex.RLock()
|
|
defer fake.findCreatedContainerByHandleMutex.RUnlock()
|
|
fake.findVolumeForWorkerArtifactMutex.RLock()
|
|
defer fake.findVolumeForWorkerArtifactMutex.RUnlock()
|
|
fake.findWorkerForContainerMutex.RLock()
|
|
defer fake.findWorkerForContainerMutex.RUnlock()
|
|
fake.findWorkerForVolumeMutex.RLock()
|
|
defer fake.findWorkerForVolumeMutex.RUnlock()
|
|
fake.iDMutex.RLock()
|
|
defer fake.iDMutex.RUnlock()
|
|
fake.isCheckContainerMutex.RLock()
|
|
defer fake.isCheckContainerMutex.RUnlock()
|
|
fake.isContainerWithinTeamMutex.RLock()
|
|
defer fake.isContainerWithinTeamMutex.RUnlock()
|
|
fake.nameMutex.RLock()
|
|
defer fake.nameMutex.RUnlock()
|
|
fake.orderPipelinesMutex.RLock()
|
|
defer fake.orderPipelinesMutex.RUnlock()
|
|
fake.pipelineMutex.RLock()
|
|
defer fake.pipelineMutex.RUnlock()
|
|
fake.pipelinesMutex.RLock()
|
|
defer fake.pipelinesMutex.RUnlock()
|
|
fake.privateAndPublicBuildsMutex.RLock()
|
|
defer fake.privateAndPublicBuildsMutex.RUnlock()
|
|
fake.publicPipelinesMutex.RLock()
|
|
defer fake.publicPipelinesMutex.RUnlock()
|
|
fake.renameMutex.RLock()
|
|
defer fake.renameMutex.RUnlock()
|
|
fake.renamePipelineMutex.RLock()
|
|
defer fake.renamePipelineMutex.RUnlock()
|
|
fake.savePipelineMutex.RLock()
|
|
defer fake.savePipelineMutex.RUnlock()
|
|
fake.saveWorkerMutex.RLock()
|
|
defer fake.saveWorkerMutex.RUnlock()
|
|
fake.updateProviderAuthMutex.RLock()
|
|
defer fake.updateProviderAuthMutex.RUnlock()
|
|
fake.workersMutex.RLock()
|
|
defer fake.workersMutex.RUnlock()
|
|
copiedInvocations := map[string][][]interface{}{}
|
|
for key, value := range fake.invocations {
|
|
copiedInvocations[key] = value
|
|
}
|
|
return copiedInvocations
|
|
}
|
|
|
|
func (fake *FakeTeam) 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.Team = new(FakeTeam)
|