fake_clients_factory.go

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

import (
	"context"
	"sync"

	"github.com/weaveworks/weave-gitops/core/clustersmngr"
	"github.com/weaveworks/weave-gitops/pkg/server/auth"
	v1 "k8s.io/api/core/v1"
	"k8s.io/client-go/discovery"
)

type FakeClientsFactory struct {
	GetClustersNamespacesStub        func() map[string][]v1.Namespace
	getClustersNamespacesMutex       sync.RWMutex
	getClustersNamespacesArgsForCall []struct {
	}
	getClustersNamespacesReturns struct {
		result1 map[string][]v1.Namespace
	}
	getClustersNamespacesReturnsOnCall map[int]struct {
		result1 map[string][]v1.Namespace
	}
	GetImpersonatedClientStub        func(context.Context, *auth.UserPrincipal) (clustersmngr.Client, error)
	getImpersonatedClientMutex       sync.RWMutex
	getImpersonatedClientArgsForCall []struct {
		arg1 context.Context
		arg2 *auth.UserPrincipal
	}
	getImpersonatedClientReturns struct {
		result1 clustersmngr.Client
		result2 error
	}
	getImpersonatedClientReturnsOnCall map[int]struct {
		result1 clustersmngr.Client
		result2 error
	}
	GetImpersonatedDiscoveryClientStub        func(context.Context, *auth.UserPrincipal, string) (*discovery.DiscoveryClient, error)
	getImpersonatedDiscoveryClientMutex       sync.RWMutex
	getImpersonatedDiscoveryClientArgsForCall []struct {
		arg1 context.Context
		arg2 *auth.UserPrincipal
		arg3 string
	}
	getImpersonatedDiscoveryClientReturns struct {
		result1 *discovery.DiscoveryClient
		result2 error
	}
	getImpersonatedDiscoveryClientReturnsOnCall map[int]struct {
		result1 *discovery.DiscoveryClient
		result2 error
	}
	GetServerClientStub        func(context.Context) (clustersmngr.Client, error)
	getServerClientMutex       sync.RWMutex
	getServerClientArgsForCall []struct {
		arg1 context.Context
	}
	getServerClientReturns struct {
		result1 clustersmngr.Client
		result2 error
	}
	getServerClientReturnsOnCall map[int]struct {
		result1 clustersmngr.Client
		result2 error
	}
	GetUserNamespacesStub        func(*auth.UserPrincipal) map[string][]v1.Namespace
	getUserNamespacesMutex       sync.RWMutex
	getUserNamespacesArgsForCall []struct {
		arg1 *auth.UserPrincipal
	}
	getUserNamespacesReturns struct {
		result1 map[string][]v1.Namespace
	}
	getUserNamespacesReturnsOnCall map[int]struct {
		result1 map[string][]v1.Namespace
	}
	StartStub        func(context.Context)
	startMutex       sync.RWMutex
	startArgsForCall []struct {
		arg1 context.Context
	}
	UpdateClustersStub        func(context.Context) error
	updateClustersMutex       sync.RWMutex
	updateClustersArgsForCall []struct {
		arg1 context.Context
	}
	updateClustersReturns struct {
		result1 error
	}
	updateClustersReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateNamespacesStub        func(context.Context) error
	updateNamespacesMutex       sync.RWMutex
	updateNamespacesArgsForCall []struct {
		arg1 context.Context
	}
	updateNamespacesReturns struct {
		result1 error
	}
	updateNamespacesReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateUserNamespacesStub        func(context.Context, *auth.UserPrincipal)
	updateUserNamespacesMutex       sync.RWMutex
	updateUserNamespacesArgsForCall []struct {
		arg1 context.Context
		arg2 *auth.UserPrincipal
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeClientsFactory) GetClustersNamespaces() map[string][]v1.Namespace {
	fake.getClustersNamespacesMutex.Lock()
	ret, specificReturn := fake.getClustersNamespacesReturnsOnCall[len(fake.getClustersNamespacesArgsForCall)]
	fake.getClustersNamespacesArgsForCall = append(fake.getClustersNamespacesArgsForCall, struct {
	}{})
	stub := fake.GetClustersNamespacesStub
	fakeReturns := fake.getClustersNamespacesReturns
	fake.recordInvocation("GetClustersNamespaces", []interface{}{})
	fake.getClustersNamespacesMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeClientsFactory) GetClustersNamespacesCallCount() int {
	fake.getClustersNamespacesMutex.RLock()
	defer fake.getClustersNamespacesMutex.RUnlock()
	return len(fake.getClustersNamespacesArgsForCall)
}

func (fake *FakeClientsFactory) GetClustersNamespacesCalls(stub func() map[string][]v1.Namespace) {
	fake.getClustersNamespacesMutex.Lock()
	defer fake.getClustersNamespacesMutex.Unlock()
	fake.GetClustersNamespacesStub = stub
}

func (fake *FakeClientsFactory) GetClustersNamespacesReturns(result1 map[string][]v1.Namespace) {
	fake.getClustersNamespacesMutex.Lock()
	defer fake.getClustersNamespacesMutex.Unlock()
	fake.GetClustersNamespacesStub = nil
	fake.getClustersNamespacesReturns = struct {
		result1 map[string][]v1.Namespace
	}{result1}
}

func (fake *FakeClientsFactory) GetClustersNamespacesReturnsOnCall(i int, result1 map[string][]v1.Namespace) {
	fake.getClustersNamespacesMutex.Lock()
	defer fake.getClustersNamespacesMutex.Unlock()
	fake.GetClustersNamespacesStub = nil
	if fake.getClustersNamespacesReturnsOnCall == nil {
		fake.getClustersNamespacesReturnsOnCall = make(map[int]struct {
			result1 map[string][]v1.Namespace
		})
	}
	fake.getClustersNamespacesReturnsOnCall[i] = struct {
		result1 map[string][]v1.Namespace
	}{result1}
}

func (fake *FakeClientsFactory) GetImpersonatedClient(arg1 context.Context, arg2 *auth.UserPrincipal) (clustersmngr.Client, error) {
	fake.getImpersonatedClientMutex.Lock()
	ret, specificReturn := fake.getImpersonatedClientReturnsOnCall[len(fake.getImpersonatedClientArgsForCall)]
	fake.getImpersonatedClientArgsForCall = append(fake.getImpersonatedClientArgsForCall, struct {
		arg1 context.Context
		arg2 *auth.UserPrincipal
	}{arg1, arg2})
	stub := fake.GetImpersonatedClientStub
	fakeReturns := fake.getImpersonatedClientReturns
	fake.recordInvocation("GetImpersonatedClient", []interface{}{arg1, arg2})
	fake.getImpersonatedClientMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeClientsFactory) GetImpersonatedClientCallCount() int {
	fake.getImpersonatedClientMutex.RLock()
	defer fake.getImpersonatedClientMutex.RUnlock()
	return len(fake.getImpersonatedClientArgsForCall)
}

func (fake *FakeClientsFactory) GetImpersonatedClientCalls(stub func(context.Context, *auth.UserPrincipal) (clustersmngr.Client, error)) {
	fake.getImpersonatedClientMutex.Lock()
	defer fake.getImpersonatedClientMutex.Unlock()
	fake.GetImpersonatedClientStub = stub
}

func (fake *FakeClientsFactory) GetImpersonatedClientArgsForCall(i int) (context.Context, *auth.UserPrincipal) {
	fake.getImpersonatedClientMutex.RLock()
	defer fake.getImpersonatedClientMutex.RUnlock()
	argsForCall := fake.getImpersonatedClientArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeClientsFactory) GetImpersonatedClientReturns(result1 clustersmngr.Client, result2 error) {
	fake.getImpersonatedClientMutex.Lock()
	defer fake.getImpersonatedClientMutex.Unlock()
	fake.GetImpersonatedClientStub = nil
	fake.getImpersonatedClientReturns = struct {
		result1 clustersmngr.Client
		result2 error
	}{result1, result2}
}

func (fake *FakeClientsFactory) GetImpersonatedClientReturnsOnCall(i int, result1 clustersmngr.Client, result2 error) {
	fake.getImpersonatedClientMutex.Lock()
	defer fake.getImpersonatedClientMutex.Unlock()
	fake.GetImpersonatedClientStub = nil
	if fake.getImpersonatedClientReturnsOnCall == nil {
		fake.getImpersonatedClientReturnsOnCall = make(map[int]struct {
			result1 clustersmngr.Client
			result2 error
		})
	}
	fake.getImpersonatedClientReturnsOnCall[i] = struct {
		result1 clustersmngr.Client
		result2 error
	}{result1, result2}
}

func (fake *FakeClientsFactory) GetImpersonatedDiscoveryClient(arg1 context.Context, arg2 *auth.UserPrincipal, arg3 string) (*discovery.DiscoveryClient, error) {
	fake.getImpersonatedDiscoveryClientMutex.Lock()
	ret, specificReturn := fake.getImpersonatedDiscoveryClientReturnsOnCall[len(fake.getImpersonatedDiscoveryClientArgsForCall)]
	fake.getImpersonatedDiscoveryClientArgsForCall = append(fake.getImpersonatedDiscoveryClientArgsForCall, struct {
		arg1 context.Context
		arg2 *auth.UserPrincipal
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.GetImpersonatedDiscoveryClientStub
	fakeReturns := fake.getImpersonatedDiscoveryClientReturns
	fake.recordInvocation("GetImpersonatedDiscoveryClient", []interface{}{arg1, arg2, arg3})
	fake.getImpersonatedDiscoveryClientMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeClientsFactory) GetImpersonatedDiscoveryClientCallCount() int {
	fake.getImpersonatedDiscoveryClientMutex.RLock()
	defer fake.getImpersonatedDiscoveryClientMutex.RUnlock()
	return len(fake.getImpersonatedDiscoveryClientArgsForCall)
}

func (fake *FakeClientsFactory) GetImpersonatedDiscoveryClientCalls(stub func(context.Context, *auth.UserPrincipal, string) (*discovery.DiscoveryClient, error)) {
	fake.getImpersonatedDiscoveryClientMutex.Lock()
	defer fake.getImpersonatedDiscoveryClientMutex.Unlock()
	fake.GetImpersonatedDiscoveryClientStub = stub
}

func (fake *FakeClientsFactory) GetImpersonatedDiscoveryClientArgsForCall(i int) (context.Context, *auth.UserPrincipal, string) {
	fake.getImpersonatedDiscoveryClientMutex.RLock()
	defer fake.getImpersonatedDiscoveryClientMutex.RUnlock()
	argsForCall := fake.getImpersonatedDiscoveryClientArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeClientsFactory) GetImpersonatedDiscoveryClientReturns(result1 *discovery.DiscoveryClient, result2 error) {
	fake.getImpersonatedDiscoveryClientMutex.Lock()
	defer fake.getImpersonatedDiscoveryClientMutex.Unlock()
	fake.GetImpersonatedDiscoveryClientStub = nil
	fake.getImpersonatedDiscoveryClientReturns = struct {
		result1 *discovery.DiscoveryClient
		result2 error
	}{result1, result2}
}

func (fake *FakeClientsFactory) GetImpersonatedDiscoveryClientReturnsOnCall(i int, result1 *discovery.DiscoveryClient, result2 error) {
	fake.getImpersonatedDiscoveryClientMutex.Lock()
	defer fake.getImpersonatedDiscoveryClientMutex.Unlock()
	fake.GetImpersonatedDiscoveryClientStub = nil
	if fake.getImpersonatedDiscoveryClientReturnsOnCall == nil {
		fake.getImpersonatedDiscoveryClientReturnsOnCall = make(map[int]struct {
			result1 *discovery.DiscoveryClient
			result2 error
		})
	}
	fake.getImpersonatedDiscoveryClientReturnsOnCall[i] = struct {
		result1 *discovery.DiscoveryClient
		result2 error
	}{result1, result2}
}

func (fake *FakeClientsFactory) GetServerClient(arg1 context.Context) (clustersmngr.Client, error) {
	fake.getServerClientMutex.Lock()
	ret, specificReturn := fake.getServerClientReturnsOnCall[len(fake.getServerClientArgsForCall)]
	fake.getServerClientArgsForCall = append(fake.getServerClientArgsForCall, struct {
		arg1 context.Context
	}{arg1})
	stub := fake.GetServerClientStub
	fakeReturns := fake.getServerClientReturns
	fake.recordInvocation("GetServerClient", []interface{}{arg1})
	fake.getServerClientMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeClientsFactory) GetServerClientCallCount() int {
	fake.getServerClientMutex.RLock()
	defer fake.getServerClientMutex.RUnlock()
	return len(fake.getServerClientArgsForCall)
}

func (fake *FakeClientsFactory) GetServerClientCalls(stub func(context.Context) (clustersmngr.Client, error)) {
	fake.getServerClientMutex.Lock()
	defer fake.getServerClientMutex.Unlock()
	fake.GetServerClientStub = stub
}

func (fake *FakeClientsFactory) GetServerClientArgsForCall(i int) context.Context {
	fake.getServerClientMutex.RLock()
	defer fake.getServerClientMutex.RUnlock()
	argsForCall := fake.getServerClientArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeClientsFactory) GetServerClientReturns(result1 clustersmngr.Client, result2 error) {
	fake.getServerClientMutex.Lock()
	defer fake.getServerClientMutex.Unlock()
	fake.GetServerClientStub = nil
	fake.getServerClientReturns = struct {
		result1 clustersmngr.Client
		result2 error
	}{result1, result2}
}

func (fake *FakeClientsFactory) GetServerClientReturnsOnCall(i int, result1 clustersmngr.Client, result2 error) {
	fake.getServerClientMutex.Lock()
	defer fake.getServerClientMutex.Unlock()
	fake.GetServerClientStub = nil
	if fake.getServerClientReturnsOnCall == nil {
		fake.getServerClientReturnsOnCall = make(map[int]struct {
			result1 clustersmngr.Client
			result2 error
		})
	}
	fake.getServerClientReturnsOnCall[i] = struct {
		result1 clustersmngr.Client
		result2 error
	}{result1, result2}
}

func (fake *FakeClientsFactory) GetUserNamespaces(arg1 *auth.UserPrincipal) map[string][]v1.Namespace {
	fake.getUserNamespacesMutex.Lock()
	ret, specificReturn := fake.getUserNamespacesReturnsOnCall[len(fake.getUserNamespacesArgsForCall)]
	fake.getUserNamespacesArgsForCall = append(fake.getUserNamespacesArgsForCall, struct {
		arg1 *auth.UserPrincipal
	}{arg1})
	stub := fake.GetUserNamespacesStub
	fakeReturns := fake.getUserNamespacesReturns
	fake.recordInvocation("GetUserNamespaces", []interface{}{arg1})
	fake.getUserNamespacesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeClientsFactory) GetUserNamespacesCallCount() int {
	fake.getUserNamespacesMutex.RLock()
	defer fake.getUserNamespacesMutex.RUnlock()
	return len(fake.getUserNamespacesArgsForCall)
}

func (fake *FakeClientsFactory) GetUserNamespacesCalls(stub func(*auth.UserPrincipal) map[string][]v1.Namespace) {
	fake.getUserNamespacesMutex.Lock()
	defer fake.getUserNamespacesMutex.Unlock()
	fake.GetUserNamespacesStub = stub
}

func (fake *FakeClientsFactory) GetUserNamespacesArgsForCall(i int) *auth.UserPrincipal {
	fake.getUserNamespacesMutex.RLock()
	defer fake.getUserNamespacesMutex.RUnlock()
	argsForCall := fake.getUserNamespacesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeClientsFactory) GetUserNamespacesReturns(result1 map[string][]v1.Namespace) {
	fake.getUserNamespacesMutex.Lock()
	defer fake.getUserNamespacesMutex.Unlock()
	fake.GetUserNamespacesStub = nil
	fake.getUserNamespacesReturns = struct {
		result1 map[string][]v1.Namespace
	}{result1}
}

func (fake *FakeClientsFactory) GetUserNamespacesReturnsOnCall(i int, result1 map[string][]v1.Namespace) {
	fake.getUserNamespacesMutex.Lock()
	defer fake.getUserNamespacesMutex.Unlock()
	fake.GetUserNamespacesStub = nil
	if fake.getUserNamespacesReturnsOnCall == nil {
		fake.getUserNamespacesReturnsOnCall = make(map[int]struct {
			result1 map[string][]v1.Namespace
		})
	}
	fake.getUserNamespacesReturnsOnCall[i] = struct {
		result1 map[string][]v1.Namespace
	}{result1}
}

func (fake *FakeClientsFactory) Start(arg1 context.Context) {
	fake.startMutex.Lock()
	fake.startArgsForCall = append(fake.startArgsForCall, struct {
		arg1 context.Context
	}{arg1})
	stub := fake.StartStub
	fake.recordInvocation("Start", []interface{}{arg1})
	fake.startMutex.Unlock()
	if stub != nil {
		fake.StartStub(arg1)
	}
}

func (fake *FakeClientsFactory) StartCallCount() int {
	fake.startMutex.RLock()
	defer fake.startMutex.RUnlock()
	return len(fake.startArgsForCall)
}

func (fake *FakeClientsFactory) StartCalls(stub func(context.Context)) {
	fake.startMutex.Lock()
	defer fake.startMutex.Unlock()
	fake.StartStub = stub
}

func (fake *FakeClientsFactory) StartArgsForCall(i int) context.Context {
	fake.startMutex.RLock()
	defer fake.startMutex.RUnlock()
	argsForCall := fake.startArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeClientsFactory) UpdateClusters(arg1 context.Context) error {
	fake.updateClustersMutex.Lock()
	ret, specificReturn := fake.updateClustersReturnsOnCall[len(fake.updateClustersArgsForCall)]
	fake.updateClustersArgsForCall = append(fake.updateClustersArgsForCall, struct {
		arg1 context.Context
	}{arg1})
	stub := fake.UpdateClustersStub
	fakeReturns := fake.updateClustersReturns
	fake.recordInvocation("UpdateClusters", []interface{}{arg1})
	fake.updateClustersMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeClientsFactory) UpdateClustersCallCount() int {
	fake.updateClustersMutex.RLock()
	defer fake.updateClustersMutex.RUnlock()
	return len(fake.updateClustersArgsForCall)
}

func (fake *FakeClientsFactory) UpdateClustersCalls(stub func(context.Context) error) {
	fake.updateClustersMutex.Lock()
	defer fake.updateClustersMutex.Unlock()
	fake.UpdateClustersStub = stub
}

func (fake *FakeClientsFactory) UpdateClustersArgsForCall(i int) context.Context {
	fake.updateClustersMutex.RLock()
	defer fake.updateClustersMutex.RUnlock()
	argsForCall := fake.updateClustersArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeClientsFactory) UpdateClustersReturns(result1 error) {
	fake.updateClustersMutex.Lock()
	defer fake.updateClustersMutex.Unlock()
	fake.UpdateClustersStub = nil
	fake.updateClustersReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeClientsFactory) UpdateClustersReturnsOnCall(i int, result1 error) {
	fake.updateClustersMutex.Lock()
	defer fake.updateClustersMutex.Unlock()
	fake.UpdateClustersStub = nil
	if fake.updateClustersReturnsOnCall == nil {
		fake.updateClustersReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateClustersReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeClientsFactory) UpdateNamespaces(arg1 context.Context) error {
	fake.updateNamespacesMutex.Lock()
	ret, specificReturn := fake.updateNamespacesReturnsOnCall[len(fake.updateNamespacesArgsForCall)]
	fake.updateNamespacesArgsForCall = append(fake.updateNamespacesArgsForCall, struct {
		arg1 context.Context
	}{arg1})
	stub := fake.UpdateNamespacesStub
	fakeReturns := fake.updateNamespacesReturns
	fake.recordInvocation("UpdateNamespaces", []interface{}{arg1})
	fake.updateNamespacesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeClientsFactory) UpdateNamespacesCallCount() int {
	fake.updateNamespacesMutex.RLock()
	defer fake.updateNamespacesMutex.RUnlock()
	return len(fake.updateNamespacesArgsForCall)
}

func (fake *FakeClientsFactory) UpdateNamespacesCalls(stub func(context.Context) error) {
	fake.updateNamespacesMutex.Lock()
	defer fake.updateNamespacesMutex.Unlock()
	fake.UpdateNamespacesStub = stub
}

func (fake *FakeClientsFactory) UpdateNamespacesArgsForCall(i int) context.Context {
	fake.updateNamespacesMutex.RLock()
	defer fake.updateNamespacesMutex.RUnlock()
	argsForCall := fake.updateNamespacesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeClientsFactory) UpdateNamespacesReturns(result1 error) {
	fake.updateNamespacesMutex.Lock()
	defer fake.updateNamespacesMutex.Unlock()
	fake.UpdateNamespacesStub = nil
	fake.updateNamespacesReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeClientsFactory) UpdateNamespacesReturnsOnCall(i int, result1 error) {
	fake.updateNamespacesMutex.Lock()
	defer fake.updateNamespacesMutex.Unlock()
	fake.UpdateNamespacesStub = nil
	if fake.updateNamespacesReturnsOnCall == nil {
		fake.updateNamespacesReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateNamespacesReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeClientsFactory) UpdateUserNamespaces(arg1 context.Context, arg2 *auth.UserPrincipal) {
	fake.updateUserNamespacesMutex.Lock()
	fake.updateUserNamespacesArgsForCall = append(fake.updateUserNamespacesArgsForCall, struct {
		arg1 context.Context
		arg2 *auth.UserPrincipal
	}{arg1, arg2})
	stub := fake.UpdateUserNamespacesStub
	fake.recordInvocation("UpdateUserNamespaces", []interface{}{arg1, arg2})
	fake.updateUserNamespacesMutex.Unlock()
	if stub != nil {
		fake.UpdateUserNamespacesStub(arg1, arg2)
	}
}

func (fake *FakeClientsFactory) UpdateUserNamespacesCallCount() int {
	fake.updateUserNamespacesMutex.RLock()
	defer fake.updateUserNamespacesMutex.RUnlock()
	return len(fake.updateUserNamespacesArgsForCall)
}

func (fake *FakeClientsFactory) UpdateUserNamespacesCalls(stub func(context.Context, *auth.UserPrincipal)) {
	fake.updateUserNamespacesMutex.Lock()
	defer fake.updateUserNamespacesMutex.Unlock()
	fake.UpdateUserNamespacesStub = stub
}

func (fake *FakeClientsFactory) UpdateUserNamespacesArgsForCall(i int) (context.Context, *auth.UserPrincipal) {
	fake.updateUserNamespacesMutex.RLock()
	defer fake.updateUserNamespacesMutex.RUnlock()
	argsForCall := fake.updateUserNamespacesArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeClientsFactory) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.getClustersNamespacesMutex.RLock()
	defer fake.getClustersNamespacesMutex.RUnlock()
	fake.getImpersonatedClientMutex.RLock()
	defer fake.getImpersonatedClientMutex.RUnlock()
	fake.getImpersonatedDiscoveryClientMutex.RLock()
	defer fake.getImpersonatedDiscoveryClientMutex.RUnlock()
	fake.getServerClientMutex.RLock()
	defer fake.getServerClientMutex.RUnlock()
	fake.getUserNamespacesMutex.RLock()
	defer fake.getUserNamespacesMutex.RUnlock()
	fake.startMutex.RLock()
	defer fake.startMutex.RUnlock()
	fake.updateClustersMutex.RLock()
	defer fake.updateClustersMutex.RUnlock()
	fake.updateNamespacesMutex.RLock()
	defer fake.updateNamespacesMutex.RUnlock()
	fake.updateUserNamespacesMutex.RLock()
	defer fake.updateUserNamespacesMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeClientsFactory) 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 _ clustersmngr.ClientsFactory = new(FakeClientsFactory)