Remove extra bundles argo used to try to validate regretion in favor of cover scenarios with mocks and unit tests

Author: camilamacedo86

go.mod

@@ -30,6 +30,7 @@ require (
 	golang.org/x/sync v0.16.0
 	golang.org/x/tools v0.35.0
 	gopkg.in/yaml.v2 v2.4.0
+	gotest.tools/v3 v3.5.2
 	helm.sh/helm/v3 v3.18.4
 	k8s.io/api v0.33.2
 	k8s.io/apiextensions-apiserver v0.33.2

internal/operator-controller/rukpak/render/render_test.go

@@ -1,28 +1,23 @@
 package render_test
 
 import (
-	"cmp"
 	"errors"
 	"fmt"
-	"os"
-	"path/filepath"
 	"reflect"
-	"slices"
-	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/require"
+	"gotest.tools/v3/assert"
 	appsv1 "k8s.io/api/apps/v1"
 	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 	"sigs.k8s.io/controller-runtime/pkg/client"
-	"sigs.k8s.io/yaml"
 
 	"github.com/operator-framework/api/pkg/operators/v1alpha1"
 
 	"github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/bundle"
-	"github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/bundle/source"
 	"github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/render"
-	"github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/render/registryv1"
 	. "github.com/operator-framework/operator-controller/internal/operator-controller/rukpak/util/testing"
 )
 
@@ -275,84 +270,162 @@ func Test_BundleValidatorCallsAllValidationFnsInOrder(t *testing.T) {
 	require.NoError(t, val.Validate(nil))
 	require.Equal(t, "hi", actual)
 }
+func Test_Render_WithNilBundleValidator(t *testing.T) {
+	defer func() {
+		if r := recover(); r == nil {
+			t.Error("expected panic when BundleValidator is nil")
+		}
+	}()
 
-// This test ensures consistent rendering behavior for registry+v1 bundles:
-// - Uses the bundles defined in the testdata directory
-// - Renders manifests using the registryv1 renderer
-// - Sorts rendered objects by Kind, Namespace, and Name to ensure deterministic output
-// - Writes the results to a temporary directory for inspection
-// - Ensures the rendering completes without error
-// - Automatically cleans up the generated files after the test completes
-//
-// This was introduced to prevent flaky diffs caused by non-deterministic manifest ordering.
-// Related issue: https://github.com/operator-framework/operator-controller/pull/1895
-func Test_RenderRegistryV1Bundle_GenerateAndAutoCleanup(t *testing.T) {
-	bundleRoot := "testdata/bundles"
+	renderer := render.BundleRenderer{}
+	_, _ = renderer.Render(bundle.RegistryV1{}, "ns")
+}
+
+func Test_Render_WithNoResourceGenerators(t *testing.T) {
+	renderer := render.BundleRenderer{
+		BundleValidator: render.BundleValidator{
+			func(_ *bundle.RegistryV1) []error { return nil },
+		},
+	}
+
+	_, err := renderer.Render(bundle.RegistryV1{
+		CSV: MakeCSV(WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces)),
+	}, "test", render.WithTargetNamespaces("test"), render.WithUniqueNameGenerator(render.DefaultUniqueNameGenerator))
+
+	require.NoError(t, err)
+}
+
+func Test_Render_ReturnsExactSameObjectReferences(t *testing.T) {
+	obj1 := fakeUnstructured("Service", "ns", "svc")
+	obj2 := fakeUnstructured("ConfigMap", "ns", "cfg")
+
+	mockGen := render.ResourceGenerator(func(_ *bundle.RegistryV1, _ render.Options) ([]client.Object, error) {
+		return []client.Object{obj1, obj2}, nil
+	})
+
+	renderer := render.BundleRenderer{
+		BundleValidator:    render.BundleValidator{func(_ *bundle.RegistryV1) []error { return nil }},
+		ResourceGenerators: []render.ResourceGenerator{mockGen},
+	}
+
+	result, err := renderer.Render(bundle.RegistryV1{
+		CSV: MakeCSV(WithInstallModeSupportFor(v1alpha1.InstallModeTypeAllNamespaces)),
+	}, "ns", render.WithTargetNamespaces("ns"), render.WithUniqueNameGenerator(render.DefaultUniqueNameGenerator))
 
+	require.NoError(t, err)
+	require.Same(t, obj1, result[0])
+	require.Same(t, obj2, result[1])
+}
+
+// Test_Render_ValidatesOutputForAllInstallModes ensures that the BundleRenderer
+// correctly generates and returns the exact list of client.Objects produced by the
+// ResourceGenerators, across all supported install modes (AllNamespaces, SingleNamespace, OwnNamespace).
+func Test_Render_ValidatesOutputForAllInstallModes(t *testing.T) {
 	testCases := []struct {
 		name             string
 		installNamespace string
 		watchNamespace   string
-		bundle           string
-		testCaseName     string
+		installModes     []v1alpha1.InstallMode
+		expectedNS       string
 	}{
 		{
 			name:             "AllNamespaces",
-			installNamespace: "argocd-system",
+			installNamespace: "mock-system",
 			watchNamespace:   "",
-			bundle:           "argocd-operator.v0.6.0",
-			testCaseName:     "all-namespaces",
+			installModes: []v1alpha1.InstallMode{
+				{Type: v1alpha1.InstallModeTypeAllNamespaces, Supported: true},
+			},
+			expectedNS: "mock-system",
 		},
 		{
-			name:             "SingleNamespaces",
-			installNamespace: "argocd-system",
-			watchNamespace:   "argocd-watch",
-			bundle:           "argocd-operator.v0.6.0",
-			testCaseName:     "single-namespace",
+			name:             "SingleNamespace",
+			installNamespace: "mock-system",
+			watchNamespace:   "mock-watch",
+			installModes: []v1alpha1.InstallMode{
+				{Type: v1alpha1.InstallModeTypeSingleNamespace, Supported: true},
+			},
+			expectedNS: "mock-watch",
 		},
 		{
-			name:             "OwnNamespaces",
-			installNamespace: "argocd-system",
-			watchNamespace:   "argocd-system",
-			bundle:           "argocd-operator.v0.6.0",
-			testCaseName:     "own-namespace",
+			name:             "OwnNamespace",
+			installNamespace: "mock-system",
+			watchNamespace:   "mock-system",
+			installModes: []v1alpha1.InstallMode{
+				{Type: v1alpha1.InstallModeTypeOwnNamespace, Supported: true},
+			},
+			expectedNS: "mock-system",
 		},
 	}
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			bundlePath := filepath.Join(bundleRoot, tc.bundle)
-			outputDir := filepath.Join(t.TempDir(), tc.bundle, tc.testCaseName)
+			// Given the mocks
+			expectedObjects := []client.Object{
+				fakeUnstructured("ClusterRole", "", "mock-operator.v0-role"),
+				fakeUnstructured("ClusterRoleBinding", "", "mock-operator.v0-binding"),
+				fakeUnstructured("ConfigMap", tc.expectedNS, "mock-operator-manager-config"),
+				fakeUnstructured("CustomResourceDefinition", "", "mocks.argoproj.io"),
+				fakeUnstructured("Deployment", tc.expectedNS, "mock-operator-controller-manager"),
+				fakeUnstructured("Service", tc.expectedNS, "mock-operator-controller-manager-metrics-service"),
+				fakeUnstructured("ServiceAccount", tc.expectedNS, "mock-operator-controller-manager"),
+			}
 
-			fs := os.DirFS(bundlePath)
-			bundle, err := source.FromFS(fs).GetBundle()
-			require.NoError(t, err)
+			mockGen := render.ResourceGenerator(func(_ *bundle.RegistryV1, _ render.Options) ([]client.Object, error) {
+				return expectedObjects, nil
+			})
 
-			rendered, err := registryv1.Renderer.Render(bundle, tc.installNamespace,
-				render.WithTargetNamespaces(tc.watchNamespace))
-			require.NoError(t, err)
+			mockBundle := bundle.RegistryV1{
+				CSV: v1alpha1.ClusterServiceVersion{
+					Spec: v1alpha1.ClusterServiceVersionSpec{
+						InstallModes: tc.installModes,
+					},
+				},
+			}
 
-			sorted := slices.SortedFunc(slices.Values(rendered), orderByKindNamespaceName)
+			renderer := render.BundleRenderer{
+				BundleValidator: render.BundleValidator{
+					func(_ *bundle.RegistryV1) []error { return nil },
+				},
+				ResourceGenerators: []render.ResourceGenerator{mockGen},
+			}
 
-			require.NoError(t, os.MkdirAll(outputDir, os.ModePerm))
+			opts := []render.Option{
+				render.WithTargetNamespaces(tc.watchNamespace),
+				render.WithUniqueNameGenerator(render.DefaultUniqueNameGenerator),
+			}
 
-			for idx, obj := range sorted {
-				kind := obj.GetObjectKind().GroupVersionKind().Kind
-				filename := fmt.Sprintf("%02d_%s_%s.yaml", idx, strings.ToLower(kind), obj.GetName())
-				filePath := filepath.Join(outputDir, filename)
+			// When we call:
+			objs, err := renderer.Render(mockBundle, tc.installNamespace, opts...)
 
-				data, err := yaml.Marshal(obj)
-				require.NoError(t, err)
-				require.NoError(t, os.WriteFile(filePath, data, 0600))
+			// We expected have no error and ensure that the objects
+			// returned match with the resource generator's output.
+			require.NoError(t, err)
+			require.Len(t, objs, len(expectedObjects))
+
+			for i, obj := range objs {
+				exp := expectedObjects[i]
+				assert.Equal(t, exp.GetObjectKind().GroupVersionKind().Kind, obj.GetObjectKind().GroupVersionKind().Kind)
+				assert.Equal(t, exp.GetName(), obj.GetName(), "unexpected name at index %d", i)
+				assert.Equal(t, exp.GetNamespace(), obj.GetNamespace(), "unexpected namespace at index %d", i)
 			}
 		})
 	}
 }
 
-func orderByKindNamespaceName(a client.Object, b client.Object) int {
-	return cmp.Or(
-		cmp.Compare(a.GetObjectKind().GroupVersionKind().Kind, b.GetObjectKind().GroupVersionKind().Kind),
-		cmp.Compare(a.GetNamespace(), b.GetNamespace()),
-		cmp.Compare(a.GetName(), b.GetName()),
-	)
+func fakeUnstructured(kind, namespace, name string) client.Object {
+	obj := &unstructured.Unstructured{}
+	group := ""
+	version := "v1"
+	if kind == "CustomResourceDefinition" {
+		group = "apiextensions.k8s.io"
+		version = "v1"
+	}
+	obj.SetGroupVersionKind(schema.GroupVersionKind{
+		Group:   group,
+		Version: version,
+		Kind:    kind,
+	})
+	obj.SetNamespace(namespace)
+	obj.SetName(name)
+	return obj
 }