fake_handlers.go

// This file was generated by counterfeiter
package fakes

import (
	"sync"

	"github.com/cloudfoundry/cli/plugin"
	"github.com/cloudfoundry/cli/plugin/models"
	"github.com/cloudfoundry/cli/testhelpers/rpc_server"
)

type FakeHandlers struct {
	IsMinCliVersionStub        func(args string, retVal *bool) error
	isMinCliVersionMutex       sync.RWMutex
	isMinCliVersionArgsForCall []struct {
		args   string
		retVal *bool
	}
	isMinCliVersionReturns struct {
		result1 error
	}
	SetPluginMetadataStub        func(pluginMetadata plugin.PluginMetadata, retVal *bool) error
	setPluginMetadataMutex       sync.RWMutex
	setPluginMetadataArgsForCall []struct {
		pluginMetadata plugin.PluginMetadata
		retVal         *bool
	}
	setPluginMetadataReturns struct {
		result1 error
	}
	DisableTerminalOutputStub        func(disable bool, retVal *bool) error
	disableTerminalOutputMutex       sync.RWMutex
	disableTerminalOutputArgsForCall []struct {
		disable bool
		retVal  *bool
	}
	disableTerminalOutputReturns struct {
		result1 error
	}
	CallCoreCommandStub        func(args []string, retVal *bool) error
	callCoreCommandMutex       sync.RWMutex
	callCoreCommandArgsForCall []struct {
		args   []string
		retVal *bool
	}
	callCoreCommandReturns struct {
		result1 error
	}
	GetOutputAndResetStub        func(args bool, retVal *[]string) error
	getOutputAndResetMutex       sync.RWMutex
	getOutputAndResetArgsForCall []struct {
		args   bool
		retVal *[]string
	}
	getOutputAndResetReturns struct {
		result1 error
	}
	GetCurrentOrgStub        func(args string, retVal *plugin_models.Organization) error
	getCurrentOrgMutex       sync.RWMutex
	getCurrentOrgArgsForCall []struct {
		args   string
		retVal *plugin_models.Organization
	}
	getCurrentOrgReturns struct {
		result1 error
	}
	GetCurrentSpaceStub        func(args string, retVal *plugin_models.Space) error
	getCurrentSpaceMutex       sync.RWMutex
	getCurrentSpaceArgsForCall []struct {
		args   string
		retVal *plugin_models.Space
	}
	getCurrentSpaceReturns struct {
		result1 error
	}
	UsernameStub        func(args string, retVal *string) error
	usernameMutex       sync.RWMutex
	usernameArgsForCall []struct {
		args   string
		retVal *string
	}
	usernameReturns struct {
		result1 error
	}
	UserGuidStub        func(args string, retVal *string) error
	userGuidMutex       sync.RWMutex
	userGuidArgsForCall []struct {
		args   string
		retVal *string
	}
	userGuidReturns struct {
		result1 error
	}
	UserEmailStub        func(args string, retVal *string) error
	userEmailMutex       sync.RWMutex
	userEmailArgsForCall []struct {
		args   string
		retVal *string
	}
	userEmailReturns struct {
		result1 error
	}
	IsLoggedInStub        func(args string, retVal *bool) error
	isLoggedInMutex       sync.RWMutex
	isLoggedInArgsForCall []struct {
		args   string
		retVal *bool
	}
	isLoggedInReturns struct {
		result1 error
	}
	IsSSLDisabledStub        func(args string, retVal *bool) error
	isSSLDisabledMutex       sync.RWMutex
	isSSLDisabledArgsForCall []struct {
		args   string
		retVal *bool
	}
	isSSLDisabledReturns struct {
		result1 error
	}
	HasOrganizationStub        func(args string, retVal *bool) error
	hasOrganizationMutex       sync.RWMutex
	hasOrganizationArgsForCall []struct {
		args   string
		retVal *bool
	}
	hasOrganizationReturns struct {
		result1 error
	}
	HasSpaceStub        func(args string, retVal *bool) error
	hasSpaceMutex       sync.RWMutex
	hasSpaceArgsForCall []struct {
		args   string
		retVal *bool
	}
	hasSpaceReturns struct {
		result1 error
	}
	ApiEndpointStub        func(args string, retVal *string) error
	apiEndpointMutex       sync.RWMutex
	apiEndpointArgsForCall []struct {
		args   string
		retVal *string
	}
	apiEndpointReturns struct {
		result1 error
	}
	HasAPIEndpointStub        func(args string, retVal *bool) error
	hasAPIEndpointMutex       sync.RWMutex
	hasAPIEndpointArgsForCall []struct {
		args   string
		retVal *bool
	}
	hasAPIEndpointReturns struct {
		result1 error
	}
	ApiVersionStub        func(args string, retVal *string) error
	apiVersionMutex       sync.RWMutex
	apiVersionArgsForCall []struct {
		args   string
		retVal *string
	}
	apiVersionReturns struct {
		result1 error
	}
	LoggregatorEndpointStub        func(args string, retVal *string) error
	loggregatorEndpointMutex       sync.RWMutex
	loggregatorEndpointArgsForCall []struct {
		args   string
		retVal *string
	}
	loggregatorEndpointReturns struct {
		result1 error
	}
	DopplerEndpointStub        func(args string, retVal *string) error
	dopplerEndpointMutex       sync.RWMutex
	dopplerEndpointArgsForCall []struct {
		args   string
		retVal *string
	}
	dopplerEndpointReturns struct {
		result1 error
	}
	AccessTokenStub        func(args string, retVal *string) error
	accessTokenMutex       sync.RWMutex
	accessTokenArgsForCall []struct {
		args   string
		retVal *string
	}
	accessTokenReturns struct {
		result1 error
	}
	GetAppStub        func(appName string, retVal *plugin_models.GetAppModel) error
	getAppMutex       sync.RWMutex
	getAppArgsForCall []struct {
		appName string
		retVal  *plugin_models.GetAppModel
	}
	getAppReturns struct {
		result1 error
	}
	GetAppsStub        func(args string, retVal *[]plugin_models.GetAppsModel) error
	getAppsMutex       sync.RWMutex
	getAppsArgsForCall []struct {
		args   string
		retVal *[]plugin_models.GetAppsModel
	}
	getAppsReturns struct {
		result1 error
	}
	GetOrgsStub        func(args string, retVal *[]plugin_models.GetOrgs_Model) error
	getOrgsMutex       sync.RWMutex
	getOrgsArgsForCall []struct {
		args   string
		retVal *[]plugin_models.GetOrgs_Model
	}
	getOrgsReturns struct {
		result1 error
	}
	GetSpacesStub        func(args string, retVal *[]plugin_models.GetSpaces_Model) error
	getSpacesMutex       sync.RWMutex
	getSpacesArgsForCall []struct {
		args   string
		retVal *[]plugin_models.GetSpaces_Model
	}
	getSpacesReturns struct {
		result1 error
	}
	GetServicesStub        func(args string, retVal *[]plugin_models.GetServices_Model) error
	getServicesMutex       sync.RWMutex
	getServicesArgsForCall []struct {
		args   string
		retVal *[]plugin_models.GetServices_Model
	}
	getServicesReturns struct {
		result1 error
	}
	GetOrgUsersStub        func(args []string, retVal *[]plugin_models.GetOrgUsers_Model) error
	getOrgUsersMutex       sync.RWMutex
	getOrgUsersArgsForCall []struct {
		args   []string
		retVal *[]plugin_models.GetOrgUsers_Model
	}
	getOrgUsersReturns struct {
		result1 error
	}
	GetSpaceUsersStub        func(args []string, retVal *[]plugin_models.GetSpaceUsers_Model) error
	getSpaceUsersMutex       sync.RWMutex
	getSpaceUsersArgsForCall []struct {
		args   []string
		retVal *[]plugin_models.GetSpaceUsers_Model
	}
	getSpaceUsersReturns struct {
		result1 error
	}
	GetOrgStub        func(orgName string, retVal *plugin_models.GetOrg_Model) error
	getOrgMutex       sync.RWMutex
	getOrgArgsForCall []struct {
		orgName string
		retVal  *plugin_models.GetOrg_Model
	}
	getOrgReturns struct {
		result1 error
	}
	GetSpaceStub        func(spaceName string, retVal *plugin_models.GetSpace_Model) error
	getSpaceMutex       sync.RWMutex
	getSpaceArgsForCall []struct {
		spaceName string
		retVal    *plugin_models.GetSpace_Model
	}
	getSpaceReturns struct {
		result1 error
	}
	GetServiceStub        func(serviceInstance string, retVal *plugin_models.GetService_Model) error
	getServiceMutex       sync.RWMutex
	getServiceArgsForCall []struct {
		serviceInstance string
		retVal          *plugin_models.GetService_Model
	}
	getServiceReturns struct {
		result1 error
	}
}

