zz_generated_secret_mock.go

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

package fakes

import (
	context "context"
	sync "sync"

	v1 "github.com/rancher/terraform-controller/pkg/generated/controllers/core/v1"
	generic "github.com/rancher/wrangler/pkg/generic"
	v1a "k8s.io/api/core/v1"
	v1b "k8s.io/apimachinery/pkg/apis/meta/v1"
	labels "k8s.io/apimachinery/pkg/labels"
	schema "k8s.io/apimachinery/pkg/runtime/schema"
	types "k8s.io/apimachinery/pkg/types"
	watch "k8s.io/apimachinery/pkg/watch"
	cache "k8s.io/client-go/tools/cache"
)

var (
	lockSecretControllerMockAddGenericHandler       sync.RWMutex
	lockSecretControllerMockAddGenericRemoveHandler sync.RWMutex
	lockSecretControllerMockCache                   sync.RWMutex
	lockSecretControllerMockCreate                  sync.RWMutex
	lockSecretControllerMockDelete                  sync.RWMutex
	lockSecretControllerMockEnqueue                 sync.RWMutex
	lockSecretControllerMockGet                     sync.RWMutex
	lockSecretControllerMockGroupVersionKind        sync.RWMutex
	lockSecretControllerMockInformer                sync.RWMutex
	lockSecretControllerMockList                    sync.RWMutex
	lockSecretControllerMockOnChange                sync.RWMutex
	lockSecretControllerMockOnRemove                sync.RWMutex
	lockSecretControllerMockPatch                   sync.RWMutex
	lockSecretControllerMockUpdate                  sync.RWMutex
	lockSecretControllerMockUpdater                 sync.RWMutex
	lockSecretControllerMockWatch                   sync.RWMutex
)

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

// SecretControllerMock is a mock implementation of SecretController.
//
//     func TestSomethingThatUsesSecretController(t *testing.T) {
//
//         // make and configure a mocked SecretController
//         mockedSecretController := &SecretControllerMock{
//             AddGenericHandlerFunc: func(ctx context.Context, name string, handler generic.Handler)  {
// 	               panic("mock out the AddGenericHandler method")
//             },
//             AddGenericRemoveHandlerFunc: func(ctx context.Context, name string, handler generic.Handler)  {
// 	               panic("mock out the AddGenericRemoveHandler method")
//             },
//             CacheFunc: func() v1.SecretCache {
// 	               panic("mock out the Cache method")
//             },
//             CreateFunc: func(in1 *v1a.Secret) (*v1a.Secret, error) {
// 	               panic("mock out the Create method")
//             },
//             DeleteFunc: func(namespace string, name string, options *v1b.DeleteOptions) error {
// 	               panic("mock out the Delete method")
//             },
//             EnqueueFunc: func(namespace string, name string)  {
// 	               panic("mock out the Enqueue method")
//             },
//             GetFunc: func(namespace string, name string, options v1b.GetOptions) (*v1a.Secret, error) {
// 	               panic("mock out the Get method")
//             },
//             GroupVersionKindFunc: func() schema.GroupVersionKind {
// 	               panic("mock out the GroupVersionKind method")
//             },
//             InformerFunc: func() cache.SharedIndexInformer {
// 	               panic("mock out the Informer method")
//             },
//             ListFunc: func(namespace string, opts v1b.ListOptions) (*v1a.SecretList, error) {
// 	               panic("mock out the List method")
//             },
//             OnChangeFunc: func(ctx context.Context, name string, sync v1.SecretHandler)  {
// 	               panic("mock out the OnChange method")
//             },
//             OnRemoveFunc: func(ctx context.Context, name string, sync v1.SecretHandler)  {
// 	               panic("mock out the OnRemove method")
//             },
//             PatchFunc: func(namespace string, name string, pt types.PatchType, data []byte, subresources ...string) (*v1a.Secret, error) {
// 	               panic("mock out the Patch method")
//             },
//             UpdateFunc: func(in1 *v1a.Secret) (*v1a.Secret, error) {
// 	               panic("mock out the Update method")
//             },
//             UpdaterFunc: func() generic.Updater {
// 	               panic("mock out the Updater method")
//             },
//             WatchFunc: func(namespace string, opts v1b.ListOptions) (watch.Interface, error) {
// 	               panic("mock out the Watch method")
//             },
//         }
//
//         // use mockedSecretController in code that requires SecretController
//         // and then make assertions.
//
//     }
type SecretControllerMock struct {
	// AddGenericHandlerFunc mocks the AddGenericHandler method.
	AddGenericHandlerFunc func(ctx context.Context, name string, handler generic.Handler)

	// AddGenericRemoveHandlerFunc mocks the AddGenericRemoveHandler method.
	AddGenericRemoveHandlerFunc func(ctx context.Context, name string, handler generic.Handler)

	// CacheFunc mocks the Cache method.
	CacheFunc func() v1.SecretCache

	// CreateFunc mocks the Create method.
	CreateFunc func(in1 *v1a.Secret) (*v1a.Secret, error)

	// DeleteFunc mocks the Delete method.
	DeleteFunc func(namespace string, name string, options *v1b.DeleteOptions) error

	// EnqueueFunc mocks the Enqueue method.
	EnqueueFunc func(namespace string, name string)

	// GetFunc mocks the Get method.
	GetFunc func(namespace string, name string, options v1b.GetOptions) (*v1a.Secret, error)

	// GroupVersionKindFunc mocks the GroupVersionKind method.
	GroupVersionKindFunc func() schema.GroupVersionKind

	// InformerFunc mocks the Informer method.
	InformerFunc func() cache.SharedIndexInformer

	// ListFunc mocks the List method.
	ListFunc func(namespace string, opts v1b.ListOptions) (*v1a.SecretList, error)

	// OnChangeFunc mocks the OnChange method.
	OnChangeFunc func(ctx context.Context, name string, sync v1.SecretHandler)

	// OnRemoveFunc mocks the OnRemove method.
	OnRemoveFunc func(ctx context.Context, name string, sync v1.SecretHandler)

	// PatchFunc mocks the Patch method.
	PatchFunc func(namespace string, name string, pt types.PatchType, data []byte, subresources ...string) (*v1a.Secret, error)

	// UpdateFunc mocks the Update method.
	UpdateFunc func(in1 *v1a.Secret) (*v1a.Secret, error)

	// UpdaterFunc mocks the Updater method.
	UpdaterFunc func() generic.Updater

	// WatchFunc mocks the Watch method.
	WatchFunc func(namespace string, opts v1b.ListOptions) (watch.Interface, error)

	// calls tracks calls to the methods.
	calls struct {
		// AddGenericHandler holds details about calls to the AddGenericHandler method.
		AddGenericHandler []struct {
			// Ctx is the ctx argument value.
			Ctx context.Context
			// Name is the name argument value.
			Name string
			// Handler is the handler argument value.
			Handler generic.Handler
		}
		// AddGenericRemoveHandler holds details about calls to the AddGenericRemoveHandler method.
		AddGenericRemoveHandler []struct {
			// Ctx is the ctx argument value.
			Ctx context.Context
			// Name is the name argument value.
			Name string
			// Handler is the handler argument value.
			Handler generic.Handler
		}
		// Cache holds details about calls to the Cache method.
		Cache []struct {
		}
		// Create holds details about calls to the Create method.
		Create []struct {
			// In1 is the in1 argument value.
			In1 *v1a.Secret
		}
		// Delete holds details about calls to the Delete method.
		Delete []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Name is the name argument value.
			Name string
			// Options is the options argument value.
			Options *v1b.DeleteOptions
		}
		// Enqueue holds details about calls to the Enqueue method.
		Enqueue []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Name is the name argument value.
			Name string
		}
		// Get holds details about calls to the Get method.
		Get []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Name is the name argument value.
			Name string
			// Options is the options argument value.
			Options v1b.GetOptions
		}
		// GroupVersionKind holds details about calls to the GroupVersionKind method.
		GroupVersionKind []struct {
		}
		// Informer holds details about calls to the Informer method.
		Informer []struct {
		}
		// List holds details about calls to the List method.
		List []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Opts is the opts argument value.
			Opts v1b.ListOptions
		}
		// OnChange holds details about calls to the OnChange method.
		OnChange []struct {
			// Ctx is the ctx argument value.
			Ctx context.Context
			// Name is the name argument value.
			Name string
			// Sync is the sync argument value.
			Sync v1.SecretHandler
		}
		// OnRemove holds details about calls to the OnRemove method.
		OnRemove []struct {
			// Ctx is the ctx argument value.
			Ctx context.Context
			// Name is the name argument value.
			Name string
			// Sync is the sync argument value.
			Sync v1.SecretHandler
		}
		// Patch holds details about calls to the Patch method.
		Patch []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Name is the name argument value.
			Name string
			// Pt is the pt argument value.
			Pt types.PatchType
			// Data is the data argument value.
			Data []byte
			// Subresources is the subresources argument value.
			Subresources []string
		}
		// Update holds details about calls to the Update method.
		Update []struct {
			// In1 is the in1 argument value.
			In1 *v1a.Secret
		}
		// Updater holds details about calls to the Updater method.
		Updater []struct {
		}
		// Watch holds details about calls to the Watch method.
		Watch []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Opts is the opts argument value.
			Opts v1b.ListOptions
		}
	}
}

