github.com/wanddynosios/cli/v8@v8.7.9-0.20240221182337-1a92e3a7017f/actor/sharedaction/sharedactionfakes/fake_config.go

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

import (
	"sync"

	"code.cloudfoundry.org/cli/actor/sharedaction"
)

type FakeConfig struct {
	AccessTokenStub        func() string
	accessTokenMutex       sync.RWMutex
	accessTokenArgsForCall []struct {
	}
	accessTokenReturns struct {
		result1 string
	}
	accessTokenReturnsOnCall map[int]struct {
		result1 string
	}
	BinaryNameStub        func() string
	binaryNameMutex       sync.RWMutex
	binaryNameArgsForCall []struct {
	}
	binaryNameReturns struct {
		result1 string
	}
	binaryNameReturnsOnCall map[int]struct {
		result1 string
	}
	CurrentUserNameStub        func() (string, error)
	currentUserNameMutex       sync.RWMutex
	currentUserNameArgsForCall []struct {
	}
	currentUserNameReturns struct {
		result1 string
		result2 error
	}
	currentUserNameReturnsOnCall map[int]struct {
		result1 string
		result2 error
	}
	HasTargetedOrganizationStub        func() bool
	hasTargetedOrganizationMutex       sync.RWMutex
	hasTargetedOrganizationArgsForCall []struct {
	}
	hasTargetedOrganizationReturns struct {
		result1 bool
	}
	hasTargetedOrganizationReturnsOnCall map[int]struct {
		result1 bool
	}
	HasTargetedSpaceStub        func() bool
	hasTargetedSpaceMutex       sync.RWMutex
	hasTargetedSpaceArgsForCall []struct {
	}
	hasTargetedSpaceReturns struct {
		result1 bool
	}
	hasTargetedSpaceReturnsOnCall map[int]struct {
		result1 bool
	}
	IsCFOnK8sStub        func() bool
	isCFOnK8sMutex       sync.RWMutex
	isCFOnK8sArgsForCall []struct {
	}
	isCFOnK8sReturns struct {
		result1 bool
	}
	isCFOnK8sReturnsOnCall map[int]struct {
		result1 bool
	}
	RefreshTokenStub        func() string
	refreshTokenMutex       sync.RWMutex
	refreshTokenArgsForCall []struct {
	}
	refreshTokenReturns struct {
		result1 string
	}
	refreshTokenReturnsOnCall map[int]struct {
		result1 string
	}
	TargetedOrganizationNameStub        func() string
	targetedOrganizationNameMutex       sync.RWMutex
	targetedOrganizationNameArgsForCall []struct {
	}
	targetedOrganizationNameReturns struct {
		result1 string
	}
	targetedOrganizationNameReturnsOnCall map[int]struct {
		result1 string
	}
	VerboseStub        func() (bool, []string)
	verboseMutex       sync.RWMutex
	verboseArgsForCall []struct {
	}
	verboseReturns struct {
		result1 bool
		result2 []string
	}
	verboseReturnsOnCall map[int]struct {
		result1 bool
		result2 []string
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeConfig) AccessToken() string {
	fake.accessTokenMutex.Lock()
	ret, specificReturn := fake.accessTokenReturnsOnCall[len(fake.accessTokenArgsForCall)]
	fake.accessTokenArgsForCall = append(fake.accessTokenArgsForCall, struct {
	}{})
	fake.recordInvocation("AccessToken", []interface{}{})
	fake.accessTokenMutex.Unlock()
	if fake.AccessTokenStub != nil {
		return fake.AccessTokenStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.accessTokenReturns
	return fakeReturns.result1
}

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

func (fake *FakeConfig) AccessTokenCalls(stub func() string) {
	fake.accessTokenMutex.Lock()
	defer fake.accessTokenMutex.Unlock()
	fake.AccessTokenStub = stub
}

func (fake *FakeConfig) AccessTokenReturns(result1 string) {
	fake.accessTokenMutex.Lock()
	defer fake.accessTokenMutex.Unlock()
	fake.AccessTokenStub = nil
	fake.accessTokenReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) AccessTokenReturnsOnCall(i int, result1 string) {
	fake.accessTokenMutex.Lock()
	defer fake.accessTokenMutex.Unlock()
	fake.AccessTokenStub = nil
	if fake.accessTokenReturnsOnCall == nil {
		fake.accessTokenReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.accessTokenReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) BinaryName() string {
	fake.binaryNameMutex.Lock()
	ret, specificReturn := fake.binaryNameReturnsOnCall[len(fake.binaryNameArgsForCall)]
	fake.binaryNameArgsForCall = append(fake.binaryNameArgsForCall, struct {
	}{})
	fake.recordInvocation("BinaryName", []interface{}{})
	fake.binaryNameMutex.Unlock()
	if fake.BinaryNameStub != nil {
		return fake.BinaryNameStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.binaryNameReturns
	return fakeReturns.result1
}

func (fake *FakeConfig) BinaryNameCallCount() int {
	fake.binaryNameMutex.RLock()
	defer fake.binaryNameMutex.RUnlock()
	return len(fake.binaryNameArgsForCall)
}

func (fake *FakeConfig) BinaryNameCalls(stub func() string) {
	fake.binaryNameMutex.Lock()
	defer fake.binaryNameMutex.Unlock()
	fake.BinaryNameStub = stub
}

func (fake *FakeConfig) BinaryNameReturns(result1 string) {
	fake.binaryNameMutex.Lock()
	defer fake.binaryNameMutex.Unlock()
	fake.BinaryNameStub = nil
	fake.binaryNameReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) BinaryNameReturnsOnCall(i int, result1 string) {
	fake.binaryNameMutex.Lock()
	defer fake.binaryNameMutex.Unlock()
	fake.BinaryNameStub = nil
	if fake.binaryNameReturnsOnCall == nil {
		fake.binaryNameReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.binaryNameReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) CurrentUserName() (string, error) {
	fake.currentUserNameMutex.Lock()
	ret, specificReturn := fake.currentUserNameReturnsOnCall[len(fake.currentUserNameArgsForCall)]
	fake.currentUserNameArgsForCall = append(fake.currentUserNameArgsForCall, struct {
	}{})
	fake.recordInvocation("CurrentUserName", []interface{}{})
	fake.currentUserNameMutex.Unlock()
	if fake.CurrentUserNameStub != nil {
		return fake.CurrentUserNameStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.currentUserNameReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeConfig) CurrentUserNameCallCount() int {
	fake.currentUserNameMutex.RLock()
	defer fake.currentUserNameMutex.RUnlock()
	return len(fake.currentUserNameArgsForCall)
}

func (fake *FakeConfig) CurrentUserNameCalls(stub func() (string, error)) {
	fake.currentUserNameMutex.Lock()
	defer fake.currentUserNameMutex.Unlock()
	fake.CurrentUserNameStub = stub
}

func (fake *FakeConfig) CurrentUserNameReturns(result1 string, result2 error) {
	fake.currentUserNameMutex.Lock()
	defer fake.currentUserNameMutex.Unlock()
	fake.CurrentUserNameStub = nil
	fake.currentUserNameReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeConfig) CurrentUserNameReturnsOnCall(i int, result1 string, result2 error) {
	fake.currentUserNameMutex.Lock()
	defer fake.currentUserNameMutex.Unlock()
	fake.CurrentUserNameStub = nil
	if fake.currentUserNameReturnsOnCall == nil {
		fake.currentUserNameReturnsOnCall = make(map[int]struct {
			result1 string
			result2 error
		})
	}
	fake.currentUserNameReturnsOnCall[i] = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeConfig) HasTargetedOrganization() bool {
	fake.hasTargetedOrganizationMutex.Lock()
	ret, specificReturn := fake.hasTargetedOrganizationReturnsOnCall[len(fake.hasTargetedOrganizationArgsForCall)]
	fake.hasTargetedOrganizationArgsForCall = append(fake.hasTargetedOrganizationArgsForCall, struct {
	}{})
	fake.recordInvocation("HasTargetedOrganization", []interface{}{})
	fake.hasTargetedOrganizationMutex.Unlock()
	if fake.HasTargetedOrganizationStub != nil {
		return fake.HasTargetedOrganizationStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.hasTargetedOrganizationReturns
	return fakeReturns.result1
}

func (fake *FakeConfig) HasTargetedOrganizationCallCount() int {
	fake.hasTargetedOrganizationMutex.RLock()
	defer fake.hasTargetedOrganizationMutex.RUnlock()
	return len(fake.hasTargetedOrganizationArgsForCall)
}

func (fake *FakeConfig) HasTargetedOrganizationCalls(stub func() bool) {
	fake.hasTargetedOrganizationMutex.Lock()
	defer fake.hasTargetedOrganizationMutex.Unlock()
	fake.HasTargetedOrganizationStub = stub
}

func (fake *FakeConfig) HasTargetedOrganizationReturns(result1 bool) {
	fake.hasTargetedOrganizationMutex.Lock()
	defer fake.hasTargetedOrganizationMutex.Unlock()
	fake.HasTargetedOrganizationStub = nil
	fake.hasTargetedOrganizationReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeConfig) HasTargetedOrganizationReturnsOnCall(i int, result1 bool) {
	fake.hasTargetedOrganizationMutex.Lock()
	defer fake.hasTargetedOrganizationMutex.Unlock()
	fake.HasTargetedOrganizationStub = nil
	if fake.hasTargetedOrganizationReturnsOnCall == nil {
		fake.hasTargetedOrganizationReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.hasTargetedOrganizationReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeConfig) HasTargetedSpace() bool {
	fake.hasTargetedSpaceMutex.Lock()
	ret, specificReturn := fake.hasTargetedSpaceReturnsOnCall[len(fake.hasTargetedSpaceArgsForCall)]
	fake.hasTargetedSpaceArgsForCall = append(fake.hasTargetedSpaceArgsForCall, struct {
	}{})
	fake.recordInvocation("HasTargetedSpace", []interface{}{})
	fake.hasTargetedSpaceMutex.Unlock()
	if fake.HasTargetedSpaceStub != nil {
		return fake.HasTargetedSpaceStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.hasTargetedSpaceReturns
	return fakeReturns.result1
}

func (fake *FakeConfig) HasTargetedSpaceCallCount() int {
	fake.hasTargetedSpaceMutex.RLock()
	defer fake.hasTargetedSpaceMutex.RUnlock()
	return len(fake.hasTargetedSpaceArgsForCall)
}

func (fake *FakeConfig) HasTargetedSpaceCalls(stub func() bool) {
	fake.hasTargetedSpaceMutex.Lock()
	defer fake.hasTargetedSpaceMutex.Unlock()
	fake.HasTargetedSpaceStub = stub
}

func (fake *FakeConfig) HasTargetedSpaceReturns(result1 bool) {
	fake.hasTargetedSpaceMutex.Lock()
	defer fake.hasTargetedSpaceMutex.Unlock()
	fake.HasTargetedSpaceStub = nil
	fake.hasTargetedSpaceReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeConfig) HasTargetedSpaceReturnsOnCall(i int, result1 bool) {
	fake.hasTargetedSpaceMutex.Lock()
	defer fake.hasTargetedSpaceMutex.Unlock()
	fake.HasTargetedSpaceStub = nil
	if fake.hasTargetedSpaceReturnsOnCall == nil {
		fake.hasTargetedSpaceReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.hasTargetedSpaceReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeConfig) IsCFOnK8s() bool {
	fake.isCFOnK8sMutex.Lock()
	ret, specificReturn := fake.isCFOnK8sReturnsOnCall[len(fake.isCFOnK8sArgsForCall)]
	fake.isCFOnK8sArgsForCall = append(fake.isCFOnK8sArgsForCall, struct {
	}{})
	fake.recordInvocation("IsCFOnK8s", []interface{}{})
	fake.isCFOnK8sMutex.Unlock()
	if fake.IsCFOnK8sStub != nil {
		return fake.IsCFOnK8sStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.isCFOnK8sReturns
	return fakeReturns.result1
}

func (fake *FakeConfig) IsCFOnK8sCallCount() int {
	fake.isCFOnK8sMutex.RLock()
	defer fake.isCFOnK8sMutex.RUnlock()
	return len(fake.isCFOnK8sArgsForCall)
}

func (fake *FakeConfig) IsCFOnK8sCalls(stub func() bool) {
	fake.isCFOnK8sMutex.Lock()
	defer fake.isCFOnK8sMutex.Unlock()
	fake.IsCFOnK8sStub = stub
}

func (fake *FakeConfig) IsCFOnK8sReturns(result1 bool) {
	fake.isCFOnK8sMutex.Lock()
	defer fake.isCFOnK8sMutex.Unlock()
	fake.IsCFOnK8sStub = nil
	fake.isCFOnK8sReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeConfig) IsCFOnK8sReturnsOnCall(i int, result1 bool) {
	fake.isCFOnK8sMutex.Lock()
	defer fake.isCFOnK8sMutex.Unlock()
	fake.IsCFOnK8sStub = nil
	if fake.isCFOnK8sReturnsOnCall == nil {
		fake.isCFOnK8sReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.isCFOnK8sReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeConfig) RefreshToken() string {
	fake.refreshTokenMutex.Lock()
	ret, specificReturn := fake.refreshTokenReturnsOnCall[len(fake.refreshTokenArgsForCall)]
	fake.refreshTokenArgsForCall = append(fake.refreshTokenArgsForCall, struct {
	}{})
	fake.recordInvocation("RefreshToken", []interface{}{})
	fake.refreshTokenMutex.Unlock()
	if fake.RefreshTokenStub != nil {
		return fake.RefreshTokenStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.refreshTokenReturns
	return fakeReturns.result1
}

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

func (fake *FakeConfig) RefreshTokenCalls(stub func() string) {
	fake.refreshTokenMutex.Lock()
	defer fake.refreshTokenMutex.Unlock()
	fake.RefreshTokenStub = stub
}

func (fake *FakeConfig) RefreshTokenReturns(result1 string) {
	fake.refreshTokenMutex.Lock()
	defer fake.refreshTokenMutex.Unlock()
	fake.RefreshTokenStub = nil
	fake.refreshTokenReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) RefreshTokenReturnsOnCall(i int, result1 string) {
	fake.refreshTokenMutex.Lock()
	defer fake.refreshTokenMutex.Unlock()
	fake.RefreshTokenStub = nil
	if fake.refreshTokenReturnsOnCall == nil {
		fake.refreshTokenReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.refreshTokenReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) TargetedOrganizationName() string {
	fake.targetedOrganizationNameMutex.Lock()
	ret, specificReturn := fake.targetedOrganizationNameReturnsOnCall[len(fake.targetedOrganizationNameArgsForCall)]
	fake.targetedOrganizationNameArgsForCall = append(fake.targetedOrganizationNameArgsForCall, struct {
	}{})
	fake.recordInvocation("TargetedOrganizationName", []interface{}{})
	fake.targetedOrganizationNameMutex.Unlock()
	if fake.TargetedOrganizationNameStub != nil {
		return fake.TargetedOrganizationNameStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.targetedOrganizationNameReturns
	return fakeReturns.result1
}

func (fake *FakeConfig) TargetedOrganizationNameCallCount() int {
	fake.targetedOrganizationNameMutex.RLock()
	defer fake.targetedOrganizationNameMutex.RUnlock()
	return len(fake.targetedOrganizationNameArgsForCall)
}

func (fake *FakeConfig) TargetedOrganizationNameCalls(stub func() string) {
	fake.targetedOrganizationNameMutex.Lock()
	defer fake.targetedOrganizationNameMutex.Unlock()
	fake.TargetedOrganizationNameStub = stub
}

func (fake *FakeConfig) TargetedOrganizationNameReturns(result1 string) {
	fake.targetedOrganizationNameMutex.Lock()
	defer fake.targetedOrganizationNameMutex.Unlock()
	fake.TargetedOrganizationNameStub = nil
	fake.targetedOrganizationNameReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) TargetedOrganizationNameReturnsOnCall(i int, result1 string) {
	fake.targetedOrganizationNameMutex.Lock()
	defer fake.targetedOrganizationNameMutex.Unlock()
	fake.TargetedOrganizationNameStub = nil
	if fake.targetedOrganizationNameReturnsOnCall == nil {
		fake.targetedOrganizationNameReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.targetedOrganizationNameReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) Verbose() (bool, []string) {
	fake.verboseMutex.Lock()
	ret, specificReturn := fake.verboseReturnsOnCall[len(fake.verboseArgsForCall)]
	fake.verboseArgsForCall = append(fake.verboseArgsForCall, struct {
	}{})
	fake.recordInvocation("Verbose", []interface{}{})
	fake.verboseMutex.Unlock()
	if fake.VerboseStub != nil {
		return fake.VerboseStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.verboseReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeConfig) VerboseCallCount() int {
	fake.verboseMutex.RLock()
	defer fake.verboseMutex.RUnlock()
	return len(fake.verboseArgsForCall)
}

func (fake *FakeConfig) VerboseCalls(stub func() (bool, []string)) {
	fake.verboseMutex.Lock()
	defer fake.verboseMutex.Unlock()
	fake.VerboseStub = stub
}

func (fake *FakeConfig) VerboseReturns(result1 bool, result2 []string) {
	fake.verboseMutex.Lock()
	defer fake.verboseMutex.Unlock()
	fake.VerboseStub = nil
	fake.verboseReturns = struct {
		result1 bool
		result2 []string
	}{result1, result2}
}

func (fake *FakeConfig) VerboseReturnsOnCall(i int, result1 bool, result2 []string) {
	fake.verboseMutex.Lock()
	defer fake.verboseMutex.Unlock()
	fake.VerboseStub = nil
	if fake.verboseReturnsOnCall == nil {
		fake.verboseReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 []string
		})
	}
	fake.verboseReturnsOnCall[i] = struct {
		result1 bool
		result2 []string
	}{result1, result2}
}

func (fake *FakeConfig) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.accessTokenMutex.RLock()
	defer fake.accessTokenMutex.RUnlock()
	fake.binaryNameMutex.RLock()
	defer fake.binaryNameMutex.RUnlock()
	fake.currentUserNameMutex.RLock()
	defer fake.currentUserNameMutex.RUnlock()
	fake.hasTargetedOrganizationMutex.RLock()
	defer fake.hasTargetedOrganizationMutex.RUnlock()
	fake.hasTargetedSpaceMutex.RLock()
	defer fake.hasTargetedSpaceMutex.RUnlock()
	fake.isCFOnK8sMutex.RLock()
	defer fake.isCFOnK8sMutex.RUnlock()
	fake.refreshTokenMutex.RLock()
	defer fake.refreshTokenMutex.RUnlock()
	fake.targetedOrganizationNameMutex.RLock()
	defer fake.targetedOrganizationNameMutex.RUnlock()
	fake.verboseMutex.RLock()
	defer fake.verboseMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeConfig) 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 _ sharedaction.Config = new(FakeConfig)