osd_keycloak_service_moq.go

// Code generated by moq; DO NOT EDIT.
// github.com/matryer/moq

package sso

import (
	"context"
	"github.com/bf2fc6cc711aee1a0c2a/kas-fleet-manager/pkg/api"
	"github.com/bf2fc6cc711aee1a0c2a/kas-fleet-manager/pkg/client/keycloak"
	"github.com/bf2fc6cc711aee1a0c2a/kas-fleet-manager/pkg/errors"
	"sync"
)

// Ensure, that OSDKeycloakServiceMock does implement OSDKeycloakService.
// If this is not the case, regenerate this file with moq.
var _ OSDKeycloakService = &OSDKeycloakServiceMock{}

// OSDKeycloakServiceMock is a mock implementation of OSDKeycloakService.
//
//	func TestSomethingThatUsesOSDKeycloakService(t *testing.T) {
//
//		// make and configure a mocked OSDKeycloakService
//		mockedOSDKeycloakService := &OSDKeycloakServiceMock{
//			CreateServiceAccountFunc: func(serviceAccountRequest *api.ServiceAccountRequest, ctx context.Context) (*api.ServiceAccount, *errors.ServiceError) {
//				panic("mock out the CreateServiceAccount method")
//			},
//			CreateServiceAccountInternalFunc: func(request CompleteServiceAccountRequest) (*api.ServiceAccount, *errors.ServiceError) {
//				panic("mock out the CreateServiceAccountInternal method")
//			},
//			DeRegisterClientInSSOFunc: func(kafkaNamespace string) *errors.ServiceError {
//				panic("mock out the DeRegisterClientInSSO method")
//			},
//			DeRegisterConnectorFleetshardOperatorServiceAccountFunc: func(agentClusterId string) *errors.ServiceError {
//				panic("mock out the DeRegisterConnectorFleetshardOperatorServiceAccount method")
//			},
//			DeRegisterKasFleetshardOperatorServiceAccountFunc: func(agentClusterId string) *errors.ServiceError {
//				panic("mock out the DeRegisterKasFleetshardOperatorServiceAccount method")
//			},
//			DeleteServiceAccountFunc: func(ctx context.Context, clientId string) *errors.ServiceError {
//				panic("mock out the DeleteServiceAccount method")
//			},
//			DeleteServiceAccountInternalFunc: func(clientId string) *errors.ServiceError {
//				panic("mock out the DeleteServiceAccountInternal method")
//			},
//			GetConfigFunc: func() *keycloak.KeycloakConfig {
//				panic("mock out the GetConfig method")
//			},
//			GetKafkaClientSecretFunc: func(clientId string) (string, *errors.ServiceError) {
//				panic("mock out the GetKafkaClientSecret method")
//			},
//			GetRealmConfigFunc: func() *keycloak.KeycloakRealmConfig {
//				panic("mock out the GetRealmConfig method")
//			},
//			GetServiceAccountByClientIdFunc: func(ctx context.Context, clientId string) (*api.ServiceAccount, *errors.ServiceError) {
//				panic("mock out the GetServiceAccountByClientId method")
//			},
//			GetServiceAccountByIdFunc: func(ctx context.Context, id string) (*api.ServiceAccount, *errors.ServiceError) {
//				panic("mock out the GetServiceAccountById method")
//			},
//			IsKafkaClientExistFunc: func(clientId string) *errors.ServiceError {
//				panic("mock out the IsKafkaClientExist method")
//			},
//			ListServiceAccFunc: func(ctx context.Context, first int, max int) ([]api.ServiceAccount, *errors.ServiceError) {
//				panic("mock out the ListServiceAcc method")
//			},
//			RegisterClientInSSOFunc: func(clusterId string, clusterOathCallbackURI string) (string, *errors.ServiceError) {
//				panic("mock out the RegisterClientInSSO method")
//			},
//			RegisterConnectorFleetshardOperatorServiceAccountFunc: func(agentClusterId string) (*api.ServiceAccount, *errors.ServiceError) {
//				panic("mock out the RegisterConnectorFleetshardOperatorServiceAccount method")
//			},
//			RegisterKasFleetshardOperatorServiceAccountFunc: func(agentClusterId string) (*api.ServiceAccount, *errors.ServiceError) {
//				panic("mock out the RegisterKasFleetshardOperatorServiceAccount method")
//			},
//			ResetServiceAccountCredentialsFunc: func(ctx context.Context, clientId string) (*api.ServiceAccount, *errors.ServiceError) {
//				panic("mock out the ResetServiceAccountCredentials method")
//			},
//		}
//
//		// use mockedOSDKeycloakService in code that requires OSDKeycloakService
//		// and then make assertions.
//
//	}
type OSDKeycloakServiceMock struct {
	// CreateServiceAccountFunc mocks the CreateServiceAccount method.
	CreateServiceAccountFunc func(serviceAccountRequest *api.ServiceAccountRequest, ctx context.Context) (*api.ServiceAccount, *errors.ServiceError)

	// CreateServiceAccountInternalFunc mocks the CreateServiceAccountInternal method.
	CreateServiceAccountInternalFunc func(request CompleteServiceAccountRequest) (*api.ServiceAccount, *errors.ServiceError)

	// DeRegisterClientInSSOFunc mocks the DeRegisterClientInSSO method.
	DeRegisterClientInSSOFunc func(kafkaNamespace string) *errors.ServiceError

	// DeRegisterConnectorFleetshardOperatorServiceAccountFunc mocks the DeRegisterConnectorFleetshardOperatorServiceAccount method.
	DeRegisterConnectorFleetshardOperatorServiceAccountFunc func(agentClusterId string) *errors.ServiceError

	// DeRegisterKasFleetshardOperatorServiceAccountFunc mocks the DeRegisterKasFleetshardOperatorServiceAccount method.
	DeRegisterKasFleetshardOperatorServiceAccountFunc func(agentClusterId string) *errors.ServiceError

	// DeleteServiceAccountFunc mocks the DeleteServiceAccount method.
	DeleteServiceAccountFunc func(ctx context.Context, clientId string) *errors.ServiceError

	// DeleteServiceAccountInternalFunc mocks the DeleteServiceAccountInternal method.
	DeleteServiceAccountInternalFunc func(clientId string) *errors.ServiceError

	// GetConfigFunc mocks the GetConfig method.
	GetConfigFunc func() *keycloak.KeycloakConfig

	// GetKafkaClientSecretFunc mocks the GetKafkaClientSecret method.
	GetKafkaClientSecretFunc func(clientId string) (string, *errors.ServiceError)

	// GetRealmConfigFunc mocks the GetRealmConfig method.
	GetRealmConfigFunc func() *keycloak.KeycloakRealmConfig

	// GetServiceAccountByClientIdFunc mocks the GetServiceAccountByClientId method.
	GetServiceAccountByClientIdFunc func(ctx context.Context, clientId string) (*api.ServiceAccount, *errors.ServiceError)

	// GetServiceAccountByIdFunc mocks the GetServiceAccountById method.
	GetServiceAccountByIdFunc func(ctx context.Context, id string) (*api.ServiceAccount, *errors.ServiceError)

	// IsKafkaClientExistFunc mocks the IsKafkaClientExist method.
	IsKafkaClientExistFunc func(clientId string) *errors.ServiceError

	// ListServiceAccFunc mocks the ListServiceAcc method.
	ListServiceAccFunc func(ctx context.Context, first int, max int) ([]api.ServiceAccount, *errors.ServiceError)

	// RegisterClientInSSOFunc mocks the RegisterClientInSSO method.
	RegisterClientInSSOFunc func(clusterId string, clusterOathCallbackURI string) (string, *errors.ServiceError)

	// RegisterConnectorFleetshardOperatorServiceAccountFunc mocks the RegisterConnectorFleetshardOperatorServiceAccount method.
	RegisterConnectorFleetshardOperatorServiceAccountFunc func(agentClusterId string) (*api.ServiceAccount, *errors.ServiceError)

	// RegisterKasFleetshardOperatorServiceAccountFunc mocks the RegisterKasFleetshardOperatorServiceAccount method.
	RegisterKasFleetshardOperatorServiceAccountFunc func(agentClusterId string) (*api.ServiceAccount, *errors.ServiceError)

	// ResetServiceAccountCredentialsFunc mocks the ResetServiceAccountCredentials method.
	ResetServiceAccountCredentialsFunc func(ctx context.Context, clientId string) (*api.ServiceAccount, *errors.ServiceError)

	// calls tracks calls to the methods.
	calls struct {
		// CreateServiceAccount holds details about calls to the CreateServiceAccount method.
		CreateServiceAccount []struct {
			// ServiceAccountRequest is the serviceAccountRequest argument value.
			ServiceAccountRequest *api.ServiceAccountRequest
			// Ctx is the ctx argument value.
			Ctx context.Context
		}
		// CreateServiceAccountInternal holds details about calls to the CreateServiceAccountInternal method.
		CreateServiceAccountInternal []struct {
			// Request is the request argument value.
			Request CompleteServiceAccountRequest
		}
		// DeRegisterClientInSSO holds details about calls to the DeRegisterClientInSSO method.
		DeRegisterClientInSSO []struct {
			// KafkaNamespace is the kafkaNamespace argument value.
			KafkaNamespace string
		}
		// DeRegisterConnectorFleetshardOperatorServiceAccount holds details about calls to the DeRegisterConnectorFleetshardOperatorServiceAccount method.
		DeRegisterConnectorFleetshardOperatorServiceAccount []struct {
			// AgentClusterId is the agentClusterId argument value.
			AgentClusterId string
		}
		// DeRegisterKasFleetshardOperatorServiceAccount holds details about calls to the DeRegisterKasFleetshardOperatorServiceAccount method.
		DeRegisterKasFleetshardOperatorServiceAccount []struct {
			// AgentClusterId is the agentClusterId argument value.
			AgentClusterId string
		}
		// DeleteServiceAccount holds details about calls to the DeleteServiceAccount method.
		DeleteServiceAccount []struct {
			// Ctx is the ctx argument value.
			Ctx context.Context
			// ClientId is the clientId argument value.
			ClientId string
		}
		// DeleteServiceAccountInternal holds details about calls to the DeleteServiceAccountInternal method.
		DeleteServiceAccountInternal []struct {
			// ClientId is the clientId argument value.
			ClientId string
		}
		// GetConfig holds details about calls to the GetConfig method.
		GetConfig []struct {
		}
		// GetKafkaClientSecret holds details about calls to the GetKafkaClientSecret method.
		GetKafkaClientSecret []struct {
			// ClientId is the clientId argument value.
			ClientId string
		}
		// GetRealmConfig holds details about calls to the GetRealmConfig method.
		GetRealmConfig []struct {
		}
		// GetServiceAccountByClientId holds details about calls to the GetServiceAccountByClientId method.
		GetServiceAccountByClientId []struct {
			// Ctx is the ctx argument value.
			Ctx context.Context
			// ClientId is the clientId argument value.
			ClientId string
		}
		// GetServiceAccountById holds details about calls to the GetServiceAccountById method.
		GetServiceAccountById []struct {
			// Ctx is the ctx argument value.
			Ctx context.Context
			// ID is the id argument value.
			ID string
		}
		// IsKafkaClientExist holds details about calls to the IsKafkaClientExist method.
		IsKafkaClientExist []struct {
			// ClientId is the clientId argument value.
			ClientId string
		}
		// ListServiceAcc holds details about calls to the ListServiceAcc method.
		ListServiceAcc []struct {
			// Ctx is the ctx argument value.
			Ctx context.Context
			// First is the first argument value.
			First int
			// Max is the max argument value.
			Max int
		}
		// RegisterClientInSSO holds details about calls to the RegisterClientInSSO method.
		RegisterClientInSSO []struct {
			// ClusterId is the clusterId argument value.
			ClusterId string
			// ClusterOathCallbackURI is the clusterOathCallbackURI argument value.
			ClusterOathCallbackURI string
		}
		// RegisterConnectorFleetshardOperatorServiceAccount holds details about calls to the RegisterConnectorFleetshardOperatorServiceAccount method.
		RegisterConnectorFleetshardOperatorServiceAccount []struct {
			// AgentClusterId is the agentClusterId argument value.
			AgentClusterId string
		}
		// RegisterKasFleetshardOperatorServiceAccount holds details about calls to the RegisterKasFleetshardOperatorServiceAccount method.
		RegisterKasFleetshardOperatorServiceAccount []struct {
			// AgentClusterId is the agentClusterId argument value.
			AgentClusterId string
		}
		// ResetServiceAccountCredentials holds details about calls to the ResetServiceAccountCredentials method.
		ResetServiceAccountCredentials []struct {
			// Ctx is the ctx argument value.
			Ctx context.Context
			// ClientId is the clientId argument value.
			ClientId string
		}
	}
	lockCreateServiceAccount                                sync.RWMutex
	lockCreateServiceAccountInternal                        sync.RWMutex
	lockDeRegisterClientInSSO                               sync.RWMutex
	lockDeRegisterConnectorFleetshardOperatorServiceAccount sync.RWMutex
	lockDeRegisterKasFleetshardOperatorServiceAccount       sync.RWMutex
	lockDeleteServiceAccount                                sync.RWMutex
	lockDeleteServiceAccountInternal                        sync.RWMutex
	lockGetConfig                                           sync.RWMutex
	lockGetKafkaClientSecret                                sync.RWMutex
	lockGetRealmConfig                                      sync.RWMutex
	lockGetServiceAccountByClientId                         sync.RWMutex
	lockGetServiceAccountById                               sync.RWMutex
	lockIsKafkaClientExist                                  sync.RWMutex
	lockListServiceAcc                                      sync.RWMutex
	lockRegisterClientInSSO                                 sync.RWMutex
	lockRegisterConnectorFleetshardOperatorServiceAccount   sync.RWMutex
	lockRegisterKasFleetshardOperatorServiceAccount         sync.RWMutex
	lockResetServiceAccountCredentials                      sync.RWMutex
}

