fake_repository.go

// This file was generated by counterfeiter
package fakes

import (
	. "github.com/cloudfoundry/cli/cf/configuration/core_config"
	"github.com/cloudfoundry/cli/cf/models"

	"sync"
)

type FakeRepository struct {
	ApiEndpointStub        func() string
	apiEndpointMutex       sync.RWMutex
	apiEndpointArgsForCall []struct{}
	apiEndpointReturns     struct {
		result1 string
	}
	ApiVersionStub        func() string
	apiVersionMutex       sync.RWMutex
	apiVersionArgsForCall []struct{}
	apiVersionReturns     struct {
		result1 string
	}
	HasAPIEndpointStub        func() bool
	hasAPIEndpointMutex       sync.RWMutex
	hasAPIEndpointArgsForCall []struct{}
	hasAPIEndpointReturns     struct {
		result1 bool
	}
	AuthenticationEndpointStub        func() string
	authenticationEndpointMutex       sync.RWMutex
	authenticationEndpointArgsForCall []struct{}
	authenticationEndpointReturns     struct {
		result1 string
	}
	LoggregatorEndpointStub        func() string
	loggregatorEndpointMutex       sync.RWMutex
	loggregatorEndpointArgsForCall []struct{}
	loggregatorEndpointReturns     struct {
		result1 string
	}
	UaaEndpointStub        func() string
	uaaEndpointMutex       sync.RWMutex
	uaaEndpointArgsForCall []struct{}
	uaaEndpointReturns     struct {
		result1 string
	}
	AccessTokenStub        func() string
	accessTokenMutex       sync.RWMutex
	accessTokenArgsForCall []struct{}
	accessTokenReturns     struct {
		result1 string
	}
	RefreshTokenStub        func() string
	refreshTokenMutex       sync.RWMutex
	refreshTokenArgsForCall []struct{}
	refreshTokenReturns     struct {
		result1 string
	}
	OrganizationFieldsStub        func() models.OrganizationFields
	organizationFieldsMutex       sync.RWMutex
	organizationFieldsArgsForCall []struct{}
	organizationFieldsReturns     struct {
		result1 models.OrganizationFields
	}
	HasOrganizationStub        func() bool
	hasOrganizationMutex       sync.RWMutex
	hasOrganizationArgsForCall []struct{}
	hasOrganizationReturns     struct {
		result1 bool
	}
	SpaceFieldsStub        func() models.SpaceFields
	spaceFieldsMutex       sync.RWMutex
	spaceFieldsArgsForCall []struct{}
	spaceFieldsReturns     struct {
		result1 models.SpaceFields
	}
	HasSpaceStub        func() bool
	hasSpaceMutex       sync.RWMutex
	hasSpaceArgsForCall []struct{}
	hasSpaceReturns     struct {
		result1 bool
	}
	UsernameStub        func() string
	usernameMutex       sync.RWMutex
	usernameArgsForCall []struct{}
	usernameReturns     struct {
		result1 string
	}
	UserGuidStub        func() string
	userGuidMutex       sync.RWMutex
	userGuidArgsForCall []struct{}
	userGuidReturns     struct {
		result1 string
	}
	UserEmailStub        func() string
	userEmailMutex       sync.RWMutex
	userEmailArgsForCall []struct{}
	userEmailReturns     struct {
		result1 string
	}
	IsLoggedInStub        func() bool
	isLoggedInMutex       sync.RWMutex
	isLoggedInArgsForCall []struct{}
	isLoggedInReturns     struct {
		result1 bool
	}
	IsSSLDisabledStub        func() bool
	isSSLDisabledMutex       sync.RWMutex
	isSSLDisabledArgsForCall []struct{}
	isSSLDisabledReturns     struct {
		result1 bool
	}
	AsyncTimeoutStub        func() uint
	asyncTimeoutMutex       sync.RWMutex
	asyncTimeoutArgsForCall []struct{}
	asyncTimeoutReturns     struct {
		result1 uint
	}
	TraceStub        func() string
	traceMutex       sync.RWMutex
	traceArgsForCall []struct{}
	traceReturns     struct {
		result1 string
	}
	ColorEnabledStub        func() string
	colorEnabledMutex       sync.RWMutex
	colorEnabledArgsForCall []struct{}
	colorEnabledReturns     struct {
		result1 string
	}
	LocaleStub        func() string
	localeMutex       sync.RWMutex
	localeArgsForCall []struct{}
	localeReturns     struct {
		result1 string
	}
	PluginsStub        func() map[string]string
	pluginsMutex       sync.RWMutex
	pluginsArgsForCall []struct{}
	pluginsReturns     struct {
		result1 map[string]string
	}
	UserHomePathStub        func() string
	userHomePathMutex       sync.RWMutex
	userHomePathArgsForCall []struct{}
	userHomePathReturns     struct {
		result1 string
	}
	ClearSessionStub          func()
	clearSessionMutex         sync.RWMutex
	clearSessionArgsForCall   []struct{}
	SetApiEndpointStub        func(string)
	setApiEndpointMutex       sync.RWMutex
	setApiEndpointArgsForCall []struct {
		arg1 string
	}
	SetApiVersionStub        func(string)
	setApiVersionMutex       sync.RWMutex
	setApiVersionArgsForCall []struct {
		arg1 string
	}
	SetAuthenticationEndpointStub        func(string)
	setAuthenticationEndpointMutex       sync.RWMutex
	setAuthenticationEndpointArgsForCall []struct {
		arg1 string
	}
	SetLoggregatorEndpointStub        func(string)
	setLoggregatorEndpointMutex       sync.RWMutex
	setLoggregatorEndpointArgsForCall []struct {
		arg1 string
	}
	SetUaaEndpointStub        func(string)
	setUaaEndpointMutex       sync.RWMutex
	setUaaEndpointArgsForCall []struct {
		arg1 string
	}
	SetAccessTokenStub        func(string)
	setAccessTokenMutex       sync.RWMutex
	setAccessTokenArgsForCall []struct {
		arg1 string
	}
	SetRefreshTokenStub        func(string)
	setRefreshTokenMutex       sync.RWMutex
	setRefreshTokenArgsForCall []struct {
		arg1 string
	}
	SetOrganizationFieldsStub        func(models.OrganizationFields)
	setOrganizationFieldsMutex       sync.RWMutex
	setOrganizationFieldsArgsForCall []struct {
		arg1 models.OrganizationFields
	}
	SetSpaceFieldsStub        func(models.SpaceFields)
	setSpaceFieldsMutex       sync.RWMutex
	setSpaceFieldsArgsForCall []struct {
		arg1 models.SpaceFields
	}
	SetSSLDisabledStub        func(bool)
	setSSLDisabledMutex       sync.RWMutex
	setSSLDisabledArgsForCall []struct {
		arg1 bool
	}
	SetAsyncTimeoutStub        func(uint)
	setAsyncTimeoutMutex       sync.RWMutex
	setAsyncTimeoutArgsForCall []struct {
		arg1 uint
	}
	SetTraceStub        func(string)
	setTraceMutex       sync.RWMutex
	setTraceArgsForCall []struct {
		arg1 string
	}
	SetColorEnabledStub        func(string)
	setColorEnabledMutex       sync.RWMutex
	setColorEnabledArgsForCall []struct {
		arg1 string
	}
	SetLocaleStub        func(string)
	setLocaleMutex       sync.RWMutex
	setLocaleArgsForCall []struct {
		arg1 string
	}
	SetPluginStub        func(string, string)
	setPluginMutex       sync.RWMutex
	setPluginArgsForCall []struct {
		arg1 string
		arg2 string
	}
	CloseStub        func()
	closeMutex       sync.RWMutex
	closeArgsForCall []struct{}
}

