fix normalieze manifests issue (#585)

* fix normalieze manifests issue

Signed-off-by: yxxhero <aiopsclub@163.com>

* refactor: unexport normalize helper and harden tests

- Rename ContentNormalizeManifests to unexported normalizeContent
  (avoids widening the public API; name avoids clash with the
  normalizeManifests bool parameter)
- Move the test into an internal package (manifest) to access the
  unexported helper
- Add an error-path case (sequence cannot unmarshal into map)
- Use require.NoError/require.Error and direct []byte comparison

Signed-off-by: yxxhero <aiopsclub@163.com>

---------

Signed-off-by: yxxhero <aiopsclub@163.com>

Author: yxxhero

manifest/normalize_test.go

@@ -0,0 +1,62 @@
+package manifest
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestNormalizeContent(t *testing.T) {
+	tests := []struct {
+		name           string
+		content        []byte
+		expectedOutput []byte
+		expectError    bool
+	}{
+		{
+			name: "Valid content",
+			content: []byte(`apiVersion: v1
+kind: Pod
+metadata:
+  name: my-pod
+spec:
+  containers:
+  - name: my-container
+    image: nginx`),
+			expectedOutput: []byte(`apiVersion: v1
+kind: Pod
+metadata:
+  name: my-pod
+spec:
+  containers:
+  - image: nginx
+    name: my-container
+`),
+		},
+		{
+			// yaml.v2 marshals a nil map to "{}\n". Empty content never
+			// reaches this path in practice (Parse filters it earlier),
+			// but document the behavior regardless.
+			name:           "Empty content",
+			content:        []byte(""),
+			expectedOutput: []byte("{}\n"),
+		},
+		{
+			name:        "Sequence cannot unmarshal into map",
+			content:     []byte("- a\n- b"),
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			output, err := normalizeContent(tt.content)
+			if tt.expectError {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+			require.Equal(t, tt.expectedOutput, output)
+		})
+	}
+}

manifest/parse.go

@@ -190,15 +190,11 @@ func parseContent(content []byte, defaultNamespace string, normalizeManifests bo
 	}
 
 	if normalizeManifests {
-		var object map[interface{}]interface{}
-		if err := yaml.Unmarshal(content, &object); err != nil {
-			log.Fatalf("YAML unmarshal error: %s\nCan't unmarshal %s", err, content)
-		}
-		normalizedContent, err := yaml.Marshal(object)
-		if err != nil {
-			log.Fatalf("YAML marshal error: %s\nCan't marshal %v", err, object)
+		var normalizeErr error
+		content, normalizeErr = normalizeContent(content)
+		if normalizeErr != nil {
+			log.Fatalf("Error normalizing manifests: %v", normalizeErr)
 		}
-		content = normalizedContent
 	}
 
 	if isHook(parsedMetadata, excludedHooks...) {
@@ -220,6 +216,21 @@ func parseContent(content []byte, defaultNamespace string, normalizeManifests bo
 	}, nil
 }
 
+func normalizeContent(content []byte) ([]byte, error) {
+	// Unmarshal and marshal again content to normalize yaml structure
+	// This avoids style differences to show up as diffs but it can
+	// make the output different from the original template (since it is in normalized form)
+	var object map[interface{}]interface{}
+	if err := yaml.Unmarshal(content, &object); err != nil {
+		return nil, err
+	}
+	normalizedContent, err := yaml.Marshal(object)
+	if err != nil {
+		return nil, err
+	}
+	return normalizedContent, nil
+}
+
 func isHook(metadata metadata, hooks ...string) bool {
 	for _, hook := range hooks {
 		if metadata.Metadata.Annotations[hookAnnotation] == hook {