// CreateServiceAccount calls CreateServiceAccountFunc.
func (mock *OSDKeycloakServiceMock) CreateServiceAccount(serviceAccountRequest *api.ServiceAccountRequest, ctx context.Context) (*api.ServiceAccount, *errors.ServiceError) {
	if mock.CreateServiceAccountFunc == nil {
		panic("OSDKeycloakServiceMock.CreateServiceAccountFunc: method is nil but OSDKeycloakService.CreateServiceAccount was just called")
	}
	callInfo := struct {
		ServiceAccountRequest *api.ServiceAccountRequest
		Ctx                   context.Context
	}{
		ServiceAccountRequest: serviceAccountRequest,
		Ctx:                   ctx,
	}
	mock.lockCreateServiceAccount.Lock()
	mock.calls.CreateServiceAccount = append(mock.calls.CreateServiceAccount, callInfo)
	mock.lockCreateServiceAccount.Unlock()
	return mock.CreateServiceAccountFunc(serviceAccountRequest, ctx)
}

// CreateServiceAccountCalls gets all the calls that were made to CreateServiceAccount.
// Check the length with:
//
//	len(mockedOSDKeycloakService.CreateServiceAccountCalls())
func (mock *OSDKeycloakServiceMock) CreateServiceAccountCalls() []struct {
	ServiceAccountRequest *api.ServiceAccountRequest
	Ctx                   context.Context
} {
	var calls []struct {
		ServiceAccountRequest *api.ServiceAccountRequest
		Ctx                   context.Context
	}
	mock.lockCreateServiceAccount.RLock()
	calls = mock.calls.CreateServiceAccount
	mock.lockCreateServiceAccount.RUnlock()
	return calls
}