func (fake *FakeRepository) ApiEndpoint() string {
	fake.apiEndpointMutex.Lock()
	defer fake.apiEndpointMutex.Unlock()
	fake.apiEndpointArgsForCall = append(fake.apiEndpointArgsForCall, struct{}{})
	if fake.ApiEndpointStub != nil {
		return fake.ApiEndpointStub()
	} else {
		return fake.apiEndpointReturns.result1
	}
}

func (fake *FakeRepository) ApiEndpointCallCount() int {
	fake.apiEndpointMutex.RLock()
	defer fake.apiEndpointMutex.RUnlock()
	return len(fake.apiEndpointArgsForCall)
}

func (fake *FakeRepository) ApiEndpointReturns(result1 string) {
	fake.apiEndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeRepository) ApiVersion() string {
	fake.apiVersionMutex.Lock()
	defer fake.apiVersionMutex.Unlock()
	fake.apiVersionArgsForCall = append(fake.apiVersionArgsForCall, struct{}{})
	if fake.ApiVersionStub != nil {
		return fake.ApiVersionStub()
	} else {
		return fake.apiVersionReturns.result1
	}
}

func (fake *FakeRepository) ApiVersionCallCount() int {
	fake.apiVersionMutex.RLock()
	defer fake.apiVersionMutex.RUnlock()
	return len(fake.apiVersionArgsForCall)
}

func (fake *FakeRepository) ApiVersionReturns(result1 string) {
	fake.apiVersionReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeRepository) HasAPIEndpoint() bool {
	fake.hasAPIEndpointMutex.Lock()
	defer fake.hasAPIEndpointMutex.Unlock()
	fake.hasAPIEndpointArgsForCall = append(fake.hasAPIEndpointArgsForCall, struct{}{})
	if fake.HasAPIEndpointStub != nil {
		return fake.HasAPIEndpointStub()
	} else {
		return fake.hasAPIEndpointReturns.result1
	}
}

func (fake *FakeRepository) HasAPIEndpointCallCount() int {
	fake.hasAPIEndpointMutex.RLock()
	defer fake.hasAPIEndpointMutex.RUnlock()
	return len(fake.hasAPIEndpointArgsForCall)
}