// AddGenericHandler calls AddGenericHandlerFunc.
func (mock *SecretControllerMock) AddGenericHandler(ctx context.Context, name string, handler generic.Handler) {
	if mock.AddGenericHandlerFunc == nil {
		panic("SecretControllerMock.AddGenericHandlerFunc: method is nil but SecretController.AddGenericHandler was just called")
	}
	callInfo := struct {
		Ctx     context.Context
		Name    string
		Handler generic.Handler
	}{
		Ctx:     ctx,
		Name:    name,
		Handler: handler,
	}
	lockSecretControllerMockAddGenericHandler.Lock()
	mock.calls.AddGenericHandler = append(mock.calls.AddGenericHandler, callInfo)
	lockSecretControllerMockAddGenericHandler.Unlock()
	mock.AddGenericHandlerFunc(ctx, name, handler)
}

// AddGenericHandlerCalls gets all the calls that were made to AddGenericHandler.
// Check the length with:
//     len(mockedSecretController.AddGenericHandlerCalls())
func (mock *SecretControllerMock) AddGenericHandlerCalls() []struct {
	Ctx     context.Context
	Name    string
	Handler generic.Handler
} {
	var calls []struct {
		Ctx     context.Context
		Name    string
		Handler generic.Handler
	}
	lockSecretControllerMockAddGenericHandler.RLock()
	calls = mock.calls.AddGenericHandler
	lockSecretControllerMockAddGenericHandler.RUnlock()
	return calls
}

// AddGenericRemoveHandler calls AddGenericRemoveHandlerFunc.
func (mock *SecretControllerMock) AddGenericRemoveHandler(ctx context.Context, name string, handler generic.Handler) {
	if mock.AddGenericRemoveHandlerFunc == nil {
		panic("SecretControllerMock.AddGenericRemoveHandlerFunc: method is nil but SecretController.AddGenericRemoveHandler was just called")
	}
	callInfo := struct {
		Ctx     context.Context
		Name    string
		Handler generic.Handler
	}{
		Ctx:     ctx,
		Name:    name,
		Handler: handler,
	}
	lockSecretControllerMockAddGenericRemoveHandler.Lock()
	mock.calls.AddGenericRemoveHandler = append(mock.calls.AddGenericRemoveHandler, callInfo)
	lockSecretControllerMockAddGenericRemoveHandler.Unlock()
	mock.AddGenericRemoveHandlerFunc(ctx, name, handler)
}