// CreateServiceAccountInternal calls CreateServiceAccountInternalFunc.
func (mock *OSDKeycloakServiceMock) CreateServiceAccountInternal(request CompleteServiceAccountRequest) (*api.ServiceAccount, *errors.ServiceError) {
	if mock.CreateServiceAccountInternalFunc == nil {
		panic("OSDKeycloakServiceMock.CreateServiceAccountInternalFunc: method is nil but OSDKeycloakService.CreateServiceAccountInternal was just called")
	}
	callInfo := struct {
		Request CompleteServiceAccountRequest
	}{
		Request: request,
	}
	mock.lockCreateServiceAccountInternal.Lock()
	mock.calls.CreateServiceAccountInternal = append(mock.calls.CreateServiceAccountInternal, callInfo)
	mock.lockCreateServiceAccountInternal.Unlock()
	return mock.CreateServiceAccountInternalFunc(request)
}

// CreateServiceAccountInternalCalls gets all the calls that were made to CreateServiceAccountInternal.
// Check the length with:
//
//	len(mockedOSDKeycloakService.CreateServiceAccountInternalCalls())
func (mock *OSDKeycloakServiceMock) CreateServiceAccountInternalCalls() []struct {
	Request CompleteServiceAccountRequest
} {
	var calls []struct {
		Request CompleteServiceAccountRequest
	}
	mock.lockCreateServiceAccountInternal.RLock()
	calls = mock.calls.CreateServiceAccountInternal
	mock.lockCreateServiceAccountInternal.RUnlock()
	return calls
}