func (fake *FakeRepository) HasAPIEndpointReturns(result1 bool) {
	fake.hasAPIEndpointReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeRepository) AuthenticationEndpoint() string {
	fake.authenticationEndpointMutex.Lock()
	defer fake.authenticationEndpointMutex.Unlock()
	fake.authenticationEndpointArgsForCall = append(fake.authenticationEndpointArgsForCall, struct{}{})
	if fake.AuthenticationEndpointStub != nil {
		return fake.AuthenticationEndpointStub()
	} else {
		return fake.authenticationEndpointReturns.result1
	}
}

func (fake *FakeRepository) AuthenticationEndpointCallCount() int {
	fake.authenticationEndpointMutex.RLock()
	defer fake.authenticationEndpointMutex.RUnlock()
	return len(fake.authenticationEndpointArgsForCall)
}

func (fake *FakeRepository) AuthenticationEndpointReturns(result1 string) {
	fake.authenticationEndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeRepository) LoggregatorEndpoint() string {
	fake.loggregatorEndpointMutex.Lock()
	defer fake.loggregatorEndpointMutex.Unlock()
	fake.loggregatorEndpointArgsForCall = append(fake.loggregatorEndpointArgsForCall, struct{}{})
	if fake.LoggregatorEndpointStub != nil {
		return fake.LoggregatorEndpointStub()
	} else {
		return fake.loggregatorEndpointReturns.result1
	}
}

func (fake *FakeRepository) LoggregatorEndpointCallCount() int {
	fake.loggregatorEndpointMutex.RLock()
	defer fake.loggregatorEndpointMutex.RUnlock()
	return len(fake.loggregatorEndpointArgsForCall)
}

func (fake *FakeRepository) LoggregatorEndpointReturns(result1 string) {
	fake.loggregatorEndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeRepository) UaaEndpoint() string {
	fake.uaaEndpointMutex.Lock()
	defer fake.uaaEndpointMutex.Unlock()
	fake.uaaEndpointArgsForCall = append(fake.uaaEndpointArgsForCall, struct{}{})
	if fake.UaaEndpointStub != nil {
		return fake.UaaEndpointStub()
	} else {
		return fake.uaaEndpointReturns.result1
	}
}

func (fake *FakeRepository) UaaEndpointCallCount() int {
	fake.uaaEndpointMutex.RLock()
	defer fake.uaaEndpointMutex.RUnlock()
	return len(fake.uaaEndpointArgsForCall)
}

func (fake *FakeRepository) UaaEndpointReturns(result1 string) {
	fake.uaaEndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeRepository) AccessToken() string {
	fake.accessTokenMutex.Lock()
	defer fake.accessTokenMutex.Unlock()
	fake.accessTokenArgsForCall = append(fake.accessTokenArgsForCall, struct{}{})
	if fake.AccessTokenStub != nil {
		return fake.AccessTokenStub()
	} else {
		return fake.accessTokenReturns.result1
	}
}

func (fake *FakeRepository) AccessTokenCallCount() int {
	fake.accessTokenMutex.RLock()
	defer fake.accessTokenMutex.RUnlock()
	return len(fake.accessTokenArgsForCall)
}

func (fake *FakeRepository) AccessTokenReturns(result1 string) {
	fake.accessTokenReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeRepository) RefreshToken() string {
	fake.refreshTokenMutex.Lock()
	defer fake.refreshTokenMutex.Unlock()
	fake.refreshTokenArgsForCall = append(fake.refreshTokenArgsForCall, struct{}{})
	if fake.RefreshTokenStub != nil {
		return fake.RefreshTokenStub()
	} else {
		return fake.refreshTokenReturns.result1
	}
}

func (fake *FakeRepository) RefreshTokenCallCount() int {
	fake.refreshTokenMutex.RLock()
	defer fake.refreshTokenMutex.RUnlock()
	return len(fake.refreshTokenArgsForCall)
}

func (fake *FakeRepository) RefreshTokenReturns(result1 string) {
	fake.refreshTokenReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeRepository) OrganizationFields() models.OrganizationFields {
	fake.organizationFieldsMutex.Lock()
	defer fake.organizationFieldsMutex.Unlock()
	fake.organizationFieldsArgsForCall = append(fake.organizationFieldsArgsForCall, struct{}{})
	if fake.OrganizationFieldsStub != nil {
		return fake.OrganizationFieldsStub()
	} else {
		return fake.organizationFieldsReturns.result1
	}
}

func (fake *FakeRepository) OrganizationFieldsCallCount() int {
	fake.organizationFieldsMutex.RLock()
	defer fake.organizationFieldsMutex.RUnlock()
	return len(fake.organizationFieldsArgsForCall)
}

func (fake *FakeRepository) OrganizationFieldsReturns(result1 models.OrganizationFields) {
	fake.organizationFieldsReturns = struct {
		result1 models.OrganizationFields
	}{result1}
}

func (fake *FakeRepository) HasOrganization() bool {
	fake.hasOrganizationMutex.Lock()
	defer fake.hasOrganizationMutex.Unlock()
	fake.hasOrganizationArgsForCall = append(fake.hasOrganizationArgsForCall, struct{}{})
	if fake.HasOrganizationStub != nil {
		return fake.HasOrganizationStub()
	} else {
		return fake.hasOrganizationReturns.result1
	}
}