func (fake *FakeHandlers) IsMinCliVersion(args string, retVal *bool) error {
	fake.isMinCliVersionMutex.Lock()
	fake.isMinCliVersionArgsForCall = append(fake.isMinCliVersionArgsForCall, struct {
		args   string
		retVal *bool
	}{args, retVal})
	fake.isMinCliVersionMutex.Unlock()
	if fake.IsMinCliVersionStub != nil {
		return fake.IsMinCliVersionStub(args, retVal)
	} else {
		return fake.isMinCliVersionReturns.result1
	}
}

func (fake *FakeHandlers) IsMinCliVersionCallCount() int {
	fake.isMinCliVersionMutex.RLock()
	defer fake.isMinCliVersionMutex.RUnlock()
	return len(fake.isMinCliVersionArgsForCall)
}

func (fake *FakeHandlers) IsMinCliVersionArgsForCall(i int) (string, *bool) {
	fake.isMinCliVersionMutex.RLock()
	defer fake.isMinCliVersionMutex.RUnlock()
	return fake.isMinCliVersionArgsForCall[i].args, fake.isMinCliVersionArgsForCall[i].retVal
}

func (fake *FakeHandlers) IsMinCliVersionReturns(result1 error) {
	fake.IsMinCliVersionStub = nil
	fake.isMinCliVersionReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeHandlers) SetPluginMetadata(pluginMetadata plugin.PluginMetadata, retVal *bool) error {
	fake.setPluginMetadataMutex.Lock()
	fake.setPluginMetadataArgsForCall = append(fake.setPluginMetadataArgsForCall, struct {
		pluginMetadata plugin.PluginMetadata
		retVal         *bool
	}{pluginMetadata, retVal})
	fake.setPluginMetadataMutex.Unlock()
	if fake.SetPluginMetadataStub != nil {
		return fake.SetPluginMetadataStub(pluginMetadata, retVal)
	} else {
		return fake.setPluginMetadataReturns.result1
	}
}

