Added unit tests to refs package

Signed-off-by: jose.vazquez <[email protected]>

Author: josvazg

internal/autogen/translate/refs/context_test.go

@@ -0,0 +1,124 @@
+// Copyright 2025 MongoDB Inc
+//
+// 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 refs
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+)
+
+var (
+	testNamespace = "my-namespace"
+	mainObj       = &corev1.ConfigMap{
+		ObjectMeta: metav1.ObjectMeta{Name: "main-cm", Namespace: testNamespace},
+	}
+	dep1 = &corev1.ConfigMap{
+		ObjectMeta: metav1.ObjectMeta{Name: "dep1-cm", Namespace: testNamespace},
+	}
+	dep2 = &corev1.ConfigMap{
+		ObjectMeta: metav1.ObjectMeta{Name: "dep2-cm", Namespace: testNamespace},
+	}
+)
+
+func TestNewMapContext(t *testing.T) {
+	ctx := newMapContext(mainObj, []client.Object{dep1, dep2})
+
+	require.NotNil(t, ctx, "context should not be nil")
+	assert.Equal(t, mainObj, ctx.main, "main object should be set correctly")
+	assert.Len(t, ctx.m, 2, "map should contain the two initial dependencies")
+	assert.Len(t, ctx.added, 0, "added slice should be empty on initialization")
+
+	assert.Contains(t, ctx.m, client.ObjectKeyFromObject(dep1))
+	assert.Equal(t, dep1, ctx.m[client.ObjectKeyFromObject(dep1)])
+
+	assert.Contains(t, ctx.m, client.ObjectKeyFromObject(dep2))
+	assert.Equal(t, dep2, ctx.m[client.ObjectKeyFromObject(dep2)])
+}
+
+func TestContext_FindAndHas(t *testing.T) {
+	ctx := newMapContext(mainObj, []client.Object{dep1})
+
+	testCases := []struct {
+		name              string
+		searchName        string
+		expectedFound     client.Object
+		expectedHasResult bool
+	}{
+		{
+			name:              "should find existing object",
+			searchName:        "dep1-cm",
+			expectedFound:     dep1,
+			expectedHasResult: true,
+		},
+		{
+			name:              "should not find non-existent object",
+			searchName:        "non-existent-cm",
+			expectedFound:     nil,
+			expectedHasResult: false,
+		},
+		{
+			name:              "should not find with empty name",
+			searchName:        "",
+			expectedFound:     nil,
+			expectedHasResult: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			foundObj := ctx.find(tc.searchName)
+			hasResult := ctx.has(tc.searchName)
+
+			assert.Equal(t, tc.expectedFound, foundObj, "find() returned unexpected object")
+			assert.Equal(t, tc.expectedHasResult, hasResult, "has() returned unexpected result")
+		})
+	}
+}
+
+func TestContext_Add(t *testing.T) {
+	ctx := newMapContext(mainObj, []client.Object{dep1})
+	require.Len(t, ctx.m, 1, "pre-condition failed: map should have 1 item")
+	require.Len(t, ctx.added, 0, "pre-condition failed: added slice should be empty")
+
+	newDep := &corev1.ConfigMap{
+		ObjectMeta: metav1.ObjectMeta{Name: "new-dep-cm", Namespace: testNamespace},
+	}
+
+	require.False(t, ctx.has(newDep.GetName()), "pre-condition failed: new object should not exist yet")
+
+	ctx.add(newDep)
+
+	assert.Len(t, ctx.m, 2, "map length should be 2 after adding")
+	assert.Len(t, ctx.added, 1, "added slice should have 1 item after adding")
+	assert.True(t, ctx.has(newDep.GetName()), "has() should find the newly added object")
+	assert.Equal(t, newDep, ctx.find(newDep.GetName()), "find() should return the newly added object")
+	assert.Equal(t, newDep, ctx.added[0], "the newly added object should be in the 'added' slice")
+
+	anotherDep := &corev1.ConfigMap{
+		ObjectMeta: metav1.ObjectMeta{Name: "another-dep-cm", Namespace: testNamespace},
+	}
+	ctx.add(anotherDep)
+
+	assert.Len(t, ctx.m, 3, "map length should be 3 after second add")
+	assert.Len(t, ctx.added, 2, "added slice should have 2 items after second add")
+	assert.True(t, ctx.has(anotherDep.GetName()), "has() should find the second added object")
+	assert.Contains(t, ctx.added, newDep, "added slice should still contain the first added object")
+	assert.Contains(t, ctx.added, anotherDep, "added slice should contain the second added object")
+}