// DeRegisterClientInSSO calls DeRegisterClientInSSOFunc.
func (mock *OSDKeycloakServiceMock) DeRegisterClientInSSO(kafkaNamespace string) *errors.ServiceError {
	if mock.DeRegisterClientInSSOFunc == nil {
		panic("OSDKeycloakServiceMock.DeRegisterClientInSSOFunc: method is nil but OSDKeycloakService.DeRegisterClientInSSO was just called")
	}
	callInfo := struct {
		KafkaNamespace string
	}{
		KafkaNamespace: kafkaNamespace,
	}
	mock.lockDeRegisterClientInSSO.Lock()
	mock.calls.DeRegisterClientInSSO = append(mock.calls.DeRegisterClientInSSO, callInfo)
	mock.lockDeRegisterClientInSSO.Unlock()
	return mock.DeRegisterClientInSSOFunc(kafkaNamespace)
}

// DeRegisterClientInSSOCalls gets all the calls that were made to DeRegisterClientInSSO.
// Check the length with:
//
//	len(mockedOSDKeycloakService.DeRegisterClientInSSOCalls())
func (mock *OSDKeycloakServiceMock) DeRegisterClientInSSOCalls() []struct {
	KafkaNamespace string
} {
	var calls []struct {
		KafkaNamespace string
	}
	mock.lockDeRegisterClientInSSO.RLock()
	calls = mock.calls.DeRegisterClientInSSO
	mock.lockDeRegisterClientInSSO.RUnlock()
	return calls
}

// DeRegisterConnectorFleetshardOperatorServiceAccount calls DeRegisterConnectorFleetshardOperatorServiceAccountFunc.
func (mock *OSDKeycloakServiceMock) DeRegisterConnectorFleetshardOperatorServiceAccount(agentClusterId string) *errors.ServiceError {
	if mock.DeRegisterConnectorFleetshardOperatorServiceAccountFunc == nil {
		panic("OSDKeycloakServiceMock.DeRegisterConnectorFleetshardOperatorServiceAccountFunc: method is nil but OSDKeycloakService.DeRegisterConnectorFleetshardOperatorServiceAccount was just called")
	}
	callInfo := struct {
		AgentClusterId string
	}{
		AgentClusterId: agentClusterId,
	}
	mock.lockDeRegisterConnectorFleetshardOperatorServiceAccount.Lock()
	mock.calls.DeRegisterConnectorFleetshardOperatorServiceAccount = append(mock.calls.DeRegisterConnectorFleetshardOperatorServiceAccount, callInfo)
	mock.lockDeRegisterConnectorFleetshardOperatorServiceAccount.Unlock()
	return mock.DeRegisterConnectorFleetshardOperatorServiceAccountFunc(agentClusterId)
}

// DeRegisterConnectorFleetshardOperatorServiceAccountCalls gets all the calls that were made to DeRegisterConnectorFleetshardOperatorServiceAccount.
// Check the length with:
//
//	len(mockedOSDKeycloakService.DeRegisterConnectorFleetshardOperatorServiceAccountCalls())
func (mock *OSDKeycloakServiceMock) DeRegisterConnectorFleetshardOperatorServiceAccountCalls() []struct {
	AgentClusterId string
} {
	var calls []struct {
		AgentClusterId string
	}
	mock.lockDeRegisterConnectorFleetshardOperatorServiceAccount.RLock()
	calls = mock.calls.DeRegisterConnectorFleetshardOperatorServiceAccount
	mock.lockDeRegisterConnectorFleetshardOperatorServiceAccount.RUnlock()
	return calls
}