func (fake *FakeHandlers) SetPluginMetadataCallCount() int {
	fake.setPluginMetadataMutex.RLock()
	defer fake.setPluginMetadataMutex.RUnlock()
	return len(fake.setPluginMetadataArgsForCall)
}

func (fake *FakeHandlers) SetPluginMetadataArgsForCall(i int) (plugin.PluginMetadata, *bool) {
	fake.setPluginMetadataMutex.RLock()
	defer fake.setPluginMetadataMutex.RUnlock()
	return fake.setPluginMetadataArgsForCall[i].pluginMetadata, fake.setPluginMetadataArgsForCall[i].retVal
}

func (fake *FakeHandlers) SetPluginMetadataReturns(result1 error) {
	fake.SetPluginMetadataStub = nil
	fake.setPluginMetadataReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeHandlers) DisableTerminalOutput(disable bool, retVal *bool) error {
	fake.disableTerminalOutputMutex.Lock()
	fake.disableTerminalOutputArgsForCall = append(fake.disableTerminalOutputArgsForCall, struct {
		disable bool
		retVal  *bool
	}{disable, retVal})
	fake.disableTerminalOutputMutex.Unlock()
	if fake.DisableTerminalOutputStub != nil {
		return fake.DisableTerminalOutputStub(disable, retVal)
	} else {
		return fake.disableTerminalOutputReturns.result1
	}
}

func (fake *FakeHandlers) DisableTerminalOutputCallCount() int {
	fake.disableTerminalOutputMutex.RLock()
	defer fake.disableTerminalOutputMutex.RUnlock()
	return len(fake.disableTerminalOutputArgsForCall)
}

func (fake *FakeHandlers) DisableTerminalOutputArgsForCall(i int) (bool, *bool) {
	fake.disableTerminalOutputMutex.RLock()
	defer fake.disableTerminalOutputMutex.RUnlock()
	return fake.disableTerminalOutputArgsForCall[i].disable, fake.disableTerminalOutputArgsForCall[i].retVal
}

func (fake *FakeHandlers) DisableTerminalOutputReturns(result1 error) {
	fake.DisableTerminalOutputStub = nil
	fake.disableTerminalOutputReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeHandlers) CallCoreCommand(args []string, retVal *bool) error {
	fake.callCoreCommandMutex.Lock()
	fake.callCoreCommandArgsForCall = append(fake.callCoreCommandArgsForCall, struct {
		args   []string
		retVal *bool
	}{args, retVal})
	fake.callCoreCommandMutex.Unlock()
	if fake.CallCoreCommandStub != nil {
		return fake.CallCoreCommandStub(args, retVal)
	} else {
		return fake.callCoreCommandReturns.result1
	}
}

func (fake *FakeHandlers) CallCoreCommandCallCount() int {
	fake.callCoreCommandMutex.RLock()
	defer fake.callCoreCommandMutex.RUnlock()
	return len(fake.callCoreCommandArgsForCall)
}

func (fake *FakeHandlers) CallCoreCommandArgsForCall(i int) ([]string, *bool) {
	fake.callCoreCommandMutex.RLock()
	defer fake.callCoreCommandMutex.RUnlock()
	return fake.callCoreCommandArgsForCall[i].args, fake.callCoreCommandArgsForCall[i].retVal
}

