fake_cli_connection.go

// This file was generated by counterfeiter
package pluginfakes

import (
	"sync"

	"code.cloudfoundry.org/cli/plugin"
	"code.cloudfoundry.org/cli/plugin/models"
)

type FakeCliConnection struct {
	CliCommandWithoutTerminalOutputStub        func(args ...string) ([]string, error)
	cliCommandWithoutTerminalOutputMutex       sync.RWMutex
	cliCommandWithoutTerminalOutputArgsForCall []struct {
		args []string
	}
	cliCommandWithoutTerminalOutputReturns struct {
		result1 []string
		result2 error
	}
	CliCommandStub        func(args ...string) ([]string, error)
	cliCommandMutex       sync.RWMutex
	cliCommandArgsForCall []struct {
		args []string
	}
	cliCommandReturns struct {
		result1 []string
		result2 error
	}
	GetCurrentOrgStub        func() (plugin_models.Organization, error)
	getCurrentOrgMutex       sync.RWMutex
	getCurrentOrgArgsForCall []struct{}
	getCurrentOrgReturns     struct {
		result1 plugin_models.Organization
		result2 error
	}
	GetCurrentSpaceStub        func() (plugin_models.Space, error)
	getCurrentSpaceMutex       sync.RWMutex
	getCurrentSpaceArgsForCall []struct{}
	getCurrentSpaceReturns     struct {
		result1 plugin_models.Space
		result2 error
	}
	UsernameStub        func() (string, error)
	usernameMutex       sync.RWMutex
	usernameArgsForCall []struct{}
	usernameReturns     struct {
		result1 string
		result2 error
	}
	UserGuidStub        func() (string, error)
	userGuidMutex       sync.RWMutex
	userGuidArgsForCall []struct{}
	userGuidReturns     struct {
		result1 string
		result2 error
	}
	UserEmailStub        func() (string, error)
	userEmailMutex       sync.RWMutex
	userEmailArgsForCall []struct{}
	userEmailReturns     struct {
		result1 string
		result2 error
	}
	IsLoggedInStub        func() (bool, error)
	isLoggedInMutex       sync.RWMutex
	isLoggedInArgsForCall []struct{}
	isLoggedInReturns     struct {
		result1 bool
		result2 error
	}
	IsSSLDisabledStub        func() (bool, error)
	isSSLDisabledMutex       sync.RWMutex
	isSSLDisabledArgsForCall []struct{}
	isSSLDisabledReturns     struct {
		result1 bool
		result2 error
	}
	HasOrganizationStub        func() (bool, error)
	hasOrganizationMutex       sync.RWMutex
	hasOrganizationArgsForCall []struct{}
	hasOrganizationReturns     struct {
		result1 bool
		result2 error
	}
	HasSpaceStub        func() (bool, error)
	hasSpaceMutex       sync.RWMutex
	hasSpaceArgsForCall []struct{}
	hasSpaceReturns     struct {
		result1 bool
		result2 error
	}
	ApiEndpointStub        func() (string, error)
	apiEndpointMutex       sync.RWMutex
	apiEndpointArgsForCall []struct{}
	apiEndpointReturns     struct {
		result1 string
		result2 error
	}
	ApiVersionStub        func() (string, error)
	apiVersionMutex       sync.RWMutex
	apiVersionArgsForCall []struct{}
	apiVersionReturns     struct {
		result1 string
		result2 error
	}
	HasAPIEndpointStub        func() (bool, error)
	hasAPIEndpointMutex       sync.RWMutex
	hasAPIEndpointArgsForCall []struct{}
	hasAPIEndpointReturns     struct {
		result1 bool
		result2 error
	}
	LoggregatorEndpointStub        func() (string, error)
	loggregatorEndpointMutex       sync.RWMutex
	loggregatorEndpointArgsForCall []struct{}
	loggregatorEndpointReturns     struct {
		result1 string
		result2 error
	}
	DopplerEndpointStub        func() (string, error)
	dopplerEndpointMutex       sync.RWMutex
	dopplerEndpointArgsForCall []struct{}
	dopplerEndpointReturns     struct {
		result1 string
		result2 error
	}
	AccessTokenStub        func() (string, error)
	accessTokenMutex       sync.RWMutex
	accessTokenArgsForCall []struct{}
	accessTokenReturns     struct {
		result1 string
		result2 error
	}
	GetAppStub        func(string) (plugin_models.GetAppModel, error)
	getAppMutex       sync.RWMutex
	getAppArgsForCall []struct {
		arg1 string
	}
	getAppReturns struct {
		result1 plugin_models.GetAppModel
		result2 error
	}
	GetAppsStub        func() ([]plugin_models.GetAppsModel, error)
	getAppsMutex       sync.RWMutex
	getAppsArgsForCall []struct{}
	getAppsReturns     struct {
		result1 []plugin_models.GetAppsModel
		result2 error
	}
	GetOrgsStub        func() ([]plugin_models.GetOrgs_Model, error)
	getOrgsMutex       sync.RWMutex
	getOrgsArgsForCall []struct{}
	getOrgsReturns     struct {
		result1 []plugin_models.GetOrgs_Model
		result2 error
	}
	GetSpacesStub        func() ([]plugin_models.GetSpaces_Model, error)
	getSpacesMutex       sync.RWMutex
	getSpacesArgsForCall []struct{}
	getSpacesReturns     struct {
		result1 []plugin_models.GetSpaces_Model
		result2 error
	}
	GetOrgUsersStub        func(string, ...string) ([]plugin_models.GetOrgUsers_Model, error)
	getOrgUsersMutex       sync.RWMutex
	getOrgUsersArgsForCall []struct {
		arg1 string
		arg2 []string
	}
	getOrgUsersReturns struct {
		result1 []plugin_models.GetOrgUsers_Model
		result2 error
	}
	GetSpaceUsersStub        func(string, string) ([]plugin_models.GetSpaceUsers_Model, error)
	getSpaceUsersMutex       sync.RWMutex
	getSpaceUsersArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getSpaceUsersReturns struct {
		result1 []plugin_models.GetSpaceUsers_Model
		result2 error
	}
	GetServicesStub        func() ([]plugin_models.GetServices_Model, error)
	getServicesMutex       sync.RWMutex
	getServicesArgsForCall []struct{}
	getServicesReturns     struct {
		result1 []plugin_models.GetServices_Model
		result2 error
	}
	GetServiceStub        func(string) (plugin_models.GetService_Model, error)
	getServiceMutex       sync.RWMutex
	getServiceArgsForCall []struct {
		arg1 string
	}
	getServiceReturns struct {
		result1 plugin_models.GetService_Model
		result2 error
	}
	GetOrgStub        func(string) (plugin_models.GetOrg_Model, error)
	getOrgMutex       sync.RWMutex
	getOrgArgsForCall []struct {
		arg1 string
	}
	getOrgReturns struct {
		result1 plugin_models.GetOrg_Model
		result2 error
	}
	GetSpaceStub        func(string) (plugin_models.GetSpace_Model, error)
	getSpaceMutex       sync.RWMutex
	getSpaceArgsForCall []struct {
		arg1 string
	}
	getSpaceReturns struct {
		result1 plugin_models.GetSpace_Model
		result2 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeCliConnection) CliCommandWithoutTerminalOutput(args ...string) ([]string, error) {
	fake.cliCommandWithoutTerminalOutputMutex.Lock()
	fake.cliCommandWithoutTerminalOutputArgsForCall = append(fake.cliCommandWithoutTerminalOutputArgsForCall, struct {
		args []string
	}{args})
	fake.recordInvocation("CliCommandWithoutTerminalOutput", []interface{}{args})
	fake.cliCommandWithoutTerminalOutputMutex.Unlock()
	if fake.CliCommandWithoutTerminalOutputStub != nil {
		return fake.CliCommandWithoutTerminalOutputStub(args...)
	} else {
		return fake.cliCommandWithoutTerminalOutputReturns.result1, fake.cliCommandWithoutTerminalOutputReturns.result2
	}
}

func (fake *FakeCliConnection) CliCommandWithoutTerminalOutputCallCount() int {
	fake.cliCommandWithoutTerminalOutputMutex.RLock()
	defer fake.cliCommandWithoutTerminalOutputMutex.RUnlock()
	return len(fake.cliCommandWithoutTerminalOutputArgsForCall)
}

func (fake *FakeCliConnection) CliCommandWithoutTerminalOutputArgsForCall(i int) []string {
	fake.cliCommandWithoutTerminalOutputMutex.RLock()
	defer fake.cliCommandWithoutTerminalOutputMutex.RUnlock()
	return fake.cliCommandWithoutTerminalOutputArgsForCall[i].args
}

func (fake *FakeCliConnection) CliCommandWithoutTerminalOutputReturns(result1 []string, result2 error) {
	fake.CliCommandWithoutTerminalOutputStub = nil
	fake.cliCommandWithoutTerminalOutputReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) CliCommand(args ...string) ([]string, error) {
	fake.cliCommandMutex.Lock()
	fake.cliCommandArgsForCall = append(fake.cliCommandArgsForCall, struct {
		args []string
	}{args})
	fake.recordInvocation("CliCommand", []interface{}{args})
	fake.cliCommandMutex.Unlock()
	if fake.CliCommandStub != nil {
		return fake.CliCommandStub(args...)
	} else {
		return fake.cliCommandReturns.result1, fake.cliCommandReturns.result2
	}
}

func (fake *FakeCliConnection) CliCommandCallCount() int {
	fake.cliCommandMutex.RLock()
	defer fake.cliCommandMutex.RUnlock()
	return len(fake.cliCommandArgsForCall)
}

func (fake *FakeCliConnection) CliCommandArgsForCall(i int) []string {
	fake.cliCommandMutex.RLock()
	defer fake.cliCommandMutex.RUnlock()
	return fake.cliCommandArgsForCall[i].args
}

func (fake *FakeCliConnection) CliCommandReturns(result1 []string, result2 error) {
	fake.CliCommandStub = nil
	fake.cliCommandReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) GetCurrentOrg() (plugin_models.Organization, error) {
	fake.getCurrentOrgMutex.Lock()
	fake.getCurrentOrgArgsForCall = append(fake.getCurrentOrgArgsForCall, struct{}{})
	fake.recordInvocation("GetCurrentOrg", []interface{}{})
	fake.getCurrentOrgMutex.Unlock()
	if fake.GetCurrentOrgStub != nil {
		return fake.GetCurrentOrgStub()
	} else {
		return fake.getCurrentOrgReturns.result1, fake.getCurrentOrgReturns.result2
	}
}

func (fake *FakeCliConnection) GetCurrentOrgCallCount() int {
	fake.getCurrentOrgMutex.RLock()
	defer fake.getCurrentOrgMutex.RUnlock()
	return len(fake.getCurrentOrgArgsForCall)
}

func (fake *FakeCliConnection) GetCurrentOrgReturns(result1 plugin_models.Organization, result2 error) {
	fake.GetCurrentOrgStub = nil
	fake.getCurrentOrgReturns = struct {
		result1 plugin_models.Organization
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) GetCurrentSpace() (plugin_models.Space, error) {
	fake.getCurrentSpaceMutex.Lock()
	fake.getCurrentSpaceArgsForCall = append(fake.getCurrentSpaceArgsForCall, struct{}{})
	fake.recordInvocation("GetCurrentSpace", []interface{}{})
	fake.getCurrentSpaceMutex.Unlock()
	if fake.GetCurrentSpaceStub != nil {
		return fake.GetCurrentSpaceStub()
	} else {
		return fake.getCurrentSpaceReturns.result1, fake.getCurrentSpaceReturns.result2
	}
}

func (fake *FakeCliConnection) GetCurrentSpaceCallCount() int {
	fake.getCurrentSpaceMutex.RLock()
	defer fake.getCurrentSpaceMutex.RUnlock()
	return len(fake.getCurrentSpaceArgsForCall)
}

func (fake *FakeCliConnection) GetCurrentSpaceReturns(result1 plugin_models.Space, result2 error) {
	fake.GetCurrentSpaceStub = nil
	fake.getCurrentSpaceReturns = struct {
		result1 plugin_models.Space
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) Username() (string, error) {
	fake.usernameMutex.Lock()
	fake.usernameArgsForCall = append(fake.usernameArgsForCall, struct{}{})
	fake.recordInvocation("Username", []interface{}{})
	fake.usernameMutex.Unlock()
	if fake.UsernameStub != nil {
		return fake.UsernameStub()
	} else {
		return fake.usernameReturns.result1, fake.usernameReturns.result2
	}
}

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

func (fake *FakeCliConnection) UsernameReturns(result1 string, result2 error) {
	fake.UsernameStub = nil
	fake.usernameReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) UserGuid() (string, error) {
	fake.userGuidMutex.Lock()
	fake.userGuidArgsForCall = append(fake.userGuidArgsForCall, struct{}{})
	fake.recordInvocation("UserGuid", []interface{}{})
	fake.userGuidMutex.Unlock()
	if fake.UserGuidStub != nil {
		return fake.UserGuidStub()
	} else {
		return fake.userGuidReturns.result1, fake.userGuidReturns.result2
	}
}

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

func (fake *FakeCliConnection) UserGuidReturns(result1 string, result2 error) {
	fake.UserGuidStub = nil
	fake.userGuidReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) UserEmail() (string, error) {
	fake.userEmailMutex.Lock()
	fake.userEmailArgsForCall = append(fake.userEmailArgsForCall, struct{}{})
	fake.recordInvocation("UserEmail", []interface{}{})
	fake.userEmailMutex.Unlock()
	if fake.UserEmailStub != nil {
		return fake.UserEmailStub()
	} else {
		return fake.userEmailReturns.result1, fake.userEmailReturns.result2
	}
}

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

func (fake *FakeCliConnection) UserEmailReturns(result1 string, result2 error) {
	fake.UserEmailStub = nil
	fake.userEmailReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) IsLoggedIn() (bool, error) {
	fake.isLoggedInMutex.Lock()
	fake.isLoggedInArgsForCall = append(fake.isLoggedInArgsForCall, struct{}{})
	fake.recordInvocation("IsLoggedIn", []interface{}{})
	fake.isLoggedInMutex.Unlock()
	if fake.IsLoggedInStub != nil {
		return fake.IsLoggedInStub()
	} else {
		return fake.isLoggedInReturns.result1, fake.isLoggedInReturns.result2
	}
}

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

func (fake *FakeCliConnection) IsLoggedInReturns(result1 bool, result2 error) {
	fake.IsLoggedInStub = nil
	fake.isLoggedInReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) IsSSLDisabled() (bool, error) {
	fake.isSSLDisabledMutex.Lock()
	fake.isSSLDisabledArgsForCall = append(fake.isSSLDisabledArgsForCall, struct{}{})
	fake.recordInvocation("IsSSLDisabled", []interface{}{})
	fake.isSSLDisabledMutex.Unlock()
	if fake.IsSSLDisabledStub != nil {
		return fake.IsSSLDisabledStub()
	} else {
		return fake.isSSLDisabledReturns.result1, fake.isSSLDisabledReturns.result2
	}
}

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

func (fake *FakeCliConnection) IsSSLDisabledReturns(result1 bool, result2 error) {
	fake.IsSSLDisabledStub = nil
	fake.isSSLDisabledReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) HasOrganization() (bool, error) {
	fake.hasOrganizationMutex.Lock()
	fake.hasOrganizationArgsForCall = append(fake.hasOrganizationArgsForCall, struct{}{})
	fake.recordInvocation("HasOrganization", []interface{}{})
	fake.hasOrganizationMutex.Unlock()
	if fake.HasOrganizationStub != nil {
		return fake.HasOrganizationStub()
	} else {
		return fake.hasOrganizationReturns.result1, fake.hasOrganizationReturns.result2
	}
}

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

func (fake *FakeCliConnection) HasOrganizationReturns(result1 bool, result2 error) {
	fake.HasOrganizationStub = nil
	fake.hasOrganizationReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) HasSpace() (bool, error) {
	fake.hasSpaceMutex.Lock()
	fake.hasSpaceArgsForCall = append(fake.hasSpaceArgsForCall, struct{}{})
	fake.recordInvocation("HasSpace", []interface{}{})
	fake.hasSpaceMutex.Unlock()
	if fake.HasSpaceStub != nil {
		return fake.HasSpaceStub()
	} else {
		return fake.hasSpaceReturns.result1, fake.hasSpaceReturns.result2
	}
}

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

func (fake *FakeCliConnection) HasSpaceReturns(result1 bool, result2 error) {
	fake.HasSpaceStub = nil
	fake.hasSpaceReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) ApiEndpoint() (string, error) {
	fake.apiEndpointMutex.Lock()
	fake.apiEndpointArgsForCall = append(fake.apiEndpointArgsForCall, struct{}{})
	fake.recordInvocation("ApiEndpoint", []interface{}{})
	fake.apiEndpointMutex.Unlock()
	if fake.ApiEndpointStub != nil {
		return fake.ApiEndpointStub()
	} else {
		return fake.apiEndpointReturns.result1, fake.apiEndpointReturns.result2
	}
}

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

func (fake *FakeCliConnection) ApiEndpointReturns(result1 string, result2 error) {
	fake.ApiEndpointStub = nil
	fake.apiEndpointReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) ApiVersion() (string, error) {
	fake.apiVersionMutex.Lock()
	fake.apiVersionArgsForCall = append(fake.apiVersionArgsForCall, struct{}{})
	fake.recordInvocation("ApiVersion", []interface{}{})
	fake.apiVersionMutex.Unlock()
	if fake.ApiVersionStub != nil {
		return fake.ApiVersionStub()
	} else {
		return fake.apiVersionReturns.result1, fake.apiVersionReturns.result2
	}
}

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

func (fake *FakeCliConnection) ApiVersionReturns(result1 string, result2 error) {
	fake.ApiVersionStub = nil
	fake.apiVersionReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) HasAPIEndpoint() (bool, error) {
	fake.hasAPIEndpointMutex.Lock()
	fake.hasAPIEndpointArgsForCall = append(fake.hasAPIEndpointArgsForCall, struct{}{})
	fake.recordInvocation("HasAPIEndpoint", []interface{}{})
	fake.hasAPIEndpointMutex.Unlock()
	if fake.HasAPIEndpointStub != nil {
		return fake.HasAPIEndpointStub()
	} else {
		return fake.hasAPIEndpointReturns.result1, fake.hasAPIEndpointReturns.result2
	}
}

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

func (fake *FakeCliConnection) HasAPIEndpointReturns(result1 bool, result2 error) {
	fake.HasAPIEndpointStub = nil
	fake.hasAPIEndpointReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) LoggregatorEndpoint() (string, error) {
	fake.loggregatorEndpointMutex.Lock()
	fake.loggregatorEndpointArgsForCall = append(fake.loggregatorEndpointArgsForCall, struct{}{})
	fake.recordInvocation("LoggregatorEndpoint", []interface{}{})
	fake.loggregatorEndpointMutex.Unlock()
	if fake.LoggregatorEndpointStub != nil {
		return fake.LoggregatorEndpointStub()
	} else {
		return fake.loggregatorEndpointReturns.result1, fake.loggregatorEndpointReturns.result2
	}
}

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

func (fake *FakeCliConnection) LoggregatorEndpointReturns(result1 string, result2 error) {
	fake.LoggregatorEndpointStub = nil
	fake.loggregatorEndpointReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) DopplerEndpoint() (string, error) {
	fake.dopplerEndpointMutex.Lock()
	fake.dopplerEndpointArgsForCall = append(fake.dopplerEndpointArgsForCall, struct{}{})
	fake.recordInvocation("DopplerEndpoint", []interface{}{})
	fake.dopplerEndpointMutex.Unlock()
	if fake.DopplerEndpointStub != nil {
		return fake.DopplerEndpointStub()
	} else {
		return fake.dopplerEndpointReturns.result1, fake.dopplerEndpointReturns.result2
	}
}

func (fake *FakeCliConnection) DopplerEndpointCallCount() int {
	fake.dopplerEndpointMutex.RLock()
	defer fake.dopplerEndpointMutex.RUnlock()
	return len(fake.dopplerEndpointArgsForCall)
}

func (fake *FakeCliConnection) DopplerEndpointReturns(result1 string, result2 error) {
	fake.DopplerEndpointStub = nil
	fake.dopplerEndpointReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) AccessToken() (string, error) {
	fake.accessTokenMutex.Lock()
	fake.accessTokenArgsForCall = append(fake.accessTokenArgsForCall, struct{}{})
	fake.recordInvocation("AccessToken", []interface{}{})
	fake.accessTokenMutex.Unlock()
	if fake.AccessTokenStub != nil {
		return fake.AccessTokenStub()
	} else {
		return fake.accessTokenReturns.result1, fake.accessTokenReturns.result2
	}
}

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

func (fake *FakeCliConnection) AccessTokenReturns(result1 string, result2 error) {
	fake.AccessTokenStub = nil
	fake.accessTokenReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) GetApp(arg1 string) (plugin_models.GetAppModel, error) {
	fake.getAppMutex.Lock()
	fake.getAppArgsForCall = append(fake.getAppArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetApp", []interface{}{arg1})
	fake.getAppMutex.Unlock()
	if fake.GetAppStub != nil {
		return fake.GetAppStub(arg1)
	} else {
		return fake.getAppReturns.result1, fake.getAppReturns.result2
	}
}

func (fake *FakeCliConnection) GetAppCallCount() int {
	fake.getAppMutex.RLock()
	defer fake.getAppMutex.RUnlock()
	return len(fake.getAppArgsForCall)
}

func (fake *FakeCliConnection) GetAppArgsForCall(i int) string {
	fake.getAppMutex.RLock()
	defer fake.getAppMutex.RUnlock()
	return fake.getAppArgsForCall[i].arg1
}

func (fake *FakeCliConnection) GetAppReturns(result1 plugin_models.GetAppModel, result2 error) {
	fake.GetAppStub = nil
	fake.getAppReturns = struct {
		result1 plugin_models.GetAppModel
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) GetApps() ([]plugin_models.GetAppsModel, error) {
	fake.getAppsMutex.Lock()
	fake.getAppsArgsForCall = append(fake.getAppsArgsForCall, struct{}{})
	fake.recordInvocation("GetApps", []interface{}{})
	fake.getAppsMutex.Unlock()
	if fake.GetAppsStub != nil {
		return fake.GetAppsStub()
	} else {
		return fake.getAppsReturns.result1, fake.getAppsReturns.result2
	}
}

func (fake *FakeCliConnection) GetAppsCallCount() int {
	fake.getAppsMutex.RLock()
	defer fake.getAppsMutex.RUnlock()
	return len(fake.getAppsArgsForCall)
}

func (fake *FakeCliConnection) GetAppsReturns(result1 []plugin_models.GetAppsModel, result2 error) {
	fake.GetAppsStub = nil
	fake.getAppsReturns = struct {
		result1 []plugin_models.GetAppsModel
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) GetOrgs() ([]plugin_models.GetOrgs_Model, error) {
	fake.getOrgsMutex.Lock()
	fake.getOrgsArgsForCall = append(fake.getOrgsArgsForCall, struct{}{})
	fake.recordInvocation("GetOrgs", []interface{}{})
	fake.getOrgsMutex.Unlock()
	if fake.GetOrgsStub != nil {
		return fake.GetOrgsStub()
	} else {
		return fake.getOrgsReturns.result1, fake.getOrgsReturns.result2
	}
}

func (fake *FakeCliConnection) GetOrgsCallCount() int {
	fake.getOrgsMutex.RLock()
	defer fake.getOrgsMutex.RUnlock()
	return len(fake.getOrgsArgsForCall)
}

func (fake *FakeCliConnection) GetOrgsReturns(result1 []plugin_models.GetOrgs_Model, result2 error) {
	fake.GetOrgsStub = nil
	fake.getOrgsReturns = struct {
		result1 []plugin_models.GetOrgs_Model
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) GetSpaces() ([]plugin_models.GetSpaces_Model, error) {
	fake.getSpacesMutex.Lock()
	fake.getSpacesArgsForCall = append(fake.getSpacesArgsForCall, struct{}{})
	fake.recordInvocation("GetSpaces", []interface{}{})
	fake.getSpacesMutex.Unlock()
	if fake.GetSpacesStub != nil {
		return fake.GetSpacesStub()
	} else {
		return fake.getSpacesReturns.result1, fake.getSpacesReturns.result2
	}
}

func (fake *FakeCliConnection) GetSpacesCallCount() int {
	fake.getSpacesMutex.RLock()
	defer fake.getSpacesMutex.RUnlock()
	return len(fake.getSpacesArgsForCall)
}

func (fake *FakeCliConnection) GetSpacesReturns(result1 []plugin_models.GetSpaces_Model, result2 error) {
	fake.GetSpacesStub = nil
	fake.getSpacesReturns = struct {
		result1 []plugin_models.GetSpaces_Model
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) GetOrgUsers(arg1 string, arg2 ...string) ([]plugin_models.GetOrgUsers_Model, error) {
	fake.getOrgUsersMutex.Lock()
	fake.getOrgUsersArgsForCall = append(fake.getOrgUsersArgsForCall, struct {
		arg1 string
		arg2 []string
	}{arg1, arg2})
	fake.recordInvocation("GetOrgUsers", []interface{}{arg1, arg2})
	fake.getOrgUsersMutex.Unlock()
	if fake.GetOrgUsersStub != nil {
		return fake.GetOrgUsersStub(arg1, arg2...)
	} else {
		return fake.getOrgUsersReturns.result1, fake.getOrgUsersReturns.result2
	}
}

func (fake *FakeCliConnection) GetOrgUsersCallCount() int {
	fake.getOrgUsersMutex.RLock()
	defer fake.getOrgUsersMutex.RUnlock()
	return len(fake.getOrgUsersArgsForCall)
}

func (fake *FakeCliConnection) GetOrgUsersArgsForCall(i int) (string, []string) {
	fake.getOrgUsersMutex.RLock()
	defer fake.getOrgUsersMutex.RUnlock()
	return fake.getOrgUsersArgsForCall[i].arg1, fake.getOrgUsersArgsForCall[i].arg2
}

func (fake *FakeCliConnection) GetOrgUsersReturns(result1 []plugin_models.GetOrgUsers_Model, result2 error) {
	fake.GetOrgUsersStub = nil
	fake.getOrgUsersReturns = struct {
		result1 []plugin_models.GetOrgUsers_Model
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) GetSpaceUsers(arg1 string, arg2 string) ([]plugin_models.GetSpaceUsers_Model, error) {
	fake.getSpaceUsersMutex.Lock()
	fake.getSpaceUsersArgsForCall = append(fake.getSpaceUsersArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetSpaceUsers", []interface{}{arg1, arg2})
	fake.getSpaceUsersMutex.Unlock()
	if fake.GetSpaceUsersStub != nil {
		return fake.GetSpaceUsersStub(arg1, arg2)
	} else {
		return fake.getSpaceUsersReturns.result1, fake.getSpaceUsersReturns.result2
	}
}

func (fake *FakeCliConnection) GetSpaceUsersCallCount() int {
	fake.getSpaceUsersMutex.RLock()
	defer fake.getSpaceUsersMutex.RUnlock()
	return len(fake.getSpaceUsersArgsForCall)
}

func (fake *FakeCliConnection) GetSpaceUsersArgsForCall(i int) (string, string) {
	fake.getSpaceUsersMutex.RLock()
	defer fake.getSpaceUsersMutex.RUnlock()
	return fake.getSpaceUsersArgsForCall[i].arg1, fake.getSpaceUsersArgsForCall[i].arg2
}

func (fake *FakeCliConnection) GetSpaceUsersReturns(result1 []plugin_models.GetSpaceUsers_Model, result2 error) {
	fake.GetSpaceUsersStub = nil
	fake.getSpaceUsersReturns = struct {
		result1 []plugin_models.GetSpaceUsers_Model
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) GetServices() ([]plugin_models.GetServices_Model, error) {
	fake.getServicesMutex.Lock()
	fake.getServicesArgsForCall = append(fake.getServicesArgsForCall, struct{}{})
	fake.recordInvocation("GetServices", []interface{}{})
	fake.getServicesMutex.Unlock()
	if fake.GetServicesStub != nil {
		return fake.GetServicesStub()
	} else {
		return fake.getServicesReturns.result1, fake.getServicesReturns.result2
	}
}

func (fake *FakeCliConnection) GetServicesCallCount() int {
	fake.getServicesMutex.RLock()
	defer fake.getServicesMutex.RUnlock()
	return len(fake.getServicesArgsForCall)
}

func (fake *FakeCliConnection) GetServicesReturns(result1 []plugin_models.GetServices_Model, result2 error) {
	fake.GetServicesStub = nil
	fake.getServicesReturns = struct {
		result1 []plugin_models.GetServices_Model
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) GetService(arg1 string) (plugin_models.GetService_Model, error) {
	fake.getServiceMutex.Lock()
	fake.getServiceArgsForCall = append(fake.getServiceArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetService", []interface{}{arg1})
	fake.getServiceMutex.Unlock()
	if fake.GetServiceStub != nil {
		return fake.GetServiceStub(arg1)
	} else {
		return fake.getServiceReturns.result1, fake.getServiceReturns.result2
	}
}

func (fake *FakeCliConnection) GetServiceCallCount() int {
	fake.getServiceMutex.RLock()
	defer fake.getServiceMutex.RUnlock()
	return len(fake.getServiceArgsForCall)
}

func (fake *FakeCliConnection) GetServiceArgsForCall(i int) string {
	fake.getServiceMutex.RLock()
	defer fake.getServiceMutex.RUnlock()
	return fake.getServiceArgsForCall[i].arg1
}

func (fake *FakeCliConnection) GetServiceReturns(result1 plugin_models.GetService_Model, result2 error) {
	fake.GetServiceStub = nil
	fake.getServiceReturns = struct {
		result1 plugin_models.GetService_Model
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) GetOrg(arg1 string) (plugin_models.GetOrg_Model, error) {
	fake.getOrgMutex.Lock()
	fake.getOrgArgsForCall = append(fake.getOrgArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetOrg", []interface{}{arg1})
	fake.getOrgMutex.Unlock()
	if fake.GetOrgStub != nil {
		return fake.GetOrgStub(arg1)
	} else {
		return fake.getOrgReturns.result1, fake.getOrgReturns.result2
	}
}

func (fake *FakeCliConnection) GetOrgCallCount() int {
	fake.getOrgMutex.RLock()
	defer fake.getOrgMutex.RUnlock()
	return len(fake.getOrgArgsForCall)
}

func (fake *FakeCliConnection) GetOrgArgsForCall(i int) string {
	fake.getOrgMutex.RLock()
	defer fake.getOrgMutex.RUnlock()
	return fake.getOrgArgsForCall[i].arg1
}

func (fake *FakeCliConnection) GetOrgReturns(result1 plugin_models.GetOrg_Model, result2 error) {
	fake.GetOrgStub = nil
	fake.getOrgReturns = struct {
		result1 plugin_models.GetOrg_Model
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) GetSpace(arg1 string) (plugin_models.GetSpace_Model, error) {
	fake.getSpaceMutex.Lock()
	fake.getSpaceArgsForCall = append(fake.getSpaceArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetSpace", []interface{}{arg1})
	fake.getSpaceMutex.Unlock()
	if fake.GetSpaceStub != nil {
		return fake.GetSpaceStub(arg1)
	} else {
		return fake.getSpaceReturns.result1, fake.getSpaceReturns.result2
	}
}

func (fake *FakeCliConnection) GetSpaceCallCount() int {
	fake.getSpaceMutex.RLock()
	defer fake.getSpaceMutex.RUnlock()
	return len(fake.getSpaceArgsForCall)
}

func (fake *FakeCliConnection) GetSpaceArgsForCall(i int) string {
	fake.getSpaceMutex.RLock()
	defer fake.getSpaceMutex.RUnlock()
	return fake.getSpaceArgsForCall[i].arg1
}

func (fake *FakeCliConnection) GetSpaceReturns(result1 plugin_models.GetSpace_Model, result2 error) {
	fake.GetSpaceStub = nil
	fake.getSpaceReturns = struct {
		result1 plugin_models.GetSpace_Model
		result2 error
	}{result1, result2}
}

func (fake *FakeCliConnection) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.cliCommandWithoutTerminalOutputMutex.RLock()
	defer fake.cliCommandWithoutTerminalOutputMutex.RUnlock()
	fake.cliCommandMutex.RLock()
	defer fake.cliCommandMutex.RUnlock()
	fake.getCurrentOrgMutex.RLock()
	defer fake.getCurrentOrgMutex.RUnlock()
	fake.getCurrentSpaceMutex.RLock()
	defer fake.getCurrentSpaceMutex.RUnlock()
	fake.usernameMutex.RLock()
	defer fake.usernameMutex.RUnlock()
	fake.userGuidMutex.RLock()
	defer fake.userGuidMutex.RUnlock()
	fake.userEmailMutex.RLock()
	defer fake.userEmailMutex.RUnlock()
	fake.isLoggedInMutex.RLock()
	defer fake.isLoggedInMutex.RUnlock()
	fake.isSSLDisabledMutex.RLock()
	defer fake.isSSLDisabledMutex.RUnlock()
	fake.hasOrganizationMutex.RLock()
	defer fake.hasOrganizationMutex.RUnlock()
	fake.hasSpaceMutex.RLock()
	defer fake.hasSpaceMutex.RUnlock()
	fake.apiEndpointMutex.RLock()
	defer fake.apiEndpointMutex.RUnlock()
	fake.apiVersionMutex.RLock()
	defer fake.apiVersionMutex.RUnlock()
	fake.hasAPIEndpointMutex.RLock()
	defer fake.hasAPIEndpointMutex.RUnlock()
	fake.loggregatorEndpointMutex.RLock()
	defer fake.loggregatorEndpointMutex.RUnlock()
	fake.dopplerEndpointMutex.RLock()
	defer fake.dopplerEndpointMutex.RUnlock()
	fake.accessTokenMutex.RLock()
	defer fake.accessTokenMutex.RUnlock()
	fake.getAppMutex.RLock()
	defer fake.getAppMutex.RUnlock()
	fake.getAppsMutex.RLock()
	defer fake.getAppsMutex.RUnlock()
	fake.getOrgsMutex.RLock()
	defer fake.getOrgsMutex.RUnlock()
	fake.getSpacesMutex.RLock()
	defer fake.getSpacesMutex.RUnlock()
	fake.getOrgUsersMutex.RLock()
	defer fake.getOrgUsersMutex.RUnlock()
	fake.getSpaceUsersMutex.RLock()
	defer fake.getSpaceUsersMutex.RUnlock()
	fake.getServicesMutex.RLock()
	defer fake.getServicesMutex.RUnlock()
	fake.getServiceMutex.RLock()
	defer fake.getServiceMutex.RUnlock()
	fake.getOrgMutex.RLock()
	defer fake.getOrgMutex.RUnlock()
	fake.getSpaceMutex.RLock()
	defer fake.getSpaceMutex.RUnlock()
	return fake.invocations
}

func (fake *FakeCliConnection) 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 _ plugin.CliConnection = new(FakeCliConnection)