// DeRegisterKasFleetshardOperatorServiceAccount calls DeRegisterKasFleetshardOperatorServiceAccountFunc.
func (mock *OSDKeycloakServiceMock) DeRegisterKasFleetshardOperatorServiceAccount(agentClusterId string) *errors.ServiceError {
	if mock.DeRegisterKasFleetshardOperatorServiceAccountFunc == nil {
		panic("OSDKeycloakServiceMock.DeRegisterKasFleetshardOperatorServiceAccountFunc: method is nil but OSDKeycloakService.DeRegisterKasFleetshardOperatorServiceAccount was just called")
	}
	callInfo := struct {
		AgentClusterId string
	}{
		AgentClusterId: agentClusterId,
	}
	mock.lockDeRegisterKasFleetshardOperatorServiceAccount.Lock()
	mock.calls.DeRegisterKasFleetshardOperatorServiceAccount = append(mock.calls.DeRegisterKasFleetshardOperatorServiceAccount, callInfo)
	mock.lockDeRegisterKasFleetshardOperatorServiceAccount.Unlock()
	return mock.DeRegisterKasFleetshardOperatorServiceAccountFunc(agentClusterId)
}

// DeRegisterKasFleetshardOperatorServiceAccountCalls gets all the calls that were made to DeRegisterKasFleetshardOperatorServiceAccount.
// Check the length with:
//
//	len(mockedOSDKeycloakService.DeRegisterKasFleetshardOperatorServiceAccountCalls())
func (mock *OSDKeycloakServiceMock) DeRegisterKasFleetshardOperatorServiceAccountCalls() []struct {
	AgentClusterId string
} {
	var calls []struct {
		AgentClusterId string
	}
	mock.lockDeRegisterKasFleetshardOperatorServiceAccount.RLock()
	calls = mock.calls.DeRegisterKasFleetshardOperatorServiceAccount
	mock.lockDeRegisterKasFleetshardOperatorServiceAccount.RUnlock()
	return calls
}

// DeleteServiceAccount calls DeleteServiceAccountFunc.
func (mock *OSDKeycloakServiceMock) DeleteServiceAccount(ctx context.Context, clientId string) *errors.ServiceError {
	if mock.DeleteServiceAccountFunc == nil {
		panic("OSDKeycloakServiceMock.DeleteServiceAccountFunc: method is nil but OSDKeycloakService.DeleteServiceAccount was just called")
	}
	callInfo := struct {
		Ctx      context.Context
		ClientId string
	}{
		Ctx:      ctx,
		ClientId: clientId,
	}
	mock.lockDeleteServiceAccount.Lock()
	mock.calls.DeleteServiceAccount = append(mock.calls.DeleteServiceAccount, callInfo)
	mock.lockDeleteServiceAccount.Unlock()
	return mock.DeleteServiceAccountFunc(ctx, clientId)
}

// DeleteServiceAccountCalls gets all the calls that were made to DeleteServiceAccount.
// Check the length with:
//
//	len(mockedOSDKeycloakService.DeleteServiceAccountCalls())
func (mock *OSDKeycloakServiceMock) DeleteServiceAccountCalls() []struct {
	Ctx      context.Context
	ClientId string
} {
	var calls []struct {
		Ctx      context.Context
		ClientId string
	}
	mock.lockDeleteServiceAccount.RLock()
	calls = mock.calls.DeleteServiceAccount
	mock.lockDeleteServiceAccount.RUnlock()
	return calls
}

// DeleteServiceAccountInternal calls DeleteServiceAccountInternalFunc.
func (mock *OSDKeycloakServiceMock) DeleteServiceAccountInternal(clientId string) *errors.ServiceError {
	if mock.DeleteServiceAccountInternalFunc == nil {
		panic("OSDKeycloakServiceMock.DeleteServiceAccountInternalFunc: method is nil but OSDKeycloakService.DeleteServiceAccountInternal was just called")
	}
	callInfo := struct {
		ClientId string
	}{
		ClientId: clientId,
	}
	mock.lockDeleteServiceAccountInternal.Lock()
	mock.calls.DeleteServiceAccountInternal = append(mock.calls.DeleteServiceAccountInternal, callInfo)
	mock.lockDeleteServiceAccountInternal.Unlock()
	return mock.DeleteServiceAccountInternalFunc(clientId)
}

// DeleteServiceAccountInternalCalls gets all the calls that were made to DeleteServiceAccountInternal.
// Check the length with:
//
//	len(mockedOSDKeycloakService.DeleteServiceAccountInternalCalls())
func (mock *OSDKeycloakServiceMock) DeleteServiceAccountInternalCalls() []struct {
	ClientId string
} {
	var calls []struct {
		ClientId string
	}
	mock.lockDeleteServiceAccountInternal.RLock()
	calls = mock.calls.DeleteServiceAccountInternal
	mock.lockDeleteServiceAccountInternal.RUnlock()
	return calls
}

// GetConfig calls GetConfigFunc.
func (mock *OSDKeycloakServiceMock) GetConfig() *keycloak.KeycloakConfig {
	if mock.GetConfigFunc == nil {
		panic("OSDKeycloakServiceMock.GetConfigFunc: method is nil but OSDKeycloakService.GetConfig was just called")
	}
	callInfo := struct {
	}{}
	mock.lockGetConfig.Lock()
	mock.calls.GetConfig = append(mock.calls.GetConfig, callInfo)
	mock.lockGetConfig.Unlock()
	return mock.GetConfigFunc()
}