func (fake *FakeHandlers) CallCoreCommandReturns(result1 error) {
	fake.CallCoreCommandStub = nil
	fake.callCoreCommandReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeHandlers) GetOutputAndReset(args bool, retVal *[]string) error {
	fake.getOutputAndResetMutex.Lock()
	fake.getOutputAndResetArgsForCall = append(fake.getOutputAndResetArgsForCall, struct {
		args   bool
		retVal *[]string
	}{args, retVal})
	fake.getOutputAndResetMutex.Unlock()
	if fake.GetOutputAndResetStub != nil {
		return fake.GetOutputAndResetStub(args, retVal)
	} else {
		return fake.getOutputAndResetReturns.result1
	}
}

func (fake *FakeHandlers) GetOutputAndResetCallCount() int {
	fake.getOutputAndResetMutex.RLock()
	defer fake.getOutputAndResetMutex.RUnlock()
	return len(fake.getOutputAndResetArgsForCall)
}

func (fake *FakeHandlers) GetOutputAndResetArgsForCall(i int) (bool, *[]string) {
	fake.getOutputAndResetMutex.RLock()
	defer fake.getOutputAndResetMutex.RUnlock()
	return fake.getOutputAndResetArgsForCall[i].args, fake.getOutputAndResetArgsForCall[i].retVal
}

func (fake *FakeHandlers) GetOutputAndResetReturns(result1 error) {
	fake.GetOutputAndResetStub = nil
	fake.getOutputAndResetReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeHandlers) GetCurrentOrg(args string, retVal *plugin_models.Organization) error {
	fake.getCurrentOrgMutex.Lock()
	fake.getCurrentOrgArgsForCall = append(fake.getCurrentOrgArgsForCall, struct {
		args   string
		retVal *plugin_models.Organization
	}{args, retVal})
	fake.getCurrentOrgMutex.Unlock()
	if fake.GetCurrentOrgStub != nil {
		return fake.GetCurrentOrgStub(args, retVal)
	} else {
		return fake.getCurrentOrgReturns.result1
	}
}

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

func (fake *FakeHandlers) GetCurrentOrgArgsForCall(i int) (string, *plugin_models.Organization) {
	fake.getCurrentOrgMutex.RLock()
	defer fake.getCurrentOrgMutex.RUnlock()
	return fake.getCurrentOrgArgsForCall[i].args, fake.getCurrentOrgArgsForCall[i].retVal
}

func (fake *FakeHandlers) GetCurrentOrgReturns(result1 error) {
	fake.GetCurrentOrgStub = nil
	fake.getCurrentOrgReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeHandlers) GetCurrentSpace(args string, retVal *plugin_models.Space) error {
	fake.getCurrentSpaceMutex.Lock()
	fake.getCurrentSpaceArgsForCall = append(fake.getCurrentSpaceArgsForCall, struct {
		args   string
		retVal *plugin_models.Space
	}{args, retVal})
	fake.getCurrentSpaceMutex.Unlock()
	if fake.GetCurrentSpaceStub != nil {
		return fake.GetCurrentSpaceStub(args, retVal)
	} else {
		return fake.getCurrentSpaceReturns.result1
	}
}

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

func (fake *FakeHandlers) GetCurrentSpaceArgsForCall(i int) (string, *plugin_models.Space) {
	fake.getCurrentSpaceMutex.RLock()
	defer fake.getCurrentSpaceMutex.RUnlock()
	return fake.getCurrentSpaceArgsForCall[i].args, fake.getCurrentSpaceArgsForCall[i].retVal
}

func (fake *FakeHandlers) GetCurrentSpaceReturns(result1 error) {
	fake.GetCurrentSpaceStub = nil
	fake.getCurrentSpaceReturns = struct {
		result1 error
	}{result1}
}

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

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

func (fake *FakeHandlers) UsernameArgsForCall(i int) (string, *string) {
	fake.usernameMutex.RLock()
	defer fake.usernameMutex.RUnlock()
	return fake.usernameArgsForCall[i].args, fake.usernameArgsForCall[i].retVal
}

func (fake *FakeHandlers) UsernameReturns(result1 error) {
	fake.UsernameStub = nil
	fake.usernameReturns = struct {
		result1 error
	}{result1}
}

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

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

func (fake *FakeHandlers) UserGuidArgsForCall(i int) (string, *string) {
	fake.userGuidMutex.RLock()
	defer fake.userGuidMutex.RUnlock()
	return fake.userGuidArgsForCall[i].args, fake.userGuidArgsForCall[i].retVal
}

func (fake *FakeHandlers) UserGuidReturns(result1 error) {
	fake.UserGuidStub = nil
	fake.userGuidReturns = struct {
		result1 error
	}{result1}
}

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

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

func (fake *FakeHandlers) UserEmailArgsForCall(i int) (string, *string) {
	fake.userEmailMutex.RLock()
	defer fake.userEmailMutex.RUnlock()
	return fake.userEmailArgsForCall[i].args, fake.userEmailArgsForCall[i].retVal
}