// AddGenericRemoveHandlerCalls gets all the calls that were made to AddGenericRemoveHandler.
// Check the length with:
//     len(mockedSecretController.AddGenericRemoveHandlerCalls())
func (mock *SecretControllerMock) AddGenericRemoveHandlerCalls() []struct {
	Ctx     context.Context
	Name    string
	Handler generic.Handler
} {
	var calls []struct {
		Ctx     context.Context
		Name    string
		Handler generic.Handler
	}
	lockSecretControllerMockAddGenericRemoveHandler.RLock()
	calls = mock.calls.AddGenericRemoveHandler
	lockSecretControllerMockAddGenericRemoveHandler.RUnlock()
	return calls
}

// Cache calls CacheFunc.
func (mock *SecretControllerMock) Cache() v1.SecretCache {
	if mock.CacheFunc == nil {
		panic("SecretControllerMock.CacheFunc: method is nil but SecretController.Cache was just called")
	}
	callInfo := struct {
	}{}
	lockSecretControllerMockCache.Lock()
	mock.calls.Cache = append(mock.calls.Cache, callInfo)
	lockSecretControllerMockCache.Unlock()
	return mock.CacheFunc()
}

// CacheCalls gets all the calls that were made to Cache.
// Check the length with:
//     len(mockedSecretController.CacheCalls())
func (mock *SecretControllerMock) CacheCalls() []struct {
} {
	var calls []struct {
	}
	lockSecretControllerMockCache.RLock()
	calls = mock.calls.Cache
	lockSecretControllerMockCache.RUnlock()
	return calls
}

// Create calls CreateFunc.
func (mock *SecretControllerMock) Create(in1 *v1a.Secret) (*v1a.Secret, error) {
	if mock.CreateFunc == nil {
		panic("SecretControllerMock.CreateFunc: method is nil but SecretController.Create was just called")
	}
	callInfo := struct {
		In1 *v1a.Secret
	}{
		In1: in1,
	}
	lockSecretControllerMockCreate.Lock()
	mock.calls.Create = append(mock.calls.Create, callInfo)
	lockSecretControllerMockCreate.Unlock()
	return mock.CreateFunc(in1)
}

// CreateCalls gets all the calls that were made to Create.
// Check the length with:
//     len(mockedSecretController.CreateCalls())
func (mock *SecretControllerMock) CreateCalls() []struct {
	In1 *v1a.Secret
} {
	var calls []struct {
		In1 *v1a.Secret
	}
	lockSecretControllerMockCreate.RLock()
	calls = mock.calls.Create
	lockSecretControllerMockCreate.RUnlock()
	return calls
}

// Delete calls DeleteFunc.
func (mock *SecretControllerMock) Delete(namespace string, name string, options *v1b.DeleteOptions) error {
	if mock.DeleteFunc == nil {
		panic("SecretControllerMock.DeleteFunc: method is nil but SecretController.Delete was just called")
	}
	callInfo := struct {
		Namespace string
		Name      string
		Options   *v1b.DeleteOptions
	}{
		Namespace: namespace,
		Name:      name,
		Options:   options,
	}
	lockSecretControllerMockDelete.Lock()
	mock.calls.Delete = append(mock.calls.Delete, callInfo)
	lockSecretControllerMockDelete.Unlock()
	return mock.DeleteFunc(namespace, name, options)
}

// DeleteCalls gets all the calls that were made to Delete.
// Check the length with:
//     len(mockedSecretController.DeleteCalls())
func (mock *SecretControllerMock) DeleteCalls() []struct {
	Namespace string
	Name      string
	Options   *v1b.DeleteOptions
} {
	var calls []struct {
		Namespace string
		Name      string
		Options   *v1b.DeleteOptions
	}
	lockSecretControllerMockDelete.RLock()
	calls = mock.calls.Delete
	lockSecretControllerMockDelete.RUnlock()
	return calls
}

// Enqueue calls EnqueueFunc.
func (mock *SecretControllerMock) Enqueue(namespace string, name string) {
	if mock.EnqueueFunc == nil {
		panic("SecretControllerMock.EnqueueFunc: method is nil but SecretController.Enqueue was just called")
	}
	callInfo := struct {
		Namespace string
		Name      string
	}{
		Namespace: namespace,
		Name:      name,
	}
	lockSecretControllerMockEnqueue.Lock()
	mock.calls.Enqueue = append(mock.calls.Enqueue, callInfo)
	lockSecretControllerMockEnqueue.Unlock()
	mock.EnqueueFunc(namespace, name)
}

// EnqueueCalls gets all the calls that were made to Enqueue.
// Check the length with:
//     len(mockedSecretController.EnqueueCalls())
func (mock *SecretControllerMock) EnqueueCalls() []struct {
	Namespace string
	Name      string
} {
	var calls []struct {
		Namespace string
		Name      string
	}
	lockSecretControllerMockEnqueue.RLock()
	calls = mock.calls.Enqueue
	lockSecretControllerMockEnqueue.RUnlock()
	return calls
}

// Get calls GetFunc.
func (mock *SecretControllerMock) Get(namespace string, name string, options v1b.GetOptions) (*v1a.Secret, error) {
	if mock.GetFunc == nil {
		panic("SecretControllerMock.GetFunc: method is nil but SecretController.Get was just called")
	}
	callInfo := struct {
		Namespace string
		Name      string
		Options   v1b.GetOptions
	}{
		Namespace: namespace,
		Name:      name,
		Options:   options,
	}
	lockSecretControllerMockGet.Lock()
	mock.calls.Get = append(mock.calls.Get, callInfo)
	lockSecretControllerMockGet.Unlock()
	return mock.GetFunc(namespace, name, options)
}

// GetCalls gets all the calls that were made to Get.
// Check the length with:
//     len(mockedSecretController.GetCalls())
func (mock *SecretControllerMock) GetCalls() []struct {
	Namespace string
	Name      string
	Options   v1b.GetOptions
} {
	var calls []struct {
		Namespace string
		Name      string
		Options   v1b.GetOptions
	}
	lockSecretControllerMockGet.RLock()
	calls = mock.calls.Get
	lockSecretControllerMockGet.RUnlock()
	return calls
}