// GetConfigCalls gets all the calls that were made to GetConfig.
// Check the length with:
//
//	len(mockedOSDKeycloakService.GetConfigCalls())
func (mock *OSDKeycloakServiceMock) GetConfigCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetConfig.RLock()
	calls = mock.calls.GetConfig
	mock.lockGetConfig.RUnlock()
	return calls
}

// GetKafkaClientSecret calls GetKafkaClientSecretFunc.
func (mock *OSDKeycloakServiceMock) GetKafkaClientSecret(clientId string) (string, *errors.ServiceError) {
	if mock.GetKafkaClientSecretFunc == nil {
		panic("OSDKeycloakServiceMock.GetKafkaClientSecretFunc: method is nil but OSDKeycloakService.GetKafkaClientSecret was just called")
	}
	callInfo := struct {
		ClientId string
	}{
		ClientId: clientId,
	}
	mock.lockGetKafkaClientSecret.Lock()
	mock.calls.GetKafkaClientSecret = append(mock.calls.GetKafkaClientSecret, callInfo)
	mock.lockGetKafkaClientSecret.Unlock()
	return mock.GetKafkaClientSecretFunc(clientId)
}

// GetKafkaClientSecretCalls gets all the calls that were made to GetKafkaClientSecret.
// Check the length with:
//
//	len(mockedOSDKeycloakService.GetKafkaClientSecretCalls())
func (mock *OSDKeycloakServiceMock) GetKafkaClientSecretCalls() []struct {
	ClientId string
} {
	var calls []struct {
		ClientId string
	}
	mock.lockGetKafkaClientSecret.RLock()
	calls = mock.calls.GetKafkaClientSecret
	mock.lockGetKafkaClientSecret.RUnlock()
	return calls
}

// GetRealmConfig calls GetRealmConfigFunc.
func (mock *OSDKeycloakServiceMock) GetRealmConfig() *keycloak.KeycloakRealmConfig {
	if mock.GetRealmConfigFunc == nil {
		panic("OSDKeycloakServiceMock.GetRealmConfigFunc: method is nil but OSDKeycloakService.GetRealmConfig was just called")
	}
	callInfo := struct {
	}{}
	mock.lockGetRealmConfig.Lock()
	mock.calls.GetRealmConfig = append(mock.calls.GetRealmConfig, callInfo)
	mock.lockGetRealmConfig.Unlock()
	return mock.GetRealmConfigFunc()
}

// GetRealmConfigCalls gets all the calls that were made to GetRealmConfig.
// Check the length with:
//
//	len(mockedOSDKeycloakService.GetRealmConfigCalls())
func (mock *OSDKeycloakServiceMock) GetRealmConfigCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetRealmConfig.RLock()
	calls = mock.calls.GetRealmConfig
	mock.lockGetRealmConfig.RUnlock()
	return calls
}

// GetServiceAccountByClientId calls GetServiceAccountByClientIdFunc.
func (mock *OSDKeycloakServiceMock) GetServiceAccountByClientId(ctx context.Context, clientId string) (*api.ServiceAccount, *errors.ServiceError) {
	if mock.GetServiceAccountByClientIdFunc == nil {
		panic("OSDKeycloakServiceMock.GetServiceAccountByClientIdFunc: method is nil but OSDKeycloakService.GetServiceAccountByClientId was just called")
	}
	callInfo := struct {
		Ctx      context.Context
		ClientId string
	}{
		Ctx:      ctx,
		ClientId: clientId,
	}
	mock.lockGetServiceAccountByClientId.Lock()
	mock.calls.GetServiceAccountByClientId = append(mock.calls.GetServiceAccountByClientId, callInfo)
	mock.lockGetServiceAccountByClientId.Unlock()
	return mock.GetServiceAccountByClientIdFunc(ctx, clientId)
}

// GetServiceAccountByClientIdCalls gets all the calls that were made to GetServiceAccountByClientId.
// Check the length with:
//
//	len(mockedOSDKeycloakService.GetServiceAccountByClientIdCalls())
func (mock *OSDKeycloakServiceMock) GetServiceAccountByClientIdCalls() []struct {
	Ctx      context.Context
	ClientId string
} {
	var calls []struct {
		Ctx      context.Context
		ClientId string
	}
	mock.lockGetServiceAccountByClientId.RLock()
	calls = mock.calls.GetServiceAccountByClientId
	mock.lockGetServiceAccountByClientId.RUnlock()
	return calls
}

// GetServiceAccountById calls GetServiceAccountByIdFunc.
func (mock *OSDKeycloakServiceMock) GetServiceAccountById(ctx context.Context, id string) (*api.ServiceAccount, *errors.ServiceError) {
	if mock.GetServiceAccountByIdFunc == nil {
		panic("OSDKeycloakServiceMock.GetServiceAccountByIdFunc: method is nil but OSDKeycloakService.GetServiceAccountById was just called")
	}
	callInfo := struct {
		Ctx context.Context
		ID  string
	}{
		Ctx: ctx,
		ID:  id,
	}
	mock.lockGetServiceAccountById.Lock()
	mock.calls.GetServiceAccountById = append(mock.calls.GetServiceAccountById, callInfo)
	mock.lockGetServiceAccountById.Unlock()
	return mock.GetServiceAccountByIdFunc(ctx, id)
}