func (fake *FakeRepository) HasOrganizationCallCount() int {
	fake.hasOrganizationMutex.RLock()
	defer fake.hasOrganizationMutex.RUnlock()
	return len(fake.hasOrganizationArgsForCall)
}

func (fake *FakeRepository) HasOrganizationReturns(result1 bool) {
	fake.hasOrganizationReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeRepository) SpaceFields() models.SpaceFields {
	fake.spaceFieldsMutex.Lock()
	defer fake.spaceFieldsMutex.Unlock()
	fake.spaceFieldsArgsForCall = append(fake.spaceFieldsArgsForCall, struct{}{})
	if fake.SpaceFieldsStub != nil {
		return fake.SpaceFieldsStub()
	} else {
		return fake.spaceFieldsReturns.result1
	}
}

func (fake *FakeRepository) SpaceFieldsCallCount() int {
	fake.spaceFieldsMutex.RLock()
	defer fake.spaceFieldsMutex.RUnlock()
	return len(fake.spaceFieldsArgsForCall)
}

func (fake *FakeRepository) SpaceFieldsReturns(result1 models.SpaceFields) {
	fake.spaceFieldsReturns = struct {
		result1 models.SpaceFields
	}{result1}
}

func (fake *FakeRepository) HasSpace() bool {
	fake.hasSpaceMutex.Lock()
	defer fake.hasSpaceMutex.Unlock()
	fake.hasSpaceArgsForCall = append(fake.hasSpaceArgsForCall, struct{}{})
	if fake.HasSpaceStub != nil {
		return fake.HasSpaceStub()
	} else {
		return fake.hasSpaceReturns.result1
	}
}

func (fake *FakeRepository) HasSpaceCallCount() int {
	fake.hasSpaceMutex.RLock()
	defer fake.hasSpaceMutex.RUnlock()
	return len(fake.hasSpaceArgsForCall)
}

func (fake *FakeRepository) HasSpaceReturns(result1 bool) {
	fake.hasSpaceReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeRepository) Username() string {
	fake.usernameMutex.Lock()
	defer fake.usernameMutex.Unlock()
	fake.usernameArgsForCall = append(fake.usernameArgsForCall, struct{}{})
	if fake.UsernameStub != nil {
		return fake.UsernameStub()
	} else {
		return fake.usernameReturns.result1
	}
}

func (fake *FakeRepository) UsernameCallCount() int {
	fake.usernameMutex.RLock()
	defer fake.usernameMutex.RUnlock()
	return len(fake.usernameArgsForCall)
}

func (fake *FakeRepository) UsernameReturns(result1 string) {
	fake.usernameReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeRepository) UserGuid() string {
	fake.userGuidMutex.Lock()
	defer fake.userGuidMutex.Unlock()
	fake.userGuidArgsForCall = append(fake.userGuidArgsForCall, struct{}{})
	if fake.UserGuidStub != nil {
		return fake.UserGuidStub()
	} else {
		return fake.userGuidReturns.result1
	}
}

func (fake *FakeRepository) UserGuidCallCount() int {
	fake.userGuidMutex.RLock()
	defer fake.userGuidMutex.RUnlock()
	return len(fake.userGuidArgsForCall)
}

func (fake *FakeRepository) UserGuidReturns(result1 string) {
	fake.userGuidReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeRepository) UserEmail() string {
	fake.userEmailMutex.Lock()
	defer fake.userEmailMutex.Unlock()
	fake.userEmailArgsForCall = append(fake.userEmailArgsForCall, struct{}{})
	if fake.UserEmailStub != nil {
		return fake.UserEmailStub()
	} else {
		return fake.userEmailReturns.result1
	}
}

func (fake *FakeRepository) UserEmailCallCount() int {
	fake.userEmailMutex.RLock()
	defer fake.userEmailMutex.RUnlock()
	return len(fake.userEmailArgsForCall)
}

func (fake *FakeRepository) UserEmailReturns(result1 string) {
	fake.userEmailReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeRepository) IsLoggedIn() bool {
	fake.isLoggedInMutex.Lock()
	defer fake.isLoggedInMutex.Unlock()
	fake.isLoggedInArgsForCall = append(fake.isLoggedInArgsForCall, struct{}{})
	if fake.IsLoggedInStub != nil {
		return fake.IsLoggedInStub()
	} else {
		return fake.isLoggedInReturns.result1
	}
}

func (fake *FakeRepository) IsLoggedInCallCount() int {
	fake.isLoggedInMutex.RLock()
	defer fake.isLoggedInMutex.RUnlock()
	return len(fake.isLoggedInArgsForCall)
}

func (fake *FakeRepository) IsLoggedInReturns(result1 bool) {
	fake.isLoggedInReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeRepository) IsSSLDisabled() bool {
	fake.isSSLDisabledMutex.Lock()
	defer fake.isSSLDisabledMutex.Unlock()
	fake.isSSLDisabledArgsForCall = append(fake.isSSLDisabledArgsForCall, struct{}{})
	if fake.IsSSLDisabledStub != nil {
		return fake.IsSSLDisabledStub()
	} else {
		return fake.isSSLDisabledReturns.result1
	}
}

