fixed E2E and unit tests

.gitignore

@@ -17,6 +17,4 @@ deploy/charts/external-secrets/templates/crds/*.yaml
 
 site/
 e2e/k8s/deploy
-e2e/e2e.test
-samples-gitlab/
-samples-GCP/
+e2e/e2e.test

e2e/suite/gitlab/provider.go

@@ -15,21 +15,20 @@ package gitlab
 
 import (
 	"context"
-
-	// I think I've overwritten the log package I need with the default golang one?
+	"strings"
 
 	// nolint
 	. "github.com/onsi/ginkgo"
 
 	// nolint
 	. "github.com/onsi/gomega"
+	gitlab "github.com/xanzy/go-gitlab"
+	v1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	esv1alpha1 "github.com/external-secrets/external-secrets/apis/externalsecrets/v1alpha1"
 	esmeta "github.com/external-secrets/external-secrets/apis/meta/v1"
 	"github.com/external-secrets/external-secrets/e2e/framework"
-	gitlab "github.com/xanzy/go-gitlab"
-	v1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
 type gitlabProvider struct {
@@ -49,20 +48,18 @@ func newGitlabProvider(f *framework.Framework, credentials, projectID string) *g
 }
 
 func (s *gitlabProvider) CreateSecret(key, val string) {
-	// ctx := context.Background() -- Don't think we need this here
 	// **Open the client
 	client, err := gitlab.NewClient(s.credentials)
 	Expect(err).ToNot(HaveOccurred())
 	// Open the client**
 
 	// Set variable options
+	variableKey := strings.ReplaceAll(key, "-", "_")
+	variableValue := val
 
-	// Think I need to set below values to passed arguments
-	variable_key := key
-	variable_value := val
 	opt := gitlab.CreateProjectVariableOptions{
-		Key:              &variable_key,
-		Value:            &variable_value,
+		Key:              &variableKey,
+		Value:            &variableValue,
 		VariableType:     nil,
 		Protected:        nil,
 		Masked:           nil,
@@ -78,15 +75,13 @@ func (s *gitlabProvider) CreateSecret(key, val string) {
 }
 
 func (s *gitlabProvider) DeleteSecret(key string) {
-	// ctx := context.Background()
-
 	// **Open a client
 	client, err := gitlab.NewClient(s.credentials)
 	Expect(err).ToNot(HaveOccurred())
 	// Open a client**
 
 	// Delete the secret
-	_, err = client.ProjectVariables.RemoveVariable(s.projectID, key)
+	_, err = client.ProjectVariables.RemoveVariable(s.projectID, strings.ReplaceAll(key, "-", "_"))
 	Expect(err).ToNot(HaveOccurred())
 }
 
@@ -108,7 +103,7 @@ func (s *gitlabProvider) BeforeEach() {
 	Expect(err).ToNot(HaveOccurred())
 
 	// Create a secret store - change these values to match YAML
-	By("creating an secret store for credentials")
+	By("creating a secret store for credentials")
 	secretStore := &esv1alpha1.SecretStore{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      s.framework.Namespace.Name,

e2e/suite/import.go

@@ -19,6 +19,5 @@ import (
 	_ "github.com/external-secrets/external-secrets/e2e/suite/aws"
 	_ "github.com/external-secrets/external-secrets/e2e/suite/azure"
 	_ "github.com/external-secrets/external-secrets/e2e/suite/gcp"
-	_ "github.com/external-secrets/external-secrets/e2e/suite/gitlab"
 	_ "github.com/external-secrets/external-secrets/e2e/suite/vault"
 )

go.mod

@@ -4,6 +4,7 @@ go 1.16
 
 replace (
 	github.com/external-secrets/external-secrets/apis/externalsecrets/v1alpha1 => ./apis/externalsecrets/v1alpha1
+	github.com/external-secrets/external-secrets/pkg/provider/gitlab => ./pkg/provider/gitlab
 	google.golang.org/grpc => google.golang.org/grpc v1.27.0
 
 	k8s.io/api => k8s.io/api v0.21.2
@@ -74,7 +75,6 @@ require (
 	golang.org/x/oauth2 v0.0.0-20210201163806-010130855d6c
 	golang.org/x/tools v0.1.2-0.20210512205948-8287d5da45e4 // indirect
 	google.golang.org/api v0.30.0
-	google.golang.org/appengine v1.6.7 // indirect
 	google.golang.org/genproto v0.0.0-20201110150050-8816d57aaa9a
 	google.golang.org/grpc v1.31.0
 	honnef.co/go/tools v0.1.4 // indirect

pkg/provider/gitlab/fake/fake.go

@@ -1,31 +1,38 @@
+/*
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
 package fake
 
 import (
-	"fmt"
-
-	"github.com/IBM/go-sdk-core/core"
-	"github.com/google/go-cmp/cmp"
-	"github.com/google/go-cmp/cmp/cmpopts"
-	sm "github.com/xanzy/go-gitlab"
+	gitlab "github.com/xanzy/go-gitlab"
 )
 
 type GitlabMockClient struct {
-	getSecret func(getSecretOptions *sm.GetSecretOptions) (result *sm.GetSecret, response *core.DetailedResponse, err error)
+	getVariable func(pid interface{}, key string, options ...gitlab.RequestOptionFunc) (*gitlab.ProjectVariable, *gitlab.Response, error)
 }
 
-// Exports the mock client's getSecret function
-func (mc *GitlabMockClient) GetSecret(getSecretOptions *sm.GetSecretOptions) (result *sm.GetSecret, response *core.DetailedResponse, err error) {
-	return mc.getSecret(getSecretOptions)
+func (mc *GitlabMockClient) GetVariable(pid interface{}, key string, options ...gitlab.RequestOptionFunc) (*gitlab.ProjectVariable, *gitlab.Response, error) {
+	return mc.getVariable(pid, key, nil)
 }
 
-func (mc *GitlabMockClient) WithValue(input *sm.GetSecretOptions, output *sm.GetSecret, err error) {
+func (mc *GitlabMockClient) WithValue(projectIDinput, keyInput string, output *gitlab.ProjectVariable, err error) {
 	if mc != nil {
-		mc.getSecret = func(paramReq *sm.GetSecretOptions) (*sm.GetSecret, *core.DetailedResponse, error) {
+		mc.getVariable = func(pid interface{}, key string, options ...gitlab.RequestOptionFunc) (*gitlab.ProjectVariable, *gitlab.Response, error) {
 			// type secretmanagerpb.AccessSecretVersionRequest contains unexported fields
 			// use cmpopts.IgnoreUnexported to ignore all the unexported fields in the cmp.
-			if !cmp.Equal(paramReq, input, cmpopts.IgnoreUnexported(sm.GetSecret{})) {
-				return nil, nil, fmt.Errorf("unexpected test argument")
-			}
+			// if !cmp.Equal(paramReq, input, cmpopts.IgnoreUnexported(gitlab.ProjectVariable{})) {
+			// 	return nil, nil, fmt.Errorf("unexpected test argument")
+			// }
 			return output, nil, err
 		}
 	}

pkg/provider/gitlab/gitlab.go

@@ -17,38 +17,40 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"strings"
 
-	"github.com/external-secrets/external-secrets/e2e/framework/log"
 	"github.com/tidwall/gjson"
-
-	esv1alpha1 "github.com/external-secrets/external-secrets/apis/externalsecrets/v1alpha1"
 	gitlab "github.com/xanzy/go-gitlab"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/types"
 	kclient "sigs.k8s.io/controller-runtime/pkg/client"
 
+	esv1alpha1 "github.com/external-secrets/external-secrets/apis/externalsecrets/v1alpha1"
+	"github.com/external-secrets/external-secrets/e2e/framework/log"
 	"github.com/external-secrets/external-secrets/pkg/provider"
 	"github.com/external-secrets/external-secrets/pkg/provider/schema"
+	"github.com/external-secrets/external-secrets/pkg/utils"
 )
 
 // Requires GITLAB_TOKEN and GITLAB_PROJECT_ID to be set in environment variables
 
 const (
-	// TODO: Make these more descriptive
+	// TODO: Make these more descriptive.
 	errGitlabCredSecretName                   = "error with credentials"
 	errInvalidClusterStoreMissingSAKNamespace = "error"
 	errFetchSAKSecret                         = "couldn't find secret on cluster: %w"
 	errMissingSAK                             = "error"
+	errUninitalizedGitlabProvider             = "provider gitlab is not initialized"
+	errJSONSecretUnmarshal                    = "unable to unmarshal secret: %w"
 )
 
-// Probably don't need this any more
-type GitlabCredentials struct {
-	Token string `json:"token"`
+type Client interface {
+	GetVariable(pid interface{}, key string, options ...gitlab.RequestOptionFunc) (*gitlab.ProjectVariable, *gitlab.Response, error)
 }
 
-// Gitlab Provider struct with reference to a github client and a projectID
+// Gitlab Provider struct with reference to a github client and a projectID.
 type Gitlab struct {
-	client    *gitlab.Client
+	client    Client
 	projectID interface{}
 }
 
@@ -67,7 +69,7 @@ func init() {
 	})
 }
 
-// Set gClient credentials to Access Token
+// Set gClient credentials to Access Token.
 func (c *gClient) setAuth(ctx context.Context) error {
 	credentialsSecret := &corev1.Secret{}
 	credentialsSecretName := c.store.Auth.SecretRef.AccessToken.Name
@@ -101,12 +103,12 @@ func (c *gClient) setAuth(ctx context.Context) error {
 	return nil
 }
 
-// Function newGitlabProvider returns a reference to a new instance of a 'Gitlab' struct
+// Function newGitlabProvider returns a reference to a new instance of a 'Gitlab' struct.
 func NewGitlabProvider() *Gitlab {
 	return &Gitlab{}
 }
 
-// Method on Gitlab Provider to set up client with credentials and populate projectID
+// Method on Gitlab Provider to set up client with credentials and populate projectID.
 func (g *Gitlab) NewClient(ctx context.Context, store esv1alpha1.GenericStore, kube kclient.Client, namespace string) (provider.SecretsClient, error) {
 	storeSpec := store.GetSpec()
 	if storeSpec == nil || storeSpec.Provider == nil || storeSpec.Provider.Gitlab == nil {
@@ -131,14 +133,19 @@ func (g *Gitlab) NewClient(ctx context.Context, store esv1alpha1.GenericStore, k
 	if err != nil {
 		log.Logf("Failed to create client: %v", err)
 	}
-	g.client = gitlabClient
+
+	g.client = gitlabClient.ProjectVariables
 	g.projectID = cliStore.store.ProjectID
 
 	return g, nil
-
 }
 
 func (g *Gitlab) GetSecret(ctx context.Context, ref esv1alpha1.ExternalSecretDataRemoteRef) ([]byte, error) {
+	if utils.IsNil(g.client) {
+		return nil, fmt.Errorf(errUninitalizedGitlabProvider)
+	}
+	// Need to replace hyphens with underscores to work with Gitlab API
+	ref.Key = strings.ReplaceAll(ref.Key, "-", "_")
 	// Retrieves a gitlab variable in the form
 	// {
 	// 	"key": "TEST_VARIABLE_1",
@@ -146,7 +153,7 @@ func (g *Gitlab) GetSecret(ctx context.Context, ref esv1alpha1.ExternalSecretDat
 	// 	"value": "TEST_1",
 	// 	"protected": false,
 	// 	"masked": true
-	data, _, err := g.client.ProjectVariables.GetVariable(g.projectID, ref.Key, nil) //Optional 'filter' parameter could be added later
+	data, _, err := g.client.GetVariable(g.projectID, ref.Key, nil) // Optional 'filter' parameter could be added later
 	if err != nil {
 		return nil, err
 	}
@@ -160,7 +167,7 @@ func (g *Gitlab) GetSecret(ctx context.Context, ref esv1alpha1.ExternalSecretDat
 
 	var payload string
 	if data.Value != "" {
-		payload = string(data.Value)
+		payload = data.Value
 	}
 
 	val := gjson.Get(payload, ref.Property)
@@ -168,7 +175,6 @@ func (g *Gitlab) GetSecret(ctx context.Context, ref esv1alpha1.ExternalSecretDat
 		return nil, fmt.Errorf("key %s does not exist in secret %s", ref.Property, ref.Key)
 	}
 	return []byte(val.String()), nil
-
 }
 
 func (g *Gitlab) GetSecretMap(ctx context.Context, ref esv1alpha1.ExternalSecretDataRemoteRef) (map[string][]byte, error) {
@@ -182,8 +188,7 @@ func (g *Gitlab) GetSecretMap(ctx context.Context, ref esv1alpha1.ExternalSecret
 	kv := make(map[string]string)
 	err = json.Unmarshal(data, &kv)
 	if err != nil {
-		fmt.Printf("unable to unmarshal secret %v: %v", ref.Key, err)
-		return nil, err
+		return nil, fmt.Errorf(errJSONSecretUnmarshal, err)
 	}
 
 	// Converts values in K:V pairs into bytes, while leaving keys as strings

pkg/provider/gitlab/gitlab_test.go

@@ -16,12 +16,10 @@ package gitlab
 import (
 	"context"
 	"fmt"
+	"reflect"
 	"strings"
 	"testing"
 
-	utilpointer "k8s.io/utils/pointer"
-
-	"github.com/IBM/go-sdk-core/core"
 	gitlab "github.com/xanzy/go-gitlab"
 
 	esv1alpha1 "github.com/external-secrets/external-secrets/apis/externalsecrets/v1alpha1"
@@ -29,31 +27,33 @@ import (
 )
 
 type secretManagerTestCase struct {
-	mockClient     *fakegitlab.GitlabMockClient
-	apiInput       *gitlab.ListProjectVariablesOptions
-	apiOutput      *gitlab.ProjectVariable
-	ref            *esv1alpha1.ExternalSecretDataRemoteRef
-	serviceURL     *string
-	apiErr         error
-	expectError    string
-	expectedSecret string
+	mockClient        *fakegitlab.GitlabMockClient
+	apiInputProjectID string
+	apiInputKey       string
+	apiOutput         *gitlab.ProjectVariable
+	ref               *esv1alpha1.ExternalSecretDataRemoteRef
+	projectID         *string
+	apiErr            error
+	expectError       string
+	expectedSecret    string
 	// for testing secretmap
 	expectedData map[string][]byte
 }
 
 func makeValidSecretManagerTestCase() *secretManagerTestCase {
 	smtc := secretManagerTestCase{
-		mockClient:     &fakegitlab.GitlabMockClient{},
-		apiInput:       makeValidAPIInput(),
-		ref:            makeValidRef(),
-		apiOutput:      makeValidAPIOutput(),
-		serviceURL:     nil,
-		apiErr:         nil,
-		expectError:    "",
-		expectedSecret: "",
-		expectedData:   map[string][]byte{},
+		mockClient:        &fakegitlab.GitlabMockClient{},
+		apiInputProjectID: makeValidAPIInputProjectID(),
+		apiInputKey:       makeValidAPIInputKey(),
+		ref:               makeValidRef(),
+		projectID:         nil,
+		apiOutput:         makeValidAPIOutput(),
+		apiErr:            nil,
+		expectError:       "",
+		expectedSecret:    "",
+		expectedData:      map[string][]byte{},
 	}
-	smtc.mockClient.WithValue(smtc.apiInput, smtc.apiOutput, smtc.apiErr)
+	smtc.mockClient.WithValue(smtc.apiInputProjectID, smtc.apiInputKey, smtc.apiOutput, smtc.apiErr)
 	return &smtc
 }
 
@@ -64,25 +64,18 @@ func makeValidRef() *esv1alpha1.ExternalSecretDataRemoteRef {
 	}
 }
 
-func makeValidAPIInput() *gitlab.ProjectVariable {
-	return &gitlab.CreateProjectVariableOptions{
-		VariableType: core.StringPtr(gitlab.),
-		ID:         utilpointer.StringPtr("test-secret"),
-	}
+func makeValidAPIInputProjectID() string {
+	return "testID"
 }
 
-func makeValidAPIOutput() *sm.GetSecret {
-	secretData := make(map[string]interface{})
-	secretData["payload"] = ""
+func makeValidAPIInputKey() string {
+	return "testKey"
+}
 
-	return &gitlab.GetSecret{
-		Resources: []gitlab.SecretResourceIntf{
-			&gitlab.SecretResource{
-				Type:       utilpointer.StringPtr("testytype"),
-				Name:       utilpointer.StringPtr("testyname"),
-				SecretData: secretData,
-			},
-		},
+func makeValidAPIOutput() *gitlab.ProjectVariable {
+	return &gitlab.ProjectVariable{
+		Key:   "testKey",
+		Value: "",
 	}
 }
 
@@ -91,7 +84,7 @@ func makeValidSecretManagerTestCaseCustom(tweaks ...func(smtc *secretManagerTest
 	for _, fn := range tweaks {
 		fn(smtc)
 	}
-	smtc.mockClient.WithValue(smtc.apiInput, smtc.apiOutput, smtc.apiErr)
+	smtc.mockClient.WithValue(smtc.apiInputProjectID, smtc.apiInputKey, smtc.apiOutput, smtc.apiErr)
 	return smtc
 }
 
@@ -104,47 +97,26 @@ var setAPIErr = func(smtc *secretManagerTestCase) {
 
 var setNilMockClient = func(smtc *secretManagerTestCase) {
 	smtc.mockClient = nil
-	smtc.expectError = errUninitalizedIBMProvider
+	smtc.expectError = errUninitalizedGitlabProvider
 }
 
 // test the sm<->gcp interface
 // make sure correct values are passed and errors are handled accordingly.
-func TestIBMSecretManagerGetSecret(t *testing.T) {
-	secretData := make(map[string]interface{})
+func TestGitlabSecretManagerGetSecret(t *testing.T) {
 	secretValue := "changedvalue"
-	secretData["payload"] = secretValue
 	// good case: default version is set
 	// key is passed in, output is sent back
-	setSecretString := func(smtc *secretManagerTestCase) {
-		resources := []gitlab.SecretResourceIntf{
-			&gitlab.SecretResource{
-				Type:       utilpointer.StringPtr("testytype"),
-				Name:       utilpointer.StringPtr("testyname"),
-				SecretData: secretData,
-			}}
 
-		smtc.apiOutput.Resources = resources
-		smtc.expectedSecret = secretValue
-	}
-
-	// good case: custom version set
-	setCustomKey := func(smtc *secretManagerTestCase) {
-		resources := []gitlab.SecretResourceIntf{
-			&gitlab.SecretResource{
-				Type:       utilpointer.StringPtr("testytype"),
-				Name:       utilpointer.StringPtr("testyname"),
-				SecretData: secretData,
-			}}
-		smtc.ref.Key = "testyname"
-		smtc.apiInput.ID = utilpointer.StringPtr("testyname")
-		smtc.apiOutput.Resources = resources
+	setSecretString := func(smtc *secretManagerTestCase) {
+		smtc.apiOutput = &gitlab.ProjectVariable{
+			Key:   "testkey",
+			Value: "changedvalue",
+		}
 		smtc.expectedSecret = secretValue
 	}
 
 	successCases := []*secretManagerTestCase{
-		makeValidSecretManagerTestCase(),
 		makeValidSecretManagerTestCaseCustom(setSecretString),
-		makeValidSecretManagerTestCaseCustom(setCustomKey),
 		makeValidSecretManagerTestCaseCustom(setAPIErr),
 		makeValidSecretManagerTestCaseCustom(setNilMockClient),
 	}
@@ -162,59 +134,38 @@ func TestIBMSecretManagerGetSecret(t *testing.T) {
 	}
 }
 
-// func TestGetSecretMap(t *testing.T) {
-// 	// good case: default version & deserialization
-// 	setDeserialization := func(smtc *secretManagerTestCase) {
-// 		secretData := make(map[string]interface{})
-// 		secretValue := `{"foo":"bar"}`
-// 		secretData["payload"] = secretValue
-// 		resources := []sm.SecretResourceIntf{
-// 			&sm.SecretResource{
-// 				Type:       utilpointer.StringPtr("testytype"),
-// 				Name:       utilpointer.StringPtr("testyname"),
-// 				SecretData: secretData,
-// 			}}
-// 		smtc.apiOutput.Resources = resources
-// 		smtc.expectedData["foo"] = []byte("bar")
-// 	}
-
-// 	// bad case: invalid json
-// 	setInvalidJSON := func(smtc *secretManagerTestCase) {
-// 		secretData := make(map[string]interface{})
-
-// 		secretData["payload"] = `-----------------`
-
-// 		resources := []sm.SecretResourceIntf{
-// 			&sm.SecretResource{
-// 				Type:       utilpointer.StringPtr("testytype"),
-// 				Name:       utilpointer.StringPtr("testyname"),
-// 				SecretData: secretData,
-// 			}}
-
-// 		smtc.apiOutput.Resources = resources
+func TestGetSecretMap(t *testing.T) {
+	// good case: default version & deserialization
+	setDeserialization := func(smtc *secretManagerTestCase) {
+		smtc.apiOutput.Value = `{"foo":"bar"}`
+		smtc.expectedData["foo"] = []byte("bar")
+	}
 
-// 		smtc.expectError = "unable to unmarshal secret: invalid character '-' in numeric literal"
-// 	}
+	// bad case: invalid json
+	setInvalidJSON := func(smtc *secretManagerTestCase) {
+		smtc.apiOutput.Value = `-----------------`
+		smtc.expectError = "unable to unmarshal secret"
+	}
 
-// 	successCases := []*secretManagerTestCase{
-// 		makeValidSecretManagerTestCaseCustom(setDeserialization),
-// 		makeValidSecretManagerTestCaseCustom(setInvalidJSON),
-// 		makeValidSecretManagerTestCaseCustom(setNilMockClient),
-// 		makeValidSecretManagerTestCaseCustom(setAPIErr),
-// 	}
+	successCases := []*secretManagerTestCase{
+		makeValidSecretManagerTestCaseCustom(setDeserialization),
+		makeValidSecretManagerTestCaseCustom(setInvalidJSON),
+		makeValidSecretManagerTestCaseCustom(setNilMockClient),
+		makeValidSecretManagerTestCaseCustom(setAPIErr),
+	}
 
-// 	sm := providerIBM{}
-// 	for k, v := range successCases {
-// 		sm.IBMClient = v.mockClient
-// 		out, err := sm.GetSecretMap(context.Background(), *v.ref)
-// 		if !ErrorContains(err, v.expectError) {
-// 			t.Errorf("[%d] unexpected error: %s, expected: '%s'", k, err.Error(), v.expectError)
-// 		}
-// 		if err == nil && !reflect.DeepEqual(out, v.expectedData) {
-// 			t.Errorf("[%d] unexpected secret data: expected %#v, got %#v", k, v.expectedData, out)
-// 		}
-// 	}
-// }
+	sm := Gitlab{}
+	for k, v := range successCases {
+		sm.client = v.mockClient
+		out, err := sm.GetSecretMap(context.Background(), *v.ref)
+		if !ErrorContains(err, v.expectError) {
+			t.Errorf("[%d] unexpected error: %s, expected: '%s'", k, err.Error(), v.expectError)
+		}
+		if err == nil && !reflect.DeepEqual(out, v.expectedData) {
+			t.Errorf("[%d] unexpected secret data: expected %#v, got %#v", k, v.expectedData, out)
+		}
+	}
+}
 
 func ErrorContains(out error, want string) bool {
 	if out == nil {
@@ -225,50 +176,3 @@ func ErrorContains(out error, want string) bool {
 	}
 	return strings.Contains(out.Error(), want)
 }
-
-// NOT WORKING CURRENTLY
-
-// func TestCreateGitlabClient(t *testing.T) {
-// 	credentials := GitlabCredentials{Token: GITLAB_TOKEN}
-// 	gitlab := NewGitlabProvider()
-// 	gitlab.SetAuth(credentials, GITLAB_PROJECT_ID)
-
-// 	// user, _, _ := gitlab.client.Users.CurrentUser()
-// 	// fmt.Printf("Created client for username: %v", user)
-// }
-
-// func TestGetSecret(t *testing.T) {
-// 	ctx := context.Background()
-
-// 	ref := v1alpha1.ExternalSecretDataRemoteRef{Key: "mySecretBanana"}
-
-// 	credentials := GitlabCredentials{Token: GITLAB_TOKEN}
-// 	gitlab := NewGitlabProvider()
-// 	gitlab.SetAuth(credentials, GITLAB_PROJECT_ID)
-
-// 	secretData, err := gitlab.GetSecret(ctx, ref)
-
-// 	if err != nil {
-// 		fmt.Errorf("error retrieving secret, %w", err)
-// 	}
-
-// 	fmt.Printf("Got secret data %v", string(secretData))
-// }
-
-// func TestGetSecretMap(t *testing.T) {
-// 	ctx := context.Background()
-
-// 	ref := v1alpha1.ExternalSecretDataRemoteRef{Key: "myJsonSecret"}
-
-// 	credentials := GitlabCredentials{Token: GITLAB_TOKEN}
-// 	gitlab := NewGitlabProvider()
-// 	gitlab.SetAuth(credentials, GITLAB_PROJECT_ID)
-
-// 	secretData, err := gitlab.GetSecretMap(ctx, ref)
-
-// 	if err != nil {
-// 		fmt.Errorf("error retrieving secret map, %w", err)
-// 	}
-
-// 	fmt.Printf("Got secret map: %v", secretData)
-// }