Add secrets filter functionality for GitLab

Adding secrets filtering for GitLab and changing
the functionality to determine whether GitLab or
GitHub secrets will be created on the scm field
in the init.yaml file. Also adding unit test
along with fixing existing ones and fixing
couple of spelling mistakes

Signed-off-by: Martin Dekov <mdekov@vmware.com>

Author: Martin Dekov

main

@@ -105,10 +105,10 @@ func main() {
 		os.Exit(1)
 	}
 
-	var featuersErr error
-	plan, featuersErr = filterFeatures(plan)
-	if featuersErr != nil {
-		fmt.Fprintf(os.Stderr, "error while retreiving features: %s\n", featuersErr.Error())
+	var featuresErr error
+	plan, featuresErr = filterFeatures(plan)
+	if featuresErr != nil {
+		fmt.Fprintf(os.Stderr, "error while retreiving features: %s\n", featuresErr.Error())
 		os.Exit(1)
 	}
 
@@ -631,14 +631,15 @@ func filterFeatures(plan types.Plan) (types.Plan, error) {
 
 	plan.Features = append(plan.Features, types.DefaultFeature)
 
-	if (plan.Github != types.Github{}) {
-		plan.Features = append(plan.Features, types.GitHub)
+	plan, err = filterGitRepositoryManager(plan)
+	if err != nil {
+		return plan, fmt.Errorf("Error while filtering features: %s", err.Error())
 	}
 
 	if plan.TLS == true {
 		plan, err = filterDNSFeature(plan)
 		if err != nil {
-			return plan, err
+			return plan, fmt.Errorf("Error while filtering features: %s", err.Error())
 		}
 	}
 
@@ -661,3 +662,14 @@ func filterDNSFeature(plan types.Plan) (types.Plan, error) {
 	}
 	return plan, nil
 }
+
+func filterGitRepositoryManager(plan types.Plan) (types.Plan, error) {
+	if plan.SCM == types.GitLabManager {
+		plan.Features = append(plan.Features, types.GitLabSCM)
+	} else if plan.SCM == types.GitHubManager {
+		plan.Features = append(plan.Features, types.GitHubSCM)
+	} else {
+		return plan, fmt.Errorf("Error unsupported Git repository manager: %s", plan.SCM)
+	}
+	return plan, nil
+}

main.go

@@ -72,48 +72,125 @@ func Test_filterFeatures(t *testing.T) {
 			expectedError:    nil,
 		},
 		{
-			title: "Every field which defines populated feature is populated",
+			title: "Every field which defines populated feature is populated for github",
 			planConfig: types.Plan{
-				Github: types.Github{
-					AppID:          "example ID",
-					PrivateKeyFile: "~/home/private_key.pem",
+				SCM: types.GitHubManager,
+				TLS: true,
+				TLSConfig: types.TLSConfig{
+					DNSService: types.Route53,
 				},
+				EnableOAuth: true,
+			},
+			expectedFeatures: []string{types.DefaultFeature, types.GitHubSCM, types.Auth, types.Route53DNS},
+			expectedError:    nil,
+		},
+		{
+			title: "Every field which defines populated feature is populated for gitlab",
+			planConfig: types.Plan{
+				SCM: types.GitLabManager,
 				TLS: true,
 				TLSConfig: types.TLSConfig{
 					DNSService: types.Route53,
 				},
 				EnableOAuth: true,
 			},
-			expectedFeatures: []string{types.DefaultFeature, types.GitHub, types.Auth, types.Route53DNS},
+			expectedFeatures: []string{types.DefaultFeature, types.GitLabSCM, types.Auth, types.Route53DNS},
 			expectedError:    nil,
 		},
 		{
-			title: "Auth and TLS are enabled",
+			title: "Example in which the function throws error in this case the SCM field is empty",
 			planConfig: types.Plan{
 				TLS: true,
 				TLSConfig: types.TLSConfig{
 					DNSService: types.Route53,
 				},
 				EnableOAuth: true,
 			},
+			expectedFeatures: []string{types.DefaultFeature},
+			expectedError:    errors.New("Error while filtering features"),
+		},
+		{
+			title: "Auth and TLS are enabled along with GitLab",
+			planConfig: types.Plan{
+				TLS: true,
+				TLSConfig: types.TLSConfig{
+					DNSService: types.Route53,
+				},
+				EnableOAuth: true,
+				SCM:         types.GitHubManager,
+			},
 			expectedFeatures: []string{types.DefaultFeature, types.Auth, types.Route53DNS},
 			expectedError:    nil,
 		},
 	}
 	for _, test := range tests {
 		t.Run(test.title, func(t *testing.T) {
-			test.planConfig, _ = filterFeatures(test.planConfig)
-			for _, feature := range test.planConfig.Features {
-				t.Logf("Searching for feature: %s, ", feature)
-				for allFeatures, expectedFeature := range test.expectedFeatures {
-					if feature == expectedFeature {
+			var filterError error
+			test.planConfig, filterError = filterFeatures(test.planConfig)
+			t.Logf("Features in the plan: %v", test.planConfig.Features)
+			if filterError != nil && test.expectedError != nil {
+				if !strings.Contains(filterError.Error(), test.expectedError.Error()) {
+					t.Errorf("Expected error to contain: `%s` got: `%s`", test.expectedError.Error(), filterError.Error())
+				}
+			}
+			for _, expectedFeature := range test.expectedFeatures {
+				for allPlanFeatures, enabledFeature := range test.planConfig.Features {
+					if len(test.planConfig.Features) == 0 {
+						t.Errorf("Feature 'default' should always be present")
+					}
+					if expectedFeature == enabledFeature {
 						break
 					}
-					if allFeatures == len(test.expectedFeatures) {
-						t.Errorf("Feature: %s not found in the expected features", feature)
+					if allPlanFeatures == len(test.planConfig.Features)-1 {
+						t.Errorf("Feature: '%s' not found in: %v", expectedFeature, test.planConfig.Features)
 					}
 				}
 			}
 		})
 	}
 }
+
+func Test_filterGitRepositoryManager(t *testing.T) {
+	tests := []struct {
+		title           string
+		planConfig      types.Plan
+		expectedFeature []string
+		expectedError   error
+	}{
+		{
+			title: "SCM field is populated for gitlab",
+			planConfig: types.Plan{
+				SCM: types.GitLabManager,
+			},
+			expectedFeature: []string{types.GitLabSCM},
+			expectedError:   nil,
+		},
+		{
+			title: "SCM field is populated for github",
+			planConfig: types.Plan{
+				SCM: types.GitHubManager,
+			},
+			expectedFeature: []string{types.GitHubSCM},
+			expectedError:   nil,
+		},
+		{
+			title: "SCM field is populated for with unsupported Git repository manager",
+			planConfig: types.Plan{
+				SCM: "bitbucket",
+			},
+			expectedFeature: []string{},
+			expectedError:   errors.New("Error unsupported Git repository manager: bitbucket"),
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.title, func(t *testing.T) {
+			var configErr error
+			test.planConfig, configErr = filterGitRepositoryManager(test.planConfig)
+			if configErr != nil && test.expectedError != nil {
+				if !strings.EqualFold(configErr.Error(), test.expectedError.Error()) {
+					t.Errorf("Expected error: '%s' got: '%s'", test.expectedError, configErr)
+				}
+			}
+		})
+	}
+}

main_test.go

@@ -8,25 +8,29 @@ import (
 const (
 	// DefaultFeature filter is for the features which are mandatory
 	DefaultFeature = "default"
-	// GitHub filter enables secrets created with the scm_github filter
-	GitHub = "scm_github"
-	// GitLab filter is the feature
-	GitLab = "scm_gitlab"
+	// GitHubSCM filter enables secrets created with the scm_github filter
+	GitHubSCM = "scm_github"
+	// GitLabSCM filter is the feature which enables secret creation for GitLab
+	GitLabSCM = "scm_gitlab"
 	// Auth filter enables OAuth secret creation
 	Auth = "auth"
 	// GCPDNS filter enables the creation of secrets for Google Cloud Platform DNS when TLS is enabled
 	GCPDNS = "gcp_dns01"
 	// DODNS filter enables the creation of secrets for Digital Ocean DNS when TLS is enabled
 	DODNS = "do_dns01"
-	// DODNS filter enables the creation of secrets for Amazon Route53 DNS when TLS is enabled
+	// Route53DNS filter enables the creation of secrets for Amazon Route53 DNS when TLS is enabled
 	Route53DNS = "route53_dns01"
 
 	// CloudDNS is the dns_service field in yaml file for Google Cloud Platform
 	CloudDNS = "clouddns"
-	// CloudDns is the dns_service field in yaml file for Digital Ocean
+	// DigitalOcean is the dns_service field in yaml file for Digital Ocean
 	DigitalOcean = "digitalocean"
 	// Route53 is the dns_service field in yaml file for Amazon
 	Route53 = "route53"
+	// GitLabManager repository manager name as displayed in the init.yaml file
+	GitLabManager = "gitlab"
+	// GitHubManager repository manager name as displayed in the init.yaml file
+	GitHubManager = "github"
 )
 
 type Plan struct {