func (fake *FakeHandlers) UserEmailReturns(result1 error) {
	fake.UserEmailStub = nil
	fake.userEmailReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeHandlers) IsLoggedIn(args string, retVal *bool) error {
	fake.isLoggedInMutex.Lock()
	fake.isLoggedInArgsForCall = append(fake.isLoggedInArgsForCall, struct {
		args   string
		retVal *bool
	}{args, retVal})
	fake.isLoggedInMutex.Unlock()
	if fake.IsLoggedInStub != nil {
		return fake.IsLoggedInStub(args, retVal)
	} else {
		return fake.isLoggedInReturns.result1
	}
}

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

func (fake *FakeHandlers) IsLoggedInArgsForCall(i int) (string, *bool) {
	fake.isLoggedInMutex.RLock()
	defer fake.isLoggedInMutex.RUnlock()
	return fake.isLoggedInArgsForCall[i].args, fake.isLoggedInArgsForCall[i].retVal
}

func (fake *FakeHandlers) IsLoggedInReturns(result1 error) {
	fake.IsLoggedInStub = nil
	fake.isLoggedInReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeHandlers) IsSSLDisabled(args string, retVal *bool) error {
	fake.isSSLDisabledMutex.Lock()
	fake.isSSLDisabledArgsForCall = append(fake.isSSLDisabledArgsForCall, struct {
		args   string
		retVal *bool
	}{args, retVal})
	fake.isSSLDisabledMutex.Unlock()
	if fake.IsSSLDisabledStub != nil {
		return fake.IsSSLDisabledStub(args, retVal)
	} else {
		return fake.isSSLDisabledReturns.result1
	}
}

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

func (fake *FakeHandlers) IsSSLDisabledArgsForCall(i int) (string, *bool) {
	fake.isSSLDisabledMutex.RLock()
	defer fake.isSSLDisabledMutex.RUnlock()
	return fake.isSSLDisabledArgsForCall[i].args, fake.isSSLDisabledArgsForCall[i].retVal
}

func (fake *FakeHandlers) IsSSLDisabledReturns(result1 error) {
	fake.IsSSLDisabledStub = nil
	fake.isSSLDisabledReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeHandlers) HasOrganization(args string, retVal *bool) error {
	fake.hasOrganizationMutex.Lock()
	fake.hasOrganizationArgsForCall = append(fake.hasOrganizationArgsForCall, struct {
		args   string
		retVal *bool
	}{args, retVal})
	fake.hasOrganizationMutex.Unlock()
	if fake.HasOrganizationStub != nil {
		return fake.HasOrganizationStub(args, retVal)
	} else {
		return fake.hasOrganizationReturns.result1
	}
}

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

func (fake *FakeHandlers) HasOrganizationArgsForCall(i int) (string, *bool) {
	fake.hasOrganizationMutex.RLock()
	defer fake.hasOrganizationMutex.RUnlock()
	return fake.hasOrganizationArgsForCall[i].args, fake.hasOrganizationArgsForCall[i].retVal
}

func (fake *FakeHandlers) HasOrganizationReturns(result1 error) {
	fake.HasOrganizationStub = nil
	fake.hasOrganizationReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeHandlers) HasSpace(args string, retVal *bool) error {
	fake.hasSpaceMutex.Lock()
	fake.hasSpaceArgsForCall = append(fake.hasSpaceArgsForCall, struct {
		args   string
		retVal *bool
	}{args, retVal})
	fake.hasSpaceMutex.Unlock()
	if fake.HasSpaceStub != nil {
		return fake.HasSpaceStub(args, retVal)
	} else {
		return fake.hasSpaceReturns.result1
	}
}

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

func (fake *FakeHandlers) HasSpaceArgsForCall(i int) (string, *bool) {
	fake.hasSpaceMutex.RLock()
	defer fake.hasSpaceMutex.RUnlock()
	return fake.hasSpaceArgsForCall[i].args, fake.hasSpaceArgsForCall[i].retVal
}

func (fake *FakeHandlers) HasSpaceReturns(result1 error) {
	fake.HasSpaceStub = nil
	fake.hasSpaceReturns = struct {
		result1 error
	}{result1}
}

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

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

func (fake *FakeHandlers) ApiEndpointArgsForCall(i int) (string, *string) {
	fake.apiEndpointMutex.RLock()
	defer fake.apiEndpointMutex.RUnlock()
	return fake.apiEndpointArgsForCall[i].args, fake.apiEndpointArgsForCall[i].retVal
}