// GroupVersionKind calls GroupVersionKindFunc.
func (mock *SecretControllerMock) GroupVersionKind() schema.GroupVersionKind {
	if mock.GroupVersionKindFunc == nil {
		panic("SecretControllerMock.GroupVersionKindFunc: method is nil but SecretController.GroupVersionKind was just called")
	}
	callInfo := struct {
	}{}
	lockSecretControllerMockGroupVersionKind.Lock()
	mock.calls.GroupVersionKind = append(mock.calls.GroupVersionKind, callInfo)
	lockSecretControllerMockGroupVersionKind.Unlock()
	return mock.GroupVersionKindFunc()
}

// GroupVersionKindCalls gets all the calls that were made to GroupVersionKind.
// Check the length with:
//     len(mockedSecretController.GroupVersionKindCalls())
func (mock *SecretControllerMock) GroupVersionKindCalls() []struct {
} {
	var calls []struct {
	}
	lockSecretControllerMockGroupVersionKind.RLock()
	calls = mock.calls.GroupVersionKind
	lockSecretControllerMockGroupVersionKind.RUnlock()
	return calls
}

// Informer calls InformerFunc.
func (mock *SecretControllerMock) Informer() cache.SharedIndexInformer {
	if mock.InformerFunc == nil {
		panic("SecretControllerMock.InformerFunc: method is nil but SecretController.Informer was just called")
	}
	callInfo := struct {
	}{}
	lockSecretControllerMockInformer.Lock()
	mock.calls.Informer = append(mock.calls.Informer, callInfo)
	lockSecretControllerMockInformer.Unlock()
	return mock.InformerFunc()
}

// InformerCalls gets all the calls that were made to Informer.
// Check the length with:
//     len(mockedSecretController.InformerCalls())
func (mock *SecretControllerMock) InformerCalls() []struct {
} {
	var calls []struct {
	}
	lockSecretControllerMockInformer.RLock()
	calls = mock.calls.Informer
	lockSecretControllerMockInformer.RUnlock()
	return calls
}

// List calls ListFunc.
func (mock *SecretControllerMock) List(namespace string, opts v1b.ListOptions) (*v1a.SecretList, error) {
	if mock.ListFunc == nil {
		panic("SecretControllerMock.ListFunc: method is nil but SecretController.List was just called")
	}
	callInfo := struct {
		Namespace string
		Opts      v1b.ListOptions
	}{
		Namespace: namespace,
		Opts:      opts,
	}
	lockSecretControllerMockList.Lock()
	mock.calls.List = append(mock.calls.List, callInfo)
	lockSecretControllerMockList.Unlock()
	return mock.ListFunc(namespace, opts)
}

// ListCalls gets all the calls that were made to List.
// Check the length with:
//     len(mockedSecretController.ListCalls())
func (mock *SecretControllerMock) ListCalls() []struct {
	Namespace string
	Opts      v1b.ListOptions
} {
	var calls []struct {
		Namespace string
		Opts      v1b.ListOptions
	}
	lockSecretControllerMockList.RLock()
	calls = mock.calls.List
	lockSecretControllerMockList.RUnlock()
	return calls
}

// OnChange calls OnChangeFunc.
func (mock *SecretControllerMock) OnChange(ctx context.Context, name string, sync v1.SecretHandler) {
	if mock.OnChangeFunc == nil {
		panic("SecretControllerMock.OnChangeFunc: method is nil but SecretController.OnChange was just called")
	}
	callInfo := struct {
		Ctx  context.Context
		Name string
		Sync v1.SecretHandler
	}{
		Ctx:  ctx,
		Name: name,
		Sync: sync,
	}
	lockSecretControllerMockOnChange.Lock()
	mock.calls.OnChange = append(mock.calls.OnChange, callInfo)
	lockSecretControllerMockOnChange.Unlock()
	mock.OnChangeFunc(ctx, name, sync)
}

// OnChangeCalls gets all the calls that were made to OnChange.
// Check the length with:
//     len(mockedSecretController.OnChangeCalls())
func (mock *SecretControllerMock) OnChangeCalls() []struct {
	Ctx  context.Context
	Name string
	Sync v1.SecretHandler
} {
	var calls []struct {
		Ctx  context.Context
		Name string
		Sync v1.SecretHandler
	}
	lockSecretControllerMockOnChange.RLock()
	calls = mock.calls.OnChange
	lockSecretControllerMockOnChange.RUnlock()
	return calls
}

// OnRemove calls OnRemoveFunc.
func (mock *SecretControllerMock) OnRemove(ctx context.Context, name string, sync v1.SecretHandler) {
	if mock.OnRemoveFunc == nil {
		panic("SecretControllerMock.OnRemoveFunc: method is nil but SecretController.OnRemove was just called")
	}
	callInfo := struct {
		Ctx  context.Context
		Name string
		Sync v1.SecretHandler
	}{
		Ctx:  ctx,
		Name: name,
		Sync: sync,
	}
	lockSecretControllerMockOnRemove.Lock()
	mock.calls.OnRemove = append(mock.calls.OnRemove, callInfo)
	lockSecretControllerMockOnRemove.Unlock()
	mock.OnRemoveFunc(ctx, name, sync)
}

// OnRemoveCalls gets all the calls that were made to OnRemove.
// Check the length with:
//     len(mockedSecretController.OnRemoveCalls())
func (mock *SecretControllerMock) OnRemoveCalls() []struct {
	Ctx  context.Context
	Name string
	Sync v1.SecretHandler
} {
	var calls []struct {
		Ctx  context.Context
		Name string
		Sync v1.SecretHandler
	}
	lockSecretControllerMockOnRemove.RLock()
	calls = mock.calls.OnRemove
	lockSecretControllerMockOnRemove.RUnlock()
	return calls
}