internal/autogen/translate/refs/handler.go

@@ -30,7 +30,7 @@ const (
 	SecretProperySelector = "$.data.#"
 )
 
-// Handler hodls the context needed to expand or collapse the references on an
+// Handler holds the context needed to expand or collapse the references on an
 // Kubernetes object translaion to and from API data
 type Handler struct {
 	*context
@@ -41,25 +41,43 @@ func NewHandler(main client.Object, deps []client.Object) *Handler {
 	return &Handler{context: newMapContext(main, deps)}
 }
 
-func (h *Handler) ExpandMappings(obj, mappings map[string]any, fields ...string) error {
+func (h *Handler) ExpandReferences(obj, mappings map[string]any, fields ...string) error {
 	h.expand = true
-	expandedPath := []string{"properties"}
-	for _, field := range fields {
-		expandedPath = append(expandedPath, field, "properties")
-	}
-	props, err := unstructured.AccessField[map[string]any](mappings, expandedPath...)
+
+	props, err := accessMappingPropsAt(mappings, fields)
 	if errors.Is(err, unstructured.ErrNotFound) {
 		return nil
+	} else if err != nil {
+		return fmt.Errorf("failed to access mappings to expand references: %w", err)
 	}
+
+	field, err := unstructured.AccessField[map[string]any](obj, fields...)
 	if err != nil {
-		return fmt.Errorf("failed to access the API mapping properties for %v: %w", expandedPath, err)
+		return fmt.Errorf("failed to access object's %v: %w", fields, err)
+	}
+	if err := h.scanProperties([]string{}, props, field); err != nil {
+		return fmt.Errorf("failed to expand references at %v: %w", fields, err)
+	}
+	return nil
+}
+
+func (h *Handler) CollapseReferences(obj, mappings map[string]any, fields ...string) error {
+	h.expand = false
+
+	props, err := accessMappingPropsAt(mappings, fields)
+	if errors.Is(err, unstructured.ErrNotFound) {
+		return nil
+	} else if err != nil {
+		return fmt.Errorf("failed to access mappings to collapse references: %w", err)
 	}
+
 	field, err := unstructured.AccessField[map[string]any](obj, fields...)
 	if err != nil {
 		return fmt.Errorf("failed to access object's %v: %w", fields, err)
 	}
-	if err := h.mapProperties([]string{}, props, field); err != nil {
-		return fmt.Errorf("failed to process properties from API into %v: %w", fields, err)
+
+	if err := h.scanProperties([]string{}, props, field); err != nil {
+		return fmt.Errorf("failed to collapse references at %v: %w", fields, err)
 	}
 	return nil
 }
@@ -68,33 +86,40 @@ func (h *Handler) Added() []client.Object {
 	return h.added
 }
 
-func (h *Handler) CollapseReferences(path []string, props, obj map[string]any) error {
-	h.expand = false
-	return h.mapProperties(path, props, obj)
+func accessMappingPropsAt(mappings map[string]any, fields []string) (map[string]any, error) {
+	expandedPath := []string{"properties"}
+	for _, field := range fields {
+		expandedPath = append(expandedPath, field, "properties")
+	}
+	props, err := unstructured.AccessField[map[string]any](mappings, expandedPath...)
+	if err != nil {
+		return nil, fmt.Errorf("failed to access the API mapping properties for %v: %w", expandedPath, err)
+	}
+	return props, nil
 }
 
-func (m *Handler) mapProperties(path []string, props, obj map[string]any) error {
+func (m *Handler) scanProperties(path []string, props, obj map[string]any) error {
 	for key, prop := range props {
 		mapping, ok := (prop).(map[string]any)
 		if !ok {
 			continue
 		}
 		subPath := append(path, key)
 		if isReference(mapping) {
-			if err := m.mapReference(subPath, key, mapping, obj); err != nil {
+			if err := m.processReference(subPath, key, mapping, obj); err != nil {
 				return fmt.Errorf("failed to process reference: %w", err)
 			}
 			continue
 		}
-		rawField, err := unstructured.AccessField[any](obj, key) // unstructured.NestedFieldNoCopy(obj, key)
+		rawField, err := unstructured.AccessField[any](obj, key)
 		if errors.Is(err, unstructured.ErrNotFound) {
 			continue
 		}
 		if err != nil {
 			return fmt.Errorf("failed to access %q: %w", key, err)
 		}
 		if arrayField, ok := (rawField).([]any); ok {
-			if err := m.mapArray(subPath, mapping, arrayField); err != nil {
+			if err := m.scanArray(subPath, mapping, arrayField); err != nil {
 				return fmt.Errorf("failed to process array mapping %q: %w", key, err)
 			}
 			continue
@@ -103,14 +128,14 @@ func (m *Handler) mapProperties(path []string, props, obj map[string]any) error
 		if !ok {
 			return fmt.Errorf("unsupported mapping of type %T", rawField)
 		}
-		if err := m.mapObject(subPath, key, mapping, subSpec); err != nil {
+		if err := m.scanObject(subPath, key, mapping, subSpec); err != nil {
 			return fmt.Errorf("failed to process object mapping %q: %w", key, err)
 		}
 	}
 	return nil
 }
 
-func (m *Handler) mapArray(path []string, mapping map[string]any, list []any) error {
+func (m *Handler) scanArray(path []string, mapping map[string]any, list []any) error {
 	mapItems, err := unstructured.AccessField[map[string]any](mapping, "items", "properties")
 	if err != nil {
 		return fmt.Errorf("failed to access %q: %w", unstructured.Base(path), err)
@@ -128,28 +153,28 @@ func (m *Handler) mapArray(path []string, mapping map[string]any, list []any) er
 			continue
 		}
 		subPath := append(path, key)
-		if err := m.mapObject(subPath, mapName, mapping, entry); err != nil {
+		if err := m.scanObject(subPath, mapName, mapping, entry); err != nil {
 			return fmt.Errorf("failed to map property from array item %q at %v: %w", key, path, err)
 		}
 	}
 	return nil
 }
 
-func (m *Handler) mapObject(path []string, mapName string, mapping, obj map[string]any) error {
+func (m *Handler) scanObject(path []string, mapName string, mapping, obj map[string]any) error {
 	if mapping["properties"] != nil {
 		props, err := unstructured.AccessField[map[string]any](mapping, "properties")
 		if err != nil {
 			return fmt.Errorf("failed to access properties at %q: %w", path, err)
 		}
-		return m.mapProperties(path, props, obj)
+		return m.scanProperties(path, props, obj)
 	}
 	if isReference(mapping) {
-		return m.mapReference(path, mapName, mapping, obj)
+		return m.processReference(path, mapName, mapping, obj)
 	}
 	return fmt.Errorf("unsupported extension at %v with fields %v", path, unstructured.FieldsOf(mapping))
 }
 
-func (m *Handler) mapReference(path []string, mappingName string, mapping, obj map[string]any) error {
+func (m *Handler) processReference(path []string, mappingName string, mapping, obj map[string]any) error {
 	rm := refMapping{}
 	if err := unstructured.FromUnstructured(&rm, mapping); err != nil {
 		return fmt.Errorf("failed to parse a reference mapping: %w", err)