func (fake *FakeRepository) IsSSLDisabledCallCount() int {
	fake.isSSLDisabledMutex.RLock()
	defer fake.isSSLDisabledMutex.RUnlock()
	return len(fake.isSSLDisabledArgsForCall)
}

func (fake *FakeRepository) IsSSLDisabledReturns(result1 bool) {
	fake.isSSLDisabledReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeRepository) AsyncTimeout() uint {
	fake.asyncTimeoutMutex.Lock()
	defer fake.asyncTimeoutMutex.Unlock()
	fake.asyncTimeoutArgsForCall = append(fake.asyncTimeoutArgsForCall, struct{}{})
	if fake.AsyncTimeoutStub != nil {
		return fake.AsyncTimeoutStub()
	} else {
		return fake.asyncTimeoutReturns.result1
	}
}

func (fake *FakeRepository) AsyncTimeoutCallCount() int {
	fake.asyncTimeoutMutex.RLock()
	defer fake.asyncTimeoutMutex.RUnlock()
	return len(fake.asyncTimeoutArgsForCall)
}

func (fake *FakeRepository) AsyncTimeoutReturns(result1 uint) {
	fake.asyncTimeoutReturns = struct {
		result1 uint
	}{result1}
}

func (fake *FakeRepository) Trace() string {
	fake.traceMutex.Lock()
	defer fake.traceMutex.Unlock()
	fake.traceArgsForCall = append(fake.traceArgsForCall, struct{}{})
	if fake.TraceStub != nil {
		return fake.TraceStub()
	} else {
		return fake.traceReturns.result1
	}
}

func (fake *FakeRepository) TraceCallCount() int {
	fake.traceMutex.RLock()
	defer fake.traceMutex.RUnlock()
	return len(fake.traceArgsForCall)
}

func (fake *FakeRepository) TraceReturns(result1 string) {
	fake.traceReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeRepository) ColorEnabled() string {
	fake.colorEnabledMutex.Lock()
	defer fake.colorEnabledMutex.Unlock()
	fake.colorEnabledArgsForCall = append(fake.colorEnabledArgsForCall, struct{}{})
	if fake.ColorEnabledStub != nil {
		return fake.ColorEnabledStub()
	} else {
		return fake.colorEnabledReturns.result1
	}
}

func (fake *FakeRepository) ColorEnabledCallCount() int {
	fake.colorEnabledMutex.RLock()
	defer fake.colorEnabledMutex.RUnlock()
	return len(fake.colorEnabledArgsForCall)
}

func (fake *FakeRepository) ColorEnabledReturns(result1 string) {
	fake.colorEnabledReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeRepository) Locale() string {
	fake.localeMutex.Lock()
	defer fake.localeMutex.Unlock()
	fake.localeArgsForCall = append(fake.localeArgsForCall, struct{}{})
	if fake.LocaleStub != nil {
		return fake.LocaleStub()
	} else {
		return fake.localeReturns.result1
	}
}

func (fake *FakeRepository) LocaleCallCount() int {
	fake.localeMutex.RLock()
	defer fake.localeMutex.RUnlock()
	return len(fake.localeArgsForCall)
}

func (fake *FakeRepository) LocaleReturns(result1 string) {
	fake.localeReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeRepository) Plugins() map[string]string {
	fake.pluginsMutex.Lock()
	defer fake.pluginsMutex.Unlock()
	fake.pluginsArgsForCall = append(fake.pluginsArgsForCall, struct{}{})
	if fake.PluginsStub != nil {
		return fake.PluginsStub()
	} else {
		return fake.pluginsReturns.result1
	}
}

func (fake *FakeRepository) PluginsCallCount() int {
	fake.pluginsMutex.RLock()
	defer fake.pluginsMutex.RUnlock()
	return len(fake.pluginsArgsForCall)
}

func (fake *FakeRepository) PluginsReturns(result1 map[string]string) {
	fake.pluginsReturns = struct {
		result1 map[string]string
	}{result1}
}

func (fake *FakeRepository) UserHomePath() string {
	fake.userHomePathMutex.Lock()
	defer fake.userHomePathMutex.Unlock()
	fake.userHomePathArgsForCall = append(fake.userHomePathArgsForCall, struct{}{})
	if fake.UserHomePathStub != nil {
		return fake.UserHomePathStub()
	} else {
		return fake.userHomePathReturns.result1
	}
}

func (fake *FakeRepository) UserHomePathCallCount() int {
	fake.userHomePathMutex.RLock()
	defer fake.userHomePathMutex.RUnlock()
	return len(fake.userHomePathArgsForCall)
}

func (fake *FakeRepository) UserHomePathReturns(result1 string) {
	fake.userHomePathReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeRepository) ClearSession() {
	fake.clearSessionMutex.Lock()
	defer fake.clearSessionMutex.Unlock()
	fake.clearSessionArgsForCall = append(fake.clearSessionArgsForCall, struct{}{})
	if fake.ClearSessionStub != nil {
		fake.ClearSessionStub()
	}
}