// GetServiceAccountByIdCalls gets all the calls that were made to GetServiceAccountById.
// Check the length with:
//
//	len(mockedOSDKeycloakService.GetServiceAccountByIdCalls())
func (mock *OSDKeycloakServiceMock) GetServiceAccountByIdCalls() []struct {
	Ctx context.Context
	ID  string
} {
	var calls []struct {
		Ctx context.Context
		ID  string
	}
	mock.lockGetServiceAccountById.RLock()
	calls = mock.calls.GetServiceAccountById
	mock.lockGetServiceAccountById.RUnlock()
	return calls
}

// IsKafkaClientExist calls IsKafkaClientExistFunc.
func (mock *OSDKeycloakServiceMock) IsKafkaClientExist(clientId string) *errors.ServiceError {
	if mock.IsKafkaClientExistFunc == nil {
		panic("OSDKeycloakServiceMock.IsKafkaClientExistFunc: method is nil but OSDKeycloakService.IsKafkaClientExist was just called")
	}
	callInfo := struct {
		ClientId string
	}{
		ClientId: clientId,
	}
	mock.lockIsKafkaClientExist.Lock()
	mock.calls.IsKafkaClientExist = append(mock.calls.IsKafkaClientExist, callInfo)
	mock.lockIsKafkaClientExist.Unlock()
	return mock.IsKafkaClientExistFunc(clientId)
}

// IsKafkaClientExistCalls gets all the calls that were made to IsKafkaClientExist.
// Check the length with:
//
//	len(mockedOSDKeycloakService.IsKafkaClientExistCalls())
func (mock *OSDKeycloakServiceMock) IsKafkaClientExistCalls() []struct {
	ClientId string
} {
	var calls []struct {
		ClientId string
	}
	mock.lockIsKafkaClientExist.RLock()
	calls = mock.calls.IsKafkaClientExist
	mock.lockIsKafkaClientExist.RUnlock()
	return calls
}

// ListServiceAcc calls ListServiceAccFunc.
func (mock *OSDKeycloakServiceMock) ListServiceAcc(ctx context.Context, first int, max int) ([]api.ServiceAccount, *errors.ServiceError) {
	if mock.ListServiceAccFunc == nil {
		panic("OSDKeycloakServiceMock.ListServiceAccFunc: method is nil but OSDKeycloakService.ListServiceAcc was just called")
	}
	callInfo := struct {
		Ctx   context.Context
		First int
		Max   int
	}{
		Ctx:   ctx,
		First: first,
		Max:   max,
	}
	mock.lockListServiceAcc.Lock()
	mock.calls.ListServiceAcc = append(mock.calls.ListServiceAcc, callInfo)
	mock.lockListServiceAcc.Unlock()
	return mock.ListServiceAccFunc(ctx, first, max)
}

// ListServiceAccCalls gets all the calls that were made to ListServiceAcc.
// Check the length with:
//
//	len(mockedOSDKeycloakService.ListServiceAccCalls())
func (mock *OSDKeycloakServiceMock) ListServiceAccCalls() []struct {
	Ctx   context.Context
	First int
	Max   int
} {
	var calls []struct {
		Ctx   context.Context
		First int
		Max   int
	}
	mock.lockListServiceAcc.RLock()
	calls = mock.calls.ListServiceAcc
	mock.lockListServiceAcc.RUnlock()
	return calls
}

// RegisterClientInSSO calls RegisterClientInSSOFunc.
func (mock *OSDKeycloakServiceMock) RegisterClientInSSO(clusterId string, clusterOathCallbackURI string) (string, *errors.ServiceError) {
	if mock.RegisterClientInSSOFunc == nil {
		panic("OSDKeycloakServiceMock.RegisterClientInSSOFunc: method is nil but OSDKeycloakService.RegisterClientInSSO was just called")
	}
	callInfo := struct {
		ClusterId              string
		ClusterOathCallbackURI string
	}{
		ClusterId:              clusterId,
		ClusterOathCallbackURI: clusterOathCallbackURI,
	}
	mock.lockRegisterClientInSSO.Lock()
	mock.calls.RegisterClientInSSO = append(mock.calls.RegisterClientInSSO, callInfo)
	mock.lockRegisterClientInSSO.Unlock()
	return mock.RegisterClientInSSOFunc(clusterId, clusterOathCallbackURI)
}

// RegisterClientInSSOCalls gets all the calls that were made to RegisterClientInSSO.
// Check the length with:
//
//	len(mockedOSDKeycloakService.RegisterClientInSSOCalls())
func (mock *OSDKeycloakServiceMock) RegisterClientInSSOCalls() []struct {
	ClusterId              string
	ClusterOathCallbackURI string
} {
	var calls []struct {
		ClusterId              string
		ClusterOathCallbackURI string
	}
	mock.lockRegisterClientInSSO.RLock()
	calls = mock.calls.RegisterClientInSSO
	mock.lockRegisterClientInSSO.RUnlock()
	return calls
}