// Patch calls PatchFunc.
func (mock *SecretControllerMock) Patch(namespace string, name string, pt types.PatchType, data []byte, subresources ...string) (*v1a.Secret, error) {
	if mock.PatchFunc == nil {
		panic("SecretControllerMock.PatchFunc: method is nil but SecretController.Patch was just called")
	}
	callInfo := struct {
		Namespace    string
		Name         string
		Pt           types.PatchType
		Data         []byte
		Subresources []string
	}{
		Namespace:    namespace,
		Name:         name,
		Pt:           pt,
		Data:         data,
		Subresources: subresources,
	}
	lockSecretControllerMockPatch.Lock()
	mock.calls.Patch = append(mock.calls.Patch, callInfo)
	lockSecretControllerMockPatch.Unlock()
	return mock.PatchFunc(namespace, name, pt, data, subresources...)
}

// PatchCalls gets all the calls that were made to Patch.
// Check the length with:
//     len(mockedSecretController.PatchCalls())
func (mock *SecretControllerMock) PatchCalls() []struct {
	Namespace    string
	Name         string
	Pt           types.PatchType
	Data         []byte
	Subresources []string
} {
	var calls []struct {
		Namespace    string
		Name         string
		Pt           types.PatchType
		Data         []byte
		Subresources []string
	}
	lockSecretControllerMockPatch.RLock()
	calls = mock.calls.Patch
	lockSecretControllerMockPatch.RUnlock()
	return calls
}

// Update calls UpdateFunc.
func (mock *SecretControllerMock) Update(in1 *v1a.Secret) (*v1a.Secret, error) {
	if mock.UpdateFunc == nil {
		panic("SecretControllerMock.UpdateFunc: method is nil but SecretController.Update was just called")
	}
	callInfo := struct {
		In1 *v1a.Secret
	}{
		In1: in1,
	}
	lockSecretControllerMockUpdate.Lock()
	mock.calls.Update = append(mock.calls.Update, callInfo)
	lockSecretControllerMockUpdate.Unlock()
	return mock.UpdateFunc(in1)
}

// UpdateCalls gets all the calls that were made to Update.
// Check the length with:
//     len(mockedSecretController.UpdateCalls())
func (mock *SecretControllerMock) UpdateCalls() []struct {
	In1 *v1a.Secret
} {
	var calls []struct {
		In1 *v1a.Secret
	}
	lockSecretControllerMockUpdate.RLock()
	calls = mock.calls.Update
	lockSecretControllerMockUpdate.RUnlock()
	return calls
}

// Updater calls UpdaterFunc.
func (mock *SecretControllerMock) Updater() generic.Updater {
	if mock.UpdaterFunc == nil {
		panic("SecretControllerMock.UpdaterFunc: method is nil but SecretController.Updater was just called")
	}
	callInfo := struct {
	}{}
	lockSecretControllerMockUpdater.Lock()
	mock.calls.Updater = append(mock.calls.Updater, callInfo)
	lockSecretControllerMockUpdater.Unlock()
	return mock.UpdaterFunc()
}

// UpdaterCalls gets all the calls that were made to Updater.
// Check the length with:
//     len(mockedSecretController.UpdaterCalls())
func (mock *SecretControllerMock) UpdaterCalls() []struct {
} {
	var calls []struct {
	}
	lockSecretControllerMockUpdater.RLock()
	calls = mock.calls.Updater
	lockSecretControllerMockUpdater.RUnlock()
	return calls
}

// Watch calls WatchFunc.
func (mock *SecretControllerMock) Watch(namespace string, opts v1b.ListOptions) (watch.Interface, error) {
	if mock.WatchFunc == nil {
		panic("SecretControllerMock.WatchFunc: method is nil but SecretController.Watch was just called")
	}
	callInfo := struct {
		Namespace string
		Opts      v1b.ListOptions
	}{
		Namespace: namespace,
		Opts:      opts,
	}
	lockSecretControllerMockWatch.Lock()
	mock.calls.Watch = append(mock.calls.Watch, callInfo)
	lockSecretControllerMockWatch.Unlock()
	return mock.WatchFunc(namespace, opts)
}

// WatchCalls gets all the calls that were made to Watch.
// Check the length with:
//     len(mockedSecretController.WatchCalls())
func (mock *SecretControllerMock) WatchCalls() []struct {
	Namespace string
	Opts      v1b.ListOptions
} {
	var calls []struct {
		Namespace string
		Opts      v1b.ListOptions
	}
	lockSecretControllerMockWatch.RLock()
	calls = mock.calls.Watch
	lockSecretControllerMockWatch.RUnlock()
	return calls
}

var (
	lockSecretClientMockCreate sync.RWMutex
	lockSecretClientMockDelete sync.RWMutex
	lockSecretClientMockGet    sync.RWMutex
	lockSecretClientMockList   sync.RWMutex
	lockSecretClientMockPatch  sync.RWMutex
	lockSecretClientMockUpdate sync.RWMutex
	lockSecretClientMockWatch  sync.RWMutex
)

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