func (fake *FakeHandlers) ApiEndpointReturns(result1 error) {
	fake.ApiEndpointStub = nil
	fake.apiEndpointReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeHandlers) HasAPIEndpoint(args string, retVal *bool) error {
	fake.hasAPIEndpointMutex.Lock()
	fake.hasAPIEndpointArgsForCall = append(fake.hasAPIEndpointArgsForCall, struct {
		args   string
		retVal *bool
	}{args, retVal})
	fake.hasAPIEndpointMutex.Unlock()
	if fake.HasAPIEndpointStub != nil {
		return fake.HasAPIEndpointStub(args, retVal)
	} else {
		return fake.hasAPIEndpointReturns.result1
	}
}

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

func (fake *FakeHandlers) HasAPIEndpointArgsForCall(i int) (string, *bool) {
	fake.hasAPIEndpointMutex.RLock()
	defer fake.hasAPIEndpointMutex.RUnlock()
	return fake.hasAPIEndpointArgsForCall[i].args, fake.hasAPIEndpointArgsForCall[i].retVal
}

func (fake *FakeHandlers) HasAPIEndpointReturns(result1 error) {
	fake.HasAPIEndpointStub = nil
	fake.hasAPIEndpointReturns = struct {
		result1 error
	}{result1}
}

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

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

func (fake *FakeHandlers) ApiVersionArgsForCall(i int) (string, *string) {
	fake.apiVersionMutex.RLock()
	defer fake.apiVersionMutex.RUnlock()
	return fake.apiVersionArgsForCall[i].args, fake.apiVersionArgsForCall[i].retVal
}

func (fake *FakeHandlers) ApiVersionReturns(result1 error) {
	fake.ApiVersionStub = nil
	fake.apiVersionReturns = struct {
		result1 error
	}{result1}
}

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

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

func (fake *FakeHandlers) LoggregatorEndpointArgsForCall(i int) (string, *string) {
	fake.loggregatorEndpointMutex.RLock()
	defer fake.loggregatorEndpointMutex.RUnlock()
	return fake.loggregatorEndpointArgsForCall[i].args, fake.loggregatorEndpointArgsForCall[i].retVal
}

func (fake *FakeHandlers) LoggregatorEndpointReturns(result1 error) {
	fake.LoggregatorEndpointStub = nil
	fake.loggregatorEndpointReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeHandlers) DopplerEndpoint(args string, retVal *string) error {
	fake.dopplerEndpointMutex.Lock()
	fake.dopplerEndpointArgsForCall = append(fake.dopplerEndpointArgsForCall, struct {
		args   string
		retVal *string
	}{args, retVal})
	fake.dopplerEndpointMutex.Unlock()
	if fake.DopplerEndpointStub != nil {
		return fake.DopplerEndpointStub(args, retVal)
	} else {
		return fake.dopplerEndpointReturns.result1
	}
}

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

func (fake *FakeHandlers) DopplerEndpointArgsForCall(i int) (string, *string) {
	fake.dopplerEndpointMutex.RLock()
	defer fake.dopplerEndpointMutex.RUnlock()
	return fake.dopplerEndpointArgsForCall[i].args, fake.dopplerEndpointArgsForCall[i].retVal
}

func (fake *FakeHandlers) DopplerEndpointReturns(result1 error) {
	fake.DopplerEndpointStub = nil
	fake.dopplerEndpointReturns = struct {
		result1 error
	}{result1}
}

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

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

func (fake *FakeHandlers) AccessTokenArgsForCall(i int) (string, *string) {
	fake.accessTokenMutex.RLock()
	defer fake.accessTokenMutex.RUnlock()
	return fake.accessTokenArgsForCall[i].args, fake.accessTokenArgsForCall[i].retVal
}

func (fake *FakeHandlers) AccessTokenReturns(result1 error) {
	fake.AccessTokenStub = nil
	fake.accessTokenReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeHandlers) GetApp(appName string, retVal *plugin_models.GetAppModel) error {
	fake.getAppMutex.Lock()
	fake.getAppArgsForCall = append(fake.getAppArgsForCall, struct {
		appName string
		retVal  *plugin_models.GetAppModel
	}{appName, retVal})
	fake.getAppMutex.Unlock()
	if fake.GetAppStub != nil {
		return fake.GetAppStub(appName, retVal)
	} else {
		return fake.getAppReturns.result1
	}
}

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

func (fake *FakeHandlers) GetAppArgsForCall(i int) (string, *plugin_models.GetAppModel) {
	fake.getAppMutex.RLock()
	defer fake.getAppMutex.RUnlock()
	return fake.getAppArgsForCall[i].appName, fake.getAppArgsForCall[i].retVal
}

