fake_user_repository.go

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

import (
	"sync"

	"code.cloudfoundry.org/cli/cf/api"
	"code.cloudfoundry.org/cli/cf/models"
)

type FakeUserRepository struct {
	FindByUsernameStub        func(username string) (user models.UserFields, apiErr error)
	findByUsernameMutex       sync.RWMutex
	findByUsernameArgsForCall []struct {
		username string
	}
	findByUsernameReturns struct {
		result1 models.UserFields
		result2 error
	}
	findByUsernameReturnsOnCall map[int]struct {
		result1 models.UserFields
		result2 error
	}
	FindAllByUsernameStub        func(username string) (users []models.UserFields, apiErr error)
	findAllByUsernameMutex       sync.RWMutex
	findAllByUsernameArgsForCall []struct {
		username string
	}
	findAllByUsernameReturns struct {
		result1 []models.UserFields
		result2 error
	}
	findAllByUsernameReturnsOnCall map[int]struct {
		result1 []models.UserFields
		result2 error
	}
	ListUsersInOrgForRoleWithNoUAAStub        func(orgGUID string, role models.Role) ([]models.UserFields, error)
	listUsersInOrgForRoleWithNoUAAMutex       sync.RWMutex
	listUsersInOrgForRoleWithNoUAAArgsForCall []struct {
		orgGUID string
		role    models.Role
	}
	listUsersInOrgForRoleWithNoUAAReturns struct {
		result1 []models.UserFields
		result2 error
	}
	listUsersInOrgForRoleWithNoUAAReturnsOnCall map[int]struct {
		result1 []models.UserFields
		result2 error
	}
	ListUsersInSpaceForRoleWithNoUAAStub        func(spaceGUID string, role models.Role) ([]models.UserFields, error)
	listUsersInSpaceForRoleWithNoUAAMutex       sync.RWMutex
	listUsersInSpaceForRoleWithNoUAAArgsForCall []struct {
		spaceGUID string
		role      models.Role
	}
	listUsersInSpaceForRoleWithNoUAAReturns struct {
		result1 []models.UserFields
		result2 error
	}
	listUsersInSpaceForRoleWithNoUAAReturnsOnCall map[int]struct {
		result1 []models.UserFields
		result2 error
	}
	CreateStub        func(username, password string) (apiErr error)
	createMutex       sync.RWMutex
	createArgsForCall []struct {
		username string
		password string
	}
	createReturns struct {
		result1 error
	}
	createReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteStub        func(userGUID string) (apiErr error)
	deleteMutex       sync.RWMutex
	deleteArgsForCall []struct {
		userGUID string
	}
	deleteReturns struct {
		result1 error
	}
	deleteReturnsOnCall map[int]struct {
		result1 error
	}
	SetOrgRoleByGUIDStub        func(userGUID, orgGUID string, role models.Role) (apiErr error)
	setOrgRoleByGUIDMutex       sync.RWMutex
	setOrgRoleByGUIDArgsForCall []struct {
		userGUID string
		orgGUID  string
		role     models.Role
	}
	setOrgRoleByGUIDReturns struct {
		result1 error
	}
	setOrgRoleByGUIDReturnsOnCall map[int]struct {
		result1 error
	}
	SetOrgRoleByUsernameStub        func(username, orgGUID string, role models.Role) (apiErr error)
	setOrgRoleByUsernameMutex       sync.RWMutex
	setOrgRoleByUsernameArgsForCall []struct {
		username string
		orgGUID  string
		role     models.Role
	}
	setOrgRoleByUsernameReturns struct {
		result1 error
	}
	setOrgRoleByUsernameReturnsOnCall map[int]struct {
		result1 error
	}
	UnsetOrgRoleByGUIDStub        func(userGUID, orgGUID string, role models.Role) (apiErr error)
	unsetOrgRoleByGUIDMutex       sync.RWMutex
	unsetOrgRoleByGUIDArgsForCall []struct {
		userGUID string
		orgGUID  string
		role     models.Role
	}
	unsetOrgRoleByGUIDReturns struct {
		result1 error
	}
	unsetOrgRoleByGUIDReturnsOnCall map[int]struct {
		result1 error
	}
	UnsetOrgRoleByUsernameStub        func(username, orgGUID string, role models.Role) (apiErr error)
	unsetOrgRoleByUsernameMutex       sync.RWMutex
	unsetOrgRoleByUsernameArgsForCall []struct {
		username string
		orgGUID  string
		role     models.Role
	}
	unsetOrgRoleByUsernameReturns struct {
		result1 error
	}
	unsetOrgRoleByUsernameReturnsOnCall map[int]struct {
		result1 error
	}
	SetSpaceRoleByGUIDStub        func(userGUID, spaceGUID, orgGUID string, role models.Role) (apiErr error)
	setSpaceRoleByGUIDMutex       sync.RWMutex
	setSpaceRoleByGUIDArgsForCall []struct {
		userGUID  string
		spaceGUID string
		orgGUID   string
		role      models.Role
	}
	setSpaceRoleByGUIDReturns struct {
		result1 error
	}
	setSpaceRoleByGUIDReturnsOnCall map[int]struct {
		result1 error
	}
	SetSpaceRoleByUsernameStub        func(username, spaceGUID, orgGUID string, role models.Role) (apiErr error)
	setSpaceRoleByUsernameMutex       sync.RWMutex
	setSpaceRoleByUsernameArgsForCall []struct {
		username  string
		spaceGUID string
		orgGUID   string
		role      models.Role
	}
	setSpaceRoleByUsernameReturns struct {
		result1 error
	}
	setSpaceRoleByUsernameReturnsOnCall map[int]struct {
		result1 error
	}
	UnsetSpaceRoleByGUIDStub        func(userGUID, spaceGUID string, role models.Role) (apiErr error)
	unsetSpaceRoleByGUIDMutex       sync.RWMutex
	unsetSpaceRoleByGUIDArgsForCall []struct {
		userGUID  string
		spaceGUID string
		role      models.Role
	}
	unsetSpaceRoleByGUIDReturns struct {
		result1 error
	}
	unsetSpaceRoleByGUIDReturnsOnCall map[int]struct {
		result1 error
	}
	UnsetSpaceRoleByUsernameStub        func(userGUID, spaceGUID string, role models.Role) (apiErr error)
	unsetSpaceRoleByUsernameMutex       sync.RWMutex
	unsetSpaceRoleByUsernameArgsForCall []struct {
		userGUID  string
		spaceGUID string
		role      models.Role
	}
	unsetSpaceRoleByUsernameReturns struct {
		result1 error
	}
	unsetSpaceRoleByUsernameReturnsOnCall map[int]struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeUserRepository) FindByUsername(username string) (user models.UserFields, apiErr error) {
	fake.findByUsernameMutex.Lock()
	ret, specificReturn := fake.findByUsernameReturnsOnCall[len(fake.findByUsernameArgsForCall)]
	fake.findByUsernameArgsForCall = append(fake.findByUsernameArgsForCall, struct {
		username string
	}{username})
	fake.recordInvocation("FindByUsername", []interface{}{username})
	fake.findByUsernameMutex.Unlock()
	if fake.FindByUsernameStub != nil {
		return fake.FindByUsernameStub(username)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.findByUsernameReturns.result1, fake.findByUsernameReturns.result2
}

func (fake *FakeUserRepository) FindByUsernameCallCount() int {
	fake.findByUsernameMutex.RLock()
	defer fake.findByUsernameMutex.RUnlock()
	return len(fake.findByUsernameArgsForCall)
}

func (fake *FakeUserRepository) FindByUsernameArgsForCall(i int) string {
	fake.findByUsernameMutex.RLock()
	defer fake.findByUsernameMutex.RUnlock()
	return fake.findByUsernameArgsForCall[i].username
}

func (fake *FakeUserRepository) FindByUsernameReturns(result1 models.UserFields, result2 error) {
	fake.FindByUsernameStub = nil
	fake.findByUsernameReturns = struct {
		result1 models.UserFields
		result2 error
	}{result1, result2}
}

func (fake *FakeUserRepository) FindByUsernameReturnsOnCall(i int, result1 models.UserFields, result2 error) {
	fake.FindByUsernameStub = nil
	if fake.findByUsernameReturnsOnCall == nil {
		fake.findByUsernameReturnsOnCall = make(map[int]struct {
			result1 models.UserFields
			result2 error
		})
	}
	fake.findByUsernameReturnsOnCall[i] = struct {
		result1 models.UserFields
		result2 error
	}{result1, result2}
}

func (fake *FakeUserRepository) FindAllByUsername(username string) (users []models.UserFields, apiErr error) {
	fake.findAllByUsernameMutex.Lock()
	ret, specificReturn := fake.findAllByUsernameReturnsOnCall[len(fake.findAllByUsernameArgsForCall)]
	fake.findAllByUsernameArgsForCall = append(fake.findAllByUsernameArgsForCall, struct {
		username string
	}{username})
	fake.recordInvocation("FindAllByUsername", []interface{}{username})
	fake.findAllByUsernameMutex.Unlock()
	if fake.FindAllByUsernameStub != nil {
		return fake.FindAllByUsernameStub(username)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.findAllByUsernameReturns.result1, fake.findAllByUsernameReturns.result2
}

func (fake *FakeUserRepository) FindAllByUsernameCallCount() int {
	fake.findAllByUsernameMutex.RLock()
	defer fake.findAllByUsernameMutex.RUnlock()
	return len(fake.findAllByUsernameArgsForCall)
}

func (fake *FakeUserRepository) FindAllByUsernameArgsForCall(i int) string {
	fake.findAllByUsernameMutex.RLock()
	defer fake.findAllByUsernameMutex.RUnlock()
	return fake.findAllByUsernameArgsForCall[i].username
}

func (fake *FakeUserRepository) FindAllByUsernameReturns(result1 []models.UserFields, result2 error) {
	fake.FindAllByUsernameStub = nil
	fake.findAllByUsernameReturns = struct {
		result1 []models.UserFields
		result2 error
	}{result1, result2}
}

func (fake *FakeUserRepository) FindAllByUsernameReturnsOnCall(i int, result1 []models.UserFields, result2 error) {
	fake.FindAllByUsernameStub = nil
	if fake.findAllByUsernameReturnsOnCall == nil {
		fake.findAllByUsernameReturnsOnCall = make(map[int]struct {
			result1 []models.UserFields
			result2 error
		})
	}
	fake.findAllByUsernameReturnsOnCall[i] = struct {
		result1 []models.UserFields
		result2 error
	}{result1, result2}
}

func (fake *FakeUserRepository) ListUsersInOrgForRoleWithNoUAA(orgGUID string, role models.Role) ([]models.UserFields, error) {
	fake.listUsersInOrgForRoleWithNoUAAMutex.Lock()
	ret, specificReturn := fake.listUsersInOrgForRoleWithNoUAAReturnsOnCall[len(fake.listUsersInOrgForRoleWithNoUAAArgsForCall)]
	fake.listUsersInOrgForRoleWithNoUAAArgsForCall = append(fake.listUsersInOrgForRoleWithNoUAAArgsForCall, struct {
		orgGUID string
		role    models.Role
	}{orgGUID, role})
	fake.recordInvocation("ListUsersInOrgForRoleWithNoUAA", []interface{}{orgGUID, role})
	fake.listUsersInOrgForRoleWithNoUAAMutex.Unlock()
	if fake.ListUsersInOrgForRoleWithNoUAAStub != nil {
		return fake.ListUsersInOrgForRoleWithNoUAAStub(orgGUID, role)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.listUsersInOrgForRoleWithNoUAAReturns.result1, fake.listUsersInOrgForRoleWithNoUAAReturns.result2
}

func (fake *FakeUserRepository) ListUsersInOrgForRoleWithNoUAACallCount() int {
	fake.listUsersInOrgForRoleWithNoUAAMutex.RLock()
	defer fake.listUsersInOrgForRoleWithNoUAAMutex.RUnlock()
	return len(fake.listUsersInOrgForRoleWithNoUAAArgsForCall)
}

func (fake *FakeUserRepository) ListUsersInOrgForRoleWithNoUAAArgsForCall(i int) (string, models.Role) {
	fake.listUsersInOrgForRoleWithNoUAAMutex.RLock()
	defer fake.listUsersInOrgForRoleWithNoUAAMutex.RUnlock()
	return fake.listUsersInOrgForRoleWithNoUAAArgsForCall[i].orgGUID, fake.listUsersInOrgForRoleWithNoUAAArgsForCall[i].role
}

func (fake *FakeUserRepository) ListUsersInOrgForRoleWithNoUAAReturns(result1 []models.UserFields, result2 error) {
	fake.ListUsersInOrgForRoleWithNoUAAStub = nil
	fake.listUsersInOrgForRoleWithNoUAAReturns = struct {
		result1 []models.UserFields
		result2 error
	}{result1, result2}
}

func (fake *FakeUserRepository) ListUsersInOrgForRoleWithNoUAAReturnsOnCall(i int, result1 []models.UserFields, result2 error) {
	fake.ListUsersInOrgForRoleWithNoUAAStub = nil
	if fake.listUsersInOrgForRoleWithNoUAAReturnsOnCall == nil {
		fake.listUsersInOrgForRoleWithNoUAAReturnsOnCall = make(map[int]struct {
			result1 []models.UserFields
			result2 error
		})
	}
	fake.listUsersInOrgForRoleWithNoUAAReturnsOnCall[i] = struct {
		result1 []models.UserFields
		result2 error
	}{result1, result2}
}

func (fake *FakeUserRepository) ListUsersInSpaceForRoleWithNoUAA(spaceGUID string, role models.Role) ([]models.UserFields, error) {
	fake.listUsersInSpaceForRoleWithNoUAAMutex.Lock()
	ret, specificReturn := fake.listUsersInSpaceForRoleWithNoUAAReturnsOnCall[len(fake.listUsersInSpaceForRoleWithNoUAAArgsForCall)]
	fake.listUsersInSpaceForRoleWithNoUAAArgsForCall = append(fake.listUsersInSpaceForRoleWithNoUAAArgsForCall, struct {
		spaceGUID string
		role      models.Role
	}{spaceGUID, role})
	fake.recordInvocation("ListUsersInSpaceForRoleWithNoUAA", []interface{}{spaceGUID, role})
	fake.listUsersInSpaceForRoleWithNoUAAMutex.Unlock()
	if fake.ListUsersInSpaceForRoleWithNoUAAStub != nil {
		return fake.ListUsersInSpaceForRoleWithNoUAAStub(spaceGUID, role)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.listUsersInSpaceForRoleWithNoUAAReturns.result1, fake.listUsersInSpaceForRoleWithNoUAAReturns.result2
}

func (fake *FakeUserRepository) ListUsersInSpaceForRoleWithNoUAACallCount() int {
	fake.listUsersInSpaceForRoleWithNoUAAMutex.RLock()
	defer fake.listUsersInSpaceForRoleWithNoUAAMutex.RUnlock()
	return len(fake.listUsersInSpaceForRoleWithNoUAAArgsForCall)
}

func (fake *FakeUserRepository) ListUsersInSpaceForRoleWithNoUAAArgsForCall(i int) (string, models.Role) {
	fake.listUsersInSpaceForRoleWithNoUAAMutex.RLock()
	defer fake.listUsersInSpaceForRoleWithNoUAAMutex.RUnlock()
	return fake.listUsersInSpaceForRoleWithNoUAAArgsForCall[i].spaceGUID, fake.listUsersInSpaceForRoleWithNoUAAArgsForCall[i].role
}

func (fake *FakeUserRepository) ListUsersInSpaceForRoleWithNoUAAReturns(result1 []models.UserFields, result2 error) {
	fake.ListUsersInSpaceForRoleWithNoUAAStub = nil
	fake.listUsersInSpaceForRoleWithNoUAAReturns = struct {
		result1 []models.UserFields
		result2 error
	}{result1, result2}
}

func (fake *FakeUserRepository) ListUsersInSpaceForRoleWithNoUAAReturnsOnCall(i int, result1 []models.UserFields, result2 error) {
	fake.ListUsersInSpaceForRoleWithNoUAAStub = nil
	if fake.listUsersInSpaceForRoleWithNoUAAReturnsOnCall == nil {
		fake.listUsersInSpaceForRoleWithNoUAAReturnsOnCall = make(map[int]struct {
			result1 []models.UserFields
			result2 error
		})
	}
	fake.listUsersInSpaceForRoleWithNoUAAReturnsOnCall[i] = struct {
		result1 []models.UserFields
		result2 error
	}{result1, result2}
}

func (fake *FakeUserRepository) Create(username string, password string) (apiErr error) {
	fake.createMutex.Lock()
	ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)]
	fake.createArgsForCall = append(fake.createArgsForCall, struct {
		username string
		password string
	}{username, password})
	fake.recordInvocation("Create", []interface{}{username, password})
	fake.createMutex.Unlock()
	if fake.CreateStub != nil {
		return fake.CreateStub(username, password)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.createReturns.result1
}

func (fake *FakeUserRepository) CreateCallCount() int {
	fake.createMutex.RLock()
	defer fake.createMutex.RUnlock()
	return len(fake.createArgsForCall)
}

func (fake *FakeUserRepository) CreateArgsForCall(i int) (string, string) {
	fake.createMutex.RLock()
	defer fake.createMutex.RUnlock()
	return fake.createArgsForCall[i].username, fake.createArgsForCall[i].password
}

func (fake *FakeUserRepository) CreateReturns(result1 error) {
	fake.CreateStub = nil
	fake.createReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeUserRepository) CreateReturnsOnCall(i int, result1 error) {
	fake.CreateStub = nil
	if fake.createReturnsOnCall == nil {
		fake.createReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeUserRepository) Delete(userGUID string) (apiErr error) {
	fake.deleteMutex.Lock()
	ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)]
	fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct {
		userGUID string
	}{userGUID})
	fake.recordInvocation("Delete", []interface{}{userGUID})
	fake.deleteMutex.Unlock()
	if fake.DeleteStub != nil {
		return fake.DeleteStub(userGUID)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.deleteReturns.result1
}

func (fake *FakeUserRepository) DeleteCallCount() int {
	fake.deleteMutex.RLock()
	defer fake.deleteMutex.RUnlock()
	return len(fake.deleteArgsForCall)
}

func (fake *FakeUserRepository) DeleteArgsForCall(i int) string {
	fake.deleteMutex.RLock()
	defer fake.deleteMutex.RUnlock()
	return fake.deleteArgsForCall[i].userGUID
}

func (fake *FakeUserRepository) DeleteReturns(result1 error) {
	fake.DeleteStub = nil
	fake.deleteReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeUserRepository) DeleteReturnsOnCall(i int, result1 error) {
	fake.DeleteStub = nil
	if fake.deleteReturnsOnCall == nil {
		fake.deleteReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeUserRepository) SetOrgRoleByGUID(userGUID string, orgGUID string, role models.Role) (apiErr error) {
	fake.setOrgRoleByGUIDMutex.Lock()
	ret, specificReturn := fake.setOrgRoleByGUIDReturnsOnCall[len(fake.setOrgRoleByGUIDArgsForCall)]
	fake.setOrgRoleByGUIDArgsForCall = append(fake.setOrgRoleByGUIDArgsForCall, struct {
		userGUID string
		orgGUID  string
		role     models.Role
	}{userGUID, orgGUID, role})
	fake.recordInvocation("SetOrgRoleByGUID", []interface{}{userGUID, orgGUID, role})
	fake.setOrgRoleByGUIDMutex.Unlock()
	if fake.SetOrgRoleByGUIDStub != nil {
		return fake.SetOrgRoleByGUIDStub(userGUID, orgGUID, role)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.setOrgRoleByGUIDReturns.result1
}

func (fake *FakeUserRepository) SetOrgRoleByGUIDCallCount() int {
	fake.setOrgRoleByGUIDMutex.RLock()
	defer fake.setOrgRoleByGUIDMutex.RUnlock()
	return len(fake.setOrgRoleByGUIDArgsForCall)
}

func (fake *FakeUserRepository) SetOrgRoleByGUIDArgsForCall(i int) (string, string, models.Role) {
	fake.setOrgRoleByGUIDMutex.RLock()
	defer fake.setOrgRoleByGUIDMutex.RUnlock()
	return fake.setOrgRoleByGUIDArgsForCall[i].userGUID, fake.setOrgRoleByGUIDArgsForCall[i].orgGUID, fake.setOrgRoleByGUIDArgsForCall[i].role
}

func (fake *FakeUserRepository) SetOrgRoleByGUIDReturns(result1 error) {
	fake.SetOrgRoleByGUIDStub = nil
	fake.setOrgRoleByGUIDReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeUserRepository) SetOrgRoleByGUIDReturnsOnCall(i int, result1 error) {
	fake.SetOrgRoleByGUIDStub = nil
	if fake.setOrgRoleByGUIDReturnsOnCall == nil {
		fake.setOrgRoleByGUIDReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.setOrgRoleByGUIDReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeUserRepository) SetOrgRoleByUsername(username string, orgGUID string, role models.Role) (apiErr error) {
	fake.setOrgRoleByUsernameMutex.Lock()
	ret, specificReturn := fake.setOrgRoleByUsernameReturnsOnCall[len(fake.setOrgRoleByUsernameArgsForCall)]
	fake.setOrgRoleByUsernameArgsForCall = append(fake.setOrgRoleByUsernameArgsForCall, struct {
		username string
		orgGUID  string
		role     models.Role
	}{username, orgGUID, role})
	fake.recordInvocation("SetOrgRoleByUsername", []interface{}{username, orgGUID, role})
	fake.setOrgRoleByUsernameMutex.Unlock()
	if fake.SetOrgRoleByUsernameStub != nil {
		return fake.SetOrgRoleByUsernameStub(username, orgGUID, role)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.setOrgRoleByUsernameReturns.result1
}

func (fake *FakeUserRepository) SetOrgRoleByUsernameCallCount() int {
	fake.setOrgRoleByUsernameMutex.RLock()
	defer fake.setOrgRoleByUsernameMutex.RUnlock()
	return len(fake.setOrgRoleByUsernameArgsForCall)
}

func (fake *FakeUserRepository) SetOrgRoleByUsernameArgsForCall(i int) (string, string, models.Role) {
	fake.setOrgRoleByUsernameMutex.RLock()
	defer fake.setOrgRoleByUsernameMutex.RUnlock()
	return fake.setOrgRoleByUsernameArgsForCall[i].username, fake.setOrgRoleByUsernameArgsForCall[i].orgGUID, fake.setOrgRoleByUsernameArgsForCall[i].role
}

func (fake *FakeUserRepository) SetOrgRoleByUsernameReturns(result1 error) {
	fake.SetOrgRoleByUsernameStub = nil
	fake.setOrgRoleByUsernameReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeUserRepository) SetOrgRoleByUsernameReturnsOnCall(i int, result1 error) {
	fake.SetOrgRoleByUsernameStub = nil
	if fake.setOrgRoleByUsernameReturnsOnCall == nil {
		fake.setOrgRoleByUsernameReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.setOrgRoleByUsernameReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeUserRepository) UnsetOrgRoleByGUID(userGUID string, orgGUID string, role models.Role) (apiErr error) {
	fake.unsetOrgRoleByGUIDMutex.Lock()
	ret, specificReturn := fake.unsetOrgRoleByGUIDReturnsOnCall[len(fake.unsetOrgRoleByGUIDArgsForCall)]
	fake.unsetOrgRoleByGUIDArgsForCall = append(fake.unsetOrgRoleByGUIDArgsForCall, struct {
		userGUID string
		orgGUID  string
		role     models.Role
	}{userGUID, orgGUID, role})
	fake.recordInvocation("UnsetOrgRoleByGUID", []interface{}{userGUID, orgGUID, role})
	fake.unsetOrgRoleByGUIDMutex.Unlock()
	if fake.UnsetOrgRoleByGUIDStub != nil {
		return fake.UnsetOrgRoleByGUIDStub(userGUID, orgGUID, role)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.unsetOrgRoleByGUIDReturns.result1
}

func (fake *FakeUserRepository) UnsetOrgRoleByGUIDCallCount() int {
	fake.unsetOrgRoleByGUIDMutex.RLock()
	defer fake.unsetOrgRoleByGUIDMutex.RUnlock()
	return len(fake.unsetOrgRoleByGUIDArgsForCall)
}

func (fake *FakeUserRepository) UnsetOrgRoleByGUIDArgsForCall(i int) (string, string, models.Role) {
	fake.unsetOrgRoleByGUIDMutex.RLock()
	defer fake.unsetOrgRoleByGUIDMutex.RUnlock()
	return fake.unsetOrgRoleByGUIDArgsForCall[i].userGUID, fake.unsetOrgRoleByGUIDArgsForCall[i].orgGUID, fake.unsetOrgRoleByGUIDArgsForCall[i].role
}

func (fake *FakeUserRepository) UnsetOrgRoleByGUIDReturns(result1 error) {
	fake.UnsetOrgRoleByGUIDStub = nil
	fake.unsetOrgRoleByGUIDReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeUserRepository) UnsetOrgRoleByGUIDReturnsOnCall(i int, result1 error) {
	fake.UnsetOrgRoleByGUIDStub = nil
	if fake.unsetOrgRoleByGUIDReturnsOnCall == nil {
		fake.unsetOrgRoleByGUIDReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.unsetOrgRoleByGUIDReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeUserRepository) UnsetOrgRoleByUsername(username string, orgGUID string, role models.Role) (apiErr error) {
	fake.unsetOrgRoleByUsernameMutex.Lock()
	ret, specificReturn := fake.unsetOrgRoleByUsernameReturnsOnCall[len(fake.unsetOrgRoleByUsernameArgsForCall)]
	fake.unsetOrgRoleByUsernameArgsForCall = append(fake.unsetOrgRoleByUsernameArgsForCall, struct {
		username string
		orgGUID  string
		role     models.Role
	}{username, orgGUID, role})
	fake.recordInvocation("UnsetOrgRoleByUsername", []interface{}{username, orgGUID, role})
	fake.unsetOrgRoleByUsernameMutex.Unlock()
	if fake.UnsetOrgRoleByUsernameStub != nil {
		return fake.UnsetOrgRoleByUsernameStub(username, orgGUID, role)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.unsetOrgRoleByUsernameReturns.result1
}

func (fake *FakeUserRepository) UnsetOrgRoleByUsernameCallCount() int {
	fake.unsetOrgRoleByUsernameMutex.RLock()
	defer fake.unsetOrgRoleByUsernameMutex.RUnlock()
	return len(fake.unsetOrgRoleByUsernameArgsForCall)
}

func (fake *FakeUserRepository) UnsetOrgRoleByUsernameArgsForCall(i int) (string, string, models.Role) {
	fake.unsetOrgRoleByUsernameMutex.RLock()
	defer fake.unsetOrgRoleByUsernameMutex.RUnlock()
	return fake.unsetOrgRoleByUsernameArgsForCall[i].username, fake.unsetOrgRoleByUsernameArgsForCall[i].orgGUID, fake.unsetOrgRoleByUsernameArgsForCall[i].role
}

func (fake *FakeUserRepository) UnsetOrgRoleByUsernameReturns(result1 error) {
	fake.UnsetOrgRoleByUsernameStub = nil
	fake.unsetOrgRoleByUsernameReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeUserRepository) UnsetOrgRoleByUsernameReturnsOnCall(i int, result1 error) {
	fake.UnsetOrgRoleByUsernameStub = nil
	if fake.unsetOrgRoleByUsernameReturnsOnCall == nil {
		fake.unsetOrgRoleByUsernameReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.unsetOrgRoleByUsernameReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeUserRepository) SetSpaceRoleByGUID(userGUID string, spaceGUID string, orgGUID string, role models.Role) (apiErr error) {
	fake.setSpaceRoleByGUIDMutex.Lock()
	ret, specificReturn := fake.setSpaceRoleByGUIDReturnsOnCall[len(fake.setSpaceRoleByGUIDArgsForCall)]
	fake.setSpaceRoleByGUIDArgsForCall = append(fake.setSpaceRoleByGUIDArgsForCall, struct {
		userGUID  string
		spaceGUID string
		orgGUID   string
		role      models.Role
	}{userGUID, spaceGUID, orgGUID, role})
	fake.recordInvocation("SetSpaceRoleByGUID", []interface{}{userGUID, spaceGUID, orgGUID, role})
	fake.setSpaceRoleByGUIDMutex.Unlock()
	if fake.SetSpaceRoleByGUIDStub != nil {
		return fake.SetSpaceRoleByGUIDStub(userGUID, spaceGUID, orgGUID, role)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.setSpaceRoleByGUIDReturns.result1
}

func (fake *FakeUserRepository) SetSpaceRoleByGUIDCallCount() int {
	fake.setSpaceRoleByGUIDMutex.RLock()
	defer fake.setSpaceRoleByGUIDMutex.RUnlock()
	return len(fake.setSpaceRoleByGUIDArgsForCall)
}

func (fake *FakeUserRepository) SetSpaceRoleByGUIDArgsForCall(i int) (string, string, string, models.Role) {
	fake.setSpaceRoleByGUIDMutex.RLock()
	defer fake.setSpaceRoleByGUIDMutex.RUnlock()
	return fake.setSpaceRoleByGUIDArgsForCall[i].userGUID, fake.setSpaceRoleByGUIDArgsForCall[i].spaceGUID, fake.setSpaceRoleByGUIDArgsForCall[i].orgGUID, fake.setSpaceRoleByGUIDArgsForCall[i].role
}

func (fake *FakeUserRepository) SetSpaceRoleByGUIDReturns(result1 error) {
	fake.SetSpaceRoleByGUIDStub = nil
	fake.setSpaceRoleByGUIDReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeUserRepository) SetSpaceRoleByGUIDReturnsOnCall(i int, result1 error) {
	fake.SetSpaceRoleByGUIDStub = nil
	if fake.setSpaceRoleByGUIDReturnsOnCall == nil {
		fake.setSpaceRoleByGUIDReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.setSpaceRoleByGUIDReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeUserRepository) SetSpaceRoleByUsername(username string, spaceGUID string, orgGUID string, role models.Role) (apiErr error) {
	fake.setSpaceRoleByUsernameMutex.Lock()
	ret, specificReturn := fake.setSpaceRoleByUsernameReturnsOnCall[len(fake.setSpaceRoleByUsernameArgsForCall)]
	fake.setSpaceRoleByUsernameArgsForCall = append(fake.setSpaceRoleByUsernameArgsForCall, struct {
		username  string
		spaceGUID string
		orgGUID   string
		role      models.Role
	}{username, spaceGUID, orgGUID, role})
	fake.recordInvocation("SetSpaceRoleByUsername", []interface{}{username, spaceGUID, orgGUID, role})
	fake.setSpaceRoleByUsernameMutex.Unlock()
	if fake.SetSpaceRoleByUsernameStub != nil {
		return fake.SetSpaceRoleByUsernameStub(username, spaceGUID, orgGUID, role)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.setSpaceRoleByUsernameReturns.result1
}

func (fake *FakeUserRepository) SetSpaceRoleByUsernameCallCount() int {
	fake.setSpaceRoleByUsernameMutex.RLock()
	defer fake.setSpaceRoleByUsernameMutex.RUnlock()
	return len(fake.setSpaceRoleByUsernameArgsForCall)
}

func (fake *FakeUserRepository) SetSpaceRoleByUsernameArgsForCall(i int) (string, string, string, models.Role) {
	fake.setSpaceRoleByUsernameMutex.RLock()
	defer fake.setSpaceRoleByUsernameMutex.RUnlock()
	return fake.setSpaceRoleByUsernameArgsForCall[i].username, fake.setSpaceRoleByUsernameArgsForCall[i].spaceGUID, fake.setSpaceRoleByUsernameArgsForCall[i].orgGUID, fake.setSpaceRoleByUsernameArgsForCall[i].role
}

func (fake *FakeUserRepository) SetSpaceRoleByUsernameReturns(result1 error) {
	fake.SetSpaceRoleByUsernameStub = nil
	fake.setSpaceRoleByUsernameReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeUserRepository) SetSpaceRoleByUsernameReturnsOnCall(i int, result1 error) {
	fake.SetSpaceRoleByUsernameStub = nil
	if fake.setSpaceRoleByUsernameReturnsOnCall == nil {
		fake.setSpaceRoleByUsernameReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.setSpaceRoleByUsernameReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeUserRepository) UnsetSpaceRoleByGUID(userGUID string, spaceGUID string, role models.Role) (apiErr error) {
	fake.unsetSpaceRoleByGUIDMutex.Lock()
	ret, specificReturn := fake.unsetSpaceRoleByGUIDReturnsOnCall[len(fake.unsetSpaceRoleByGUIDArgsForCall)]
	fake.unsetSpaceRoleByGUIDArgsForCall = append(fake.unsetSpaceRoleByGUIDArgsForCall, struct {
		userGUID  string
		spaceGUID string
		role      models.Role
	}{userGUID, spaceGUID, role})
	fake.recordInvocation("UnsetSpaceRoleByGUID", []interface{}{userGUID, spaceGUID, role})
	fake.unsetSpaceRoleByGUIDMutex.Unlock()
	if fake.UnsetSpaceRoleByGUIDStub != nil {
		return fake.UnsetSpaceRoleByGUIDStub(userGUID, spaceGUID, role)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.unsetSpaceRoleByGUIDReturns.result1
}

func (fake *FakeUserRepository) UnsetSpaceRoleByGUIDCallCount() int {
	fake.unsetSpaceRoleByGUIDMutex.RLock()
	defer fake.unsetSpaceRoleByGUIDMutex.RUnlock()
	return len(fake.unsetSpaceRoleByGUIDArgsForCall)
}

func (fake *FakeUserRepository) UnsetSpaceRoleByGUIDArgsForCall(i int) (string, string, models.Role) {
	fake.unsetSpaceRoleByGUIDMutex.RLock()
	defer fake.unsetSpaceRoleByGUIDMutex.RUnlock()
	return fake.unsetSpaceRoleByGUIDArgsForCall[i].userGUID, fake.unsetSpaceRoleByGUIDArgsForCall[i].spaceGUID, fake.unsetSpaceRoleByGUIDArgsForCall[i].role
}

func (fake *FakeUserRepository) UnsetSpaceRoleByGUIDReturns(result1 error) {
	fake.UnsetSpaceRoleByGUIDStub = nil
	fake.unsetSpaceRoleByGUIDReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeUserRepository) UnsetSpaceRoleByGUIDReturnsOnCall(i int, result1 error) {
	fake.UnsetSpaceRoleByGUIDStub = nil
	if fake.unsetSpaceRoleByGUIDReturnsOnCall == nil {
		fake.unsetSpaceRoleByGUIDReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.unsetSpaceRoleByGUIDReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeUserRepository) UnsetSpaceRoleByUsername(userGUID string, spaceGUID string, role models.Role) (apiErr error) {
	fake.unsetSpaceRoleByUsernameMutex.Lock()
	ret, specificReturn := fake.unsetSpaceRoleByUsernameReturnsOnCall[len(fake.unsetSpaceRoleByUsernameArgsForCall)]
	fake.unsetSpaceRoleByUsernameArgsForCall = append(fake.unsetSpaceRoleByUsernameArgsForCall, struct {
		userGUID  string
		spaceGUID string
		role      models.Role
	}{userGUID, spaceGUID, role})
	fake.recordInvocation("UnsetSpaceRoleByUsername", []interface{}{userGUID, spaceGUID, role})
	fake.unsetSpaceRoleByUsernameMutex.Unlock()
	if fake.UnsetSpaceRoleByUsernameStub != nil {
		return fake.UnsetSpaceRoleByUsernameStub(userGUID, spaceGUID, role)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.unsetSpaceRoleByUsernameReturns.result1
}

func (fake *FakeUserRepository) UnsetSpaceRoleByUsernameCallCount() int {
	fake.unsetSpaceRoleByUsernameMutex.RLock()
	defer fake.unsetSpaceRoleByUsernameMutex.RUnlock()
	return len(fake.unsetSpaceRoleByUsernameArgsForCall)
}

func (fake *FakeUserRepository) UnsetSpaceRoleByUsernameArgsForCall(i int) (string, string, models.Role) {
	fake.unsetSpaceRoleByUsernameMutex.RLock()
	defer fake.unsetSpaceRoleByUsernameMutex.RUnlock()
	return fake.unsetSpaceRoleByUsernameArgsForCall[i].userGUID, fake.unsetSpaceRoleByUsernameArgsForCall[i].spaceGUID, fake.unsetSpaceRoleByUsernameArgsForCall[i].role
}

func (fake *FakeUserRepository) UnsetSpaceRoleByUsernameReturns(result1 error) {
	fake.UnsetSpaceRoleByUsernameStub = nil
	fake.unsetSpaceRoleByUsernameReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeUserRepository) UnsetSpaceRoleByUsernameReturnsOnCall(i int, result1 error) {
	fake.UnsetSpaceRoleByUsernameStub = nil
	if fake.unsetSpaceRoleByUsernameReturnsOnCall == nil {
		fake.unsetSpaceRoleByUsernameReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.unsetSpaceRoleByUsernameReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeUserRepository) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.findByUsernameMutex.RLock()
	defer fake.findByUsernameMutex.RUnlock()
	fake.findAllByUsernameMutex.RLock()
	defer fake.findAllByUsernameMutex.RUnlock()
	fake.listUsersInOrgForRoleWithNoUAAMutex.RLock()
	defer fake.listUsersInOrgForRoleWithNoUAAMutex.RUnlock()
	fake.listUsersInSpaceForRoleWithNoUAAMutex.RLock()
	defer fake.listUsersInSpaceForRoleWithNoUAAMutex.RUnlock()
	fake.createMutex.RLock()
	defer fake.createMutex.RUnlock()
	fake.deleteMutex.RLock()
	defer fake.deleteMutex.RUnlock()
	fake.setOrgRoleByGUIDMutex.RLock()
	defer fake.setOrgRoleByGUIDMutex.RUnlock()
	fake.setOrgRoleByUsernameMutex.RLock()
	defer fake.setOrgRoleByUsernameMutex.RUnlock()
	fake.unsetOrgRoleByGUIDMutex.RLock()
	defer fake.unsetOrgRoleByGUIDMutex.RUnlock()
	fake.unsetOrgRoleByUsernameMutex.RLock()
	defer fake.unsetOrgRoleByUsernameMutex.RUnlock()
	fake.setSpaceRoleByGUIDMutex.RLock()
	defer fake.setSpaceRoleByGUIDMutex.RUnlock()
	fake.setSpaceRoleByUsernameMutex.RLock()
	defer fake.setSpaceRoleByUsernameMutex.RUnlock()
	fake.unsetSpaceRoleByGUIDMutex.RLock()
	defer fake.unsetSpaceRoleByGUIDMutex.RUnlock()
	fake.unsetSpaceRoleByUsernameMutex.RLock()
	defer fake.unsetSpaceRoleByUsernameMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeUserRepository) 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 _ api.UserRepository = new(FakeUserRepository)