// SecretClientMock is a mock implementation of SecretClient.
//
//     func TestSomethingThatUsesSecretClient(t *testing.T) {
//
//         // make and configure a mocked SecretClient
//         mockedSecretClient := &SecretClientMock{
//             CreateFunc: func(in1 *v1a.Secret) (*v1a.Secret, error) {
// 	               panic("mock out the Create method")
//             },
//             DeleteFunc: func(namespace string, name string, options *v1b.DeleteOptions) error {
// 	               panic("mock out the Delete method")
//             },
//             GetFunc: func(namespace string, name string, options v1b.GetOptions) (*v1a.Secret, error) {
// 	               panic("mock out the Get method")
//             },
//             ListFunc: func(namespace string, opts v1b.ListOptions) (*v1a.SecretList, error) {
// 	               panic("mock out the List method")
//             },
//             PatchFunc: func(namespace string, name string, pt types.PatchType, data []byte, subresources ...string) (*v1a.Secret, error) {
// 	               panic("mock out the Patch method")
//             },
//             UpdateFunc: func(in1 *v1a.Secret) (*v1a.Secret, error) {
// 	               panic("mock out the Update method")
//             },
//             WatchFunc: func(namespace string, opts v1b.ListOptions) (watch.Interface, error) {
// 	               panic("mock out the Watch method")
//             },
//         }
//
//         // use mockedSecretClient in code that requires SecretClient
//         // and then make assertions.
//
//     }
type SecretClientMock struct {
	// CreateFunc mocks the Create method.
	CreateFunc func(in1 *v1a.Secret) (*v1a.Secret, error)

	// DeleteFunc mocks the Delete method.
	DeleteFunc func(namespace string, name string, options *v1b.DeleteOptions) error

	// GetFunc mocks the Get method.
	GetFunc func(namespace string, name string, options v1b.GetOptions) (*v1a.Secret, error)

	// ListFunc mocks the List method.
	ListFunc func(namespace string, opts v1b.ListOptions) (*v1a.SecretList, error)

	// PatchFunc mocks the Patch method.
	PatchFunc func(namespace string, name string, pt types.PatchType, data []byte, subresources ...string) (*v1a.Secret, error)

	// UpdateFunc mocks the Update method.
	UpdateFunc func(in1 *v1a.Secret) (*v1a.Secret, error)

	// WatchFunc mocks the Watch method.
	WatchFunc func(namespace string, opts v1b.ListOptions) (watch.Interface, error)

	// calls tracks calls to the methods.
	calls struct {
		// Create holds details about calls to the Create method.
		Create []struct {
			// In1 is the in1 argument value.
			In1 *v1a.Secret
		}
		// Delete holds details about calls to the Delete method.
		Delete []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Name is the name argument value.
			Name string
			// Options is the options argument value.
			Options *v1b.DeleteOptions
		}
		// Get holds details about calls to the Get method.
		Get []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Name is the name argument value.
			Name string
			// Options is the options argument value.
			Options v1b.GetOptions
		}
		// List holds details about calls to the List method.
		List []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Opts is the opts argument value.
			Opts v1b.ListOptions
		}
		// Patch holds details about calls to the Patch method.
		Patch []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Name is the name argument value.
			Name string
			// Pt is the pt argument value.
			Pt types.PatchType
			// Data is the data argument value.
			Data []byte
			// Subresources is the subresources argument value.
			Subresources []string
		}
		// Update holds details about calls to the Update method.
		Update []struct {
			// In1 is the in1 argument value.
			In1 *v1a.Secret
		}
		// Watch holds details about calls to the Watch method.
		Watch []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Opts is the opts argument value.
			Opts v1b.ListOptions
		}
	}
}

// Create calls CreateFunc.
func (mock *SecretClientMock) Create(in1 *v1a.Secret) (*v1a.Secret, error) {
	if mock.CreateFunc == nil {
		panic("SecretClientMock.CreateFunc: method is nil but SecretClient.Create was just called")
	}
	callInfo := struct {
		In1 *v1a.Secret
	}{
		In1: in1,
	}
	lockSecretClientMockCreate.Lock()
	mock.calls.Create = append(mock.calls.Create, callInfo)
	lockSecretClientMockCreate.Unlock()
	return mock.CreateFunc(in1)
}

// CreateCalls gets all the calls that were made to Create.
// Check the length with:
//     len(mockedSecretClient.CreateCalls())
func (mock *SecretClientMock) CreateCalls() []struct {
	In1 *v1a.Secret
} {
	var calls []struct {
		In1 *v1a.Secret
	}
	lockSecretClientMockCreate.RLock()
	calls = mock.calls.Create
	lockSecretClientMockCreate.RUnlock()
	return calls
}

// Delete calls DeleteFunc.
func (mock *SecretClientMock) Delete(namespace string, name string, options *v1b.DeleteOptions) error {
	if mock.DeleteFunc == nil {
		panic("SecretClientMock.DeleteFunc: method is nil but SecretClient.Delete was just called")
	}
	callInfo := struct {
		Namespace string
		Name      string
		Options   *v1b.DeleteOptions
	}{
		Namespace: namespace,
		Name:      name,
		Options:   options,
	}
	lockSecretClientMockDelete.Lock()
	mock.calls.Delete = append(mock.calls.Delete, callInfo)
	lockSecretClientMockDelete.Unlock()
	return mock.DeleteFunc(namespace, name, options)
}

// DeleteCalls gets all the calls that were made to Delete.
// Check the length with:
//     len(mockedSecretClient.DeleteCalls())
func (mock *SecretClientMock) DeleteCalls() []struct {
	Namespace string
	Name      string
	Options   *v1b.DeleteOptions
} {
	var calls []struct {
		Namespace string
		Name      string
		Options   *v1b.DeleteOptions
	}
	lockSecretClientMockDelete.RLock()
	calls = mock.calls.Delete
	lockSecretClientMockDelete.RUnlock()
	return calls
}

// Get calls GetFunc.
func (mock *SecretClientMock) Get(namespace string, name string, options v1b.GetOptions) (*v1a.Secret, error) {
	if mock.GetFunc == nil {
		panic("SecretClientMock.GetFunc: method is nil but SecretClient.Get was just called")
	}
	callInfo := struct {
		Namespace string
		Name      string
		Options   v1b.GetOptions
	}{
		Namespace: namespace,
		Name:      name,
		Options:   options,
	}
	lockSecretClientMockGet.Lock()
	mock.calls.Get = append(mock.calls.Get, callInfo)
	lockSecretClientMockGet.Unlock()
	return mock.GetFunc(namespace, name, options)
}

// GetCalls gets all the calls that were made to Get.
// Check the length with:
//     len(mockedSecretClient.GetCalls())
func (mock *SecretClientMock) GetCalls() []struct {
	Namespace string
	Name      string
	Options   v1b.GetOptions
} {
	var calls []struct {
		Namespace string
		Name      string
		Options   v1b.GetOptions
	}
	lockSecretClientMockGet.RLock()
	calls = mock.calls.Get
	lockSecretClientMockGet.RUnlock()
	return calls
}