func (fake *FakeHandlers) GetAppReturns(result1 error) {
	fake.GetAppStub = nil
	fake.getAppReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeHandlers) GetApps(args string, retVal *[]plugin_models.GetAppsModel) error {
	fake.getAppsMutex.Lock()
	fake.getAppsArgsForCall = append(fake.getAppsArgsForCall, struct {
		args   string
		retVal *[]plugin_models.GetAppsModel
	}{args, retVal})
	fake.getAppsMutex.Unlock()
	if fake.GetAppsStub != nil {
		return fake.GetAppsStub(args, retVal)
	} else {
		return fake.getAppsReturns.result1
	}
}

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

func (fake *FakeHandlers) GetAppsArgsForCall(i int) (string, *[]plugin_models.GetAppsModel) {
	fake.getAppsMutex.RLock()
	defer fake.getAppsMutex.RUnlock()
	return fake.getAppsArgsForCall[i].args, fake.getAppsArgsForCall[i].retVal
}

func (fake *FakeHandlers) GetAppsReturns(result1 error) {
	fake.GetAppsStub = nil
	fake.getAppsReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeHandlers) GetOrgs(args string, retVal *[]plugin_models.GetOrgs_Model) error {
	fake.getOrgsMutex.Lock()
	fake.getOrgsArgsForCall = append(fake.getOrgsArgsForCall, struct {
		args   string
		retVal *[]plugin_models.GetOrgs_Model
	}{args, retVal})
	fake.getOrgsMutex.Unlock()
	if fake.GetOrgsStub != nil {
		return fake.GetOrgsStub(args, retVal)
	} else {
		return fake.getOrgsReturns.result1
	}
}

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

func (fake *FakeHandlers) GetOrgsArgsForCall(i int) (string, *[]plugin_models.GetOrgs_Model) {
	fake.getOrgsMutex.RLock()
	defer fake.getOrgsMutex.RUnlock()
	return fake.getOrgsArgsForCall[i].args, fake.getOrgsArgsForCall[i].retVal
}

func (fake *FakeHandlers) GetOrgsReturns(result1 error) {
	fake.GetOrgsStub = nil
	fake.getOrgsReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeHandlers) GetSpaces(args string, retVal *[]plugin_models.GetSpaces_Model) error {
	fake.getSpacesMutex.Lock()
	fake.getSpacesArgsForCall = append(fake.getSpacesArgsForCall, struct {
		args   string
		retVal *[]plugin_models.GetSpaces_Model
	}{args, retVal})
	fake.getSpacesMutex.Unlock()
	if fake.GetSpacesStub != nil {
		return fake.GetSpacesStub(args, retVal)
	} else {
		return fake.getSpacesReturns.result1
	}
}

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

func (fake *FakeHandlers) GetSpacesArgsForCall(i int) (string, *[]plugin_models.GetSpaces_Model) {
	fake.getSpacesMutex.RLock()
	defer fake.getSpacesMutex.RUnlock()
	return fake.getSpacesArgsForCall[i].args, fake.getSpacesArgsForCall[i].retVal
}

func (fake *FakeHandlers) GetSpacesReturns(result1 error) {
	fake.GetSpacesStub = nil
	fake.getSpacesReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeHandlers) GetServices(args string, retVal *[]plugin_models.GetServices_Model) error {
	fake.getServicesMutex.Lock()
	fake.getServicesArgsForCall = append(fake.getServicesArgsForCall, struct {
		args   string
		retVal *[]plugin_models.GetServices_Model
	}{args, retVal})
	fake.getServicesMutex.Unlock()
	if fake.GetServicesStub != nil {
		return fake.GetServicesStub(args, retVal)
	} else {
		return fake.getServicesReturns.result1
	}
}

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

func (fake *FakeHandlers) GetServicesArgsForCall(i int) (string, *[]plugin_models.GetServices_Model) {
	fake.getServicesMutex.RLock()
	defer fake.getServicesMutex.RUnlock()
	return fake.getServicesArgsForCall[i].args, fake.getServicesArgsForCall[i].retVal
}

func (fake *FakeHandlers) GetServicesReturns(result1 error) {
	fake.GetServicesStub = nil
	fake.getServicesReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeHandlers) GetOrgUsers(args []string, retVal *[]plugin_models.GetOrgUsers_Model) error {
	fake.getOrgUsersMutex.Lock()
	fake.getOrgUsersArgsForCall = append(fake.getOrgUsersArgsForCall, struct {
		args   []string
		retVal *[]plugin_models.GetOrgUsers_Model
	}{args, retVal})
	fake.getOrgUsersMutex.Unlock()
	if fake.GetOrgUsersStub != nil {
		return fake.GetOrgUsersStub(args, retVal)
	} else {
		return fake.getOrgUsersReturns.result1
	}
}

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