// RegisterConnectorFleetshardOperatorServiceAccount calls RegisterConnectorFleetshardOperatorServiceAccountFunc.
func (mock *OSDKeycloakServiceMock) RegisterConnectorFleetshardOperatorServiceAccount(agentClusterId string) (*api.ServiceAccount, *errors.ServiceError) {
	if mock.RegisterConnectorFleetshardOperatorServiceAccountFunc == nil {
		panic("OSDKeycloakServiceMock.RegisterConnectorFleetshardOperatorServiceAccountFunc: method is nil but OSDKeycloakService.RegisterConnectorFleetshardOperatorServiceAccount was just called")
	}
	callInfo := struct {
		AgentClusterId string
	}{
		AgentClusterId: agentClusterId,
	}
	mock.lockRegisterConnectorFleetshardOperatorServiceAccount.Lock()
	mock.calls.RegisterConnectorFleetshardOperatorServiceAccount = append(mock.calls.RegisterConnectorFleetshardOperatorServiceAccount, callInfo)
	mock.lockRegisterConnectorFleetshardOperatorServiceAccount.Unlock()
	return mock.RegisterConnectorFleetshardOperatorServiceAccountFunc(agentClusterId)
}

// RegisterConnectorFleetshardOperatorServiceAccountCalls gets all the calls that were made to RegisterConnectorFleetshardOperatorServiceAccount.
// Check the length with:
//
//	len(mockedOSDKeycloakService.RegisterConnectorFleetshardOperatorServiceAccountCalls())
func (mock *OSDKeycloakServiceMock) RegisterConnectorFleetshardOperatorServiceAccountCalls() []struct {
	AgentClusterId string
} {
	var calls []struct {
		AgentClusterId string
	}
	mock.lockRegisterConnectorFleetshardOperatorServiceAccount.RLock()
	calls = mock.calls.RegisterConnectorFleetshardOperatorServiceAccount
	mock.lockRegisterConnectorFleetshardOperatorServiceAccount.RUnlock()
	return calls
}

// RegisterKasFleetshardOperatorServiceAccount calls RegisterKasFleetshardOperatorServiceAccountFunc.
func (mock *OSDKeycloakServiceMock) RegisterKasFleetshardOperatorServiceAccount(agentClusterId string) (*api.ServiceAccount, *errors.ServiceError) {
	if mock.RegisterKasFleetshardOperatorServiceAccountFunc == nil {
		panic("OSDKeycloakServiceMock.RegisterKasFleetshardOperatorServiceAccountFunc: method is nil but OSDKeycloakService.RegisterKasFleetshardOperatorServiceAccount was just called")
	}
	callInfo := struct {
		AgentClusterId string
	}{
		AgentClusterId: agentClusterId,
	}
	mock.lockRegisterKasFleetshardOperatorServiceAccount.Lock()
	mock.calls.RegisterKasFleetshardOperatorServiceAccount = append(mock.calls.RegisterKasFleetshardOperatorServiceAccount, callInfo)
	mock.lockRegisterKasFleetshardOperatorServiceAccount.Unlock()
	return mock.RegisterKasFleetshardOperatorServiceAccountFunc(agentClusterId)
}

// RegisterKasFleetshardOperatorServiceAccountCalls gets all the calls that were made to RegisterKasFleetshardOperatorServiceAccount.
// Check the length with:
//
//	len(mockedOSDKeycloakService.RegisterKasFleetshardOperatorServiceAccountCalls())
func (mock *OSDKeycloakServiceMock) RegisterKasFleetshardOperatorServiceAccountCalls() []struct {
	AgentClusterId string
} {
	var calls []struct {
		AgentClusterId string
	}
	mock.lockRegisterKasFleetshardOperatorServiceAccount.RLock()
	calls = mock.calls.RegisterKasFleetshardOperatorServiceAccount
	mock.lockRegisterKasFleetshardOperatorServiceAccount.RUnlock()
	return calls
}

// ResetServiceAccountCredentials calls ResetServiceAccountCredentialsFunc.
func (mock *OSDKeycloakServiceMock) ResetServiceAccountCredentials(ctx context.Context, clientId string) (*api.ServiceAccount, *errors.ServiceError) {
	if mock.ResetServiceAccountCredentialsFunc == nil {
		panic("OSDKeycloakServiceMock.ResetServiceAccountCredentialsFunc: method is nil but OSDKeycloakService.ResetServiceAccountCredentials was just called")
	}
	callInfo := struct {
		Ctx      context.Context
		ClientId string
	}{
		Ctx:      ctx,
		ClientId: clientId,
	}
	mock.lockResetServiceAccountCredentials.Lock()
	mock.calls.ResetServiceAccountCredentials = append(mock.calls.ResetServiceAccountCredentials, callInfo)
	mock.lockResetServiceAccountCredentials.Unlock()
	return mock.ResetServiceAccountCredentialsFunc(ctx, clientId)
}

// ResetServiceAccountCredentialsCalls gets all the calls that were made to ResetServiceAccountCredentials.
// Check the length with:
//
//	len(mockedOSDKeycloakService.ResetServiceAccountCredentialsCalls())
func (mock *OSDKeycloakServiceMock) ResetServiceAccountCredentialsCalls() []struct {
	Ctx      context.Context
	ClientId string
} {
	var calls []struct {
		Ctx      context.Context
		ClientId string
	}
	mock.lockResetServiceAccountCredentials.RLock()
	calls = mock.calls.ResetServiceAccountCredentials
	mock.lockResetServiceAccountCredentials.RUnlock()
	return calls
}