Adds DeleteSecret for GCPSM

Signed-off-by: Gustavo <gusfcarvalho@gmail.com>

pkg/provider/gcp/secretmanager/client.go

@@ -74,6 +74,7 @@ type Client struct {
 }
 
 type GoogleSecretManagerClient interface {
+	DeleteSecret(ctx context.Context, req *secretmanagerpb.DeleteSecretRequest, opts ...gax.CallOption) error
 	AccessSecretVersion(ctx context.Context, req *secretmanagerpb.AccessSecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.AccessSecretVersionResponse, error)
 	ListSecrets(ctx context.Context, req *secretmanagerpb.ListSecretsRequest, opts ...gax.CallOption) *secretmanager.SecretIterator
 	AddSecretVersion(ctx context.Context, req *secretmanagerpb.AddSecretVersionRequest, opts ...gax.CallOption) (*secretmanagerpb.SecretVersion, error)
@@ -85,7 +86,33 @@ type GoogleSecretManagerClient interface {
 var log = ctrl.Log.WithName("provider").WithName("gcp").WithName("secretsmanager")
 
 func (c *Client) DeleteSecret(ctx context.Context, remoteRef esv1beta1.PushRemoteRef) error {
-	return fmt.Errorf("not implemented")
+	var gcpSecret *secretmanagerpb.Secret
+	var err error
+
+	gcpSecret, err = c.smClient.GetSecret(ctx, &secretmanagerpb.GetSecretRequest{
+		Name: fmt.Sprintf("projects/%s/secrets/%s", c.store.ProjectID, remoteRef.GetRemoteKey()),
+	})
+	var gErr *apierror.APIError
+
+	if errors.As(err, &gErr) {
+		if gErr.GRPCStatus().Code() == codes.NotFound {
+			return nil
+		}
+		return err
+	}
+	if err != nil {
+		return err
+	}
+	manager, ok := gcpSecret.Labels["managed-by"]
+
+	if !ok || manager != "external-secrets" {
+		return nil
+	}
+
+	deleteSecretVersionReq := &secretmanagerpb.DeleteSecretRequest{
+		Name: fmt.Sprintf("projects/%s/secrets/%s", c.store.ProjectID, remoteRef.GetRemoteKey()),
+	}
+	return c.smClient.DeleteSecret(ctx, deleteSecretVersionReq)
 }
 
 // SetSecret pushes a kubernetes secret key into gcp provider Secret.

pkg/provider/gcp/secretmanager/client_test.go

@@ -15,6 +15,7 @@ package secretmanager
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"reflect"
 	"strings"
@@ -194,6 +195,114 @@ func (f fakeRef) GetRemoteKey() string {
 	return f.key
 }
 
+func TestDeleteSecret(t *testing.T) {
+	fErr := status.Error(codes.NotFound, "failed")
+	notFoundError, _ := apierror.FromError(fErr)
+	pErr := status.Error(codes.PermissionDenied, "failed")
+	permissionDeniedError, _ := apierror.FromError(pErr)
+	fakeClient := fakesm.MockSMClient{}
+	type args struct {
+		client          fakesm.MockSMClient
+		getSecretOutput fakesm.GetSecretMockReturn
+		deleteSecretErr error
+	}
+	type want struct {
+		err error
+	}
+	type testCase struct {
+		args   args
+		want   want
+		reason string
+	}
+	tests := map[string]testCase{
+		"Deletes Successfully": {
+			args: args{
+				client: fakeClient,
+				getSecretOutput: fakesm.GetSecretMockReturn{
+					Secret: &secretmanagerpb.Secret{
+
+						Name: "projects/foo/secret/bar",
+						Labels: map[string]string{
+							"managed-by": "external-secrets",
+						},
+					},
+					Err: nil,
+				},
+			},
+		},
+		"Not Managed by ESO": {
+			args: args{
+				client: fakeClient,
+				getSecretOutput: fakesm.GetSecretMockReturn{
+					Secret: &secretmanagerpb.Secret{
+
+						Name:   "projects/foo/secret/bar",
+						Labels: map[string]string{},
+					},
+					Err: nil,
+				},
+			},
+		},
+		"Secret Not Found": {
+			args: args{
+				client: fakeClient,
+				getSecretOutput: fakesm.GetSecretMockReturn{
+					Secret: nil,
+					Err:    notFoundError,
+				},
+			},
+		},
+		"Random Error": {
+			args: args{
+				client: fakeClient,
+				getSecretOutput: fakesm.GetSecretMockReturn{
+					Secret: nil,
+					Err:    errors.New("This errored out"),
+				},
+			},
+			want: want{
+				err: errors.New("This errored out"),
+			},
+		},
+		"Random GError": {
+			args: args{
+				client: fakeClient,
+				getSecretOutput: fakesm.GetSecretMockReturn{
+					Secret: nil,
+					Err:    permissionDeniedError,
+				},
+			},
+			want: want{
+				err: errors.New("failed"),
+			},
+		},
+	}
+	for name, tc := range tests {
+		t.Run(name, func(t *testing.T) {
+			ref := fakeRef{key: "fake-key"}
+			client := Client{
+				smClient: &tc.args.client,
+				store: &esv1beta1.GCPSMProvider{
+					ProjectID: "foo",
+				},
+			}
+			tc.args.client.NewGetSecretFn(tc.args.getSecretOutput)
+			tc.args.client.NewDeleteSecretFn(tc.args.deleteSecretErr)
+			err := client.DeleteSecret(context.TODO(), ref)
+			// Error nil XOR tc.want.err nil
+			if ((err == nil) || (tc.want.err == nil)) && !((err == nil) && (tc.want.err == nil)) {
+				t.Errorf("\nTesting SetSecret:\nName: %v\nReason: %v\nWant error: %v\nGot error: %v", name, tc.reason, tc.want.err, err)
+			}
+
+			// if errors are the same type but their contents do not match
+			if err != nil && tc.want.err != nil {
+				if !strings.Contains(err.Error(), tc.want.err.Error()) {
+					t.Errorf("\nTesting SetSecret:\nName: %v\nReason: %v\nWant error: %v\nGot error got nil", name, tc.reason, tc.want.err)
+				}
+			}
+		})
+	}
+}
 func TestSetSecret(t *testing.T) {
 	ref := fakeRef{key: "/baz"}
 

pkg/provider/gcp/secretmanager/fake/fake.go

@@ -32,6 +32,7 @@ type MockSMClient struct {
 	createSecretFn func(ctx context.Context, req *secretmanagerpb.CreateSecretRequest, opts ...gax.CallOption) (*secretmanagerpb.Secret, error)
 	closeFn        func() error
 	GetSecretFn    func(ctx context.Context, req *secretmanagerpb.GetSecretRequest, opts ...gax.CallOption) (*secretmanagerpb.Secret, error)
+	DeleteSecretFn func(ctx context.Context, req *secretmanagerpb.DeleteSecretRequest, opts ...gax.CallOption) error
 }
 
 type AccessSecretVersionMockReturn struct {
@@ -54,6 +55,14 @@ type CreateSecretMockReturn struct {
 	Err    error
 }
 
+func (mc *MockSMClient) DeleteSecret(ctx context.Context, req *secretmanagerpb.DeleteSecretRequest, opts ...gax.CallOption) error {
+	return mc.DeleteSecretFn(ctx, req)
+}
+func (mc *MockSMClient) NewDeleteSecretFn(err error) {
+	mc.DeleteSecretFn = func(ctx context.Context, req *secretmanagerpb.DeleteSecretRequest, opts ...gax.CallOption) error {
+		return err
+	}
+}
 func (mc *MockSMClient) GetSecret(ctx context.Context, req *secretmanagerpb.GetSecretRequest, opts ...gax.CallOption) (*secretmanagerpb.Secret, error) {
 	return mc.GetSecretFn(ctx, req)
 }

pkg/provider/gcp/secretmanager/internal/fakes/client.go

@@ -1,516 +0,0 @@
-// Code generated by counterfeiter. DO NOT EDIT.
-package fakes
-
-import (
-	"context"
-	"sync"
-
-	secretmanagerb "cloud.google.com/go/secretmanager/apiv1"
-	"github.com/external-secrets/external-secrets/pkg/provider/gcp/secretmanager"
-	gax "github.com/googleapis/gax-go/v2"
-	secretmanagera "google.golang.org/genproto/googleapis/cloud/secretmanager/v1"
-)
-
-type GoogleSecretManagerClient struct {
-	AccessSecretVersionStub        func(context.Context, *secretmanagera.AccessSecretVersionRequest, ...gax.CallOption) (*secretmanagera.AccessSecretVersionResponse, error)
-	accessSecretVersionMutex       sync.RWMutex
-	accessSecretVersionArgsForCall []struct {
-		arg1 context.Context
-		arg2 *secretmanagera.AccessSecretVersionRequest
-		arg3 []gax.CallOption
-	}
-	accessSecretVersionReturns struct {
-		result1 *secretmanagera.AccessSecretVersionResponse
-		result2 error
-	}
-	accessSecretVersionReturnsOnCall map[int]struct {
-		result1 *secretmanagera.AccessSecretVersionResponse
-		result2 error
-	}
-	AddSecretVersionStub        func(context.Context, *secretmanagera.AddSecretVersionRequest, ...gax.CallOption) (*secretmanagera.SecretVersion, error)
-	addSecretVersionMutex       sync.RWMutex
-	addSecretVersionArgsForCall []struct {
-		arg1 context.Context
-		arg2 *secretmanagera.AddSecretVersionRequest
-		arg3 []gax.CallOption
-	}
-	addSecretVersionReturns struct {
-		result1 *secretmanagera.SecretVersion
-		result2 error
-	}
-	addSecretVersionReturnsOnCall map[int]struct {
-		result1 *secretmanagera.SecretVersion
-		result2 error
-	}
-	CloseStub        func() error
-	closeMutex       sync.RWMutex
-	closeArgsForCall []struct {
-	}
-	closeReturns struct {
-		result1 error
-	}
-	closeReturnsOnCall map[int]struct {
-		result1 error
-	}
-	CreateSecretStub        func(context.Context, *secretmanagera.CreateSecretRequest, ...gax.CallOption) (*secretmanagera.Secret, error)
-	createSecretMutex       sync.RWMutex
-	createSecretArgsForCall []struct {
-		arg1 context.Context
-		arg2 *secretmanagera.CreateSecretRequest
-		arg3 []gax.CallOption
-	}
-	createSecretReturns struct {
-		result1 *secretmanagera.Secret
-		result2 error
-	}
-	createSecretReturnsOnCall map[int]struct {
-		result1 *secretmanagera.Secret
-		result2 error
-	}
-	GetSecretStub        func(context.Context, *secretmanagera.GetSecretRequest, ...gax.CallOption) (*secretmanagera.Secret, error)
-	getSecretMutex       sync.RWMutex
-	getSecretArgsForCall []struct {
-		arg1 context.Context
-		arg2 *secretmanagera.GetSecretRequest
-		arg3 []gax.CallOption
-	}
-	getSecretReturns struct {
-		result1 *secretmanagera.Secret
-		result2 error
-	}
-	getSecretReturnsOnCall map[int]struct {
-		result1 *secretmanagera.Secret
-		result2 error
-	}
-	ListSecretsStub        func(context.Context, *secretmanagera.ListSecretsRequest, ...gax.CallOption) *secretmanagerb.SecretIterator
-	listSecretsMutex       sync.RWMutex
-	listSecretsArgsForCall []struct {
-		arg1 context.Context
-		arg2 *secretmanagera.ListSecretsRequest
-		arg3 []gax.CallOption
-	}
-	listSecretsReturns struct {
-		result1 *secretmanagerb.SecretIterator
-	}
-	listSecretsReturnsOnCall map[int]struct {
-		result1 *secretmanagerb.SecretIterator
-	}
-	invocations      map[string][][]interface{}
-	invocationsMutex sync.RWMutex
-}
-
-func (fake *GoogleSecretManagerClient) AccessSecretVersion(arg1 context.Context, arg2 *secretmanagera.AccessSecretVersionRequest, arg3 ...gax.CallOption) (*secretmanagera.AccessSecretVersionResponse, error) {
-	fake.accessSecretVersionMutex.Lock()
-	ret, specificReturn := fake.accessSecretVersionReturnsOnCall[len(fake.accessSecretVersionArgsForCall)]
-	fake.accessSecretVersionArgsForCall = append(fake.accessSecretVersionArgsForCall, struct {
-		arg1 context.Context
-		arg2 *secretmanagera.AccessSecretVersionRequest
-		arg3 []gax.CallOption
-	}{arg1, arg2, arg3})
-	stub := fake.AccessSecretVersionStub
-	fakeReturns := fake.accessSecretVersionReturns
-	fake.recordInvocation("AccessSecretVersion", []interface{}{arg1, arg2, arg3})
-	fake.accessSecretVersionMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2, arg3...)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *GoogleSecretManagerClient) AccessSecretVersionCallCount() int {
-	fake.accessSecretVersionMutex.RLock()
-	defer fake.accessSecretVersionMutex.RUnlock()
-	return len(fake.accessSecretVersionArgsForCall)
-}
-
-func (fake *GoogleSecretManagerClient) AccessSecretVersionCalls(stub func(context.Context, *secretmanagera.AccessSecretVersionRequest, ...gax.CallOption) (*secretmanagera.AccessSecretVersionResponse, error)) {
-	fake.accessSecretVersionMutex.Lock()
-	defer fake.accessSecretVersionMutex.Unlock()
-	fake.AccessSecretVersionStub = stub
-}
-
-func (fake *GoogleSecretManagerClient) AccessSecretVersionArgsForCall(i int) (context.Context, *secretmanagera.AccessSecretVersionRequest, []gax.CallOption) {
-	fake.accessSecretVersionMutex.RLock()
-	defer fake.accessSecretVersionMutex.RUnlock()
-	argsForCall := fake.accessSecretVersionArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
-}
-
-func (fake *GoogleSecretManagerClient) AccessSecretVersionReturns(result1 *secretmanagera.AccessSecretVersionResponse, result2 error) {
-	fake.accessSecretVersionMutex.Lock()
-	defer fake.accessSecretVersionMutex.Unlock()
-	fake.AccessSecretVersionStub = nil
-	fake.accessSecretVersionReturns = struct {
-		result1 *secretmanagera.AccessSecretVersionResponse
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *GoogleSecretManagerClient) AccessSecretVersionReturnsOnCall(i int, result1 *secretmanagera.AccessSecretVersionResponse, result2 error) {
-	fake.accessSecretVersionMutex.Lock()
-	defer fake.accessSecretVersionMutex.Unlock()
-	fake.AccessSecretVersionStub = nil
-	if fake.accessSecretVersionReturnsOnCall == nil {
-		fake.accessSecretVersionReturnsOnCall = make(map[int]struct {
-			result1 *secretmanagera.AccessSecretVersionResponse
-			result2 error
-		})
-	}
-	fake.accessSecretVersionReturnsOnCall[i] = struct {
-		result1 *secretmanagera.AccessSecretVersionResponse
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *GoogleSecretManagerClient) AddSecretVersion(arg1 context.Context, arg2 *secretmanagera.AddSecretVersionRequest, arg3 ...gax.CallOption) (*secretmanagera.SecretVersion, error) {
-	fake.addSecretVersionMutex.Lock()
-	ret, specificReturn := fake.addSecretVersionReturnsOnCall[len(fake.addSecretVersionArgsForCall)]
-	fake.addSecretVersionArgsForCall = append(fake.addSecretVersionArgsForCall, struct {
-		arg1 context.Context
-		arg2 *secretmanagera.AddSecretVersionRequest
-		arg3 []gax.CallOption
-	}{arg1, arg2, arg3})
-	stub := fake.AddSecretVersionStub
-	fakeReturns := fake.addSecretVersionReturns
-	fake.recordInvocation("AddSecretVersion", []interface{}{arg1, arg2, arg3})
-	fake.addSecretVersionMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2, arg3...)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *GoogleSecretManagerClient) AddSecretVersionCallCount() int {
-	fake.addSecretVersionMutex.RLock()
-	defer fake.addSecretVersionMutex.RUnlock()
-	return len(fake.addSecretVersionArgsForCall)
-}
-
-func (fake *GoogleSecretManagerClient) AddSecretVersionCalls(stub func(context.Context, *secretmanagera.AddSecretVersionRequest, ...gax.CallOption) (*secretmanagera.SecretVersion, error)) {
-	fake.addSecretVersionMutex.Lock()
-	defer fake.addSecretVersionMutex.Unlock()
-	fake.AddSecretVersionStub = stub
-}
-
-func (fake *GoogleSecretManagerClient) AddSecretVersionArgsForCall(i int) (context.Context, *secretmanagera.AddSecretVersionRequest, []gax.CallOption) {
-	fake.addSecretVersionMutex.RLock()
-	defer fake.addSecretVersionMutex.RUnlock()
-	argsForCall := fake.addSecretVersionArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
-}
-
-func (fake *GoogleSecretManagerClient) AddSecretVersionReturns(result1 *secretmanagera.SecretVersion, result2 error) {
-	fake.addSecretVersionMutex.Lock()
-	defer fake.addSecretVersionMutex.Unlock()
-	fake.AddSecretVersionStub = nil
-	fake.addSecretVersionReturns = struct {
-		result1 *secretmanagera.SecretVersion
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *GoogleSecretManagerClient) AddSecretVersionReturnsOnCall(i int, result1 *secretmanagera.SecretVersion, result2 error) {
-	fake.addSecretVersionMutex.Lock()
-	defer fake.addSecretVersionMutex.Unlock()
-	fake.AddSecretVersionStub = nil
-	if fake.addSecretVersionReturnsOnCall == nil {
-		fake.addSecretVersionReturnsOnCall = make(map[int]struct {
-			result1 *secretmanagera.SecretVersion
-			result2 error
-		})
-	}
-	fake.addSecretVersionReturnsOnCall[i] = struct {
-		result1 *secretmanagera.SecretVersion
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *GoogleSecretManagerClient) Close() error {
-	fake.closeMutex.Lock()
-	ret, specificReturn := fake.closeReturnsOnCall[len(fake.closeArgsForCall)]
-	fake.closeArgsForCall = append(fake.closeArgsForCall, struct {
-	}{})
-	stub := fake.CloseStub
-	fakeReturns := fake.closeReturns
-	fake.recordInvocation("Close", []interface{}{})
-	fake.closeMutex.Unlock()
-	if stub != nil {
-		return stub()
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *GoogleSecretManagerClient) CloseCallCount() int {
-	fake.closeMutex.RLock()
-	defer fake.closeMutex.RUnlock()
-	return len(fake.closeArgsForCall)
-}
-
-func (fake *GoogleSecretManagerClient) CloseCalls(stub func() error) {
-	fake.closeMutex.Lock()
-	defer fake.closeMutex.Unlock()
-	fake.CloseStub = stub
-}
-
-func (fake *GoogleSecretManagerClient) CloseReturns(result1 error) {
-	fake.closeMutex.Lock()
-	defer fake.closeMutex.Unlock()
-	fake.CloseStub = nil
-	fake.closeReturns = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *GoogleSecretManagerClient) CloseReturnsOnCall(i int, result1 error) {
-	fake.closeMutex.Lock()
-	defer fake.closeMutex.Unlock()
-	fake.CloseStub = nil
-	if fake.closeReturnsOnCall == nil {
-		fake.closeReturnsOnCall = make(map[int]struct {
-			result1 error
-		})
-	}
-	fake.closeReturnsOnCall[i] = struct {
-		result1 error
-	}{result1}
-}
-
-func (fake *GoogleSecretManagerClient) CreateSecret(arg1 context.Context, arg2 *secretmanagera.CreateSecretRequest, arg3 ...gax.CallOption) (*secretmanagera.Secret, error) {
-	fake.createSecretMutex.Lock()
-	ret, specificReturn := fake.createSecretReturnsOnCall[len(fake.createSecretArgsForCall)]
-	fake.createSecretArgsForCall = append(fake.createSecretArgsForCall, struct {
-		arg1 context.Context
-		arg2 *secretmanagera.CreateSecretRequest
-		arg3 []gax.CallOption
-	}{arg1, arg2, arg3})
-	stub := fake.CreateSecretStub
-	fakeReturns := fake.createSecretReturns
-	fake.recordInvocation("CreateSecret", []interface{}{arg1, arg2, arg3})
-	fake.createSecretMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2, arg3...)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *GoogleSecretManagerClient) CreateSecretCallCount() int {
-	fake.createSecretMutex.RLock()
-	defer fake.createSecretMutex.RUnlock()
-	return len(fake.createSecretArgsForCall)
-}
-
-func (fake *GoogleSecretManagerClient) CreateSecretCalls(stub func(context.Context, *secretmanagera.CreateSecretRequest, ...gax.CallOption) (*secretmanagera.Secret, error)) {
-	fake.createSecretMutex.Lock()
-	defer fake.createSecretMutex.Unlock()
-	fake.CreateSecretStub = stub
-}
-
-func (fake *GoogleSecretManagerClient) CreateSecretArgsForCall(i int) (context.Context, *secretmanagera.CreateSecretRequest, []gax.CallOption) {
-	fake.createSecretMutex.RLock()
-	defer fake.createSecretMutex.RUnlock()
-	argsForCall := fake.createSecretArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
-}
-
-func (fake *GoogleSecretManagerClient) CreateSecretReturns(result1 *secretmanagera.Secret, result2 error) {
-	fake.createSecretMutex.Lock()
-	defer fake.createSecretMutex.Unlock()
-	fake.CreateSecretStub = nil
-	fake.createSecretReturns = struct {
-		result1 *secretmanagera.Secret
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *GoogleSecretManagerClient) CreateSecretReturnsOnCall(i int, result1 *secretmanagera.Secret, result2 error) {
-	fake.createSecretMutex.Lock()
-	defer fake.createSecretMutex.Unlock()
-	fake.CreateSecretStub = nil
-	if fake.createSecretReturnsOnCall == nil {
-		fake.createSecretReturnsOnCall = make(map[int]struct {
-			result1 *secretmanagera.Secret
-			result2 error
-		})
-	}
-	fake.createSecretReturnsOnCall[i] = struct {
-		result1 *secretmanagera.Secret
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *GoogleSecretManagerClient) GetSecret(arg1 context.Context, arg2 *secretmanagera.GetSecretRequest, arg3 ...gax.CallOption) (*secretmanagera.Secret, error) {
-	fake.getSecretMutex.Lock()
-	ret, specificReturn := fake.getSecretReturnsOnCall[len(fake.getSecretArgsForCall)]
-	fake.getSecretArgsForCall = append(fake.getSecretArgsForCall, struct {
-		arg1 context.Context
-		arg2 *secretmanagera.GetSecretRequest
-		arg3 []gax.CallOption
-	}{arg1, arg2, arg3})
-	stub := fake.GetSecretStub
-	fakeReturns := fake.getSecretReturns
-	fake.recordInvocation("GetSecret", []interface{}{arg1, arg2, arg3})
-	fake.getSecretMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2, arg3...)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *GoogleSecretManagerClient) GetSecretCallCount() int {
-	fake.getSecretMutex.RLock()
-	defer fake.getSecretMutex.RUnlock()
-	return len(fake.getSecretArgsForCall)
-}
-
-func (fake *GoogleSecretManagerClient) GetSecretCalls(stub func(context.Context, *secretmanagera.GetSecretRequest, ...gax.CallOption) (*secretmanagera.Secret, error)) {
-	fake.getSecretMutex.Lock()
-	defer fake.getSecretMutex.Unlock()
-	fake.GetSecretStub = stub
-}
-
-func (fake *GoogleSecretManagerClient) GetSecretArgsForCall(i int) (context.Context, *secretmanagera.GetSecretRequest, []gax.CallOption) {
-	fake.getSecretMutex.RLock()
-	defer fake.getSecretMutex.RUnlock()
-	argsForCall := fake.getSecretArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
-}
-
-func (fake *GoogleSecretManagerClient) GetSecretReturns(result1 *secretmanagera.Secret, result2 error) {
-	fake.getSecretMutex.Lock()
-	defer fake.getSecretMutex.Unlock()
-	fake.GetSecretStub = nil
-	fake.getSecretReturns = struct {
-		result1 *secretmanagera.Secret
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *GoogleSecretManagerClient) GetSecretReturnsOnCall(i int, result1 *secretmanagera.Secret, result2 error) {
-	fake.getSecretMutex.Lock()
-	defer fake.getSecretMutex.Unlock()
-	fake.GetSecretStub = nil
-	if fake.getSecretReturnsOnCall == nil {
-		fake.getSecretReturnsOnCall = make(map[int]struct {
-			result1 *secretmanagera.Secret
-			result2 error
-		})
-	}
-	fake.getSecretReturnsOnCall[i] = struct {
-		result1 *secretmanagera.Secret
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *GoogleSecretManagerClient) ListSecrets(arg1 context.Context, arg2 *secretmanagera.ListSecretsRequest, arg3 ...gax.CallOption) *secretmanagerb.SecretIterator {
-	fake.listSecretsMutex.Lock()
-	ret, specificReturn := fake.listSecretsReturnsOnCall[len(fake.listSecretsArgsForCall)]
-	fake.listSecretsArgsForCall = append(fake.listSecretsArgsForCall, struct {
-		arg1 context.Context
-		arg2 *secretmanagera.ListSecretsRequest
-		arg3 []gax.CallOption
-	}{arg1, arg2, arg3})
-	stub := fake.ListSecretsStub
-	fakeReturns := fake.listSecretsReturns
-	fake.recordInvocation("ListSecrets", []interface{}{arg1, arg2, arg3})
-	fake.listSecretsMutex.Unlock()
-	if stub != nil {
-		return stub(arg1, arg2, arg3...)
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *GoogleSecretManagerClient) ListSecretsCallCount() int {
-	fake.listSecretsMutex.RLock()
-	defer fake.listSecretsMutex.RUnlock()
-	return len(fake.listSecretsArgsForCall)
-}
-
-func (fake *GoogleSecretManagerClient) ListSecretsCalls(stub func(context.Context, *secretmanagera.ListSecretsRequest, ...gax.CallOption) *secretmanagerb.SecretIterator) {
-	fake.listSecretsMutex.Lock()
-	defer fake.listSecretsMutex.Unlock()
-	fake.ListSecretsStub = stub
-}
-
-func (fake *GoogleSecretManagerClient) ListSecretsArgsForCall(i int) (context.Context, *secretmanagera.ListSecretsRequest, []gax.CallOption) {
-	fake.listSecretsMutex.RLock()
-	defer fake.listSecretsMutex.RUnlock()
-	argsForCall := fake.listSecretsArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
-}
-
-func (fake *GoogleSecretManagerClient) ListSecretsReturns(result1 *secretmanagerb.SecretIterator) {
-	fake.listSecretsMutex.Lock()
-	defer fake.listSecretsMutex.Unlock()
-	fake.ListSecretsStub = nil
-	fake.listSecretsReturns = struct {
-		result1 *secretmanagerb.SecretIterator
-	}{result1}
-}
-
-func (fake *GoogleSecretManagerClient) ListSecretsReturnsOnCall(i int, result1 *secretmanagerb.SecretIterator) {
-	fake.listSecretsMutex.Lock()
-	defer fake.listSecretsMutex.Unlock()
-	fake.ListSecretsStub = nil
-	if fake.listSecretsReturnsOnCall == nil {
-		fake.listSecretsReturnsOnCall = make(map[int]struct {
-			result1 *secretmanagerb.SecretIterator
-		})
-	}
-	fake.listSecretsReturnsOnCall[i] = struct {
-		result1 *secretmanagerb.SecretIterator
-	}{result1}
-}
-
-func (fake *GoogleSecretManagerClient) Invocations() map[string][][]interface{} {
-	fake.invocationsMutex.RLock()
-	defer fake.invocationsMutex.RUnlock()
-	fake.accessSecretVersionMutex.RLock()
-	defer fake.accessSecretVersionMutex.RUnlock()
-	fake.addSecretVersionMutex.RLock()
-	defer fake.addSecretVersionMutex.RUnlock()
-	fake.closeMutex.RLock()
-	defer fake.closeMutex.RUnlock()
-	fake.createSecretMutex.RLock()
-	defer fake.createSecretMutex.RUnlock()
-	fake.getSecretMutex.RLock()
-	defer fake.getSecretMutex.RUnlock()
-	fake.listSecretsMutex.RLock()
-	defer fake.listSecretsMutex.RUnlock()
-	copiedInvocations := map[string][][]interface{}{}
-	for key, value := range fake.invocations {
-		copiedInvocations[key] = value
-	}
-	return copiedInvocations
-}
-
-func (fake *GoogleSecretManagerClient) 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 _ secretmanager.GoogleSecretManagerClient = new(GoogleSecretManagerClient)

pkg/provider/vault/internal/fakes/client.go

@@ -1,446 +0,0 @@
-// Code generated by counterfeiter. DO NOT EDIT.
-package fakes
-
-import (
-	"sync"
-
-	"github.com/external-secrets/external-secrets/pkg/provider/vault"
-)
-
-type VaultClient struct {
-	AddHeaderStub        func(string, string)
-	addHeaderMutex       sync.RWMutex
-	addHeaderArgsForCall []struct {
-		arg1 string
-		arg2 string
-	}
-	AuthStub        func() vault.Auth
-	authMutex       sync.RWMutex
-	authArgsForCall []struct {
-	}
-	authReturns struct {
-		result1 vault.Auth
-	}
-	authReturnsOnCall map[int]struct {
-		result1 vault.Auth
-	}
-	AuthTokenStub        func() vault.Token
-	authTokenMutex       sync.RWMutex
-	authTokenArgsForCall []struct {
-	}
-	authTokenReturns struct {
-		result1 vault.Token
-	}
-	authTokenReturnsOnCall map[int]struct {
-		result1 vault.Token
-	}
-	ClearTokenStub        func()
-	clearTokenMutex       sync.RWMutex
-	clearTokenArgsForCall []struct {
-	}
-	LogicalStub        func() vault.Logical
-	logicalMutex       sync.RWMutex
-	logicalArgsForCall []struct {
-	}
-	logicalReturns struct {
-		result1 vault.Logical
-	}
-	logicalReturnsOnCall map[int]struct {
-		result1 vault.Logical
-	}
-	SetNamespaceStub        func(string)
-	setNamespaceMutex       sync.RWMutex
-	setNamespaceArgsForCall []struct {
-		arg1 string
-	}
-	SetTokenStub        func(string)
-	setTokenMutex       sync.RWMutex
-	setTokenArgsForCall []struct {
-		arg1 string
-	}
-	TokenStub        func() string
-	tokenMutex       sync.RWMutex
-	tokenArgsForCall []struct {
-	}
-	tokenReturns struct {
-		result1 string
-	}
-	tokenReturnsOnCall map[int]struct {
-		result1 string
-	}
-	invocations      map[string][][]interface{}
-	invocationsMutex sync.RWMutex
-}
-
-func (fake *VaultClient) AddHeader(arg1 string, arg2 string) {
-	fake.addHeaderMutex.Lock()
-	fake.addHeaderArgsForCall = append(fake.addHeaderArgsForCall, struct {
-		arg1 string
-		arg2 string
-	}{arg1, arg2})
-	stub := fake.AddHeaderStub
-	fake.recordInvocation("AddHeader", []interface{}{arg1, arg2})
-	fake.addHeaderMutex.Unlock()
-	if stub != nil {
-		fake.AddHeaderStub(arg1, arg2)
-	}
-}
-
-func (fake *VaultClient) AddHeaderCallCount() int {
-	fake.addHeaderMutex.RLock()
-	defer fake.addHeaderMutex.RUnlock()
-	return len(fake.addHeaderArgsForCall)
-}
-
-func (fake *VaultClient) AddHeaderCalls(stub func(string, string)) {
-	fake.addHeaderMutex.Lock()
-	defer fake.addHeaderMutex.Unlock()
-	fake.AddHeaderStub = stub
-}
-
-func (fake *VaultClient) AddHeaderArgsForCall(i int) (string, string) {
-	fake.addHeaderMutex.RLock()
-	defer fake.addHeaderMutex.RUnlock()
-	argsForCall := fake.addHeaderArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *VaultClient) Auth() vault.Auth {
-	fake.authMutex.Lock()
-	ret, specificReturn := fake.authReturnsOnCall[len(fake.authArgsForCall)]
-	fake.authArgsForCall = append(fake.authArgsForCall, struct {
-	}{})
-	stub := fake.AuthStub
-	fakeReturns := fake.authReturns
-	fake.recordInvocation("Auth", []interface{}{})
-	fake.authMutex.Unlock()
-	if stub != nil {
-		return stub()
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *VaultClient) AuthCallCount() int {
-	fake.authMutex.RLock()
-	defer fake.authMutex.RUnlock()
-	return len(fake.authArgsForCall)
-}
-
-func (fake *VaultClient) AuthCalls(stub func() vault.Auth) {
-	fake.authMutex.Lock()
-	defer fake.authMutex.Unlock()
-	fake.AuthStub = stub
-}
-
-func (fake *VaultClient) AuthReturns(result1 vault.Auth) {
-	fake.authMutex.Lock()
-	defer fake.authMutex.Unlock()
-	fake.AuthStub = nil
-	fake.authReturns = struct {
-		result1 vault.Auth
-	}{result1}
-}
-
-func (fake *VaultClient) AuthReturnsOnCall(i int, result1 vault.Auth) {
-	fake.authMutex.Lock()
-	defer fake.authMutex.Unlock()
-	fake.AuthStub = nil
-	if fake.authReturnsOnCall == nil {
-		fake.authReturnsOnCall = make(map[int]struct {
-			result1 vault.Auth
-		})
-	}
-	fake.authReturnsOnCall[i] = struct {
-		result1 vault.Auth
-	}{result1}
-}
-
-func (fake *VaultClient) AuthToken() vault.Token {
-	fake.authTokenMutex.Lock()
-	ret, specificReturn := fake.authTokenReturnsOnCall[len(fake.authTokenArgsForCall)]
-	fake.authTokenArgsForCall = append(fake.authTokenArgsForCall, struct {
-	}{})
-	stub := fake.AuthTokenStub
-	fakeReturns := fake.authTokenReturns
-	fake.recordInvocation("AuthToken", []interface{}{})
-	fake.authTokenMutex.Unlock()
-	if stub != nil {
-		return stub()
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *VaultClient) AuthTokenCallCount() int {
-	fake.authTokenMutex.RLock()
-	defer fake.authTokenMutex.RUnlock()
-	return len(fake.authTokenArgsForCall)
-}
-
-func (fake *VaultClient) AuthTokenCalls(stub func() vault.Token) {
-	fake.authTokenMutex.Lock()
-	defer fake.authTokenMutex.Unlock()
-	fake.AuthTokenStub = stub
-}
-
-func (fake *VaultClient) AuthTokenReturns(result1 vault.Token) {
-	fake.authTokenMutex.Lock()
-	defer fake.authTokenMutex.Unlock()
-	fake.AuthTokenStub = nil
-	fake.authTokenReturns = struct {
-		result1 vault.Token
-	}{result1}
-}
-
-func (fake *VaultClient) AuthTokenReturnsOnCall(i int, result1 vault.Token) {
-	fake.authTokenMutex.Lock()
-	defer fake.authTokenMutex.Unlock()
-	fake.AuthTokenStub = nil
-	if fake.authTokenReturnsOnCall == nil {
-		fake.authTokenReturnsOnCall = make(map[int]struct {
-			result1 vault.Token
-		})
-	}
-	fake.authTokenReturnsOnCall[i] = struct {
-		result1 vault.Token
-	}{result1}
-}
-
-func (fake *VaultClient) ClearToken() {
-	fake.clearTokenMutex.Lock()
-	fake.clearTokenArgsForCall = append(fake.clearTokenArgsForCall, struct {
-	}{})
-	stub := fake.ClearTokenStub
-	fake.recordInvocation("ClearToken", []interface{}{})
-	fake.clearTokenMutex.Unlock()
-	if stub != nil {
-		fake.ClearTokenStub()
-	}
-}
-
-func (fake *VaultClient) ClearTokenCallCount() int {
-	fake.clearTokenMutex.RLock()
-	defer fake.clearTokenMutex.RUnlock()
-	return len(fake.clearTokenArgsForCall)
-}
-
-func (fake *VaultClient) ClearTokenCalls(stub func()) {
-	fake.clearTokenMutex.Lock()
-	defer fake.clearTokenMutex.Unlock()
-	fake.ClearTokenStub = stub
-}
-
-func (fake *VaultClient) Logical() vault.Logical {
-	fake.logicalMutex.Lock()
-	ret, specificReturn := fake.logicalReturnsOnCall[len(fake.logicalArgsForCall)]
-	fake.logicalArgsForCall = append(fake.logicalArgsForCall, struct {
-	}{})
-	stub := fake.LogicalStub
-	fakeReturns := fake.logicalReturns
-	fake.recordInvocation("Logical", []interface{}{})
-	fake.logicalMutex.Unlock()
-	if stub != nil {
-		return stub()
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *VaultClient) LogicalCallCount() int {
-	fake.logicalMutex.RLock()
-	defer fake.logicalMutex.RUnlock()
-	return len(fake.logicalArgsForCall)
-}
-
-func (fake *VaultClient) LogicalCalls(stub func() vault.Logical) {
-	fake.logicalMutex.Lock()
-	defer fake.logicalMutex.Unlock()
-	fake.LogicalStub = stub
-}
-
-func (fake *VaultClient) LogicalReturns(result1 vault.Logical) {
-	fake.logicalMutex.Lock()
-	defer fake.logicalMutex.Unlock()
-	fake.LogicalStub = nil
-	fake.logicalReturns = struct {
-		result1 vault.Logical
-	}{result1}
-}
-
-func (fake *VaultClient) LogicalReturnsOnCall(i int, result1 vault.Logical) {
-	fake.logicalMutex.Lock()
-	defer fake.logicalMutex.Unlock()
-	fake.LogicalStub = nil
-	if fake.logicalReturnsOnCall == nil {
-		fake.logicalReturnsOnCall = make(map[int]struct {
-			result1 vault.Logical
-		})
-	}
-	fake.logicalReturnsOnCall[i] = struct {
-		result1 vault.Logical
-	}{result1}
-}
-
-func (fake *VaultClient) SetNamespace(arg1 string) {
-	fake.setNamespaceMutex.Lock()
-	fake.setNamespaceArgsForCall = append(fake.setNamespaceArgsForCall, struct {
-		arg1 string
-	}{arg1})
-	stub := fake.SetNamespaceStub
-	fake.recordInvocation("SetNamespace", []interface{}{arg1})
-	fake.setNamespaceMutex.Unlock()
-	if stub != nil {
-		fake.SetNamespaceStub(arg1)
-	}
-}
-
-func (fake *VaultClient) SetNamespaceCallCount() int {
-	fake.setNamespaceMutex.RLock()
-	defer fake.setNamespaceMutex.RUnlock()
-	return len(fake.setNamespaceArgsForCall)
-}
-
-func (fake *VaultClient) SetNamespaceCalls(stub func(string)) {
-	fake.setNamespaceMutex.Lock()
-	defer fake.setNamespaceMutex.Unlock()
-	fake.SetNamespaceStub = stub
-}
-
-func (fake *VaultClient) SetNamespaceArgsForCall(i int) string {
-	fake.setNamespaceMutex.RLock()
-	defer fake.setNamespaceMutex.RUnlock()
-	argsForCall := fake.setNamespaceArgsForCall[i]
-	return argsForCall.arg1
-}
-
-func (fake *VaultClient) SetToken(arg1 string) {
-	fake.setTokenMutex.Lock()
-	fake.setTokenArgsForCall = append(fake.setTokenArgsForCall, struct {
-		arg1 string
-	}{arg1})
-	stub := fake.SetTokenStub
-	fake.recordInvocation("SetToken", []interface{}{arg1})
-	fake.setTokenMutex.Unlock()
-	if stub != nil {
-		fake.SetTokenStub(arg1)
-	}
-}
-
-func (fake *VaultClient) SetTokenCallCount() int {
-	fake.setTokenMutex.RLock()
-	defer fake.setTokenMutex.RUnlock()
-	return len(fake.setTokenArgsForCall)
-}
-
-func (fake *VaultClient) SetTokenCalls(stub func(string)) {
-	fake.setTokenMutex.Lock()
-	defer fake.setTokenMutex.Unlock()
-	fake.SetTokenStub = stub
-}
-
-func (fake *VaultClient) SetTokenArgsForCall(i int) string {
-	fake.setTokenMutex.RLock()
-	defer fake.setTokenMutex.RUnlock()
-	argsForCall := fake.setTokenArgsForCall[i]
-	return argsForCall.arg1
-}
-
-func (fake *VaultClient) Token() string {
-	fake.tokenMutex.Lock()
-	ret, specificReturn := fake.tokenReturnsOnCall[len(fake.tokenArgsForCall)]
-	fake.tokenArgsForCall = append(fake.tokenArgsForCall, struct {
-	}{})
-	stub := fake.TokenStub
-	fakeReturns := fake.tokenReturns
-	fake.recordInvocation("Token", []interface{}{})
-	fake.tokenMutex.Unlock()
-	if stub != nil {
-		return stub()
-	}
-	if specificReturn {
-		return ret.result1
-	}
-	return fakeReturns.result1
-}
-
-func (fake *VaultClient) TokenCallCount() int {
-	fake.tokenMutex.RLock()
-	defer fake.tokenMutex.RUnlock()
-	return len(fake.tokenArgsForCall)
-}
-
-func (fake *VaultClient) TokenCalls(stub func() string) {
-	fake.tokenMutex.Lock()
-	defer fake.tokenMutex.Unlock()
-	fake.TokenStub = stub
-}
-
-func (fake *VaultClient) TokenReturns(result1 string) {
-	fake.tokenMutex.Lock()
-	defer fake.tokenMutex.Unlock()
-	fake.TokenStub = nil
-	fake.tokenReturns = struct {
-		result1 string
-	}{result1}
-}
-
-func (fake *VaultClient) TokenReturnsOnCall(i int, result1 string) {
-	fake.tokenMutex.Lock()
-	defer fake.tokenMutex.Unlock()
-	fake.TokenStub = nil
-	if fake.tokenReturnsOnCall == nil {
-		fake.tokenReturnsOnCall = make(map[int]struct {
-			result1 string
-		})
-	}
-	fake.tokenReturnsOnCall[i] = struct {
-		result1 string
-	}{result1}
-}
-
-func (fake *VaultClient) Invocations() map[string][][]interface{} {
-	fake.invocationsMutex.RLock()
-	defer fake.invocationsMutex.RUnlock()
-	fake.addHeaderMutex.RLock()
-	defer fake.addHeaderMutex.RUnlock()
-	fake.authMutex.RLock()
-	defer fake.authMutex.RUnlock()
-	fake.authTokenMutex.RLock()
-	defer fake.authTokenMutex.RUnlock()
-	fake.clearTokenMutex.RLock()
-	defer fake.clearTokenMutex.RUnlock()
-	fake.logicalMutex.RLock()
-	defer fake.logicalMutex.RUnlock()
-	fake.setNamespaceMutex.RLock()
-	defer fake.setNamespaceMutex.RUnlock()
-	fake.setTokenMutex.RLock()
-	defer fake.setTokenMutex.RUnlock()
-	fake.tokenMutex.RLock()
-	defer fake.tokenMutex.RUnlock()
-	copiedInvocations := map[string][][]interface{}{}
-	for key, value := range fake.invocations {
-		copiedInvocations[key] = value
-	}
-	return copiedInvocations
-}
-
-func (fake *VaultClient) 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 _ vault.Client = new(VaultClient)