func (fake *FakeRepository) ClearSessionCallCount() int {
	fake.clearSessionMutex.RLock()
	defer fake.clearSessionMutex.RUnlock()
	return len(fake.clearSessionArgsForCall)
}

func (fake *FakeRepository) SetApiEndpoint(arg1 string) {
	fake.setApiEndpointMutex.Lock()
	defer fake.setApiEndpointMutex.Unlock()
	fake.setApiEndpointArgsForCall = append(fake.setApiEndpointArgsForCall, struct {
		arg1 string
	}{arg1})
	if fake.SetApiEndpointStub != nil {
		fake.SetApiEndpointStub(arg1)
	}
}

func (fake *FakeRepository) SetApiEndpointCallCount() int {
	fake.setApiEndpointMutex.RLock()
	defer fake.setApiEndpointMutex.RUnlock()
	return len(fake.setApiEndpointArgsForCall)
}

func (fake *FakeRepository) SetApiEndpointArgsForCall(i int) string {
	fake.setApiEndpointMutex.RLock()
	defer fake.setApiEndpointMutex.RUnlock()
	return fake.setApiEndpointArgsForCall[i].arg1
}

func (fake *FakeRepository) SetApiVersion(arg1 string) {
	fake.setApiVersionMutex.Lock()
	defer fake.setApiVersionMutex.Unlock()
	fake.setApiVersionArgsForCall = append(fake.setApiVersionArgsForCall, struct {
		arg1 string
	}{arg1})
	if fake.SetApiVersionStub != nil {
		fake.SetApiVersionStub(arg1)
	}
}

func (fake *FakeRepository) SetApiVersionCallCount() int {
	fake.setApiVersionMutex.RLock()
	defer fake.setApiVersionMutex.RUnlock()
	return len(fake.setApiVersionArgsForCall)
}

func (fake *FakeRepository) SetApiVersionArgsForCall(i int) string {
	fake.setApiVersionMutex.RLock()
	defer fake.setApiVersionMutex.RUnlock()
	return fake.setApiVersionArgsForCall[i].arg1
}

func (fake *FakeRepository) SetAuthenticationEndpoint(arg1 string) {
	fake.setAuthenticationEndpointMutex.Lock()
	defer fake.setAuthenticationEndpointMutex.Unlock()
	fake.setAuthenticationEndpointArgsForCall = append(fake.setAuthenticationEndpointArgsForCall, struct {
		arg1 string
	}{arg1})
	if fake.SetAuthenticationEndpointStub != nil {
		fake.SetAuthenticationEndpointStub(arg1)
	}
}

func (fake *FakeRepository) SetAuthenticationEndpointCallCount() int {
	fake.setAuthenticationEndpointMutex.RLock()
	defer fake.setAuthenticationEndpointMutex.RUnlock()
	return len(fake.setAuthenticationEndpointArgsForCall)
}

func (fake *FakeRepository) SetAuthenticationEndpointArgsForCall(i int) string {
	fake.setAuthenticationEndpointMutex.RLock()
	defer fake.setAuthenticationEndpointMutex.RUnlock()
	return fake.setAuthenticationEndpointArgsForCall[i].arg1
}

func (fake *FakeRepository) SetLoggregatorEndpoint(arg1 string) {
	fake.setLoggregatorEndpointMutex.Lock()
	defer fake.setLoggregatorEndpointMutex.Unlock()
	fake.setLoggregatorEndpointArgsForCall = append(fake.setLoggregatorEndpointArgsForCall, struct {
		arg1 string
	}{arg1})
	if fake.SetLoggregatorEndpointStub != nil {
		fake.SetLoggregatorEndpointStub(arg1)
	}
}

func (fake *FakeRepository) SetLoggregatorEndpointCallCount() int {
	fake.setLoggregatorEndpointMutex.RLock()
	defer fake.setLoggregatorEndpointMutex.RUnlock()
	return len(fake.setLoggregatorEndpointArgsForCall)
}

func (fake *FakeRepository) SetLoggregatorEndpointArgsForCall(i int) string {
	fake.setLoggregatorEndpointMutex.RLock()
	defer fake.setLoggregatorEndpointMutex.RUnlock()
	return fake.setLoggregatorEndpointArgsForCall[i].arg1
}

func (fake *FakeRepository) SetUaaEndpoint(arg1 string) {
	fake.setUaaEndpointMutex.Lock()
	defer fake.setUaaEndpointMutex.Unlock()
	fake.setUaaEndpointArgsForCall = append(fake.setUaaEndpointArgsForCall, struct {
		arg1 string
	}{arg1})
	if fake.SetUaaEndpointStub != nil {
		fake.SetUaaEndpointStub(arg1)
	}
}

func (fake *FakeRepository) SetUaaEndpointCallCount() int {
	fake.setUaaEndpointMutex.RLock()
	defer fake.setUaaEndpointMutex.RUnlock()
	return len(fake.setUaaEndpointArgsForCall)
}

func (fake *FakeRepository) SetUaaEndpointArgsForCall(i int) string {
	fake.setUaaEndpointMutex.RLock()
	defer fake.setUaaEndpointMutex.RUnlock()
	return fake.setUaaEndpointArgsForCall[i].arg1
}

