fake_team_factory.go

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

import (
	"sync"

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

type FakeTeamFactory struct {
	CreateTeamStub        func(atc.Team) (db.Team, error)
	createTeamMutex       sync.RWMutex
	createTeamArgsForCall []struct {
		arg1 atc.Team
	}
	createTeamReturns struct {
		result1 db.Team
		result2 error
	}
	createTeamReturnsOnCall map[int]struct {
		result1 db.Team
		result2 error
	}
	FindTeamStub        func(string) (db.Team, bool, error)
	findTeamMutex       sync.RWMutex
	findTeamArgsForCall []struct {
		arg1 string
	}
	findTeamReturns struct {
		result1 db.Team
		result2 bool
		result3 error
	}
	findTeamReturnsOnCall map[int]struct {
		result1 db.Team
		result2 bool
		result3 error
	}
	GetTeamsStub        func() ([]db.Team, error)
	getTeamsMutex       sync.RWMutex
	getTeamsArgsForCall []struct{}
	getTeamsReturns     struct {
		result1 []db.Team
		result2 error
	}
	getTeamsReturnsOnCall map[int]struct {
		result1 []db.Team
		result2 error
	}
	GetByIDStub        func(teamID int) db.Team
	getByIDMutex       sync.RWMutex
	getByIDArgsForCall []struct {
		teamID int
	}
	getByIDReturns struct {
		result1 db.Team
	}
	getByIDReturnsOnCall map[int]struct {
		result1 db.Team
	}
	CreateDefaultTeamIfNotExistsStub        func() (db.Team, error)
	createDefaultTeamIfNotExistsMutex       sync.RWMutex
	createDefaultTeamIfNotExistsArgsForCall []struct{}
	createDefaultTeamIfNotExistsReturns     struct {
		result1 db.Team
		result2 error
	}
	createDefaultTeamIfNotExistsReturnsOnCall map[int]struct {
		result1 db.Team
		result2 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeTeamFactory) CreateTeam(arg1 atc.Team) (db.Team, error) {
	fake.createTeamMutex.Lock()
	ret, specificReturn := fake.createTeamReturnsOnCall[len(fake.createTeamArgsForCall)]
	fake.createTeamArgsForCall = append(fake.createTeamArgsForCall, struct {
		arg1 atc.Team
	}{arg1})
	fake.recordInvocation("CreateTeam", []interface{}{arg1})
	fake.createTeamMutex.Unlock()
	if fake.CreateTeamStub != nil {
		return fake.CreateTeamStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.createTeamReturns.result1, fake.createTeamReturns.result2
}

func (fake *FakeTeamFactory) CreateTeamCallCount() int {
	fake.createTeamMutex.RLock()
	defer fake.createTeamMutex.RUnlock()
	return len(fake.createTeamArgsForCall)
}

func (fake *FakeTeamFactory) CreateTeamArgsForCall(i int) atc.Team {
	fake.createTeamMutex.RLock()
	defer fake.createTeamMutex.RUnlock()
	return fake.createTeamArgsForCall[i].arg1
}

func (fake *FakeTeamFactory) CreateTeamReturns(result1 db.Team, result2 error) {
	fake.CreateTeamStub = nil
	fake.createTeamReturns = struct {
		result1 db.Team
		result2 error
	}{result1, result2}
}

func (fake *FakeTeamFactory) CreateTeamReturnsOnCall(i int, result1 db.Team, result2 error) {
	fake.CreateTeamStub = nil
	if fake.createTeamReturnsOnCall == nil {
		fake.createTeamReturnsOnCall = make(map[int]struct {
			result1 db.Team
			result2 error
		})
	}
	fake.createTeamReturnsOnCall[i] = struct {
		result1 db.Team
		result2 error
	}{result1, result2}
}

func (fake *FakeTeamFactory) FindTeam(arg1 string) (db.Team, bool, error) {
	fake.findTeamMutex.Lock()
	ret, specificReturn := fake.findTeamReturnsOnCall[len(fake.findTeamArgsForCall)]
	fake.findTeamArgsForCall = append(fake.findTeamArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("FindTeam", []interface{}{arg1})
	fake.findTeamMutex.Unlock()
	if fake.FindTeamStub != nil {
		return fake.FindTeamStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.findTeamReturns.result1, fake.findTeamReturns.result2, fake.findTeamReturns.result3
}

func (fake *FakeTeamFactory) FindTeamCallCount() int {
	fake.findTeamMutex.RLock()
	defer fake.findTeamMutex.RUnlock()
	return len(fake.findTeamArgsForCall)
}

func (fake *FakeTeamFactory) FindTeamArgsForCall(i int) string {
	fake.findTeamMutex.RLock()
	defer fake.findTeamMutex.RUnlock()
	return fake.findTeamArgsForCall[i].arg1
}

func (fake *FakeTeamFactory) FindTeamReturns(result1 db.Team, result2 bool, result3 error) {
	fake.FindTeamStub = nil
	fake.findTeamReturns = struct {
		result1 db.Team
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeTeamFactory) FindTeamReturnsOnCall(i int, result1 db.Team, result2 bool, result3 error) {
	fake.FindTeamStub = nil
	if fake.findTeamReturnsOnCall == nil {
		fake.findTeamReturnsOnCall = make(map[int]struct {
			result1 db.Team
			result2 bool
			result3 error
		})
	}
	fake.findTeamReturnsOnCall[i] = struct {
		result1 db.Team
		result2 bool
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeTeamFactory) GetTeams() ([]db.Team, error) {
	fake.getTeamsMutex.Lock()
	ret, specificReturn := fake.getTeamsReturnsOnCall[len(fake.getTeamsArgsForCall)]
	fake.getTeamsArgsForCall = append(fake.getTeamsArgsForCall, struct{}{})
	fake.recordInvocation("GetTeams", []interface{}{})
	fake.getTeamsMutex.Unlock()
	if fake.GetTeamsStub != nil {
		return fake.GetTeamsStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.getTeamsReturns.result1, fake.getTeamsReturns.result2
}

func (fake *FakeTeamFactory) GetTeamsCallCount() int {
	fake.getTeamsMutex.RLock()
	defer fake.getTeamsMutex.RUnlock()
	return len(fake.getTeamsArgsForCall)
}

func (fake *FakeTeamFactory) GetTeamsReturns(result1 []db.Team, result2 error) {
	fake.GetTeamsStub = nil
	fake.getTeamsReturns = struct {
		result1 []db.Team
		result2 error
	}{result1, result2}
}

func (fake *FakeTeamFactory) GetTeamsReturnsOnCall(i int, result1 []db.Team, result2 error) {
	fake.GetTeamsStub = nil
	if fake.getTeamsReturnsOnCall == nil {
		fake.getTeamsReturnsOnCall = make(map[int]struct {
			result1 []db.Team
			result2 error
		})
	}
	fake.getTeamsReturnsOnCall[i] = struct {
		result1 []db.Team
		result2 error
	}{result1, result2}
}

func (fake *FakeTeamFactory) GetByID(teamID int) db.Team {
	fake.getByIDMutex.Lock()
	ret, specificReturn := fake.getByIDReturnsOnCall[len(fake.getByIDArgsForCall)]
	fake.getByIDArgsForCall = append(fake.getByIDArgsForCall, struct {
		teamID int
	}{teamID})
	fake.recordInvocation("GetByID", []interface{}{teamID})
	fake.getByIDMutex.Unlock()
	if fake.GetByIDStub != nil {
		return fake.GetByIDStub(teamID)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.getByIDReturns.result1
}

func (fake *FakeTeamFactory) GetByIDCallCount() int {
	fake.getByIDMutex.RLock()
	defer fake.getByIDMutex.RUnlock()
	return len(fake.getByIDArgsForCall)
}

func (fake *FakeTeamFactory) GetByIDArgsForCall(i int) int {
	fake.getByIDMutex.RLock()
	defer fake.getByIDMutex.RUnlock()
	return fake.getByIDArgsForCall[i].teamID
}

func (fake *FakeTeamFactory) GetByIDReturns(result1 db.Team) {
	fake.GetByIDStub = nil
	fake.getByIDReturns = struct {
		result1 db.Team
	}{result1}
}

func (fake *FakeTeamFactory) GetByIDReturnsOnCall(i int, result1 db.Team) {
	fake.GetByIDStub = nil
	if fake.getByIDReturnsOnCall == nil {
		fake.getByIDReturnsOnCall = make(map[int]struct {
			result1 db.Team
		})
	}
	fake.getByIDReturnsOnCall[i] = struct {
		result1 db.Team
	}{result1}
}

func (fake *FakeTeamFactory) CreateDefaultTeamIfNotExists() (db.Team, error) {
	fake.createDefaultTeamIfNotExistsMutex.Lock()
	ret, specificReturn := fake.createDefaultTeamIfNotExistsReturnsOnCall[len(fake.createDefaultTeamIfNotExistsArgsForCall)]
	fake.createDefaultTeamIfNotExistsArgsForCall = append(fake.createDefaultTeamIfNotExistsArgsForCall, struct{}{})
	fake.recordInvocation("CreateDefaultTeamIfNotExists", []interface{}{})
	fake.createDefaultTeamIfNotExistsMutex.Unlock()
	if fake.CreateDefaultTeamIfNotExistsStub != nil {
		return fake.CreateDefaultTeamIfNotExistsStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.createDefaultTeamIfNotExistsReturns.result1, fake.createDefaultTeamIfNotExistsReturns.result2
}

func (fake *FakeTeamFactory) CreateDefaultTeamIfNotExistsCallCount() int {
	fake.createDefaultTeamIfNotExistsMutex.RLock()
	defer fake.createDefaultTeamIfNotExistsMutex.RUnlock()
	return len(fake.createDefaultTeamIfNotExistsArgsForCall)
}

func (fake *FakeTeamFactory) CreateDefaultTeamIfNotExistsReturns(result1 db.Team, result2 error) {
	fake.CreateDefaultTeamIfNotExistsStub = nil
	fake.createDefaultTeamIfNotExistsReturns = struct {
		result1 db.Team
		result2 error
	}{result1, result2}
}

func (fake *FakeTeamFactory) CreateDefaultTeamIfNotExistsReturnsOnCall(i int, result1 db.Team, result2 error) {
	fake.CreateDefaultTeamIfNotExistsStub = nil
	if fake.createDefaultTeamIfNotExistsReturnsOnCall == nil {
		fake.createDefaultTeamIfNotExistsReturnsOnCall = make(map[int]struct {
			result1 db.Team
			result2 error
		})
	}
	fake.createDefaultTeamIfNotExistsReturnsOnCall[i] = struct {
		result1 db.Team
		result2 error
	}{result1, result2}
}

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

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