#4 move tests to their designated files

pkg/domain/blueprintMaskV1.go

@@ -21,10 +21,10 @@ type BlueprintMaskV1 struct {
 // Validate checks the structure and data of a blueprint mask and returns an error if there are any problems
 func (blueprintMask *BlueprintMaskV1) Validate() error {
 	if blueprintMask.API == "" {
-		return errors.Errorf("could not validate mask API, mask API must not be empty")
+		return errors.Errorf("could not Validate mask API, mask API must not be empty")
 	}
 	if blueprintMask.ID == "" {
-		return errors.Errorf("could not validate mask ID, mask ID must not be empty")
+		return errors.Errorf("could not Validate mask ID, mask ID must not be empty")
 	}
 
 	err := blueprintMask.validateDogus()
@@ -60,7 +60,7 @@ func (blueprintMask *BlueprintMaskV1) validateDoguUniqueness() error {
 	for _, dogu := range blueprintMask.Dogus {
 		_, seen := seenDogu[dogu.Name]
 		if seen {
-			return errors.Errorf("could not validate blueprint mask, there is at least one duplicate for this dogu: %s", dogu.Name)
+			return errors.Errorf("could not Validate blueprint mask, there is at least one duplicate for this dogu: %s", dogu.Name)
 		}
 		seenDogu[dogu.Name] = true
 	}

pkg/domain/blueprintV2.go

@@ -36,27 +36,27 @@ type RegistryConfig map[string]map[string]interface{}
 func (blueprint *BlueprintV2) Validate() error {
 	err := blueprint.validateDogus()
 	if err != nil {
-		return err
+		return errors.Wrap(err, "could not Validate blueprint")
 	}
 
 	err = blueprint.validateDoguUniqueness()
 	if err != nil {
-		return err
+		return errors.Wrap(err, "could not Validate blueprint")
 	}
 
 	err = blueprint.validateComponents()
 	if err != nil {
-		return err
+		return errors.Wrap(err, "could not Validate blueprint")
 	}
 
 	err = blueprint.validateComponentUniqueness()
 	if err != nil {
-		return err
+		return errors.Wrap(err, "could not Validate blueprint")
 	}
 
 	err = blueprint.validateRegistryConfig()
 	if err != nil {
-		return err
+		return errors.Wrap(err, "could not Validate blueprint")
 	}
 
 	return nil
@@ -65,7 +65,7 @@ func (blueprint *BlueprintV2) Validate() error {
 func (blueprint *BlueprintV2) validateDogus() error {
 	for _, dogu := range blueprint.Dogus {
 
-		err := dogu.validate()
+		err := dogu.Validate()
 		if err != nil {
 			return err
 		}
@@ -78,15 +78,15 @@ func (blueprint *BlueprintV2) validateDoguUniqueness() error {
 	doguNames := Map(blueprint.Dogus, func(dogu TargetDogu) string { return dogu.Name })
 	duplicates := getDuplicates(doguNames)
 	if len(duplicates) != 0 {
-		return errors.Errorf("could not validate blueprint, there are duplicate dogus: %v", duplicates)
+		return errors.Errorf("could not Validate blueprint, there are duplicate dogus: %v", duplicates)
 	}
 	return nil
 }
 
 func (blueprint *BlueprintV2) validateComponents() error {
 	for _, component := range blueprint.Components {
 
-		err := component.validate()
+		err := component.Validate()
 		if err != nil {
 			return err
 		}
@@ -100,15 +100,15 @@ func (blueprint *BlueprintV2) validateComponentUniqueness() error {
 	componentNames := Map(blueprint.Components, func(component Component) string { return component.Name })
 	duplicates := getDuplicates(componentNames)
 	if len(duplicates) != 0 {
-		return errors.Errorf("could not validate blueprint, there are duplicate components: %v", duplicates)
+		return errors.Errorf("could not Validate blueprint, there are duplicate components: %v", duplicates)
 	}
 	return nil
 }
 
 func (blueprint *BlueprintV2) validateRegistryConfig() error {
 	for key, value := range blueprint.RegistryConfig {
 		if len(key) == 0 {
-			return errors.Errorf("could not validate blueprint, a config key is empty")
+			return errors.Errorf("could not Validate blueprint, a config key is empty")
 		}
 
 		err := validateKeysNotEmpty(value)
@@ -123,7 +123,7 @@ func (blueprint *BlueprintV2) validateRegistryConfig() error {
 func validateKeysNotEmpty(config map[string]interface{}) error {
 	for key, value := range config {
 		if len(key) == 0 {
-			return errors.Errorf("could not validate blueprint, a config key is empty")
+			return errors.Errorf("could not Validate blueprint, a config key is empty")
 		}
 
 		switch vTyped := value.(type) {

pkg/domain/blueprintV2_test.go

@@ -1,109 +1,12 @@
 package domain
 
 import (
-	"encoding/json"
 	"github.com/stretchr/testify/require"
-	"reflect"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 )
 
-func TestTargetState_String(t *testing.T) {
-	tests := []struct {
-		name  string
-		state TargetState
-		want  string
-	}{
-		{
-			"String() map enum to string",
-			TargetStatePresent,
-			"present",
-		},
-		{
-			"String() map enum to string",
-			TargetStateAbsent,
-			"absent",
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := tt.state.String(); got != tt.want {
-				t.Errorf("TargetState.String() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestTargetState_MarshalJSON(t *testing.T) {
-	tests := []struct {
-		name    string
-		state   TargetState
-		want    []byte
-		wantErr bool
-	}{
-		{
-			"MarshalJSON to bytes",
-			TargetStatePresent,
-			[]byte("\"present\""),
-			false,
-		},
-		{
-			"MarshalJSON to bytes",
-			TargetStateAbsent,
-			[]byte("\"absent\""),
-			false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := tt.state.MarshalJSON()
-			if (err != nil) != tt.wantErr {
-				t.Errorf("TargetState.MarshalJSON() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("TargetState.MarshalJSON() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestTargetState_UnmarshalJSON_secondValue(t *testing.T) {
-	jsonBlob := []byte("\"absent\"")
-	var sut TargetState
-	err := json.Unmarshal(jsonBlob, &sut)
-
-	assert.Nil(t, err)
-	assert.Equal(t, TargetState(TargetStateAbsent), sut)
-}
-
-func TestTargetState_UnmarshalJSON_firstValue(t *testing.T) {
-	jsonBlob := []byte("\"present\"")
-	var sut TargetState
-	err := json.Unmarshal(jsonBlob, &sut)
-
-	assert.Nil(t, err)
-	assert.Equal(t, TargetState(TargetStatePresent), sut)
-}
-
-func TestTargetState_UnmarshalJSON_unknownValueParsesToFirstState(t *testing.T) {
-	jsonBlob := []byte("\"test\"")
-	var sut TargetState
-	err := json.Unmarshal(jsonBlob, &sut)
-
-	assert.Nil(t, err)
-	assert.Equal(t, TargetState(TargetStatePresent), sut)
-}
-
-func TestTargetState_UnmarshalJSON_error(t *testing.T) {
-	jsonBlob := []byte("test")
-	var sut TargetState
-	err := json.Unmarshal(jsonBlob, &sut)
-
-	assert.NotNil(t, err)
-}
-
 func Test_validate_ok(t *testing.T) {
 	dogus := []TargetDogu{
 		{Name: "absent/dogu1", Version: "3.2.1-0", TargetState: TargetStateAbsent},
@@ -135,30 +38,7 @@ func Test_validate_errorOnDoguProblem(t *testing.T) {
 	err := blueprint.Validate()
 
 	require.NotNil(t, err)
-	assert.Contains(t, err.Error(), "could not validate blueprint, dogu field Name must not be empty")
-}
-func Test_validateDogu_errorOnMissingDoguName(t *testing.T) {
-	dogus := []TargetDogu{
-		{Version: "3.2.1-2", TargetState: TargetStatePresent},
-	}
-	blueprint := BlueprintV2{Dogus: dogus}
-
-	err := blueprint.Validate()
-
-	require.NotNil(t, err)
-	assert.Contains(t, err.Error(), "could not validate blueprint, dogu field Name must not be empty")
-}
-
-func Test_validateDogu_errorOnEmptyDoguName(t *testing.T) {
-	dogus := []TargetDogu{
-		{Name: "", Version: "3.2.1-2", TargetState: TargetStatePresent},
-	}
-	blueprint := BlueprintV2{Dogus: dogus}
-
-	err := blueprint.Validate()
-
-	require.NotNil(t, err)
-	assert.Contains(t, err.Error(), "could not validate blueprint, dogu field Name must not be empty")
+	assert.Contains(t, err.Error(), "could not Validate blueprint: dogu field Name must not be empty")
 }
 
 func Test_validateDogus_ok(t *testing.T) {
@@ -200,7 +80,7 @@ func Test_validateComponents_ok(t *testing.T) {
 	require.Nil(t, err)
 }
 
-func Test_validateComponents_errorOnMissingDoguName(t *testing.T) {
+func Test_validateComponents_errorOnMissingName(t *testing.T) {
 	components := []Component{
 		{Name: "absent-component", TargetState: TargetStateAbsent},
 		{Name: "present-component", Version: "3.2.1-2", TargetState: TargetStatePresent},
@@ -222,7 +102,7 @@ func Test_validateDoguUniqueness(t *testing.T) {
 	err := blueprint.validateDoguUniqueness()
 
 	require.NotNil(t, err)
-	assert.Contains(t, err.Error(), "could not validate blueprint, there are duplicate dogus: [present/dogu1]")
+	assert.Contains(t, err.Error(), "could not Validate blueprint, there are duplicate dogus: [present/dogu1]")
 }
 
 func Test_validateComponentUniqueness(t *testing.T) {
@@ -236,7 +116,7 @@ func Test_validateComponentUniqueness(t *testing.T) {
 	err := blueprint.validateComponentUniqueness()
 
 	require.NotNil(t, err)
-	assert.Contains(t, err.Error(), "could not validate blueprint, there are duplicate components: [present/component1]")
+	assert.Contains(t, err.Error(), "could not Validate blueprint, there are duplicate components: [present/component1]")
 }
 
 func TestValidationGlobalValid(t *testing.T) {
@@ -266,7 +146,7 @@ func TestValidationGlobalEmptyKeyError(t *testing.T) {
 	err := blueprint.Validate()
 	assert.NotNil(t, err)
 
-	assert.Contains(t, err.Error(), "could not validate blueprint, a config key is empty")
+	assert.Contains(t, err.Error(), "could not Validate blueprint, a config key is empty")
 }
 
 func TestSetDoguRegistryKeysSuccessful(t *testing.T) {

pkg/domain/component.go

@@ -14,12 +14,13 @@ type Component struct {
 	TargetState TargetState `json:"targetState"`
 }
 
-func (component *Component) validate() error {
+// Validate checks if the component is semantically correct.
+func (component *Component) Validate() error {
 	if component.Name == "" {
-		return errors.Errorf("could not validate blueprint, component name must not be empty: %s", component)
+		return errors.Errorf("component name must not be empty: %s", component)
 	}
 	if component.TargetState != TargetStateAbsent && component.Version == "" {
-		return errors.Errorf("could not validate blueprint, component version must not be empty: %s", component)
+		return errors.Errorf("component version must not be empty: %s", component)
 	}
 
 	return nil

pkg/domain/component_test.go

@@ -9,51 +9,51 @@ import (
 func Test_validateComponents_errorOnMissingComponentVersion(t *testing.T) {
 	component := Component{Name: "present-component", TargetState: TargetStatePresent}
 
-	err := component.validate()
+	err := component.Validate()
 
 	require.NotNil(t, err)
-	assert.Contains(t, err.Error(), "could not validate blueprint, component version must not be empty")
+	assert.Contains(t, err.Error(), "component version must not be empty")
 }
 
 func Test_validateComponents_errorOnEmptyComponentVersion(t *testing.T) {
 	component := Component{Name: "present/component", Version: "", TargetState: TargetStatePresent}
 
-	err := component.validate()
+	err := component.Validate()
 
 	require.NotNil(t, err)
-	assert.Contains(t, err.Error(), "could not validate blueprint, component version must not be empty")
+	assert.Contains(t, err.Error(), "component version must not be empty")
 }
 
 func Test_validateComponents_errorOnMissingComponentName(t *testing.T) {
 	component := Component{Version: "1.2.3", TargetState: TargetStatePresent}
 
-	err := component.validate()
+	err := component.Validate()
 
 	require.NotNil(t, err)
-	assert.Contains(t, err.Error(), "could not validate blueprint, component name must not be empty")
+	assert.Contains(t, err.Error(), "component name must not be empty")
 }
 
 func Test_validateComponents_errorOnEmptyComponentName(t *testing.T) {
 	component := Component{Name: "", Version: "1.2.3", TargetState: TargetStatePresent}
 
-	err := component.validate()
+	err := component.Validate()
 
 	require.NotNil(t, err)
-	assert.Contains(t, err.Error(), "could not validate blueprint, component name must not be empty")
+	assert.Contains(t, err.Error(), "component name must not be empty")
 }
 
 func Test_validateComponents_emptyComponentStateDefaultsToPresent(t *testing.T) {
 	component := Component{Name: "present-component", Version: "1.2.3"}
 
-	err := component.validate()
+	err := component.Validate()
 
 	require.Nil(t, err)
 }
 
 func Test_validateComponents_missingComponentVersionOkayForAbsent(t *testing.T) {
 	component := Component{Name: "present-component", TargetState: TargetStateAbsent}
 
-	err := component.validate()
+	err := component.Validate()
 
 	require.Nil(t, err)
 }

pkg/domain/maskTargetDogu.go

@@ -16,10 +16,10 @@ type MaskTargetDogu struct {
 
 func (dogu MaskTargetDogu) validate() error {
 	if dogu.Name == "" {
-		return errors.Errorf("could not validate blueprint mask, dogu field Name must not be empty: %s", dogu)
+		return errors.Errorf("could not Validate blueprint mask, dogu field Name must not be empty: %s", dogu)
 	}
 	if dogu.TargetState.String() == "" {
-		return errors.Errorf("could not validate dogu, dogu target state must not be empty: %s", dogu)
+		return errors.Errorf("could not Validate dogu, dogu target state must not be empty: %s", dogu)
 	}
 
 	return nil

pkg/domain/maskTargetDogu_test.go

@@ -35,5 +35,5 @@ func Test_validateMaskTargetDogu_errorOnMissingNameForDogu(t *testing.T) {
 	err := dogu.validate()
 
 	require.Error(t, err)
-	require.ErrorContains(t, err, "could not validate blueprint mask, dogu field Name must not be empty")
+	require.ErrorContains(t, err, "could not Validate blueprint mask, dogu field Name must not be empty")
 }