WIP: Refactor PushSecret Controller tests to use Kubebuilder

Signed-off-by: Gustavo Carvalho <gustavo.carvalho@container-solutions.com>
Co-authored-by: Nick Ruffles <nick.ruffles@engineerbetter.com>
Co-authored-by: Marcus Dantas <marcus.dantas@engineerbetter.com>

pkg/controllers/pushsecret/internal/fakes/client.go

@@ -1,784 +0,0 @@
-// Code generated by counterfeiter. DO NOT EDIT.
-package fakes
-
-import (
-	"context"
-	"sync"
-
-	"k8s.io/apimachinery/pkg/api/meta"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/types"
-	"sigs.k8s.io/controller-runtime/pkg/client"
-)
-
-type Client struct {
-	CreateStub        func(context.Context, client.Object, ...client.CreateOption) error
-	createMutex       sync.RWMutex
-	createArgsForCall []struct {
-		arg1 context.Context
-		arg2 client.Object
-		arg3 []client.CreateOption
-	}
-	createReturns struct {
-		result1 error
-	}
-	createReturnsOnCall map[int]struct {
-		result1 error
-	}
-	DeleteStub        func(context.Context, client.Object, ...client.DeleteOption) error
-	deleteMutex       sync.RWMutex
-	deleteArgsForCall []struct {
-		arg1 context.Context
-		arg2 client.Object
-		arg3 []client.DeleteOption
-	}
-	deleteReturns struct {
-		result1 error
-	}
-	deleteReturnsOnCall map[int]struct {
-		result1 error
-	}
-	DeleteAllOfStub        func(context.Context, client.Object, ...client.DeleteAllOfOption) error
-	deleteAllOfMutex       sync.RWMutex
-	deleteAllOfArgsForCall []struct {
-		arg1 context.Context
-		arg2 client.Object
-		arg3 []client.DeleteAllOfOption
-	}
-	deleteAllOfReturns struct {
-		result1 error
-	}
-	deleteAllOfReturnsOnCall map[int]struct {
-		result1 error
-	}
-	GetStub        func(context.Context, types.NamespacedName, client.Object) error
-	getMutex       sync.RWMutex
-	getArgsForCall []struct {
-		arg1 context.Context
-		arg2 types.NamespacedName
-		arg3 client.Object
-	}
-	getReturns struct {
-		result1 error
-	}
-	getReturnsOnCall map[int]struct {
-		result1 error
-	}
-	ListStub        func(context.Context, client.ObjectList, ...client.ListOption) error
-	listMutex       sync.RWMutex
-	listArgsForCall []struct {
-		arg1 context.Context
-		arg2 client.ObjectList
-		arg3 []client.ListOption
-	}
-	listReturns struct {
-		result1 error
-	}
-	listReturnsOnCall map[int]struct {
-		result1 error
-	}
-	PatchStub        func(context.Context, client.Object, client.Patch, ...client.PatchOption) error
-	patchMutex       sync.RWMutex
-	patchArgsForCall []struct {
-		arg1 context.Context
-		arg2 client.Object
-		arg3 client.Patch
-		arg4 []client.PatchOption
-	}
-	patchReturns struct {
-		result1 error
-	}
-	patchReturnsOnCall map[int]struct {
-		result1 error
-	}
-	RESTMapperStub        func() meta.RESTMapper
-	rESTMapperMutex       sync.RWMutex
-	rESTMapperArgsForCall []struct {
-	}
-	rESTMapperReturns struct {
-		result1 meta.RESTMapper
-	}
-	rESTMapperReturnsOnCall map[int]struct {
-		result1 meta.RESTMapper
-	}
-	SchemeStub        func() *runtime.Scheme
-	schemeMutex       sync.RWMutex
-	schemeArgsForCall []struct {
-	}
-	schemeReturns struct {
-		result1 *runtime.Scheme
-	}
-	schemeReturnsOnCall map[int]struct {
-		result1 *runtime.Scheme
-	}
-	StatusStub        func() client.StatusWriter
-	statusMutex       sync.RWMutex
-	statusArgsForCall []struct {
-	}
-	statusReturns struct {
-		result1 client.StatusWriter
-	}
-	statusReturnsOnCall map[int]struct {
-		result1 client.StatusWriter
-	}
-	UpdateStub        func(context.Context, client.Object, ...client.UpdateOption) error
-	updateMutex       sync.RWMutex
-	updateArgsForCall []struct {
-		arg1 context.Context
-		arg2 client.Object
-		arg3 []client.UpdateOption
-	}
-	updateReturns struct {
-		result1 error
-	}
-	updateReturnsOnCall map[int]struct {
-		result1 error
-	}
-	invocations      map[string][][]interface{}
-	invocationsMutex sync.RWMutex
-}
-
-func (fake *Client) Create(arg1 context.Context, arg2 client.Object, arg3 ...client.CreateOption) error {
-	fake.createMutex.Lock()
-	ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)]
-	fake.createArgsForCall = append(fake.createArgsForCall, struct {
-		arg1 context.Context
-		arg2 client.Object
-		arg3 []client.CreateOption
-	}{arg1, arg2, arg3})
-	stub := fake.CreateStub
-	fakeReturns := fake.createReturns
-	fake.recordInvocation("Create", []interface{}{arg1, arg2, arg3})
-	fake.createMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2, arg3...)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Client) CreateCallCount() int {
-	fake.createMutex.RLock()
-	defer fake.createMutex.RUnlock()
-	return len(fake.createArgsForCall)
-}
-
-func (fake *Client) CreateCalls(stub func(context.Context, client.Object, ...client.CreateOption) error) {
-	fake.createMutex.Lock()
-	defer fake.createMutex.Unlock()
-	fake.CreateStub = stub
-}
-
-func (fake *Client) CreateArgsForCall(i int) (context.Context, client.Object, []client.CreateOption) {
-	fake.createMutex.RLock()
-	defer fake.createMutex.RUnlock()
-	argsForCall := fake.createArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
-}
-
-func (fake *Client) CreateReturns(result1 error) {
-	fake.createMutex.Lock()
-	defer fake.createMutex.Unlock()
-	fake.CreateStub = nil
-	fake.createReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Client) CreateReturnsOnCall(i int, result1 error) {
-	fake.createMutex.Lock()
-	defer fake.createMutex.Unlock()
-	fake.CreateStub = nil
-	if fake.createReturnsOnCall == nil {
-		fake.createReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.createReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Client) Delete(arg1 context.Context, arg2 client.Object, arg3 ...client.DeleteOption) error {
-	fake.deleteMutex.Lock()
-	ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)]
-	fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct {
-		arg1 context.Context
-		arg2 client.Object
-		arg3 []client.DeleteOption
-	}{arg1, arg2, arg3})
-	stub := fake.DeleteStub
-	fakeReturns := fake.deleteReturns
-	fake.recordInvocation("Delete", []interface{}{arg1, arg2, arg3})
-	fake.deleteMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2, arg3...)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Client) DeleteCallCount() int {
-	fake.deleteMutex.RLock()
-	defer fake.deleteMutex.RUnlock()
-	return len(fake.deleteArgsForCall)
-}
-
-func (fake *Client) DeleteCalls(stub func(context.Context, client.Object, ...client.DeleteOption) error) {
-	fake.deleteMutex.Lock()
-	defer fake.deleteMutex.Unlock()
-	fake.DeleteStub = stub
-}
-
-func (fake *Client) DeleteArgsForCall(i int) (context.Context, client.Object, []client.DeleteOption) {
-	fake.deleteMutex.RLock()
-	defer fake.deleteMutex.RUnlock()
-	argsForCall := fake.deleteArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
-}
-
-func (fake *Client) DeleteReturns(result1 error) {
-	fake.deleteMutex.Lock()
-	defer fake.deleteMutex.Unlock()
-	fake.DeleteStub = nil
-	fake.deleteReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Client) DeleteReturnsOnCall(i int, result1 error) {
-	fake.deleteMutex.Lock()
-	defer fake.deleteMutex.Unlock()
-	fake.DeleteStub = nil
-	if fake.deleteReturnsOnCall == nil {
-		fake.deleteReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.deleteReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Client) DeleteAllOf(arg1 context.Context, arg2 client.Object, arg3 ...client.DeleteAllOfOption) error {
-	fake.deleteAllOfMutex.Lock()
-	ret, specificReturn := fake.deleteAllOfReturnsOnCall[len(fake.deleteAllOfArgsForCall)]
-	fake.deleteAllOfArgsForCall = append(fake.deleteAllOfArgsForCall, struct {
-		arg1 context.Context
-		arg2 client.Object
-		arg3 []client.DeleteAllOfOption
-	}{arg1, arg2, arg3})
-	stub := fake.DeleteAllOfStub
-	fakeReturns := fake.deleteAllOfReturns
-	fake.recordInvocation("DeleteAllOf", []interface{}{arg1, arg2, arg3})
-	fake.deleteAllOfMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2, arg3...)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Client) DeleteAllOfCallCount() int {
-	fake.deleteAllOfMutex.RLock()
-	defer fake.deleteAllOfMutex.RUnlock()
-	return len(fake.deleteAllOfArgsForCall)
-}
-
-func (fake *Client) DeleteAllOfCalls(stub func(context.Context, client.Object, ...client.DeleteAllOfOption) error) {
-	fake.deleteAllOfMutex.Lock()
-	defer fake.deleteAllOfMutex.Unlock()
-	fake.DeleteAllOfStub = stub
-}
-
-func (fake *Client) DeleteAllOfArgsForCall(i int) (context.Context, client.Object, []client.DeleteAllOfOption) {
-	fake.deleteAllOfMutex.RLock()
-	defer fake.deleteAllOfMutex.RUnlock()
-	argsForCall := fake.deleteAllOfArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
-}
-
-func (fake *Client) DeleteAllOfReturns(result1 error) {
-	fake.deleteAllOfMutex.Lock()
-	defer fake.deleteAllOfMutex.Unlock()
-	fake.DeleteAllOfStub = nil
-	fake.deleteAllOfReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Client) DeleteAllOfReturnsOnCall(i int, result1 error) {
-	fake.deleteAllOfMutex.Lock()
-	defer fake.deleteAllOfMutex.Unlock()
-	fake.DeleteAllOfStub = nil
-	if fake.deleteAllOfReturnsOnCall == nil {
-		fake.deleteAllOfReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.deleteAllOfReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Client) Get(arg1 context.Context, arg2 types.NamespacedName, arg3 client.Object) error {
-	fake.getMutex.Lock()
-	ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)]
-	fake.getArgsForCall = append(fake.getArgsForCall, struct {
-		arg1 context.Context
-		arg2 types.NamespacedName
-		arg3 client.Object
-	}{arg1, arg2, arg3})
-	stub := fake.GetStub
-	fakeReturns := fake.getReturns
-	fake.recordInvocation("Get", []interface{}{arg1, arg2, arg3})
-	fake.getMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2, arg3)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Client) GetCallCount() int {
-	fake.getMutex.RLock()
-	defer fake.getMutex.RUnlock()
-	return len(fake.getArgsForCall)
-}
-
-func (fake *Client) GetCalls(stub func(context.Context, types.NamespacedName, client.Object) error) {
-	fake.getMutex.Lock()
-	defer fake.getMutex.Unlock()
-	fake.GetStub = stub
-}
-
-func (fake *Client) GetArgsForCall(i int) (context.Context, types.NamespacedName, client.Object) {
-	fake.getMutex.RLock()
-	defer fake.getMutex.RUnlock()
-	argsForCall := fake.getArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
-}
-
-func (fake *Client) GetReturns(result1 error) {
-	fake.getMutex.Lock()
-	defer fake.getMutex.Unlock()
-	fake.GetStub = nil
-	fake.getReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Client) GetReturnsOnCall(i int, result1 error) {
-	fake.getMutex.Lock()
-	defer fake.getMutex.Unlock()
-	fake.GetStub = nil
-	if fake.getReturnsOnCall == nil {
-		fake.getReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.getReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Client) List(arg1 context.Context, arg2 client.ObjectList, arg3 ...client.ListOption) error {
-	fake.listMutex.Lock()
-	ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)]
-	fake.listArgsForCall = append(fake.listArgsForCall, struct {
-		arg1 context.Context
-		arg2 client.ObjectList
-		arg3 []client.ListOption
-	}{arg1, arg2, arg3})
-	stub := fake.ListStub
-	fakeReturns := fake.listReturns
-	fake.recordInvocation("List", []interface{}{arg1, arg2, arg3})
-	fake.listMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2, arg3...)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Client) ListCallCount() int {
-	fake.listMutex.RLock()
-	defer fake.listMutex.RUnlock()
-	return len(fake.listArgsForCall)
-}
-
-func (fake *Client) ListCalls(stub func(context.Context, client.ObjectList, ...client.ListOption) error) {
-	fake.listMutex.Lock()
-	defer fake.listMutex.Unlock()
-	fake.ListStub = stub
-}
-
-func (fake *Client) ListArgsForCall(i int) (context.Context, client.ObjectList, []client.ListOption) {
-	fake.listMutex.RLock()
-	defer fake.listMutex.RUnlock()
-	argsForCall := fake.listArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
-}
-
-func (fake *Client) ListReturns(result1 error) {
-	fake.listMutex.Lock()
-	defer fake.listMutex.Unlock()
-	fake.ListStub = nil
-	fake.listReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Client) ListReturnsOnCall(i int, result1 error) {
-	fake.listMutex.Lock()
-	defer fake.listMutex.Unlock()
-	fake.ListStub = nil
-	if fake.listReturnsOnCall == nil {
-		fake.listReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.listReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Client) Patch(arg1 context.Context, arg2 client.Object, arg3 client.Patch, arg4 ...client.PatchOption) error {
-	fake.patchMutex.Lock()
-	ret, specificReturn := fake.patchReturnsOnCall[len(fake.patchArgsForCall)]
-	fake.patchArgsForCall = append(fake.patchArgsForCall, struct {
-		arg1 context.Context
-		arg2 client.Object
-		arg3 client.Patch
-		arg4 []client.PatchOption
-	}{arg1, arg2, arg3, arg4})
-	stub := fake.PatchStub
-	fakeReturns := fake.patchReturns
-	fake.recordInvocation("Patch", []interface{}{arg1, arg2, arg3, arg4})
-	fake.patchMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2, arg3, arg4...)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Client) PatchCallCount() int {
-	fake.patchMutex.RLock()
-	defer fake.patchMutex.RUnlock()
-	return len(fake.patchArgsForCall)
-}
-
-func (fake *Client) PatchCalls(stub func(context.Context, client.Object, client.Patch, ...client.PatchOption) error) {
-	fake.patchMutex.Lock()
-	defer fake.patchMutex.Unlock()
-	fake.PatchStub = stub
-}
-
-func (fake *Client) PatchArgsForCall(i int) (context.Context, client.Object, client.Patch, []client.PatchOption) {
-	fake.patchMutex.RLock()
-	defer fake.patchMutex.RUnlock()
-	argsForCall := fake.patchArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
-}
-
-func (fake *Client) PatchReturns(result1 error) {
-	fake.patchMutex.Lock()
-	defer fake.patchMutex.Unlock()
-	fake.PatchStub = nil
-	fake.patchReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Client) PatchReturnsOnCall(i int, result1 error) {
-	fake.patchMutex.Lock()
-	defer fake.patchMutex.Unlock()
-	fake.PatchStub = nil
-	if fake.patchReturnsOnCall == nil {
-		fake.patchReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.patchReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Client) RESTMapper() meta.RESTMapper {
-	fake.rESTMapperMutex.Lock()
-	ret, specificReturn := fake.rESTMapperReturnsOnCall[len(fake.rESTMapperArgsForCall)]
-	fake.rESTMapperArgsForCall = append(fake.rESTMapperArgsForCall, struct {
-	}{})
-	stub := fake.RESTMapperStub
-	fakeReturns := fake.rESTMapperReturns
-	fake.recordInvocation("RESTMapper", []interface{}{})
-	fake.rESTMapperMutex.Unlock()
-	if stub != nil {
-		return stub()
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Client) RESTMapperCallCount() int {
-	fake.rESTMapperMutex.RLock()
-	defer fake.rESTMapperMutex.RUnlock()
-	return len(fake.rESTMapperArgsForCall)
-}
-
-func (fake *Client) RESTMapperCalls(stub func() meta.RESTMapper) {
-	fake.rESTMapperMutex.Lock()
-	defer fake.rESTMapperMutex.Unlock()
-	fake.RESTMapperStub = stub
-}
-
-func (fake *Client) RESTMapperReturns(result1 meta.RESTMapper) {
-	fake.rESTMapperMutex.Lock()
-	defer fake.rESTMapperMutex.Unlock()
-	fake.RESTMapperStub = nil
-	fake.rESTMapperReturns = struct {
-		result1 meta.RESTMapper
-	}{result1}
-}
-
-func (fake *Client) RESTMapperReturnsOnCall(i int, result1 meta.RESTMapper) {
-	fake.rESTMapperMutex.Lock()
-	defer fake.rESTMapperMutex.Unlock()
-	fake.RESTMapperStub = nil
-	if fake.rESTMapperReturnsOnCall == nil {
-		fake.rESTMapperReturnsOnCall = make(map[int]struct {
-			result1 meta.RESTMapper
-		})
-	}
-	fake.rESTMapperReturnsOnCall[i] = struct {
-		result1 meta.RESTMapper
-	}{result1}
-}
-
-func (fake *Client) Scheme() *runtime.Scheme {
-	fake.schemeMutex.Lock()
-	ret, specificReturn := fake.schemeReturnsOnCall[len(fake.schemeArgsForCall)]
-	fake.schemeArgsForCall = append(fake.schemeArgsForCall, struct {
-	}{})
-	stub := fake.SchemeStub
-	fakeReturns := fake.schemeReturns
-	fake.recordInvocation("Scheme", []interface{}{})
-	fake.schemeMutex.Unlock()
-	if stub != nil {
-		return stub()
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Client) SchemeCallCount() int {
-	fake.schemeMutex.RLock()
-	defer fake.schemeMutex.RUnlock()
-	return len(fake.schemeArgsForCall)
-}
-
-func (fake *Client) SchemeCalls(stub func() *runtime.Scheme) {
-	fake.schemeMutex.Lock()
-	defer fake.schemeMutex.Unlock()
-	fake.SchemeStub = stub
-}
-
-func (fake *Client) SchemeReturns(result1 *runtime.Scheme) {
-	fake.schemeMutex.Lock()
-	defer fake.schemeMutex.Unlock()
-	fake.SchemeStub = nil
-	fake.schemeReturns = struct {
-		result1 *runtime.Scheme
-	}{result1}
-}
-
-func (fake *Client) SchemeReturnsOnCall(i int, result1 *runtime.Scheme) {
-	fake.schemeMutex.Lock()
-	defer fake.schemeMutex.Unlock()
-	fake.SchemeStub = nil
-	if fake.schemeReturnsOnCall == nil {
-		fake.schemeReturnsOnCall = make(map[int]struct {
-			result1 *runtime.Scheme
-		})
-	}
-	fake.schemeReturnsOnCall[i] = struct {
-		result1 *runtime.Scheme
-	}{result1}
-}
-
-func (fake *Client) Status() client.StatusWriter {
-	fake.statusMutex.Lock()
-	ret, specificReturn := fake.statusReturnsOnCall[len(fake.statusArgsForCall)]
-	fake.statusArgsForCall = append(fake.statusArgsForCall, struct {
-	}{})
-	stub := fake.StatusStub
-	fakeReturns := fake.statusReturns
-	fake.recordInvocation("Status", []interface{}{})
-	fake.statusMutex.Unlock()
-	if stub != nil {
-		return stub()
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Client) StatusCallCount() int {
-	fake.statusMutex.RLock()
-	defer fake.statusMutex.RUnlock()
-	return len(fake.statusArgsForCall)
-}
-
-func (fake *Client) StatusCalls(stub func() client.StatusWriter) {
-	fake.statusMutex.Lock()
-	defer fake.statusMutex.Unlock()
-	fake.StatusStub = stub
-}
-
-func (fake *Client) StatusReturns(result1 client.StatusWriter) {
-	fake.statusMutex.Lock()
-	defer fake.statusMutex.Unlock()
-	fake.StatusStub = nil
-	fake.statusReturns = struct {
-		result1 client.StatusWriter
-	}{result1}
-}
-
-func (fake *Client) StatusReturnsOnCall(i int, result1 client.StatusWriter) {
-	fake.statusMutex.Lock()
-	defer fake.statusMutex.Unlock()
-	fake.StatusStub = nil
-	if fake.statusReturnsOnCall == nil {
-		fake.statusReturnsOnCall = make(map[int]struct {
-			result1 client.StatusWriter
-		})
-	}
-	fake.statusReturnsOnCall[i] = struct {
-		result1 client.StatusWriter
-	}{result1}
-}
-
-func (fake *Client) Update(arg1 context.Context, arg2 client.Object, arg3 ...client.UpdateOption) error {
-	fake.updateMutex.Lock()
-	ret, specificReturn := fake.updateReturnsOnCall[len(fake.updateArgsForCall)]
-	fake.updateArgsForCall = append(fake.updateArgsForCall, struct {
-		arg1 context.Context
-		arg2 client.Object
-		arg3 []client.UpdateOption
-	}{arg1, arg2, arg3})
-	stub := fake.UpdateStub
-	fakeReturns := fake.updateReturns
-	fake.recordInvocation("Update", []interface{}{arg1, arg2, arg3})
-	fake.updateMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2, arg3...)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Client) UpdateCallCount() int {
-	fake.updateMutex.RLock()
-	defer fake.updateMutex.RUnlock()
-	return len(fake.updateArgsForCall)
-}
-
-func (fake *Client) UpdateCalls(stub func(context.Context, client.Object, ...client.UpdateOption) error) {
-	fake.updateMutex.Lock()
-	defer fake.updateMutex.Unlock()
-	fake.UpdateStub = stub
-}
-
-func (fake *Client) UpdateArgsForCall(i int) (context.Context, client.Object, []client.UpdateOption) {
-	fake.updateMutex.RLock()
-	defer fake.updateMutex.RUnlock()
-	argsForCall := fake.updateArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
-}
-
-func (fake *Client) UpdateReturns(result1 error) {
-	fake.updateMutex.Lock()
-	defer fake.updateMutex.Unlock()
-	fake.UpdateStub = nil
-	fake.updateReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Client) UpdateReturnsOnCall(i int, result1 error) {
-	fake.updateMutex.Lock()
-	defer fake.updateMutex.Unlock()
-	fake.UpdateStub = nil
-	if fake.updateReturnsOnCall == nil {
-		fake.updateReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.updateReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Client) Invocations() map[string][][]interface{} {
-	fake.invocationsMutex.RLock()
-	defer fake.invocationsMutex.RUnlock()
-	fake.createMutex.RLock()
-	defer fake.createMutex.RUnlock()
-	fake.deleteMutex.RLock()
-	defer fake.deleteMutex.RUnlock()
-	fake.deleteAllOfMutex.RLock()
-	defer fake.deleteAllOfMutex.RUnlock()
-	fake.getMutex.RLock()
-	defer fake.getMutex.RUnlock()
-	fake.listMutex.RLock()
-	defer fake.listMutex.RUnlock()
-	fake.patchMutex.RLock()
-	defer fake.patchMutex.RUnlock()
-	fake.rESTMapperMutex.RLock()
-	defer fake.rESTMapperMutex.RUnlock()
-	fake.schemeMutex.RLock()
-	defer fake.schemeMutex.RUnlock()
-	fake.statusMutex.RLock()
-	defer fake.statusMutex.RUnlock()
-	fake.updateMutex.RLock()
-	defer fake.updateMutex.RUnlock()
-	copiedInvocations := map[string][][]interface{}{}
-	for key, value := range fake.invocations {
-		copiedInvocations[key] = value
-	}
-	return copiedInvocations
-}
-
-func (fake *Client) 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 _ client.Client = new(Client)

pkg/controllers/pushsecret/internal/fakes/manager.go

@@ -1,1288 +0,0 @@
-// Code generated by counterfeiter. DO NOT EDIT.
-package fakes
-
-import (
-	"context"
-	"net/http"
-	"sync"
-
-	"github.com/go-logr/logr"
-	"k8s.io/apimachinery/pkg/api/meta"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/client-go/rest"
-	"k8s.io/client-go/tools/record"
-	"sigs.k8s.io/controller-runtime/pkg/cache"
-	"sigs.k8s.io/controller-runtime/pkg/client"
-	"sigs.k8s.io/controller-runtime/pkg/config/v1alpha1"
-	"sigs.k8s.io/controller-runtime/pkg/healthz"
-	"sigs.k8s.io/controller-runtime/pkg/manager"
-	"sigs.k8s.io/controller-runtime/pkg/webhook"
-)
-
-type Manager struct {
-	AddStub        func(manager.Runnable) error
-	addMutex       sync.RWMutex
-	addArgsForCall []struct {
-		arg1 manager.Runnable
-	}
-	addReturns struct {
-		result1 error
-	}
-	addReturnsOnCall map[int]struct {
-		result1 error
-	}
-	AddHealthzCheckStub        func(string, healthz.Checker) error
-	addHealthzCheckMutex       sync.RWMutex
-	addHealthzCheckArgsForCall []struct {
-		arg1 string
-		arg2 healthz.Checker
-	}
-	addHealthzCheckReturns struct {
-		result1 error
-	}
-	addHealthzCheckReturnsOnCall map[int]struct {
-		result1 error
-	}
-	AddMetricsExtraHandlerStub        func(string, http.Handler) error
-	addMetricsExtraHandlerMutex       sync.RWMutex
-	addMetricsExtraHandlerArgsForCall []struct {
-		arg1 string
-		arg2 http.Handler
-	}
-	addMetricsExtraHandlerReturns struct {
-		result1 error
-	}
-	addMetricsExtraHandlerReturnsOnCall map[int]struct {
-		result1 error
-	}
-	AddReadyzCheckStub        func(string, healthz.Checker) error
-	addReadyzCheckMutex       sync.RWMutex
-	addReadyzCheckArgsForCall []struct {
-		arg1 string
-		arg2 healthz.Checker
-	}
-	addReadyzCheckReturns struct {
-		result1 error
-	}
-	addReadyzCheckReturnsOnCall map[int]struct {
-		result1 error
-	}
-	ElectedStub        func() <-chan struct{}
-	electedMutex       sync.RWMutex
-	electedArgsForCall []struct {
-	}
-	electedReturns struct {
-		result1 <-chan struct{}
-	}
-	electedReturnsOnCall map[int]struct {
-		result1 <-chan struct{}
-	}
-	GetAPIReaderStub        func() client.Reader
-	getAPIReaderMutex       sync.RWMutex
-	getAPIReaderArgsForCall []struct {
-	}
-	getAPIReaderReturns struct {
-		result1 client.Reader
-	}
-	getAPIReaderReturnsOnCall map[int]struct {
-		result1 client.Reader
-	}
-	GetCacheStub        func() cache.Cache
-	getCacheMutex       sync.RWMutex
-	getCacheArgsForCall []struct {
-	}
-	getCacheReturns struct {
-		result1 cache.Cache
-	}
-	getCacheReturnsOnCall map[int]struct {
-		result1 cache.Cache
-	}
-	GetClientStub        func() client.Client
-	getClientMutex       sync.RWMutex
-	getClientArgsForCall []struct {
-	}
-	getClientReturns struct {
-		result1 client.Client
-	}
-	getClientReturnsOnCall map[int]struct {
-		result1 client.Client
-	}
-	GetConfigStub        func() *rest.Config
-	getConfigMutex       sync.RWMutex
-	getConfigArgsForCall []struct {
-	}
-	getConfigReturns struct {
-		result1 *rest.Config
-	}
-	getConfigReturnsOnCall map[int]struct {
-		result1 *rest.Config
-	}
-	GetControllerOptionsStub        func() v1alpha1.ControllerConfigurationSpec
-	getControllerOptionsMutex       sync.RWMutex
-	getControllerOptionsArgsForCall []struct {
-	}
-	getControllerOptionsReturns struct {
-		result1 v1alpha1.ControllerConfigurationSpec
-	}
-	getControllerOptionsReturnsOnCall map[int]struct {
-		result1 v1alpha1.ControllerConfigurationSpec
-	}
-	GetEventRecorderForStub        func(string) record.EventRecorder
-	getEventRecorderForMutex       sync.RWMutex
-	getEventRecorderForArgsForCall []struct {
-		arg1 string
-	}
-	getEventRecorderForReturns struct {
-		result1 record.EventRecorder
-	}
-	getEventRecorderForReturnsOnCall map[int]struct {
-		result1 record.EventRecorder
-	}
-	GetFieldIndexerStub        func() client.FieldIndexer
-	getFieldIndexerMutex       sync.RWMutex
-	getFieldIndexerArgsForCall []struct {
-	}
-	getFieldIndexerReturns struct {
-		result1 client.FieldIndexer
-	}
-	getFieldIndexerReturnsOnCall map[int]struct {
-		result1 client.FieldIndexer
-	}
-	GetLoggerStub        func() logr.Logger
-	getLoggerMutex       sync.RWMutex
-	getLoggerArgsForCall []struct {
-	}
-	getLoggerReturns struct {
-		result1 logr.Logger
-	}
-	getLoggerReturnsOnCall map[int]struct {
-		result1 logr.Logger
-	}
-	GetRESTMapperStub        func() meta.RESTMapper
-	getRESTMapperMutex       sync.RWMutex
-	getRESTMapperArgsForCall []struct {
-	}
-	getRESTMapperReturns struct {
-		result1 meta.RESTMapper
-	}
-	getRESTMapperReturnsOnCall map[int]struct {
-		result1 meta.RESTMapper
-	}
-	GetSchemeStub        func() *runtime.Scheme
-	getSchemeMutex       sync.RWMutex
-	getSchemeArgsForCall []struct {
-	}
-	getSchemeReturns struct {
-		result1 *runtime.Scheme
-	}
-	getSchemeReturnsOnCall map[int]struct {
-		result1 *runtime.Scheme
-	}
-	GetWebhookServerStub        func() *webhook.Server
-	getWebhookServerMutex       sync.RWMutex
-	getWebhookServerArgsForCall []struct {
-	}
-	getWebhookServerReturns struct {
-		result1 *webhook.Server
-	}
-	getWebhookServerReturnsOnCall map[int]struct {
-		result1 *webhook.Server
-	}
-	SetFieldsStub        func(interface{}) error
-	setFieldsMutex       sync.RWMutex
-	setFieldsArgsForCall []struct {
-		arg1 interface{}
-	}
-	setFieldsReturns struct {
-		result1 error
-	}
-	setFieldsReturnsOnCall map[int]struct {
-		result1 error
-	}
-	StartStub        func(context.Context) error
-	startMutex       sync.RWMutex
-	startArgsForCall []struct {
-		arg1 context.Context
-	}
-	startReturns struct {
-		result1 error
-	}
-	startReturnsOnCall map[int]struct {
-		result1 error
-	}
-	invocations      map[string][][]interface{}
-	invocationsMutex sync.RWMutex
-}
-
-func (fake *Manager) Add(arg1 manager.Runnable) error {
-	fake.addMutex.Lock()
-	ret, specificReturn := fake.addReturnsOnCall[len(fake.addArgsForCall)]
-	fake.addArgsForCall = append(fake.addArgsForCall, struct {
-		arg1 manager.Runnable
-	}{arg1})
-	stub := fake.AddStub
-	fakeReturns := fake.addReturns
-	fake.recordInvocation("Add", []interface{}{arg1})
-	fake.addMutex.Unlock()
-	if stub != nil {
-		return stub(arg1)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Manager) AddCallCount() int {
-	fake.addMutex.RLock()
-	defer fake.addMutex.RUnlock()
-	return len(fake.addArgsForCall)
-}
-
-func (fake *Manager) AddCalls(stub func(manager.Runnable) error) {
-	fake.addMutex.Lock()
-	defer fake.addMutex.Unlock()
-	fake.AddStub = stub
-}
-
-func (fake *Manager) AddArgsForCall(i int) manager.Runnable {
-	fake.addMutex.RLock()
-	defer fake.addMutex.RUnlock()
-	argsForCall := fake.addArgsForCall[i]
-	return argsForCall.arg1
-}
-
-func (fake *Manager) AddReturns(result1 error) {
-	fake.addMutex.Lock()
-	defer fake.addMutex.Unlock()
-	fake.AddStub = nil
-	fake.addReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Manager) AddReturnsOnCall(i int, result1 error) {
-	fake.addMutex.Lock()
-	defer fake.addMutex.Unlock()
-	fake.AddStub = nil
-	if fake.addReturnsOnCall == nil {
-		fake.addReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.addReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Manager) AddHealthzCheck(arg1 string, arg2 healthz.Checker) error {
-	fake.addHealthzCheckMutex.Lock()
-	ret, specificReturn := fake.addHealthzCheckReturnsOnCall[len(fake.addHealthzCheckArgsForCall)]
-	fake.addHealthzCheckArgsForCall = append(fake.addHealthzCheckArgsForCall, struct {
-		arg1 string
-		arg2 healthz.Checker
-	}{arg1, arg2})
-	stub := fake.AddHealthzCheckStub
-	fakeReturns := fake.addHealthzCheckReturns
-	fake.recordInvocation("AddHealthzCheck", []interface{}{arg1, arg2})
-	fake.addHealthzCheckMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Manager) AddHealthzCheckCallCount() int {
-	fake.addHealthzCheckMutex.RLock()
-	defer fake.addHealthzCheckMutex.RUnlock()
-	return len(fake.addHealthzCheckArgsForCall)
-}
-
-func (fake *Manager) AddHealthzCheckCalls(stub func(string, healthz.Checker) error) {
-	fake.addHealthzCheckMutex.Lock()
-	defer fake.addHealthzCheckMutex.Unlock()
-	fake.AddHealthzCheckStub = stub
-}
-
-func (fake *Manager) AddHealthzCheckArgsForCall(i int) (string, healthz.Checker) {
-	fake.addHealthzCheckMutex.RLock()
-	defer fake.addHealthzCheckMutex.RUnlock()
-	argsForCall := fake.addHealthzCheckArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *Manager) AddHealthzCheckReturns(result1 error) {
-	fake.addHealthzCheckMutex.Lock()
-	defer fake.addHealthzCheckMutex.Unlock()
-	fake.AddHealthzCheckStub = nil
-	fake.addHealthzCheckReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Manager) AddHealthzCheckReturnsOnCall(i int, result1 error) {
-	fake.addHealthzCheckMutex.Lock()
-	defer fake.addHealthzCheckMutex.Unlock()
-	fake.AddHealthzCheckStub = nil
-	if fake.addHealthzCheckReturnsOnCall == nil {
-		fake.addHealthzCheckReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.addHealthzCheckReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Manager) AddMetricsExtraHandler(arg1 string, arg2 http.Handler) error {
-	fake.addMetricsExtraHandlerMutex.Lock()
-	ret, specificReturn := fake.addMetricsExtraHandlerReturnsOnCall[len(fake.addMetricsExtraHandlerArgsForCall)]
-	fake.addMetricsExtraHandlerArgsForCall = append(fake.addMetricsExtraHandlerArgsForCall, struct {
-		arg1 string
-		arg2 http.Handler
-	}{arg1, arg2})
-	stub := fake.AddMetricsExtraHandlerStub
-	fakeReturns := fake.addMetricsExtraHandlerReturns
-	fake.recordInvocation("AddMetricsExtraHandler", []interface{}{arg1, arg2})
-	fake.addMetricsExtraHandlerMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Manager) AddMetricsExtraHandlerCallCount() int {
-	fake.addMetricsExtraHandlerMutex.RLock()
-	defer fake.addMetricsExtraHandlerMutex.RUnlock()
-	return len(fake.addMetricsExtraHandlerArgsForCall)
-}
-
-func (fake *Manager) AddMetricsExtraHandlerCalls(stub func(string, http.Handler) error) {
-	fake.addMetricsExtraHandlerMutex.Lock()
-	defer fake.addMetricsExtraHandlerMutex.Unlock()
-	fake.AddMetricsExtraHandlerStub = stub
-}
-
-func (fake *Manager) AddMetricsExtraHandlerArgsForCall(i int) (string, http.Handler) {
-	fake.addMetricsExtraHandlerMutex.RLock()
-	defer fake.addMetricsExtraHandlerMutex.RUnlock()
-	argsForCall := fake.addMetricsExtraHandlerArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *Manager) AddMetricsExtraHandlerReturns(result1 error) {
-	fake.addMetricsExtraHandlerMutex.Lock()
-	defer fake.addMetricsExtraHandlerMutex.Unlock()
-	fake.AddMetricsExtraHandlerStub = nil
-	fake.addMetricsExtraHandlerReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Manager) AddMetricsExtraHandlerReturnsOnCall(i int, result1 error) {
-	fake.addMetricsExtraHandlerMutex.Lock()
-	defer fake.addMetricsExtraHandlerMutex.Unlock()
-	fake.AddMetricsExtraHandlerStub = nil
-	if fake.addMetricsExtraHandlerReturnsOnCall == nil {
-		fake.addMetricsExtraHandlerReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.addMetricsExtraHandlerReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Manager) AddReadyzCheck(arg1 string, arg2 healthz.Checker) error {
-	fake.addReadyzCheckMutex.Lock()
-	ret, specificReturn := fake.addReadyzCheckReturnsOnCall[len(fake.addReadyzCheckArgsForCall)]
-	fake.addReadyzCheckArgsForCall = append(fake.addReadyzCheckArgsForCall, struct {
-		arg1 string
-		arg2 healthz.Checker
-	}{arg1, arg2})
-	stub := fake.AddReadyzCheckStub
-	fakeReturns := fake.addReadyzCheckReturns
-	fake.recordInvocation("AddReadyzCheck", []interface{}{arg1, arg2})
-	fake.addReadyzCheckMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Manager) AddReadyzCheckCallCount() int {
-	fake.addReadyzCheckMutex.RLock()
-	defer fake.addReadyzCheckMutex.RUnlock()
-	return len(fake.addReadyzCheckArgsForCall)
-}
-
-func (fake *Manager) AddReadyzCheckCalls(stub func(string, healthz.Checker) error) {
-	fake.addReadyzCheckMutex.Lock()
-	defer fake.addReadyzCheckMutex.Unlock()
-	fake.AddReadyzCheckStub = stub
-}
-
-func (fake *Manager) AddReadyzCheckArgsForCall(i int) (string, healthz.Checker) {
-	fake.addReadyzCheckMutex.RLock()
-	defer fake.addReadyzCheckMutex.RUnlock()
-	argsForCall := fake.addReadyzCheckArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *Manager) AddReadyzCheckReturns(result1 error) {
-	fake.addReadyzCheckMutex.Lock()
-	defer fake.addReadyzCheckMutex.Unlock()
-	fake.AddReadyzCheckStub = nil
-	fake.addReadyzCheckReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Manager) AddReadyzCheckReturnsOnCall(i int, result1 error) {
-	fake.addReadyzCheckMutex.Lock()
-	defer fake.addReadyzCheckMutex.Unlock()
-	fake.AddReadyzCheckStub = nil
-	if fake.addReadyzCheckReturnsOnCall == nil {
-		fake.addReadyzCheckReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.addReadyzCheckReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Manager) Elected() <-chan struct{} {
-	fake.electedMutex.Lock()
-	ret, specificReturn := fake.electedReturnsOnCall[len(fake.electedArgsForCall)]
-	fake.electedArgsForCall = append(fake.electedArgsForCall, struct {
-	}{})
-	stub := fake.ElectedStub
-	fakeReturns := fake.electedReturns
-	fake.recordInvocation("Elected", []interface{}{})
-	fake.electedMutex.Unlock()
-	if stub != nil {
-		return stub()
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Manager) ElectedCallCount() int {
-	fake.electedMutex.RLock()
-	defer fake.electedMutex.RUnlock()
-	return len(fake.electedArgsForCall)
-}
-
-func (fake *Manager) ElectedCalls(stub func() <-chan struct{}) {
-	fake.electedMutex.Lock()
-	defer fake.electedMutex.Unlock()
-	fake.ElectedStub = stub
-}
-
-func (fake *Manager) ElectedReturns(result1 <-chan struct{}) {
-	fake.electedMutex.Lock()
-	defer fake.electedMutex.Unlock()
-	fake.ElectedStub = nil
-	fake.electedReturns = struct {
-		result1 <-chan struct{}
-	}{result1}
-}
-
-func (fake *Manager) ElectedReturnsOnCall(i int, result1 <-chan struct{}) {
-	fake.electedMutex.Lock()
-	defer fake.electedMutex.Unlock()
-	fake.ElectedStub = nil
-	if fake.electedReturnsOnCall == nil {
-		fake.electedReturnsOnCall = make(map[int]struct {
-			result1 <-chan struct{}
-		})
-	}
-	fake.electedReturnsOnCall[i] = struct {
-		result1 <-chan struct{}
-	}{result1}
-}
-
-func (fake *Manager) GetAPIReader() client.Reader {
-	fake.getAPIReaderMutex.Lock()
-	ret, specificReturn := fake.getAPIReaderReturnsOnCall[len(fake.getAPIReaderArgsForCall)]
-	fake.getAPIReaderArgsForCall = append(fake.getAPIReaderArgsForCall, struct {
-	}{})
-	stub := fake.GetAPIReaderStub
-	fakeReturns := fake.getAPIReaderReturns
-	fake.recordInvocation("GetAPIReader", []interface{}{})
-	fake.getAPIReaderMutex.Unlock()
-	if stub != nil {
-		return stub()
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Manager) GetAPIReaderCallCount() int {
-	fake.getAPIReaderMutex.RLock()
-	defer fake.getAPIReaderMutex.RUnlock()
-	return len(fake.getAPIReaderArgsForCall)
-}
-
-func (fake *Manager) GetAPIReaderCalls(stub func() client.Reader) {
-	fake.getAPIReaderMutex.Lock()
-	defer fake.getAPIReaderMutex.Unlock()
-	fake.GetAPIReaderStub = stub
-}
-
-func (fake *Manager) GetAPIReaderReturns(result1 client.Reader) {
-	fake.getAPIReaderMutex.Lock()
-	defer fake.getAPIReaderMutex.Unlock()
-	fake.GetAPIReaderStub = nil
-	fake.getAPIReaderReturns = struct {
-		result1 client.Reader
-	}{result1}
-}
-
-func (fake *Manager) GetAPIReaderReturnsOnCall(i int, result1 client.Reader) {
-	fake.getAPIReaderMutex.Lock()
-	defer fake.getAPIReaderMutex.Unlock()
-	fake.GetAPIReaderStub = nil
-	if fake.getAPIReaderReturnsOnCall == nil {
-		fake.getAPIReaderReturnsOnCall = make(map[int]struct {
-			result1 client.Reader
-		})
-	}
-	fake.getAPIReaderReturnsOnCall[i] = struct {
-		result1 client.Reader
-	}{result1}
-}
-
-func (fake *Manager) GetCache() cache.Cache {
-	fake.getCacheMutex.Lock()
-	ret, specificReturn := fake.getCacheReturnsOnCall[len(fake.getCacheArgsForCall)]
-	fake.getCacheArgsForCall = append(fake.getCacheArgsForCall, struct {
-	}{})
-	stub := fake.GetCacheStub
-	fakeReturns := fake.getCacheReturns
-	fake.recordInvocation("GetCache", []interface{}{})
-	fake.getCacheMutex.Unlock()
-	if stub != nil {
-		return stub()
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Manager) GetCacheCallCount() int {
-	fake.getCacheMutex.RLock()
-	defer fake.getCacheMutex.RUnlock()
-	return len(fake.getCacheArgsForCall)
-}
-
-func (fake *Manager) GetCacheCalls(stub func() cache.Cache) {
-	fake.getCacheMutex.Lock()
-	defer fake.getCacheMutex.Unlock()
-	fake.GetCacheStub = stub
-}
-
-func (fake *Manager) GetCacheReturns(result1 cache.Cache) {
-	fake.getCacheMutex.Lock()
-	defer fake.getCacheMutex.Unlock()
-	fake.GetCacheStub = nil
-	fake.getCacheReturns = struct {
-		result1 cache.Cache
-	}{result1}
-}
-
-func (fake *Manager) GetCacheReturnsOnCall(i int, result1 cache.Cache) {
-	fake.getCacheMutex.Lock()
-	defer fake.getCacheMutex.Unlock()
-	fake.GetCacheStub = nil
-	if fake.getCacheReturnsOnCall == nil {
-		fake.getCacheReturnsOnCall = make(map[int]struct {
-			result1 cache.Cache
-		})
-	}
-	fake.getCacheReturnsOnCall[i] = struct {
-		result1 cache.Cache
-	}{result1}
-}
-
-func (fake *Manager) GetClient() client.Client {
-	fake.getClientMutex.Lock()
-	ret, specificReturn := fake.getClientReturnsOnCall[len(fake.getClientArgsForCall)]
-	fake.getClientArgsForCall = append(fake.getClientArgsForCall, struct {
-	}{})
-	stub := fake.GetClientStub
-	fakeReturns := fake.getClientReturns
-	fake.recordInvocation("GetClient", []interface{}{})
-	fake.getClientMutex.Unlock()
-	if stub != nil {
-		return stub()
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Manager) GetClientCallCount() int {
-	fake.getClientMutex.RLock()
-	defer fake.getClientMutex.RUnlock()
-	return len(fake.getClientArgsForCall)
-}
-
-func (fake *Manager) GetClientCalls(stub func() client.Client) {
-	fake.getClientMutex.Lock()
-	defer fake.getClientMutex.Unlock()
-	fake.GetClientStub = stub
-}
-
-func (fake *Manager) GetClientReturns(result1 client.Client) {
-	fake.getClientMutex.Lock()
-	defer fake.getClientMutex.Unlock()
-	fake.GetClientStub = nil
-	fake.getClientReturns = struct {
-		result1 client.Client
-	}{result1}
-}
-
-func (fake *Manager) GetClientReturnsOnCall(i int, result1 client.Client) {
-	fake.getClientMutex.Lock()
-	defer fake.getClientMutex.Unlock()
-	fake.GetClientStub = nil
-	if fake.getClientReturnsOnCall == nil {
-		fake.getClientReturnsOnCall = make(map[int]struct {
-			result1 client.Client
-		})
-	}
-	fake.getClientReturnsOnCall[i] = struct {
-		result1 client.Client
-	}{result1}
-}
-
-func (fake *Manager) GetConfig() *rest.Config {
-	fake.getConfigMutex.Lock()
-	ret, specificReturn := fake.getConfigReturnsOnCall[len(fake.getConfigArgsForCall)]
-	fake.getConfigArgsForCall = append(fake.getConfigArgsForCall, struct {
-	}{})
-	stub := fake.GetConfigStub
-	fakeReturns := fake.getConfigReturns
-	fake.recordInvocation("GetConfig", []interface{}{})
-	fake.getConfigMutex.Unlock()
-	if stub != nil {
-		return stub()
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Manager) GetConfigCallCount() int {
-	fake.getConfigMutex.RLock()
-	defer fake.getConfigMutex.RUnlock()
-	return len(fake.getConfigArgsForCall)
-}
-
-func (fake *Manager) GetConfigCalls(stub func() *rest.Config) {
-	fake.getConfigMutex.Lock()
-	defer fake.getConfigMutex.Unlock()
-	fake.GetConfigStub = stub
-}
-
-func (fake *Manager) GetConfigReturns(result1 *rest.Config) {
-	fake.getConfigMutex.Lock()
-	defer fake.getConfigMutex.Unlock()
-	fake.GetConfigStub = nil
-	fake.getConfigReturns = struct {
-		result1 *rest.Config
-	}{result1}
-}
-
-func (fake *Manager) GetConfigReturnsOnCall(i int, result1 *rest.Config) {
-	fake.getConfigMutex.Lock()
-	defer fake.getConfigMutex.Unlock()
-	fake.GetConfigStub = nil
-	if fake.getConfigReturnsOnCall == nil {
-		fake.getConfigReturnsOnCall = make(map[int]struct {
-			result1 *rest.Config
-		})
-	}
-	fake.getConfigReturnsOnCall[i] = struct {
-		result1 *rest.Config
-	}{result1}
-}
-
-func (fake *Manager) GetControllerOptions() v1alpha1.ControllerConfigurationSpec {
-	fake.getControllerOptionsMutex.Lock()
-	ret, specificReturn := fake.getControllerOptionsReturnsOnCall[len(fake.getControllerOptionsArgsForCall)]
-	fake.getControllerOptionsArgsForCall = append(fake.getControllerOptionsArgsForCall, struct {
-	}{})
-	stub := fake.GetControllerOptionsStub
-	fakeReturns := fake.getControllerOptionsReturns
-	fake.recordInvocation("GetControllerOptions", []interface{}{})
-	fake.getControllerOptionsMutex.Unlock()
-	if stub != nil {
-		return stub()
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Manager) GetControllerOptionsCallCount() int {
-	fake.getControllerOptionsMutex.RLock()
-	defer fake.getControllerOptionsMutex.RUnlock()
-	return len(fake.getControllerOptionsArgsForCall)
-}
-
-func (fake *Manager) GetControllerOptionsCalls(stub func() v1alpha1.ControllerConfigurationSpec) {
-	fake.getControllerOptionsMutex.Lock()
-	defer fake.getControllerOptionsMutex.Unlock()
-	fake.GetControllerOptionsStub = stub
-}
-
-func (fake *Manager) GetControllerOptionsReturns(result1 v1alpha1.ControllerConfigurationSpec) {
-	fake.getControllerOptionsMutex.Lock()
-	defer fake.getControllerOptionsMutex.Unlock()
-	fake.GetControllerOptionsStub = nil
-	fake.getControllerOptionsReturns = struct {
-		result1 v1alpha1.ControllerConfigurationSpec
-	}{result1}
-}
-
-func (fake *Manager) GetControllerOptionsReturnsOnCall(i int, result1 v1alpha1.ControllerConfigurationSpec) {
-	fake.getControllerOptionsMutex.Lock()
-	defer fake.getControllerOptionsMutex.Unlock()
-	fake.GetControllerOptionsStub = nil
-	if fake.getControllerOptionsReturnsOnCall == nil {
-		fake.getControllerOptionsReturnsOnCall = make(map[int]struct {
-			result1 v1alpha1.ControllerConfigurationSpec
-		})
-	}
-	fake.getControllerOptionsReturnsOnCall[i] = struct {
-		result1 v1alpha1.ControllerConfigurationSpec
-	}{result1}
-}
-
-func (fake *Manager) GetEventRecorderFor(arg1 string) record.EventRecorder {
-	fake.getEventRecorderForMutex.Lock()
-	ret, specificReturn := fake.getEventRecorderForReturnsOnCall[len(fake.getEventRecorderForArgsForCall)]
-	fake.getEventRecorderForArgsForCall = append(fake.getEventRecorderForArgsForCall, struct {
-		arg1 string
-	}{arg1})
-	stub := fake.GetEventRecorderForStub
-	fakeReturns := fake.getEventRecorderForReturns
-	fake.recordInvocation("GetEventRecorderFor", []interface{}{arg1})
-	fake.getEventRecorderForMutex.Unlock()
-	if stub != nil {
-		return stub(arg1)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Manager) GetEventRecorderForCallCount() int {
-	fake.getEventRecorderForMutex.RLock()
-	defer fake.getEventRecorderForMutex.RUnlock()
-	return len(fake.getEventRecorderForArgsForCall)
-}
-
-func (fake *Manager) GetEventRecorderForCalls(stub func(string) record.EventRecorder) {
-	fake.getEventRecorderForMutex.Lock()
-	defer fake.getEventRecorderForMutex.Unlock()
-	fake.GetEventRecorderForStub = stub
-}
-
-func (fake *Manager) GetEventRecorderForArgsForCall(i int) string {
-	fake.getEventRecorderForMutex.RLock()
-	defer fake.getEventRecorderForMutex.RUnlock()
-	argsForCall := fake.getEventRecorderForArgsForCall[i]
-	return argsForCall.arg1
-}
-
-func (fake *Manager) GetEventRecorderForReturns(result1 record.EventRecorder) {
-	fake.getEventRecorderForMutex.Lock()
-	defer fake.getEventRecorderForMutex.Unlock()
-	fake.GetEventRecorderForStub = nil
-	fake.getEventRecorderForReturns = struct {
-		result1 record.EventRecorder
-	}{result1}
-}
-
-func (fake *Manager) GetEventRecorderForReturnsOnCall(i int, result1 record.EventRecorder) {
-	fake.getEventRecorderForMutex.Lock()
-	defer fake.getEventRecorderForMutex.Unlock()
-	fake.GetEventRecorderForStub = nil
-	if fake.getEventRecorderForReturnsOnCall == nil {
-		fake.getEventRecorderForReturnsOnCall = make(map[int]struct {
-			result1 record.EventRecorder
-		})
-	}
-	fake.getEventRecorderForReturnsOnCall[i] = struct {
-		result1 record.EventRecorder
-	}{result1}
-}
-
-func (fake *Manager) GetFieldIndexer() client.FieldIndexer {
-	fake.getFieldIndexerMutex.Lock()
-	ret, specificReturn := fake.getFieldIndexerReturnsOnCall[len(fake.getFieldIndexerArgsForCall)]
-	fake.getFieldIndexerArgsForCall = append(fake.getFieldIndexerArgsForCall, struct {
-	}{})
-	stub := fake.GetFieldIndexerStub
-	fakeReturns := fake.getFieldIndexerReturns
-	fake.recordInvocation("GetFieldIndexer", []interface{}{})
-	fake.getFieldIndexerMutex.Unlock()
-	if stub != nil {
-		return stub()
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Manager) GetFieldIndexerCallCount() int {
-	fake.getFieldIndexerMutex.RLock()
-	defer fake.getFieldIndexerMutex.RUnlock()
-	return len(fake.getFieldIndexerArgsForCall)
-}
-
-func (fake *Manager) GetFieldIndexerCalls(stub func() client.FieldIndexer) {
-	fake.getFieldIndexerMutex.Lock()
-	defer fake.getFieldIndexerMutex.Unlock()
-	fake.GetFieldIndexerStub = stub
-}
-
-func (fake *Manager) GetFieldIndexerReturns(result1 client.FieldIndexer) {
-	fake.getFieldIndexerMutex.Lock()
-	defer fake.getFieldIndexerMutex.Unlock()
-	fake.GetFieldIndexerStub = nil
-	fake.getFieldIndexerReturns = struct {
-		result1 client.FieldIndexer
-	}{result1}
-}
-
-func (fake *Manager) GetFieldIndexerReturnsOnCall(i int, result1 client.FieldIndexer) {
-	fake.getFieldIndexerMutex.Lock()
-	defer fake.getFieldIndexerMutex.Unlock()
-	fake.GetFieldIndexerStub = nil
-	if fake.getFieldIndexerReturnsOnCall == nil {
-		fake.getFieldIndexerReturnsOnCall = make(map[int]struct {
-			result1 client.FieldIndexer
-		})
-	}
-	fake.getFieldIndexerReturnsOnCall[i] = struct {
-		result1 client.FieldIndexer
-	}{result1}
-}
-
-func (fake *Manager) GetLogger() logr.Logger {
-	fake.getLoggerMutex.Lock()
-	ret, specificReturn := fake.getLoggerReturnsOnCall[len(fake.getLoggerArgsForCall)]
-	fake.getLoggerArgsForCall = append(fake.getLoggerArgsForCall, struct {
-	}{})
-	stub := fake.GetLoggerStub
-	fakeReturns := fake.getLoggerReturns
-	fake.recordInvocation("GetLogger", []interface{}{})
-	fake.getLoggerMutex.Unlock()
-	if stub != nil {
-		return stub()
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Manager) GetLoggerCallCount() int {
-	fake.getLoggerMutex.RLock()
-	defer fake.getLoggerMutex.RUnlock()
-	return len(fake.getLoggerArgsForCall)
-}
-
-func (fake *Manager) GetLoggerCalls(stub func() logr.Logger) {
-	fake.getLoggerMutex.Lock()
-	defer fake.getLoggerMutex.Unlock()
-	fake.GetLoggerStub = stub
-}
-
-func (fake *Manager) GetLoggerReturns(result1 logr.Logger) {
-	fake.getLoggerMutex.Lock()
-	defer fake.getLoggerMutex.Unlock()
-	fake.GetLoggerStub = nil
-	fake.getLoggerReturns = struct {
-		result1 logr.Logger
-	}{result1}
-}
-
-func (fake *Manager) GetLoggerReturnsOnCall(i int, result1 logr.Logger) {
-	fake.getLoggerMutex.Lock()
-	defer fake.getLoggerMutex.Unlock()
-	fake.GetLoggerStub = nil
-	if fake.getLoggerReturnsOnCall == nil {
-		fake.getLoggerReturnsOnCall = make(map[int]struct {
-			result1 logr.Logger
-		})
-	}
-	fake.getLoggerReturnsOnCall[i] = struct {
-		result1 logr.Logger
-	}{result1}
-}
-
-func (fake *Manager) GetRESTMapper() meta.RESTMapper {
-	fake.getRESTMapperMutex.Lock()
-	ret, specificReturn := fake.getRESTMapperReturnsOnCall[len(fake.getRESTMapperArgsForCall)]
-	fake.getRESTMapperArgsForCall = append(fake.getRESTMapperArgsForCall, struct {
-	}{})
-	stub := fake.GetRESTMapperStub
-	fakeReturns := fake.getRESTMapperReturns
-	fake.recordInvocation("GetRESTMapper", []interface{}{})
-	fake.getRESTMapperMutex.Unlock()
-	if stub != nil {
-		return stub()
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Manager) GetRESTMapperCallCount() int {
-	fake.getRESTMapperMutex.RLock()
-	defer fake.getRESTMapperMutex.RUnlock()
-	return len(fake.getRESTMapperArgsForCall)
-}
-
-func (fake *Manager) GetRESTMapperCalls(stub func() meta.RESTMapper) {
-	fake.getRESTMapperMutex.Lock()
-	defer fake.getRESTMapperMutex.Unlock()
-	fake.GetRESTMapperStub = stub
-}
-
-func (fake *Manager) GetRESTMapperReturns(result1 meta.RESTMapper) {
-	fake.getRESTMapperMutex.Lock()
-	defer fake.getRESTMapperMutex.Unlock()
-	fake.GetRESTMapperStub = nil
-	fake.getRESTMapperReturns = struct {
-		result1 meta.RESTMapper
-	}{result1}
-}
-
-func (fake *Manager) GetRESTMapperReturnsOnCall(i int, result1 meta.RESTMapper) {
-	fake.getRESTMapperMutex.Lock()
-	defer fake.getRESTMapperMutex.Unlock()
-	fake.GetRESTMapperStub = nil
-	if fake.getRESTMapperReturnsOnCall == nil {
-		fake.getRESTMapperReturnsOnCall = make(map[int]struct {
-			result1 meta.RESTMapper
-		})
-	}
-	fake.getRESTMapperReturnsOnCall[i] = struct {
-		result1 meta.RESTMapper
-	}{result1}
-}
-
-func (fake *Manager) GetScheme() *runtime.Scheme {
-	fake.getSchemeMutex.Lock()
-	ret, specificReturn := fake.getSchemeReturnsOnCall[len(fake.getSchemeArgsForCall)]
-	fake.getSchemeArgsForCall = append(fake.getSchemeArgsForCall, struct {
-	}{})
-	stub := fake.GetSchemeStub
-	fakeReturns := fake.getSchemeReturns
-	fake.recordInvocation("GetScheme", []interface{}{})
-	fake.getSchemeMutex.Unlock()
-	if stub != nil {
-		return stub()
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Manager) GetSchemeCallCount() int {
-	fake.getSchemeMutex.RLock()
-	defer fake.getSchemeMutex.RUnlock()
-	return len(fake.getSchemeArgsForCall)
-}
-
-func (fake *Manager) GetSchemeCalls(stub func() *runtime.Scheme) {
-	fake.getSchemeMutex.Lock()
-	defer fake.getSchemeMutex.Unlock()
-	fake.GetSchemeStub = stub
-}
-
-func (fake *Manager) GetSchemeReturns(result1 *runtime.Scheme) {
-	fake.getSchemeMutex.Lock()
-	defer fake.getSchemeMutex.Unlock()
-	fake.GetSchemeStub = nil
-	fake.getSchemeReturns = struct {
-		result1 *runtime.Scheme
-	}{result1}
-}
-
-func (fake *Manager) GetSchemeReturnsOnCall(i int, result1 *runtime.Scheme) {
-	fake.getSchemeMutex.Lock()
-	defer fake.getSchemeMutex.Unlock()
-	fake.GetSchemeStub = nil
-	if fake.getSchemeReturnsOnCall == nil {
-		fake.getSchemeReturnsOnCall = make(map[int]struct {
-			result1 *runtime.Scheme
-		})
-	}
-	fake.getSchemeReturnsOnCall[i] = struct {
-		result1 *runtime.Scheme
-	}{result1}
-}
-
-func (fake *Manager) GetWebhookServer() *webhook.Server {
-	fake.getWebhookServerMutex.Lock()
-	ret, specificReturn := fake.getWebhookServerReturnsOnCall[len(fake.getWebhookServerArgsForCall)]
-	fake.getWebhookServerArgsForCall = append(fake.getWebhookServerArgsForCall, struct {
-	}{})
-	stub := fake.GetWebhookServerStub
-	fakeReturns := fake.getWebhookServerReturns
-	fake.recordInvocation("GetWebhookServer", []interface{}{})
-	fake.getWebhookServerMutex.Unlock()
-	if stub != nil {
-		return stub()
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Manager) GetWebhookServerCallCount() int {
-	fake.getWebhookServerMutex.RLock()
-	defer fake.getWebhookServerMutex.RUnlock()
-	return len(fake.getWebhookServerArgsForCall)
-}
-
-func (fake *Manager) GetWebhookServerCalls(stub func() *webhook.Server) {
-	fake.getWebhookServerMutex.Lock()
-	defer fake.getWebhookServerMutex.Unlock()
-	fake.GetWebhookServerStub = stub
-}
-
-func (fake *Manager) GetWebhookServerReturns(result1 *webhook.Server) {
-	fake.getWebhookServerMutex.Lock()
-	defer fake.getWebhookServerMutex.Unlock()
-	fake.GetWebhookServerStub = nil
-	fake.getWebhookServerReturns = struct {
-		result1 *webhook.Server
-	}{result1}
-}
-
-func (fake *Manager) GetWebhookServerReturnsOnCall(i int, result1 *webhook.Server) {
-	fake.getWebhookServerMutex.Lock()
-	defer fake.getWebhookServerMutex.Unlock()
-	fake.GetWebhookServerStub = nil
-	if fake.getWebhookServerReturnsOnCall == nil {
-		fake.getWebhookServerReturnsOnCall = make(map[int]struct {
-			result1 *webhook.Server
-		})
-	}
-	fake.getWebhookServerReturnsOnCall[i] = struct {
-		result1 *webhook.Server
-	}{result1}
-}
-
-func (fake *Manager) SetFields(arg1 interface{}) error {
-	fake.setFieldsMutex.Lock()
-	ret, specificReturn := fake.setFieldsReturnsOnCall[len(fake.setFieldsArgsForCall)]
-	fake.setFieldsArgsForCall = append(fake.setFieldsArgsForCall, struct {
-		arg1 interface{}
-	}{arg1})
-	stub := fake.SetFieldsStub
-	fakeReturns := fake.setFieldsReturns
-	fake.recordInvocation("SetFields", []interface{}{arg1})
-	fake.setFieldsMutex.Unlock()
-	if stub != nil {
-		return stub(arg1)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Manager) SetFieldsCallCount() int {
-	fake.setFieldsMutex.RLock()
-	defer fake.setFieldsMutex.RUnlock()
-	return len(fake.setFieldsArgsForCall)
-}
-
-func (fake *Manager) SetFieldsCalls(stub func(interface{}) error) {
-	fake.setFieldsMutex.Lock()
-	defer fake.setFieldsMutex.Unlock()
-	fake.SetFieldsStub = stub
-}
-
-func (fake *Manager) SetFieldsArgsForCall(i int) interface{} {
-	fake.setFieldsMutex.RLock()
-	defer fake.setFieldsMutex.RUnlock()
-	argsForCall := fake.setFieldsArgsForCall[i]
-	return argsForCall.arg1
-}
-
-func (fake *Manager) SetFieldsReturns(result1 error) {
-	fake.setFieldsMutex.Lock()
-	defer fake.setFieldsMutex.Unlock()
-	fake.SetFieldsStub = nil
-	fake.setFieldsReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Manager) SetFieldsReturnsOnCall(i int, result1 error) {
-	fake.setFieldsMutex.Lock()
-	defer fake.setFieldsMutex.Unlock()
-	fake.SetFieldsStub = nil
-	if fake.setFieldsReturnsOnCall == nil {
-		fake.setFieldsReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.setFieldsReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Manager) Start(arg1 context.Context) error {
-	fake.startMutex.Lock()
-	ret, specificReturn := fake.startReturnsOnCall[len(fake.startArgsForCall)]
-	fake.startArgsForCall = append(fake.startArgsForCall, struct {
-		arg1 context.Context
-	}{arg1})
-	stub := fake.StartStub
-	fakeReturns := fake.startReturns
-	fake.recordInvocation("Start", []interface{}{arg1})
-	fake.startMutex.Unlock()
-	if stub != nil {
-		return stub(arg1)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *Manager) StartCallCount() int {
-	fake.startMutex.RLock()
-	defer fake.startMutex.RUnlock()
-	return len(fake.startArgsForCall)
-}
-
-func (fake *Manager) StartCalls(stub func(context.Context) error) {
-	fake.startMutex.Lock()
-	defer fake.startMutex.Unlock()
-	fake.StartStub = stub
-}
-
-func (fake *Manager) StartArgsForCall(i int) context.Context {
-	fake.startMutex.RLock()
-	defer fake.startMutex.RUnlock()
-	argsForCall := fake.startArgsForCall[i]
-	return argsForCall.arg1
-}
-
-func (fake *Manager) StartReturns(result1 error) {
-	fake.startMutex.Lock()
-	defer fake.startMutex.Unlock()
-	fake.StartStub = nil
-	fake.startReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Manager) StartReturnsOnCall(i int, result1 error) {
-	fake.startMutex.Lock()
-	defer fake.startMutex.Unlock()
-	fake.StartStub = nil
-	if fake.startReturnsOnCall == nil {
-		fake.startReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.startReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *Manager) Invocations() map[string][][]interface{} {
-	fake.invocationsMutex.RLock()
-	defer fake.invocationsMutex.RUnlock()
-	fake.addMutex.RLock()
-	defer fake.addMutex.RUnlock()
-	fake.addHealthzCheckMutex.RLock()
-	defer fake.addHealthzCheckMutex.RUnlock()
-	fake.addMetricsExtraHandlerMutex.RLock()
-	defer fake.addMetricsExtraHandlerMutex.RUnlock()
-	fake.addReadyzCheckMutex.RLock()
-	defer fake.addReadyzCheckMutex.RUnlock()
-	fake.electedMutex.RLock()
-	defer fake.electedMutex.RUnlock()
-	fake.getAPIReaderMutex.RLock()
-	defer fake.getAPIReaderMutex.RUnlock()
-	fake.getCacheMutex.RLock()
-	defer fake.getCacheMutex.RUnlock()
-	fake.getClientMutex.RLock()
-	defer fake.getClientMutex.RUnlock()
-	fake.getConfigMutex.RLock()
-	defer fake.getConfigMutex.RUnlock()
-	fake.getControllerOptionsMutex.RLock()
-	defer fake.getControllerOptionsMutex.RUnlock()
-	fake.getEventRecorderForMutex.RLock()
-	defer fake.getEventRecorderForMutex.RUnlock()
-	fake.getFieldIndexerMutex.RLock()
-	defer fake.getFieldIndexerMutex.RUnlock()
-	fake.getLoggerMutex.RLock()
-	defer fake.getLoggerMutex.RUnlock()
-	fake.getRESTMapperMutex.RLock()
-	defer fake.getRESTMapperMutex.RUnlock()
-	fake.getSchemeMutex.RLock()
-	defer fake.getSchemeMutex.RUnlock()
-	fake.getWebhookServerMutex.RLock()
-	defer fake.getWebhookServerMutex.RUnlock()
-	fake.setFieldsMutex.RLock()
-	defer fake.setFieldsMutex.RUnlock()
-	fake.startMutex.RLock()
-	defer fake.startMutex.RUnlock()
-	copiedInvocations := map[string][][]interface{}{}
-	for key, value := range fake.invocations {
-		copiedInvocations[key] = value
-	}
-	return copiedInvocations
-}
-
-func (fake *Manager) 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 _ manager.Manager = new(Manager)

pkg/controllers/pushsecret/internal/fakes/recorder.go

@@ -1,179 +0,0 @@
-// Code generated by counterfeiter. DO NOT EDIT.
-package fakes
-
-import (
-	"sync"
-
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/client-go/tools/record"
-)
-
-type FakeEventRecorder struct {
-	AnnotatedEventfStub        func(runtime.Object, map[string]string, string, string, string, ...interface{})
-	annotatedEventfMutex       sync.RWMutex
-	annotatedEventfArgsForCall []struct {
-		arg1 runtime.Object
-		arg2 map[string]string
-		arg3 string
-		arg4 string
-		arg5 string
-		arg6 []interface{}
-	}
-	EventStub        func(runtime.Object, string, string, string)
-	eventMutex       sync.RWMutex
-	eventArgsForCall []struct {
-		arg1 runtime.Object
-		arg2 string
-		arg3 string
-		arg4 string
-	}
-	EventfStub        func(runtime.Object, string, string, string, ...interface{})
-	eventfMutex       sync.RWMutex
-	eventfArgsForCall []struct {
-		arg1 runtime.Object
-		arg2 string
-		arg3 string
-		arg4 string
-		arg5 []interface{}
-	}
-	invocations      map[string][][]interface{}
-	invocationsMutex sync.RWMutex
-}
-
-func (fake *FakeEventRecorder) AnnotatedEventf(arg1 runtime.Object, arg2 map[string]string, arg3 string, arg4 string, arg5 string, arg6 ...interface{}) {
-	fake.annotatedEventfMutex.Lock()
-	fake.annotatedEventfArgsForCall = append(fake.annotatedEventfArgsForCall, struct {
-		arg1 runtime.Object
-		arg2 map[string]string
-		arg3 string
-		arg4 string
-		arg5 string
-		arg6 []interface{}
-	}{arg1, arg2, arg3, arg4, arg5, arg6})
-	stub := fake.AnnotatedEventfStub
-	fake.recordInvocation("AnnotatedEventf", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6})
-	fake.annotatedEventfMutex.Unlock()
-	if stub != nil {
-		fake.AnnotatedEventfStub(arg1, arg2, arg3, arg4, arg5, arg6...)
-	}
-}
-
-func (fake *FakeEventRecorder) AnnotatedEventfCallCount() int {
-	fake.annotatedEventfMutex.RLock()
-	defer fake.annotatedEventfMutex.RUnlock()
-	return len(fake.annotatedEventfArgsForCall)
-}
-
-func (fake *FakeEventRecorder) AnnotatedEventfCalls(stub func(runtime.Object, map[string]string, string, string, string, ...interface{})) {
-	fake.annotatedEventfMutex.Lock()
-	defer fake.annotatedEventfMutex.Unlock()
-	fake.AnnotatedEventfStub = stub
-}
-
-func (fake *FakeEventRecorder) AnnotatedEventfArgsForCall(i int) (runtime.Object, map[string]string, string, string, string, []interface{}) {
-	fake.annotatedEventfMutex.RLock()
-	defer fake.annotatedEventfMutex.RUnlock()
-	argsForCall := fake.annotatedEventfArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6
-}
-
-func (fake *FakeEventRecorder) Event(arg1 runtime.Object, arg2 string, arg3 string, arg4 string) {
-	fake.eventMutex.Lock()
-	fake.eventArgsForCall = append(fake.eventArgsForCall, struct {
-		arg1 runtime.Object
-		arg2 string
-		arg3 string
-		arg4 string
-	}{arg1, arg2, arg3, arg4})
-	stub := fake.EventStub
-	fake.recordInvocation("Event", []interface{}{arg1, arg2, arg3, arg4})
-	fake.eventMutex.Unlock()
-	if stub != nil {
-		fake.EventStub(arg1, arg2, arg3, arg4)
-	}
-}
-
-func (fake *FakeEventRecorder) EventCallCount() int {
-	fake.eventMutex.RLock()
-	defer fake.eventMutex.RUnlock()
-	return len(fake.eventArgsForCall)
-}
-
-func (fake *FakeEventRecorder) EventCalls(stub func(runtime.Object, string, string, string)) {
-	fake.eventMutex.Lock()
-	defer fake.eventMutex.Unlock()
-	fake.EventStub = stub
-}
-
-func (fake *FakeEventRecorder) EventArgsForCall(i int) (runtime.Object, string, string, string) {
-	fake.eventMutex.RLock()
-	defer fake.eventMutex.RUnlock()
-	argsForCall := fake.eventArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
-}
-
-func (fake *FakeEventRecorder) Eventf(arg1 runtime.Object, arg2 string, arg3 string, arg4 string, arg5 ...interface{}) {
-	fake.eventfMutex.Lock()
-	fake.eventfArgsForCall = append(fake.eventfArgsForCall, struct {
-		arg1 runtime.Object
-		arg2 string
-		arg3 string
-		arg4 string
-		arg5 []interface{}
-	}{arg1, arg2, arg3, arg4, arg5})
-	stub := fake.EventfStub
-	fake.recordInvocation("Eventf", []interface{}{arg1, arg2, arg3, arg4, arg5})
-	fake.eventfMutex.Unlock()
-	if stub != nil {
-		fake.EventfStub(arg1, arg2, arg3, arg4, arg5...)
-	}
-}
-
-func (fake *FakeEventRecorder) EventfCallCount() int {
-	fake.eventfMutex.RLock()
-	defer fake.eventfMutex.RUnlock()
-	return len(fake.eventfArgsForCall)
-}
-
-func (fake *FakeEventRecorder) EventfCalls(stub func(runtime.Object, string, string, string, ...interface{})) {
-	fake.eventfMutex.Lock()
-	defer fake.eventfMutex.Unlock()
-	fake.EventfStub = stub
-}
-
-func (fake *FakeEventRecorder) EventfArgsForCall(i int) (runtime.Object, string, string, string, []interface{}) {
-	fake.eventfMutex.RLock()
-	defer fake.eventfMutex.RUnlock()
-	argsForCall := fake.eventfArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
-}
-
-func (fake *FakeEventRecorder) Invocations() map[string][][]interface{} {
-	fake.invocationsMutex.RLock()
-	defer fake.invocationsMutex.RUnlock()
-	fake.annotatedEventfMutex.RLock()
-	defer fake.annotatedEventfMutex.RUnlock()
-	fake.eventMutex.RLock()
-	defer fake.eventMutex.RUnlock()
-	fake.eventfMutex.RLock()
-	defer fake.eventfMutex.RUnlock()
-	copiedInvocations := map[string][][]interface{}{}
-	for key, value := range fake.invocations {
-		copiedInvocations[key] = value
-	}
-	return copiedInvocations
-}
-
-func (fake *FakeEventRecorder) 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 _ record.EventRecorder = new(FakeEventRecorder)

pkg/controllers/pushsecret/internal/fakes/statuswriter.go

@@ -1,196 +0,0 @@
-// Code generated by counterfeiter. DO NOT EDIT.
-package fakes
-
-import (
-	"context"
-	"sync"
-
-	"sigs.k8s.io/controller-runtime/pkg/client"
-)
-
-type StatusWriter struct {
-	PatchStub        func(context.Context, client.Object, client.Patch, ...client.PatchOption) error
-	patchMutex       sync.RWMutex
-	patchArgsForCall []struct {
-		arg1 context.Context
-		arg2 client.Object
-		arg3 client.Patch
-		arg4 []client.PatchOption
-	}
-	patchReturns struct {
-		result1 error
-	}
-	patchReturnsOnCall map[int]struct {
-		result1 error
-	}
-	UpdateStub        func(context.Context, client.Object, ...client.UpdateOption) error
-	updateMutex       sync.RWMutex
-	updateArgsForCall []struct {
-		arg1 context.Context
-		arg2 client.Object
-		arg3 []client.UpdateOption
-	}
-	updateReturns struct {
-		result1 error
-	}
-	updateReturnsOnCall map[int]struct {
-		result1 error
-	}
-	invocations      map[string][][]interface{}
-	invocationsMutex sync.RWMutex
-}
-
-func (fake *StatusWriter) Patch(arg1 context.Context, arg2 client.Object, arg3 client.Patch, arg4 ...client.PatchOption) error {
-	fake.patchMutex.Lock()
-	ret, specificReturn := fake.patchReturnsOnCall[len(fake.patchArgsForCall)]
-	fake.patchArgsForCall = append(fake.patchArgsForCall, struct {
-		arg1 context.Context
-		arg2 client.Object
-		arg3 client.Patch
-		arg4 []client.PatchOption
-	}{arg1, arg2, arg3, arg4})
-	stub := fake.PatchStub
-	fakeReturns := fake.patchReturns
-	fake.recordInvocation("Patch", []interface{}{arg1, arg2, arg3, arg4})
-	fake.patchMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2, arg3, arg4...)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *StatusWriter) PatchCallCount() int {
-	fake.patchMutex.RLock()
-	defer fake.patchMutex.RUnlock()
-	return len(fake.patchArgsForCall)
-}
-
-func (fake *StatusWriter) PatchCalls(stub func(context.Context, client.Object, client.Patch, ...client.PatchOption) error) {
-	fake.patchMutex.Lock()
-	defer fake.patchMutex.Unlock()
-	fake.PatchStub = stub
-}
-
-func (fake *StatusWriter) PatchArgsForCall(i int) (context.Context, client.Object, client.Patch, []client.PatchOption) {
-	fake.patchMutex.RLock()
-	defer fake.patchMutex.RUnlock()
-	argsForCall := fake.patchArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
-}
-
-func (fake *StatusWriter) PatchReturns(result1 error) {
-	fake.patchMutex.Lock()
-	defer fake.patchMutex.Unlock()
-	fake.PatchStub = nil
-	fake.patchReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *StatusWriter) PatchReturnsOnCall(i int, result1 error) {
-	fake.patchMutex.Lock()
-	defer fake.patchMutex.Unlock()
-	fake.PatchStub = nil
-	if fake.patchReturnsOnCall == nil {
-		fake.patchReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.patchReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *StatusWriter) Update(arg1 context.Context, arg2 client.Object, arg3 ...client.UpdateOption) error {
-	fake.updateMutex.Lock()
-	ret, specificReturn := fake.updateReturnsOnCall[len(fake.updateArgsForCall)]
-	fake.updateArgsForCall = append(fake.updateArgsForCall, struct {
-		arg1 context.Context
-		arg2 client.Object
-		arg3 []client.UpdateOption
-	}{arg1, arg2, arg3})
-	stub := fake.UpdateStub
-	fakeReturns := fake.updateReturns
-	fake.recordInvocation("Update", []interface{}{arg1, arg2, arg3})
-	fake.updateMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2, arg3...)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *StatusWriter) UpdateCallCount() int {
-	fake.updateMutex.RLock()
-	defer fake.updateMutex.RUnlock()
-	return len(fake.updateArgsForCall)
-}
-
-func (fake *StatusWriter) UpdateCalls(stub func(context.Context, client.Object, ...client.UpdateOption) error) {
-	fake.updateMutex.Lock()
-	defer fake.updateMutex.Unlock()
-	fake.UpdateStub = stub
-}
-
-func (fake *StatusWriter) UpdateArgsForCall(i int) (context.Context, client.Object, []client.UpdateOption) {
-	fake.updateMutex.RLock()
-	defer fake.updateMutex.RUnlock()
-	argsForCall := fake.updateArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
-}
-
-func (fake *StatusWriter) UpdateReturns(result1 error) {
-	fake.updateMutex.Lock()
-	defer fake.updateMutex.Unlock()
-	fake.UpdateStub = nil
-	fake.updateReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *StatusWriter) UpdateReturnsOnCall(i int, result1 error) {
-	fake.updateMutex.Lock()
-	defer fake.updateMutex.Unlock()
-	fake.UpdateStub = nil
-	if fake.updateReturnsOnCall == nil {
-		fake.updateReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.updateReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *StatusWriter) Invocations() map[string][][]interface{} {
-	fake.invocationsMutex.RLock()
-	defer fake.invocationsMutex.RUnlock()
-	fake.patchMutex.RLock()
-	defer fake.patchMutex.RUnlock()
-	fake.updateMutex.RLock()
-	defer fake.updateMutex.RUnlock()
-	copiedInvocations := map[string][][]interface{}{}
-	for key, value := range fake.invocations {
-		copiedInvocations[key] = value
-	}
-	return copiedInvocations
-}
-
-func (fake *StatusWriter) 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 _ client.StatusWriter = new(StatusWriter)

pkg/controllers/pushsecret/pushsecret_controller.go

@@ -106,14 +106,6 @@ func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Resu
 	ps = SetPushSecretCondition(ps, *cond)
 	// Set status for PushSecret
 	r.recorder.Event(&ps, v1.EventTypeNormal, esapi.ReasonSynced, msg)
-
-	if refreshInt == 0 {
-		return ctrl.Result{
-			RequeueAfter: 0,
-			Requeue:      false,
-		}, nil
-	}
-
 	return ctrl.Result{RequeueAfter: refreshInt}, nil
 }
 

pkg/controllers/pushsecret/pushsecret_controller_test.go

@@ -15,426 +15,228 @@ limitations under the License.
 package pushsecret
 
 import (
+	"bytes"
 	"context"
-	"errors"
 	"fmt"
+	"os"
+	"strconv"
 	"time"
 
-	"github.com/go-logr/logr"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
-	ctrl "sigs.k8s.io/controller-runtime"
-	kubeclient "sigs.k8s.io/controller-runtime/pkg/client"
 
-	esapi "github.com/external-secrets/external-secrets/apis/externalsecrets/v1alpha1"
+	v1alpha1 "github.com/external-secrets/external-secrets/apis/externalsecrets/v1alpha1"
 	v1beta1 "github.com/external-secrets/external-secrets/apis/externalsecrets/v1beta1"
-	"github.com/external-secrets/external-secrets/pkg/controllers/pushsecret/internal/fakes"
+	ctest "github.com/external-secrets/external-secrets/pkg/controllers/commontest"
 	"github.com/external-secrets/external-secrets/pkg/provider/testing/fake"
 )
 
-var fakeProvider *fake.Client
-
-var _ = Describe("pushsecret", func() {
-	var (
-		reconciler *Reconciler
-		client     *fakes.Client
-		recorder   *fakes.FakeEventRecorder
-	)
-	BeforeEach(func() {
-		client = new(fakes.Client)
-		recorder = &fakes.FakeEventRecorder{}
-		reconciler = &Reconciler{client, logr.Discard(), nil, recorder, time.Minute, ""}
-	})
-
-	Describe("#Reconcile", func() {
-		var (
-			statusWriter *fakes.StatusWriter
-		)
-
-		BeforeEach(func() {
-			statusWriter = new(fakes.StatusWriter)
-			client.StatusReturns(statusWriter)
-		})
-
-		It("succeeds", func() {
-			namspacedName := types.NamespacedName{Namespace: "foo", Name: "Bar"}
-			result, err := reconciler.Reconcile(context.Background(), ctrl.Request{NamespacedName: namspacedName})
-			Expect(result).To(Equal(ctrl.Result{RequeueAfter: time.Minute}))
-			Expect(err).NotTo(HaveOccurred())
-			Expect(client.GetCallCount()).To(Equal(2))
-			Expect(client.StatusCallCount()).To(Equal(1))
-
-			_, gotNamespacedName, _ := client.GetArgsForCall(0)
-			Expect(gotNamespacedName).To(Equal(namspacedName))
-
-			Expect(statusWriter.PatchCallCount()).To(Equal(1))
-			_, _, patch, _ := statusWriter.PatchArgsForCall(0)
-			Expect(patch.Type()).To(Equal(types.MergePatchType))
-			Expect(recorder.EventCallCount()).To(Equal(1))
-			_, _, reason, message := recorder.EventArgsForCall(0)
-			Expect(reason).To(Equal(esapi.ReasonSynced))
-			Expect(message).To(Equal("PushSecret synced successfully"))
-		})
-		It("requeues after specified time", func() {
-			client.GetStub = func(context context.Context, name types.NamespacedName, obj kubeclient.Object) error {
-				myObj := obj
-				switch obj.(type) {
-				case *esapi.PushSecret:
-					t := myObj.(*esapi.PushSecret)
-					t.Spec.RefreshInterval = &metav1.Duration{Duration: 0 * time.Second}
-					return nil
-				default:
-					return nil
-				}
-			}
-
-			namspacedName := types.NamespacedName{Namespace: "foo", Name: "Bar"}
-			result, err := reconciler.Reconcile(context.Background(), ctrl.Request{NamespacedName: namspacedName})
-			Expect(result).To(Equal(ctrl.Result{RequeueAfter: 0, Requeue: false}))
-			Expect(err).NotTo(HaveOccurred())
-			Expect(client.GetCallCount()).To(Equal(2))
-			Expect(client.StatusCallCount()).To(Equal(1))
-
-			_, gotNamespacedName, _ := client.GetArgsForCall(0)
-			Expect(gotNamespacedName).To(Equal(namspacedName))
-
-			Expect(statusWriter.PatchCallCount()).To(Equal(1))
-			_, _, patch, _ := statusWriter.PatchArgsForCall(0)
-			Expect(patch.Type()).To(Equal(types.MergePatchType))
-			Expect(recorder.EventCallCount()).To(Equal(1))
-			_, _, reason, message := recorder.EventArgsForCall(0)
-			Expect(reason).To(Equal(esapi.ReasonSynced))
-			Expect(message).To(Equal("PushSecret synced successfully"))
-		})
-
-		When("an error returns in get", func() {
-			BeforeEach(func() {
-				client.GetReturns(errors.New("UnknownError"))
-			})
-
-			It("returns the error", func() {
-				namspacedName := types.NamespacedName{Namespace: "foo", Name: "Bar"}
-				_, err := reconciler.Reconcile(context.Background(), ctrl.Request{NamespacedName: namspacedName})
-
-				Expect(err).To(MatchError("get resource: UnknownError"))
-				Expect(client.GetCallCount()).To(Equal(1))
-				Expect(client.StatusCallCount()).To(Equal(0))
-				_, _, reason, message := recorder.EventArgsForCall(0)
-				Expect(reason).To(Equal(esapi.ReasonErrored))
-				Expect(message).To(Equal("unable to get PushSecret"))
-			})
-		})
-		When("an error returns in get secret", func() {
-			BeforeEach(func() {
-				client.GetStub = func(context context.Context, name types.NamespacedName, obj kubeclient.Object) error {
-					switch obj.(type) {
-					case *v1.Secret:
-						return fmt.Errorf("GetSecretError")
-					default:
-						return nil
-					}
-				}
-			})
-
-			It("returns the error", func() {
-				namspacedName := types.NamespacedName{Namespace: "foo", Name: "Bar"}
-				_, err := reconciler.Reconcile(context.Background(), ctrl.Request{NamespacedName: namspacedName})
-
-				Expect(err).To(MatchError("GetSecretError"))
-				_, _, reason, message := recorder.EventArgsForCall(0)
-				Expect(reason).To(Equal(esapi.ReasonErrored))
-				Expect(message).To(Equal(errFailedGetSecret))
-			})
-		})
-
-		When("an error returns in get secret store", func() {
-			BeforeEach(func() {
-				client.GetStub = func(context context.Context, name types.NamespacedName, obj kubeclient.Object) error {
-					switch v := obj.(type) {
-					case *esapi.PushSecret:
-						v.Spec.SecretStoreRefs = []esapi.PushSecretStoreRef{
-							{Name: "a", Kind: "secretstore"},
-						}
-					}
-					switch obj.(type) {
-					case *v1beta1.SecretStore:
-						return fmt.Errorf("BORK")
-					default:
-						return nil
-					}
-
-				}
-			})
-
-			It("returns the error", func() {
-				namspacedName := types.NamespacedName{Namespace: "foo", Name: "Bar"}
-				_, err := reconciler.Reconcile(context.Background(), ctrl.Request{NamespacedName: namspacedName})
-
-				Expect(err).To(MatchError("could not get SecretStore \"a\", BORK"))
-				_, _, reason, message := recorder.EventArgsForCall(0)
-				Expect(reason).To(Equal(esapi.ReasonErrored))
-				Expect(message).To(Equal("could not get SecretStore \"a\", BORK"))
-			})
-		})
-
-		When("an error returns in set secret to providers", func() {
-			BeforeEach(func() {
-				client.GetStub = func(context context.Context, name types.NamespacedName, obj kubeclient.Object) error {
-					switch v := obj.(type) {
-					case *esapi.PushSecret:
-						v.Spec.SecretStoreRefs = []esapi.PushSecretStoreRef{
-							{Name: "a", Kind: "secretstore"},
-						}
-					case *v1beta1.SecretStore:
-						v.Kind = "PotatoStore"
-					}
-					switch obj.(type) {
-					default:
-						return nil
-					}
+var (
+	fakeProvider *fake.Client
+	timeout      = time.Second * 10
+	interval     = time.Millisecond * 250
+)
 
-				}
-			})
+type testCase struct {
+	store      v1beta1.GenericStore
+	pushsecret *v1alpha1.PushSecret
+	secret     *v1.Secret
+	assert     func(pushsecret *v1alpha1.PushSecret, secret *v1.Secret) bool
+}
 
-			It("returns the error", func() {
-				namspacedName := types.NamespacedName{Namespace: "foo", Name: "Bar"}
-				_, err := reconciler.Reconcile(context.Background(), ctrl.Request{NamespacedName: namspacedName})
+func init() {
+	fakeProvider = fake.New()
+	v1beta1.ForceRegister(fakeProvider, &v1beta1.SecretStoreProvider{
+		Fake: &v1beta1.FakeProvider{},
+	})
+}
 
-				Expect(err).To(MatchError("could not start provider"))
-				_, _, reason, message := recorder.EventArgsForCall(0)
-				Expect(reason).To(Equal(esapi.ReasonErrored))
-				Expect(message).To(Equal("set secret failed: could not start provider"))
-			})
-		})
+type testTweaks func(*testCase)
+
+var _ = Describe("ExternalSecret controller", func() {
+	const (
+		PushSecretName             = "test-es"
+		PushSecretFQDN             = "externalsecrets.external-secrets.io/test-es"
+		PushSecretStore            = "test-store"
+		SecretName                 = "test-secret"
+		PushSecretTargetSecretName = "test-secret"
+		FakeManager                = "fake.manager"
+		expectedSecretVal          = "SOMEVALUE was templated"
+		targetPropObj              = "{{ .targetProperty | toString | upper }} was templated"
+		FooValue                   = "map-foo-value"
+		BarValue                   = "map-bar-value"
+	)
 
-		When("an object is not found", func() {
-			BeforeEach(func() {
-				client.GetReturns(statusErrorNotFound{})
-			})
+	var PushSecretNamespace string
 
-			It("returns an empty result without error", func() {
-				namspacedName := types.NamespacedName{Namespace: "foo", Name: "Bar"}
-				_, err := reconciler.Reconcile(context.Background(), ctrl.Request{NamespacedName: namspacedName})
+	// if we are in debug and need to increase the timeout for testing, we can do so by using an env var
+	if customTimeout := os.Getenv("TEST_CUSTOM_TIMEOUT_SEC"); customTimeout != "" {
+		if t, err := strconv.Atoi(customTimeout); err == nil {
+			timeout = time.Second * time.Duration(t)
+		}
+	}
 
-				Expect(err).NotTo(HaveOccurred())
-			})
-		})
+	BeforeEach(func() {
+		var err error
+		PushSecretNamespace, err = ctest.CreateNamespace("test-ns", k8sClient)
+		Expect(err).ToNot(HaveOccurred())
+		fakeProvider.Reset()
 	})
 
-	Describe("#GetPushSecretCondition", func() {
-		It("returns nil for empty secret sink status", func() {
-			pushSecretStatus := new(esapi.PushSecretStatus)
-			pushSecretConditionType := new(esapi.PushSecretConditionType)
-
-			Expect(GetPushSecretCondition(*pushSecretStatus, *pushSecretConditionType)).To(BeNil())
+	AfterEach(func() {
+		Expect(k8sClient.Delete(context.Background(), &v1.Namespace{
+			ObjectMeta: metav1.ObjectMeta{
+				Name: PushSecretNamespace,
+			},
+		})).To(Succeed())
+		k8sClient.Delete(context.Background(), &v1beta1.SecretStore{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      PushSecretStore,
+				Namespace: PushSecretNamespace,
+			},
 		})
-
-		It("returns correct condition for secret sink status", func() {
-			pushSecretStatusCondition := esapi.PushSecretStatusCondition{Type: esapi.PushSecretReady}
-			pushSecretStatus := esapi.PushSecretStatus{Conditions: []esapi.PushSecretStatusCondition{pushSecretStatusCondition}}
-			pushSecretConditionType := esapi.PushSecretReady
-
-			Expect(GetPushSecretCondition(pushSecretStatus, pushSecretConditionType)).To(Equal(&pushSecretStatusCondition))
+		k8sClient.Delete(context.Background(), &v1.Secret{
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      SecretName,
+				Namespace: PushSecretNamespace,
+			},
 		})
 	})
 
-	Describe("#SetPushSecretCondition", func() {
-		It("appends a condition", func() {
-			pushSecret := esapi.PushSecret{}
-
-			pushSecretStatusCondition := esapi.PushSecretStatusCondition{}
-			pushSecretStatus := esapi.PushSecretStatus{Conditions: []esapi.PushSecretStatusCondition{pushSecretStatusCondition}}
-			expected := esapi.PushSecret{Status: pushSecretStatus}
-			Expect(SetPushSecretCondition(pushSecret, pushSecretStatusCondition)).To(Equal(expected))
-		})
-
-		It("changes an existing condition", func() {
-			conditionStatusTrue := v1.ConditionTrue
-			pushSecretWithCondition := esapi.PushSecret{Status: esapi.PushSecretStatus{Conditions: []esapi.PushSecretStatusCondition{
-				{
-					Status: conditionStatusTrue,
-					Type:   esapi.PushSecretReady,
+	makeDefaultTestcase := func() *testCase {
+		return &testCase{
+			pushsecret: &v1alpha1.PushSecret{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      PushSecretName,
+					Namespace: PushSecretNamespace,
 				},
-			}},
-			}
-			pushSecretStatusConditionTrue := esapi.PushSecretStatusCondition{Status: conditionStatusTrue,
-				Type:    esapi.PushSecretReady,
-				Message: "Update status",
-			}
-
-			got := SetPushSecretCondition(pushSecretWithCondition, pushSecretStatusConditionTrue)
-			Expect(len(got.Status.Conditions)).To(Equal(1))
-			Expect(got.Status.Conditions[0]).To(Equal(pushSecretStatusConditionTrue))
-		})
-	})
-	Describe("#GetSecret", func() {
-		It("returns a secret if it exists", func() {
-			sink := esapi.PushSecret{
-				Spec: esapi.PushSecretSpec{
-					Selector: esapi.PushSecretSelector{
-						Secret: esapi.PushSecretSecret{
-							Name: "foo",
+				Spec: v1alpha1.PushSecretSpec{
+					SecretStoreRefs: []v1alpha1.PushSecretStoreRef{
+						{
+							Name: PushSecretStore,
+							Kind: "SecretStore",
 						},
 					},
-				},
-			}
-			sink.Namespace = "foobar"
-			_, err := reconciler.GetSecret(context.TODO(), sink)
-			Expect(err).To(BeNil())
-			_, name, _ := client.GetArgsForCall(0)
-			Expect(name.Namespace).To(Equal("foobar"))
-			Expect(name.Name).To(Equal("foo"))
-
-		})
-
-		It("returns an error if it doesn't exist", func() {
-			client.GetReturns(errors.New("secret not found"))
-			_, err := reconciler.GetSecret(context.TODO(), esapi.PushSecret{})
-			Expect(err).To(HaveOccurred())
-		})
-	})
-
-	Describe("#GetSecretStore", func() {
-		sink := esapi.PushSecret{
-			Spec: esapi.PushSecretSpec{
-				SecretStoreRefs: []esapi.PushSecretStoreRef{
-					{
-						Name: "foo",
+					Selector: v1alpha1.PushSecretSelector{
+						Secret: v1alpha1.PushSecretSecret{
+							Name: SecretName,
+						},
 					},
-				},
-			},
-		}
-		sink.Namespace = "bar"
-
-		clusterSink := esapi.PushSecret{
-			Spec: esapi.PushSecretSpec{
-				SecretStoreRefs: []esapi.PushSecretStoreRef{
-					{
-						Name: "foo",
-						Kind: "ClusterSecretStore",
+					Data: []v1alpha1.PushSecretData{
+						{
+							Match: v1alpha1.PushSecretMatch{
+								SecretKey: "key",
+								RemoteRefs: []v1alpha1.PushSecretRemoteRefs{
+									{
+										RemoteKey: "path/to/key",
+									},
+								},
+							},
+						},
 					},
 				},
 			},
-		}
-
-		It("returns a secretstore if it exists", func() {
-			_, err := reconciler.GetSecretStores(context.TODO(), sink)
-			Expect(err).To(BeNil())
-			Expect(client.GetCallCount()).To(Equal(1))
-			_, name, store := client.GetArgsForCall(0)
-			Expect(name.Namespace).To(Equal("bar"))
-			Expect(name.Name).To(Equal("foo"))
-			Expect(store).To(BeAssignableToTypeOf(&v1beta1.SecretStore{}))
-		})
-
-		It("returns an error if it doesn't exist", func() {
-			client.GetReturns(errors.New("secretstore not found"))
-			_, err := reconciler.GetSecretStores(context.TODO(), sink)
-			Expect(err).To(HaveOccurred())
-		})
-
-		It("returns a clustersecretstore if it exists", func() {
-			_, err := reconciler.GetSecretStores(context.TODO(), clusterSink)
-			Expect(err).To(BeNil())
-			Expect(client.GetCallCount()).To(Equal(1))
-			_, name, store := client.GetArgsForCall(0)
-			Expect(store).To(BeAssignableToTypeOf(&v1beta1.ClusterSecretStore{}))
-			Expect(name.Name).To(Equal("foo"))
-		})
-	})
-	Describe("#SetSecretToProviders", func() {
-		val := "supersecret"
-		secret := &v1.Secret{
-			Data: map[string][]byte{
-				"foo": []byte(val),
+			secret: &v1.Secret{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      SecretName,
+					Namespace: PushSecretNamespace,
+				},
+				Data: map[string][]byte{
+					"key": []byte("value"),
+				},
 			},
-		}
-		sink := esapi.PushSecret{
-			Spec: esapi.PushSecretSpec{
-				SecretStoreRefs: []esapi.PushSecretStoreRef{
-					{
-						Name: "foo",
-					},
+			store: &v1beta1.SecretStore{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      PushSecretStore,
+					Namespace: PushSecretNamespace,
 				},
-				Data: []esapi.PushSecretData{
-					{
-						Match: esapi.PushSecretMatch{
-							SecretKey: "foo",
-							RemoteRefs: []esapi.PushSecretRemoteRefs{
-								{
-									RemoteKey: "bar",
-								},
-							},
+				Spec: v1beta1.SecretStoreSpec{
+					Provider: &v1beta1.SecretStoreProvider{
+						Fake: &v1beta1.FakeProvider{
+							Data: []v1beta1.FakeProviderData{},
 						},
 					},
 				},
 			},
 		}
-		sink.Namespace = "bar"
+	}
 
-		secretStore := v1beta1.SecretStore{}
-		stores := make([]v1beta1.GenericStore, 0)
-		stores = append(stores, &secretStore)
-
-		It("gets the provider and client and then sets the secret", func() {
-
-			Expect(reconciler.SetSecretToProviders(context.TODO(), []v1beta1.GenericStore{}, sink, secret)).To(BeNil())
-		})
-
-		It("returns an error if it can't get a provider", func() {
-			err := reconciler.SetSecretToProviders(context.TODO(), stores, sink, secret)
-
-			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(Equal(errGetProviderFailed))
-		})
-
-		It("returns an if it can't get a client", func() {
-			specWithProvider := v1beta1.SecretStoreSpec{
-				Provider: &v1beta1.SecretStoreProvider{
-					Fake: &v1beta1.FakeProvider{},
-				},
+	// if target Secret name is not specified it should use the ExternalSecret name.
+	syncSuccessfully := func(tc *testCase) {
+		fakeProvider.SetSecretFn = func() error {
+			return nil
+		}
+		tc.assert = func(ps *v1alpha1.PushSecret, secret *v1.Secret) bool {
+			secretValue := secret.Data["key"]
+			providerValue := fakeProvider.SetSecretArgs[ps.Spec.Data[0].Match.RemoteRefs[0].RemoteKey].Value
+			return bytes.Equal(secretValue, providerValue)
+		}
+	}
+	// if target Secret name is not specified it should use the ExternalSecret name.
+	failNoSecret := func(tc *testCase) {
+		fakeProvider.SetSecretFn = func() error {
+			return nil
+		}
+		tc.secret = nil
+		tc.assert = func(ps *v1alpha1.PushSecret, secret *v1.Secret) bool {
+			return ps.Status.Conditions[0].Reason == v1alpha1.ReasonErrored
+		}
+	}
+	// if target Secret name is not specified it should use the ExternalSecret name.
+	failNoSecretStore := func(tc *testCase) {
+		fakeProvider.SetSecretFn = func() error {
+			return nil
+		}
+		tc.store = nil
+		tc.assert = func(ps *v1alpha1.PushSecret, secret *v1.Secret) bool {
+			return ps.Status.Conditions[0].Reason == v1alpha1.ReasonErrored
+		}
+	}
+	// if target Secret name is not specified it should use the ExternalSecret name.
+	setSecretFail := func(tc *testCase) {
+		fakeProvider.SetSecretFn = func() error {
+			return fmt.Errorf("boom")
+		}
+		tc.assert = func(ps *v1alpha1.PushSecret, secret *v1.Secret) bool {
+			return ps.Status.Conditions[0].Reason == v1alpha1.ReasonErrored
+		}
+	}
+	DescribeTable("When reconciling a PushSecret",
+		func(tweaks ...testTweaks) {
+			tc := makeDefaultTestcase()
+			for _, tweak := range tweaks {
+				tweak(tc)
 			}
-			fakeProvider.WithNew(func(context.Context, v1beta1.GenericStore, kubeclient.Client,
-				string) (v1beta1.SecretsClient, error) {
-				return nil, fmt.Errorf("Something went wrong")
-			})
-			secretStore = v1beta1.SecretStore{
-				Spec: specWithProvider,
+			ctx := context.Background()
+			By("creating a secret store, secret and pushsecret")
+			if tc.store != nil {
+				Expect(k8sClient.Create(ctx, tc.store)).To(Succeed())
 			}
-
-			stores[0] = &secretStore
-			err := reconciler.SetSecretToProviders(context.TODO(), stores, sink, secret)
-
-			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(Equal(errGetSecretsClientFailed))
-		})
-		It("returns an error if set secret fails", func() {
-			specWithProvider := v1beta1.SecretStoreSpec{
-				Provider: &v1beta1.SecretStoreProvider{
-					Fake: &v1beta1.FakeProvider{},
-				},
+			if tc.secret != nil {
+				Expect(k8sClient.Create(ctx, tc.secret)).To(Succeed())
 			}
-			fakeProvider.Reset()
-			fakeProvider.WithSetSecret(fmt.Errorf("something went wrong"))
-			secretStore = v1beta1.SecretStore{
-				Spec: specWithProvider,
+			if tc.pushsecret != nil {
+				Expect(k8sClient.Create(ctx, tc.pushsecret)).Should(Succeed())
 			}
-
-			stores[0] = &secretStore
-			err := reconciler.SetSecretToProviders(context.TODO(), stores, sink, secret)
-
-			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(Equal(fmt.Sprintf(errSetSecretFailed, "foo", "", "something went wrong")))
-		})
-	})
+			time.Sleep(2 * time.Second)
+			psKey := types.NamespacedName{Name: PushSecretName, Namespace: PushSecretNamespace}
+			createdPS := &v1alpha1.PushSecret{}
+			By("checking the pushSecret condition")
+			Eventually(func() bool {
+				err := k8sClient.Get(ctx, psKey, createdPS)
+				if err != nil {
+					return false
+				}
+				return tc.assert(createdPS, tc.secret)
+			}, timeout, interval).Should(BeTrue())
+			// this must be optional so we can test faulty es configuration
+		},
+		Entry("should work as we are not doing anything at all!", syncSuccessfully),
+		Entry("should fail if Secret is not created", failNoSecret),
+		Entry("should fail if SetSecret fails", setSecretFail),
+		Entry("should fail if no valid SecretStore", failNoSecretStore),
+	)
 })
-
-func init() {
-	fakeProvider = fake.New()
-	v1beta1.ForceRegister(fakeProvider, &v1beta1.SecretStoreProvider{
-		Fake: &v1beta1.FakeProvider{},
-	})
-}

pkg/controllers/pushsecret/suite_test.go

@@ -15,30 +15,91 @@ limitations under the License.
 package pushsecret
 
 import (
+	"context"
+	"path/filepath"
 	"testing"
+	"time"
 
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	"k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"go.uber.org/zap/zapcore"
+	"k8s.io/client-go/kubernetes/scheme"
+	"k8s.io/client-go/rest"
+	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/envtest"
+	logf "sigs.k8s.io/controller-runtime/pkg/log"
+	"sigs.k8s.io/controller-runtime/pkg/log/zap"
+
+	esv1alpha1 "github.com/external-secrets/external-secrets/apis/externalsecrets/v1alpha1"
+	esv1beta1 "github.com/external-secrets/external-secrets/apis/externalsecrets/v1beta1"
 )
 
+// These tests use Ginkgo (BDD-style Go testing framework). Refer to
+// http://onsi.github.io/ginkgo/ to learn more about Ginkgo.
+
+var cfg *rest.Config
+var k8sClient client.Client
+var testEnv *envtest.Environment
+var cancel context.CancelFunc
+
 func TestAPIs(t *testing.T) {
 	RegisterFailHandler(Fail)
 	RunSpecs(t, "Controller Suite")
 }
 
-type statusErrorNotFound struct {
-}
+var _ = BeforeSuite(func() {
+	log := zap.New(zap.WriteTo(GinkgoWriter), zap.Level(zapcore.DebugLevel))
 
-func (statusErrorNotFound) Status() metav1.Status {
-	return metav1.Status{
-		Reason: metav1.StatusReasonNotFound,
+	logf.SetLogger(log)
+
+	By("bootstrapping test environment")
+	testEnv = &envtest.Environment{
+		CRDDirectoryPaths: []string{filepath.Join("..", "..", "..", "deploy", "crds")},
 	}
-}
 
-func (statusErrorNotFound) Error() string {
-	return "Blurb"
-}
+	var ctx context.Context
+	ctx, cancel = context.WithCancel(context.Background())
+
+	var err error
+	cfg, err = testEnv.Start()
+	Expect(err).ToNot(HaveOccurred())
+	Expect(cfg).ToNot(BeNil())
+
+	err = esv1beta1.AddToScheme(scheme.Scheme)
+	Expect(err).NotTo(HaveOccurred())
+	err = esv1alpha1.AddToScheme(scheme.Scheme)
+	Expect(err).NotTo(HaveOccurred())
+
+	k8sManager, err := ctrl.NewManager(cfg, ctrl.Options{
+		Scheme:             scheme.Scheme,
+		MetricsBindAddress: "0", // avoid port collision when testing
+	})
+	Expect(err).ToNot(HaveOccurred())
+
+	// do not use k8sManager.GetClient()
+	// see https://github.com/kubernetes-sigs/controller-runtime/issues/343#issuecomment-469435686
+	k8sClient, err = client.New(cfg, client.Options{Scheme: scheme.Scheme})
+	Expect(k8sClient).ToNot(BeNil())
+	Expect(err).ToNot(HaveOccurred())
+
+	err = (&Reconciler{
+		Client:          k8sClient,
+		Scheme:          k8sManager.GetScheme(),
+		Log:             ctrl.Log.WithName("controllers").WithName("ExternalSecrets"),
+		RequeueInterval: time.Second,
+	}).SetupWithManager(k8sManager)
+	Expect(err).ToNot(HaveOccurred())
+
+	go func() {
+		defer GinkgoRecover()
+		Expect(k8sManager.Start(ctx)).ToNot(HaveOccurred())
+	}()
+})
 
-var _ errors.APIStatus = statusErrorNotFound{}
+var _ = AfterSuite(func() {
+	By("tearing down the test environment")
+	cancel() // stop manager
+	err := testEnv.Stop()
+	Expect(err).ToNot(HaveOccurred())
+})

pkg/provider/testing/fake/fake.go

@@ -24,8 +24,14 @@ import (
 
 var _ esv1beta1.Provider = &Client{}
 
+type SetSecretCallArgs struct {
+	Value     []byte
+	RemoteRef esv1beta1.PushRemoteRef
+}
+
 // Client is a fake client for testing.
 type Client struct {
+	SetSecretArgs   map[string]SetSecretCallArgs
 	NewFn           func(context.Context, esv1beta1.GenericStore, client.Client, string) (esv1beta1.SecretsClient, error)
 	GetSecretFn     func(context.Context, esv1beta1.ExternalSecretDataRemoteRef) ([]byte, error)
 	GetSecretMapFn  func(context.Context, esv1beta1.ExternalSecretDataRemoteRef) (map[string][]byte, error)
@@ -48,6 +54,7 @@ func New() *Client {
 		SetSecretFn: func() error {
 			return nil
 		},
+		SetSecretArgs: map[string]SetSecretCallArgs{},
 	}
 
 	v.NewFn = func(context.Context, esv1beta1.GenericStore, client.Client, string) (esv1beta1.SecretsClient, error) {
@@ -69,6 +76,10 @@ func (v *Client) GetAllSecrets(ctx context.Context, ref esv1beta1.ExternalSecret
 
 // Not Implemented SetSecret.
 func (v *Client) SetSecret(ctx context.Context, value []byte, remoteRef esv1beta1.PushRemoteRef) error {
+	v.SetSecretArgs[remoteRef.GetRemoteKey()] = SetSecretCallArgs{
+		Value:     value,
+		RemoteRef: remoteRef,
+	}
 	return v.SetSecretFn()
 }