// List calls ListFunc.
func (mock *SecretClientMock) List(namespace string, opts v1b.ListOptions) (*v1a.SecretList, error) {
	if mock.ListFunc == nil {
		panic("SecretClientMock.ListFunc: method is nil but SecretClient.List was just called")
	}
	callInfo := struct {
		Namespace string
		Opts      v1b.ListOptions
	}{
		Namespace: namespace,
		Opts:      opts,
	}
	lockSecretClientMockList.Lock()
	mock.calls.List = append(mock.calls.List, callInfo)
	lockSecretClientMockList.Unlock()
	return mock.ListFunc(namespace, opts)
}

// ListCalls gets all the calls that were made to List.
// Check the length with:
//     len(mockedSecretClient.ListCalls())
func (mock *SecretClientMock) ListCalls() []struct {
	Namespace string
	Opts      v1b.ListOptions
} {
	var calls []struct {
		Namespace string
		Opts      v1b.ListOptions
	}
	lockSecretClientMockList.RLock()
	calls = mock.calls.List
	lockSecretClientMockList.RUnlock()
	return calls
}

// Patch calls PatchFunc.
func (mock *SecretClientMock) Patch(namespace string, name string, pt types.PatchType, data []byte, subresources ...string) (*v1a.Secret, error) {
	if mock.PatchFunc == nil {
		panic("SecretClientMock.PatchFunc: method is nil but SecretClient.Patch was just called")
	}
	callInfo := struct {
		Namespace    string
		Name         string
		Pt           types.PatchType
		Data         []byte
		Subresources []string
	}{
		Namespace:    namespace,
		Name:         name,
		Pt:           pt,
		Data:         data,
		Subresources: subresources,
	}
	lockSecretClientMockPatch.Lock()
	mock.calls.Patch = append(mock.calls.Patch, callInfo)
	lockSecretClientMockPatch.Unlock()
	return mock.PatchFunc(namespace, name, pt, data, subresources...)
}

// PatchCalls gets all the calls that were made to Patch.
// Check the length with:
//     len(mockedSecretClient.PatchCalls())
func (mock *SecretClientMock) PatchCalls() []struct {
	Namespace    string
	Name         string
	Pt           types.PatchType
	Data         []byte
	Subresources []string
} {
	var calls []struct {
		Namespace    string
		Name         string
		Pt           types.PatchType
		Data         []byte
		Subresources []string
	}
	lockSecretClientMockPatch.RLock()
	calls = mock.calls.Patch
	lockSecretClientMockPatch.RUnlock()
	return calls
}

// Update calls UpdateFunc.
func (mock *SecretClientMock) Update(in1 *v1a.Secret) (*v1a.Secret, error) {
	if mock.UpdateFunc == nil {
		panic("SecretClientMock.UpdateFunc: method is nil but SecretClient.Update was just called")
	}
	callInfo := struct {
		In1 *v1a.Secret
	}{
		In1: in1,
	}
	lockSecretClientMockUpdate.Lock()
	mock.calls.Update = append(mock.calls.Update, callInfo)
	lockSecretClientMockUpdate.Unlock()
	return mock.UpdateFunc(in1)
}

// UpdateCalls gets all the calls that were made to Update.
// Check the length with:
//     len(mockedSecretClient.UpdateCalls())
func (mock *SecretClientMock) UpdateCalls() []struct {
	In1 *v1a.Secret
} {
	var calls []struct {
		In1 *v1a.Secret
	}
	lockSecretClientMockUpdate.RLock()
	calls = mock.calls.Update
	lockSecretClientMockUpdate.RUnlock()
	return calls
}

// Watch calls WatchFunc.
func (mock *SecretClientMock) Watch(namespace string, opts v1b.ListOptions) (watch.Interface, error) {
	if mock.WatchFunc == nil {
		panic("SecretClientMock.WatchFunc: method is nil but SecretClient.Watch was just called")
	}
	callInfo := struct {
		Namespace string
		Opts      v1b.ListOptions
	}{
		Namespace: namespace,
		Opts:      opts,
	}
	lockSecretClientMockWatch.Lock()
	mock.calls.Watch = append(mock.calls.Watch, callInfo)
	lockSecretClientMockWatch.Unlock()
	return mock.WatchFunc(namespace, opts)
}

// WatchCalls gets all the calls that were made to Watch.
// Check the length with:
//     len(mockedSecretClient.WatchCalls())
func (mock *SecretClientMock) WatchCalls() []struct {
	Namespace string
	Opts      v1b.ListOptions
} {
	var calls []struct {
		Namespace string
		Opts      v1b.ListOptions
	}
	lockSecretClientMockWatch.RLock()
	calls = mock.calls.Watch
	lockSecretClientMockWatch.RUnlock()
	return calls
}

var (
	lockSecretCacheMockAddIndexer sync.RWMutex
	lockSecretCacheMockGet        sync.RWMutex
	lockSecretCacheMockGetByIndex sync.RWMutex
	lockSecretCacheMockList       sync.RWMutex
)

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

