refactor: Unify naming for reading manifest

Instead of having *convert/parse/to*, we now have *parse* as the single prefix for reading manifest related data.

pkg/manifest/account.go

@@ -40,7 +40,7 @@ func (e invalidUUIDError) Unwrap() error {
 	return e.err
 }
 
-func convertSingleAccount(c *LoaderContext, a account) (Account, error) {
+func parseSingleAccount(c *LoaderContext, a account) (Account, error) {
 
 	if a.AccountUUID == "" {
 		return Account{}, errAccUidMissing
@@ -75,8 +75,8 @@ func convertSingleAccount(c *LoaderContext, a account) (Account, error) {
 	return acc, nil
 }
 
-// convertAccounts converts the persistence definition to the in-memory definition
-func convertAccounts(c *LoaderContext, accounts []account) (map[string]Account, error) {
+// parseAccounts converts the persistence definition to the in-memory definition
+func parseAccounts(c *LoaderContext, accounts []account) (map[string]Account, error) {
 
 	result := make(map[string]Account, len(accounts))
 
@@ -85,7 +85,7 @@ func convertAccounts(c *LoaderContext, accounts []account) (map[string]Account,
 			return nil, fmt.Errorf("failed to parse account on position %d: %w", i, errNameMissing)
 		}
 
-		acc, err := convertSingleAccount(c, a)
+		acc, err := parseSingleAccount(c, a)
 		if err != nil {
 			return nil, fmt.Errorf("failed to parse account %q: %w", a.Name, err)
 		}

pkg/manifest/account_test.go

@@ -61,7 +61,7 @@ func TestValidAccounts(t *testing.T) {
 		},
 	}
 
-	v, err := convertAccounts(&LoaderContext{}, []account{acc, acc2})
+	v, err := parseAccounts(&LoaderContext{}, []account{acc, acc2})
 	assert.NoError(t, err)
 
 	assert.Equal(t, v, map[string]Account{
@@ -119,31 +119,31 @@ func TestInvalidAccounts(t *testing.T) {
 	}
 
 	// validate that the default is valid
-	_, err := convertAccounts(&LoaderContext{}, []account{validAccount})
+	_, err := parseAccounts(&LoaderContext{}, []account{validAccount})
 	assert.NoError(t, err)
 
 	// tests
 	t.Run("name is missing", func(t *testing.T) {
 		a := validAccount
 		a.Name = ""
 
-		_, err := convertAccounts(&LoaderContext{}, []account{a})
+		_, err := parseAccounts(&LoaderContext{}, []account{a})
 		assert.ErrorIs(t, err, errNameMissing)
 	})
 
 	t.Run("accountUUID is missing", func(t *testing.T) {
 		a := validAccount
 		a.AccountUUID = ""
 
-		_, err := convertAccounts(&LoaderContext{}, []account{a})
+		_, err := parseAccounts(&LoaderContext{}, []account{a})
 		assert.ErrorIs(t, err, errAccUidMissing)
 	})
 
 	t.Run("accountUUID is invalid", func(t *testing.T) {
 		a := deepCopy(t, validAccount)
 		a.AccountUUID = "this-is-not-a-valid-uuid"
 
-		_, err := convertAccounts(&LoaderContext{}, []account{a})
+		_, err := parseAccounts(&LoaderContext{}, []account{a})
 		uuidErr := invalidUUIDError{}
 		if assert.ErrorAs(t, err, &uuidErr) {
 			assert.Equal(t, uuidErr.uuid, "this-is-not-a-valid-uuid")
@@ -154,15 +154,15 @@ func TestInvalidAccounts(t *testing.T) {
 		a := deepCopy(t, validAccount)
 		a.OAuth = oAuth{}
 
-		_, err := convertAccounts(&LoaderContext{}, []account{a})
+		_, err := parseAccounts(&LoaderContext{}, []account{a})
 		assert.ErrorContains(t, err, "oAuth is invalid")
 	})
 
 	t.Run("oAuth.id is not set", func(t *testing.T) {
 		a := deepCopy(t, validAccount)
 		a.OAuth.ClientID = authSecret{}
 
-		_, err := convertAccounts(&LoaderContext{}, []account{a})
+		_, err := parseAccounts(&LoaderContext{}, []account{a})
 		assert.ErrorContains(t, err, "ClientID: no name given or empty")
 
 	})
@@ -171,7 +171,7 @@ func TestInvalidAccounts(t *testing.T) {
 		a := deepCopy(t, validAccount)
 		a.OAuth.ClientSecret = authSecret{}
 
-		_, err := convertAccounts(&LoaderContext{}, []account{a})
+		_, err := parseAccounts(&LoaderContext{}, []account{a})
 		assert.ErrorContains(t, err, "ClientSecret: no name given or empty")
 	})
 }

pkg/manifest/manifest_loader.go

@@ -152,7 +152,7 @@ func LoadManifest(context *LoaderContext) (Manifest, []error) {
 	var errs []error
 
 	// projects
-	projectDefinitions, projectErrors := toProjectDefinitions(&projectLoaderContext{
+	projectDefinitions, projectErrors := parseProjects(&projectLoaderContext{
 		fs:           workingDirFs,
 		manifestPath: relativeManifestPath,
 	}, manifestYAML.Projects)
@@ -163,15 +163,15 @@ func LoadManifest(context *LoaderContext) (Manifest, []error) {
 	}
 
 	// environments
-	environmentDefinitions, manifestErrors := toEnvironments(context, manifestYAML.EnvironmentGroups)
+	environmentDefinitions, manifestErrors := parseEnvironments(context, manifestYAML.EnvironmentGroups)
 	if manifestErrors != nil {
 		errs = append(errs, manifestErrors...)
 	} else if len(environmentDefinitions) == 0 {
 		errs = append(errs, newManifestLoaderError(context.ManifestPath, "no environments defined in manifest"))
 	}
 
 	// accounts
-	accounts, accErr := convertAccounts(context, manifestYAML.Accounts)
+	accounts, accErr := parseAccounts(context, manifestYAML.Accounts)
 	if accErr != nil {
 		errs = append(errs, newManifestLoaderError(context.ManifestPath, accErr.Error()))
 	}
@@ -330,7 +330,7 @@ func validateVersion(m manifest) error {
 	return nil
 }
 
-func toEnvironments(context *LoaderContext, groups []group) (map[string]EnvironmentDefinition, []error) { // nolint:gocognit
+func parseEnvironments(context *LoaderContext, groups []group) (map[string]EnvironmentDefinition, []error) { // nolint:gocognit
 	var errors []error
 	environments := make(map[string]EnvironmentDefinition)
 
@@ -367,7 +367,7 @@ func toEnvironments(context *LoaderContext, groups []group) (map[string]Environm
 				continue
 			}
 
-			parsedEnv, configErrors := parseEnvironment(context, env, group.Name)
+			parsedEnv, configErrors := parseSingleEnvironment(context, env, group.Name)
 
 			if configErrors != nil {
 				errors = append(errors, configErrors...)
@@ -415,7 +415,7 @@ func shouldSkipEnv(context *LoaderContext, group group, env environment) bool {
 	return true
 }
 
-func parseEnvironment(context *LoaderContext, config environment, group string) (EnvironmentDefinition, []error) {
+func parseSingleEnvironment(context *LoaderContext, config environment, group string) (EnvironmentDefinition, []error) {
 	var errs []error
 
 	a, err := parseAuth(context, config.Auth)
@@ -489,7 +489,7 @@ func parseURLDefinition(context *LoaderContext, u url) (URLDefinition, error) {
 	return URLDefinition{}, fmt.Errorf("%q is not a valid URL type", u.Type)
 }
 
-func toProjectDefinitions(context *projectLoaderContext, definitions []project) (map[string]ProjectDefinition, []error) {
+func parseProjects(context *projectLoaderContext, definitions []project) (map[string]ProjectDefinition, []error) {
 	var errors []error
 	result := make(map[string]ProjectDefinition)
 

pkg/manifest/manifest_loader_test.go

@@ -483,11 +483,11 @@ func Test_toProjectDefinitions(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			context := &projectLoaderContext{testFs, "path/to/a/manifest.yaml"}
 
-			got, gotErrs := toProjectDefinitions(context, tt.projectDefinitions)
+			got, gotErrs := parseProjects(context, tt.projectDefinitions)
 
 			numErrs := len(gotErrs)
 			if (tt.wantErrs && numErrs <= 0) || (!tt.wantErrs && numErrs > 0) {
-				t.Errorf("toProjectDefinitions() returned unexpected Errors = %v", gotErrs)
+				t.Errorf("parseProjects() returned unexpected Errors = %v", gotErrs)
 			}
 
 			assert.Equal(t, tt.want, got)