func (fake *FakeRepository) SetAccessToken(arg1 string) {
	fake.setAccessTokenMutex.Lock()
	defer fake.setAccessTokenMutex.Unlock()
	fake.setAccessTokenArgsForCall = append(fake.setAccessTokenArgsForCall, struct {
		arg1 string
	}{arg1})
	if fake.SetAccessTokenStub != nil {
		fake.SetAccessTokenStub(arg1)
	}
}

func (fake *FakeRepository) SetAccessTokenCallCount() int {
	fake.setAccessTokenMutex.RLock()
	defer fake.setAccessTokenMutex.RUnlock()
	return len(fake.setAccessTokenArgsForCall)
}

func (fake *FakeRepository) SetAccessTokenArgsForCall(i int) string {
	fake.setAccessTokenMutex.RLock()
	defer fake.setAccessTokenMutex.RUnlock()
	return fake.setAccessTokenArgsForCall[i].arg1
}

func (fake *FakeRepository) SetRefreshToken(arg1 string) {
	fake.setRefreshTokenMutex.Lock()
	defer fake.setRefreshTokenMutex.Unlock()
	fake.setRefreshTokenArgsForCall = append(fake.setRefreshTokenArgsForCall, struct {
		arg1 string
	}{arg1})
	if fake.SetRefreshTokenStub != nil {
		fake.SetRefreshTokenStub(arg1)
	}
}

func (fake *FakeRepository) SetRefreshTokenCallCount() int {
	fake.setRefreshTokenMutex.RLock()
	defer fake.setRefreshTokenMutex.RUnlock()
	return len(fake.setRefreshTokenArgsForCall)
}

func (fake *FakeRepository) SetRefreshTokenArgsForCall(i int) string {
	fake.setRefreshTokenMutex.RLock()
	defer fake.setRefreshTokenMutex.RUnlock()
	return fake.setRefreshTokenArgsForCall[i].arg1
}

func (fake *FakeRepository) SetOrganizationFields(arg1 models.OrganizationFields) {
	fake.setOrganizationFieldsMutex.Lock()
	defer fake.setOrganizationFieldsMutex.Unlock()
	fake.setOrganizationFieldsArgsForCall = append(fake.setOrganizationFieldsArgsForCall, struct {
		arg1 models.OrganizationFields
	}{arg1})
	if fake.SetOrganizationFieldsStub != nil {
		fake.SetOrganizationFieldsStub(arg1)
	}
}

func (fake *FakeRepository) SetOrganizationFieldsCallCount() int {
	fake.setOrganizationFieldsMutex.RLock()
	defer fake.setOrganizationFieldsMutex.RUnlock()
	return len(fake.setOrganizationFieldsArgsForCall)
}

func (fake *FakeRepository) SetOrganizationFieldsArgsForCall(i int) models.OrganizationFields {
	fake.setOrganizationFieldsMutex.RLock()
	defer fake.setOrganizationFieldsMutex.RUnlock()
	return fake.setOrganizationFieldsArgsForCall[i].arg1
}

func (fake *FakeRepository) SetSpaceFields(arg1 models.SpaceFields) {
	fake.setSpaceFieldsMutex.Lock()
	defer fake.setSpaceFieldsMutex.Unlock()
	fake.setSpaceFieldsArgsForCall = append(fake.setSpaceFieldsArgsForCall, struct {
		arg1 models.SpaceFields
	}{arg1})
	if fake.SetSpaceFieldsStub != nil {
		fake.SetSpaceFieldsStub(arg1)
	}
}

func (fake *FakeRepository) SetSpaceFieldsCallCount() int {
	fake.setSpaceFieldsMutex.RLock()
	defer fake.setSpaceFieldsMutex.RUnlock()
	return len(fake.setSpaceFieldsArgsForCall)
}

func (fake *FakeRepository) SetSpaceFieldsArgsForCall(i int) models.SpaceFields {
	fake.setSpaceFieldsMutex.RLock()
	defer fake.setSpaceFieldsMutex.RUnlock()
	return fake.setSpaceFieldsArgsForCall[i].arg1
}

func (fake *FakeRepository) SetSSLDisabled(arg1 bool) {
	fake.setSSLDisabledMutex.Lock()
	defer fake.setSSLDisabledMutex.Unlock()
	fake.setSSLDisabledArgsForCall = append(fake.setSSLDisabledArgsForCall, struct {
		arg1 bool
	}{arg1})
	if fake.SetSSLDisabledStub != nil {
		fake.SetSSLDisabledStub(arg1)
	}
}

func (fake *FakeRepository) SetSSLDisabledCallCount() int {
	fake.setSSLDisabledMutex.RLock()
	defer fake.setSSLDisabledMutex.RUnlock()
	return len(fake.setSSLDisabledArgsForCall)
}

func (fake *FakeRepository) SetSSLDisabledArgsForCall(i int) bool {
	fake.setSSLDisabledMutex.RLock()
	defer fake.setSSLDisabledMutex.RUnlock()
	return fake.setSSLDisabledArgsForCall[i].arg1
}