// SecretCacheMock is a mock implementation of SecretCache.
//
//     func TestSomethingThatUsesSecretCache(t *testing.T) {
//
//         // make and configure a mocked SecretCache
//         mockedSecretCache := &SecretCacheMock{
//             AddIndexerFunc: func(indexName string, indexer v1.SecretIndexer)  {
// 	               panic("mock out the AddIndexer method")
//             },
//             GetFunc: func(namespace string, name string) (*v1a.Secret, error) {
// 	               panic("mock out the Get method")
//             },
//             GetByIndexFunc: func(indexName string, key string) ([]*v1a.Secret, error) {
// 	               panic("mock out the GetByIndex method")
//             },
//             ListFunc: func(namespace string, selector labels.Selector) ([]*v1a.Secret, error) {
// 	               panic("mock out the List method")
//             },
//         }
//
//         // use mockedSecretCache in code that requires SecretCache
//         // and then make assertions.
//
//     }
type SecretCacheMock struct {
	// AddIndexerFunc mocks the AddIndexer method.
	AddIndexerFunc func(indexName string, indexer v1.SecretIndexer)

	// GetFunc mocks the Get method.
	GetFunc func(namespace string, name string) (*v1a.Secret, error)

	// GetByIndexFunc mocks the GetByIndex method.
	GetByIndexFunc func(indexName string, key string) ([]*v1a.Secret, error)

	// ListFunc mocks the List method.
	ListFunc func(namespace string, selector labels.Selector) ([]*v1a.Secret, error)

	// calls tracks calls to the methods.
	calls struct {
		// AddIndexer holds details about calls to the AddIndexer method.
		AddIndexer []struct {
			// IndexName is the indexName argument value.
			IndexName string
			// Indexer is the indexer argument value.
			Indexer v1.SecretIndexer
		}
		// Get holds details about calls to the Get method.
		Get []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Name is the name argument value.
			Name string
		}
		// GetByIndex holds details about calls to the GetByIndex method.
		GetByIndex []struct {
			// IndexName is the indexName argument value.
			IndexName string
			// Key is the key argument value.
			Key string
		}
		// List holds details about calls to the List method.
		List []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Selector is the selector argument value.
			Selector labels.Selector
		}
	}
}

// AddIndexer calls AddIndexerFunc.
func (mock *SecretCacheMock) AddIndexer(indexName string, indexer v1.SecretIndexer) {
	if mock.AddIndexerFunc == nil {
		panic("SecretCacheMock.AddIndexerFunc: method is nil but SecretCache.AddIndexer was just called")
	}
	callInfo := struct {
		IndexName string
		Indexer   v1.SecretIndexer
	}{
		IndexName: indexName,
		Indexer:   indexer,
	}
	lockSecretCacheMockAddIndexer.Lock()
	mock.calls.AddIndexer = append(mock.calls.AddIndexer, callInfo)
	lockSecretCacheMockAddIndexer.Unlock()
	mock.AddIndexerFunc(indexName, indexer)
}

// AddIndexerCalls gets all the calls that were made to AddIndexer.
// Check the length with:
//     len(mockedSecretCache.AddIndexerCalls())
func (mock *SecretCacheMock) AddIndexerCalls() []struct {
	IndexName string
	Indexer   v1.SecretIndexer
} {
	var calls []struct {
		IndexName string
		Indexer   v1.SecretIndexer
	}
	lockSecretCacheMockAddIndexer.RLock()
	calls = mock.calls.AddIndexer
	lockSecretCacheMockAddIndexer.RUnlock()
	return calls
}

// Get calls GetFunc.
func (mock *SecretCacheMock) Get(namespace string, name string) (*v1a.Secret, error) {
	if mock.GetFunc == nil {
		panic("SecretCacheMock.GetFunc: method is nil but SecretCache.Get was just called")
	}
	callInfo := struct {
		Namespace string
		Name      string
	}{
		Namespace: namespace,
		Name:      name,
	}
	lockSecretCacheMockGet.Lock()
	mock.calls.Get = append(mock.calls.Get, callInfo)
	lockSecretCacheMockGet.Unlock()
	return mock.GetFunc(namespace, name)
}

// GetCalls gets all the calls that were made to Get.
// Check the length with:
//     len(mockedSecretCache.GetCalls())
func (mock *SecretCacheMock) GetCalls() []struct {
	Namespace string
	Name      string
} {
	var calls []struct {
		Namespace string
		Name      string
	}
	lockSecretCacheMockGet.RLock()
	calls = mock.calls.Get
	lockSecretCacheMockGet.RUnlock()
	return calls
}

// GetByIndex calls GetByIndexFunc.
func (mock *SecretCacheMock) GetByIndex(indexName string, key string) ([]*v1a.Secret, error) {
	if mock.GetByIndexFunc == nil {
		panic("SecretCacheMock.GetByIndexFunc: method is nil but SecretCache.GetByIndex was just called")
	}
	callInfo := struct {
		IndexName string
		Key       string
	}{
		IndexName: indexName,
		Key:       key,
	}
	lockSecretCacheMockGetByIndex.Lock()
	mock.calls.GetByIndex = append(mock.calls.GetByIndex, callInfo)
	lockSecretCacheMockGetByIndex.Unlock()
	return mock.GetByIndexFunc(indexName, key)
}

// GetByIndexCalls gets all the calls that were made to GetByIndex.
// Check the length with:
//     len(mockedSecretCache.GetByIndexCalls())
func (mock *SecretCacheMock) GetByIndexCalls() []struct {
	IndexName string
	Key       string
} {
	var calls []struct {
		IndexName string
		Key       string
	}
	lockSecretCacheMockGetByIndex.RLock()
	calls = mock.calls.GetByIndex
	lockSecretCacheMockGetByIndex.RUnlock()
	return calls
}

// List calls ListFunc.
func (mock *SecretCacheMock) List(namespace string, selector labels.Selector) ([]*v1a.Secret, error) {
	if mock.ListFunc == nil {
		panic("SecretCacheMock.ListFunc: method is nil but SecretCache.List was just called")
	}
	callInfo := struct {
		Namespace string
		Selector  labels.Selector
	}{
		Namespace: namespace,
		Selector:  selector,
	}
	lockSecretCacheMockList.Lock()
	mock.calls.List = append(mock.calls.List, callInfo)
	lockSecretCacheMockList.Unlock()
	return mock.ListFunc(namespace, selector)
}

// ListCalls gets all the calls that were made to List.
// Check the length with:
//     len(mockedSecretCache.ListCalls())
func (mock *SecretCacheMock) ListCalls() []struct {
	Namespace string
	Selector  labels.Selector
} {
	var calls []struct {
		Namespace string
		Selector  labels.Selector
	}
	lockSecretCacheMockList.RLock()
	calls = mock.calls.List
	lockSecretCacheMockList.RUnlock()
	return calls
}