func (fake *FakeHandlers) GetOrgUsersArgsForCall(i int) ([]string, *[]plugin_models.GetOrgUsers_Model) {
	fake.getOrgUsersMutex.RLock()
	defer fake.getOrgUsersMutex.RUnlock()
	return fake.getOrgUsersArgsForCall[i].args, fake.getOrgUsersArgsForCall[i].retVal
}

func (fake *FakeHandlers) GetOrgUsersReturns(result1 error) {
	fake.GetOrgUsersStub = nil
	fake.getOrgUsersReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeHandlers) GetSpaceUsers(args []string, retVal *[]plugin_models.GetSpaceUsers_Model) error {
	fake.getSpaceUsersMutex.Lock()
	fake.getSpaceUsersArgsForCall = append(fake.getSpaceUsersArgsForCall, struct {
		args   []string
		retVal *[]plugin_models.GetSpaceUsers_Model
	}{args, retVal})
	fake.getSpaceUsersMutex.Unlock()
	if fake.GetSpaceUsersStub != nil {
		return fake.GetSpaceUsersStub(args, retVal)
	} else {
		return fake.getSpaceUsersReturns.result1
	}
}

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

func (fake *FakeHandlers) GetSpaceUsersArgsForCall(i int) ([]string, *[]plugin_models.GetSpaceUsers_Model) {
	fake.getSpaceUsersMutex.RLock()
	defer fake.getSpaceUsersMutex.RUnlock()
	return fake.getSpaceUsersArgsForCall[i].args, fake.getSpaceUsersArgsForCall[i].retVal
}

func (fake *FakeHandlers) GetSpaceUsersReturns(result1 error) {
	fake.GetSpaceUsersStub = nil
	fake.getSpaceUsersReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeHandlers) GetOrg(orgName string, retVal *plugin_models.GetOrg_Model) error {
	fake.getOrgMutex.Lock()
	fake.getOrgArgsForCall = append(fake.getOrgArgsForCall, struct {
		orgName string
		retVal  *plugin_models.GetOrg_Model
	}{orgName, retVal})
	fake.getOrgMutex.Unlock()
	if fake.GetOrgStub != nil {
		return fake.GetOrgStub(orgName, retVal)
	} else {
		return fake.getOrgReturns.result1
	}
}

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

func (fake *FakeHandlers) GetOrgArgsForCall(i int) (string, *plugin_models.GetOrg_Model) {
	fake.getOrgMutex.RLock()
	defer fake.getOrgMutex.RUnlock()
	return fake.getOrgArgsForCall[i].orgName, fake.getOrgArgsForCall[i].retVal
}

func (fake *FakeHandlers) GetOrgReturns(result1 error) {
	fake.GetOrgStub = nil
	fake.getOrgReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeHandlers) GetSpace(spaceName string, retVal *plugin_models.GetSpace_Model) error {
	fake.getSpaceMutex.Lock()
	fake.getSpaceArgsForCall = append(fake.getSpaceArgsForCall, struct {
		spaceName string
		retVal    *plugin_models.GetSpace_Model
	}{spaceName, retVal})
	fake.getSpaceMutex.Unlock()
	if fake.GetSpaceStub != nil {
		return fake.GetSpaceStub(spaceName, retVal)
	} else {
		return fake.getSpaceReturns.result1
	}
}

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

func (fake *FakeHandlers) GetSpaceArgsForCall(i int) (string, *plugin_models.GetSpace_Model) {
	fake.getSpaceMutex.RLock()
	defer fake.getSpaceMutex.RUnlock()
	return fake.getSpaceArgsForCall[i].spaceName, fake.getSpaceArgsForCall[i].retVal
}

func (fake *FakeHandlers) GetSpaceReturns(result1 error) {
	fake.GetSpaceStub = nil
	fake.getSpaceReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeHandlers) GetService(serviceInstance string, retVal *plugin_models.GetService_Model) error {
	fake.getServiceMutex.Lock()
	fake.getServiceArgsForCall = append(fake.getServiceArgsForCall, struct {
		serviceInstance string
		retVal          *plugin_models.GetService_Model
	}{serviceInstance, retVal})
	fake.getServiceMutex.Unlock()
	if fake.GetServiceStub != nil {
		return fake.GetServiceStub(serviceInstance, retVal)
	} else {
		return fake.getServiceReturns.result1
	}
}

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

func (fake *FakeHandlers) GetServiceArgsForCall(i int) (string, *plugin_models.GetService_Model) {
	fake.getServiceMutex.RLock()
	defer fake.getServiceMutex.RUnlock()
	return fake.getServiceArgsForCall[i].serviceInstance, fake.getServiceArgsForCall[i].retVal
}

func (fake *FakeHandlers) GetServiceReturns(result1 error) {
	fake.GetServiceStub = nil
	fake.getServiceReturns = struct {
		result1 error
	}{result1}
}

var _ test_rpc_server.Handlers = new(FakeHandlers)