func (fake *FakeRepository) SetAsyncTimeout(arg1 uint) {
	fake.setAsyncTimeoutMutex.Lock()
	defer fake.setAsyncTimeoutMutex.Unlock()
	fake.setAsyncTimeoutArgsForCall = append(fake.setAsyncTimeoutArgsForCall, struct {
		arg1 uint
	}{arg1})
	if fake.SetAsyncTimeoutStub != nil {
		fake.SetAsyncTimeoutStub(arg1)
	}
}

func (fake *FakeRepository) SetAsyncTimeoutCallCount() int {
	fake.setAsyncTimeoutMutex.RLock()
	defer fake.setAsyncTimeoutMutex.RUnlock()
	return len(fake.setAsyncTimeoutArgsForCall)
}

func (fake *FakeRepository) SetAsyncTimeoutArgsForCall(i int) uint {
	fake.setAsyncTimeoutMutex.RLock()
	defer fake.setAsyncTimeoutMutex.RUnlock()
	return fake.setAsyncTimeoutArgsForCall[i].arg1
}

func (fake *FakeRepository) SetTrace(arg1 string) {
	fake.setTraceMutex.Lock()
	defer fake.setTraceMutex.Unlock()
	fake.setTraceArgsForCall = append(fake.setTraceArgsForCall, struct {
		arg1 string
	}{arg1})
	if fake.SetTraceStub != nil {
		fake.SetTraceStub(arg1)
	}
}

func (fake *FakeRepository) SetTraceCallCount() int {
	fake.setTraceMutex.RLock()
	defer fake.setTraceMutex.RUnlock()
	return len(fake.setTraceArgsForCall)
}

func (fake *FakeRepository) SetTraceArgsForCall(i int) string {
	fake.setTraceMutex.RLock()
	defer fake.setTraceMutex.RUnlock()
	return fake.setTraceArgsForCall[i].arg1
}

func (fake *FakeRepository) SetColorEnabled(arg1 string) {
	fake.setColorEnabledMutex.Lock()
	defer fake.setColorEnabledMutex.Unlock()
	fake.setColorEnabledArgsForCall = append(fake.setColorEnabledArgsForCall, struct {
		arg1 string
	}{arg1})
	if fake.SetColorEnabledStub != nil {
		fake.SetColorEnabledStub(arg1)
	}
}

func (fake *FakeRepository) SetColorEnabledCallCount() int {
	fake.setColorEnabledMutex.RLock()
	defer fake.setColorEnabledMutex.RUnlock()
	return len(fake.setColorEnabledArgsForCall)
}

func (fake *FakeRepository) SetColorEnabledArgsForCall(i int) string {
	fake.setColorEnabledMutex.RLock()
	defer fake.setColorEnabledMutex.RUnlock()
	return fake.setColorEnabledArgsForCall[i].arg1
}

func (fake *FakeRepository) SetLocale(arg1 string) {
	fake.setLocaleMutex.Lock()
	defer fake.setLocaleMutex.Unlock()
	fake.setLocaleArgsForCall = append(fake.setLocaleArgsForCall, struct {
		arg1 string
	}{arg1})
	if fake.SetLocaleStub != nil {
		fake.SetLocaleStub(arg1)
	}
}

func (fake *FakeRepository) SetLocaleCallCount() int {
	fake.setLocaleMutex.RLock()
	defer fake.setLocaleMutex.RUnlock()
	return len(fake.setLocaleArgsForCall)
}

func (fake *FakeRepository) SetLocaleArgsForCall(i int) string {
	fake.setLocaleMutex.RLock()
	defer fake.setLocaleMutex.RUnlock()
	return fake.setLocaleArgsForCall[i].arg1
}

func (fake *FakeRepository) SetPlugin(arg1 string, arg2 string) {
	fake.setPluginMutex.Lock()
	defer fake.setPluginMutex.Unlock()
	fake.setPluginArgsForCall = append(fake.setPluginArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	if fake.SetPluginStub != nil {
		fake.SetPluginStub(arg1, arg2)
	}
}

func (fake *FakeRepository) SetPluginCallCount() int {
	fake.setPluginMutex.RLock()
	defer fake.setPluginMutex.RUnlock()
	return len(fake.setPluginArgsForCall)
}

func (fake *FakeRepository) SetPluginArgsForCall(i int) (string, string) {
	fake.setPluginMutex.RLock()
	defer fake.setPluginMutex.RUnlock()
	return fake.setPluginArgsForCall[i].arg1, fake.setPluginArgsForCall[i].arg2
}

func (fake *FakeRepository) Close() {
	fake.closeMutex.Lock()
	defer fake.closeMutex.Unlock()
	fake.closeArgsForCall = append(fake.closeArgsForCall, struct{}{})
	if fake.CloseStub != nil {
		fake.CloseStub()
	}
}

func (fake *FakeRepository) CloseCallCount() int {
	fake.closeMutex.RLock()
	defer fake.closeMutex.RUnlock()
	return len(fake.closeArgsForCall)
}

var _ Repository = new(FakeRepository)