fix: enforce existence for explicit templates

Updates `ResolveCoreTemplate`, `ResolveCellTemplate`, and `ResolveShardTemplate`
to return an error if a specific template name (explicitly requested or
cluster default) is not found.

Maintains the "safe fallback" behavior only for the implicit "default"
template lookup, ensuring that user typos or missing critical config
fail-fast while allowing Level 4 defaults to apply for standard setups.

Author: fernando-villalba

pkg/cluster-handler/controller/multigrescluster/multigrescluster_controller_test.go

@@ -317,6 +317,26 @@ func TestMultigresClusterReconciler_Reconcile(t *testing.T) {
 				}
 			},
 		},
+		{
+			name: "Create: MultiAdmin with ImagePullSecrets",
+			cluster: func() *multigresv1alpha1.MultigresCluster {
+				c := baseCluster.DeepCopy()
+				c.Spec.Images.ImagePullSecrets = []corev1.LocalObjectReference{{Name: "my-secret"}}
+				return c
+			}(),
+			existingObjects: []client.Object{coreTpl, cellTpl, shardTpl},
+			expectError:     false,
+			validate: func(t *testing.T, c client.Client) {
+				ctx := context.Background()
+				deploy := &appsv1.Deployment{}
+				if err := c.Get(ctx, types.NamespacedName{Name: clusterName + "-multiadmin", Namespace: namespace}, deploy); err != nil {
+					t.Fatal("MultiAdmin not created")
+				}
+				if len(deploy.Spec.Template.Spec.ImagePullSecrets) != 1 || deploy.Spec.Template.Spec.ImagePullSecrets[0].Name != "my-secret" {
+					t.Errorf("ImagePullSecrets not propagated. Got %v", deploy.Spec.Template.Spec.ImagePullSecrets)
+				}
+			},
+		},
 		{
 			name: "Create: Inline Etcd",
 			cluster: func() *multigresv1alpha1.MultigresCluster {
@@ -475,6 +495,26 @@ func TestMultigresClusterReconciler_Reconcile(t *testing.T) {
 			expectError:     true, // Updated to true because controller now enforces 50 char limit
 			validate:        func(t *testing.T, c client.Client) {},
 		},
+		{
+			name: "Create: No Global Topo Config",
+			cluster: func() *multigresv1alpha1.MultigresCluster {
+				c := baseCluster.DeepCopy()
+				c.Spec.GlobalTopoServer = multigresv1alpha1.GlobalTopoServerSpec{} // Empty
+				c.Spec.TemplateDefaults = multigresv1alpha1.TemplateDefaults{}     // Empty
+				c.Spec.MultiAdmin = multigresv1alpha1.MultiAdminConfig{}           // Empty
+				return c
+			}(),
+			existingObjects: []client.Object{cellTpl, shardTpl}, // No Core Template
+			expectError:     false,
+			validate: func(t *testing.T, c client.Client) {
+				// Verify Cell got empty topo address
+				cell := &multigresv1alpha1.Cell{}
+				_ = c.Get(context.Background(), types.NamespacedName{Name: clusterName + "-zone-a", Namespace: namespace}, cell)
+				if cell.Spec.GlobalTopoServer.Address != "" {
+					t.Errorf("Expected empty topo address, got %q", cell.Spec.GlobalTopoServer.Address)
+				}
+			},
+		},
 		{
 			name: "Status: Aggregation Logic",
 			cluster: func() *multigresv1alpha1.MultigresCluster {
@@ -602,6 +642,37 @@ func TestMultigresClusterReconciler_Reconcile(t *testing.T) {
 		// ---------------------------------------------------------------------
 		// Error Injection Scenarios
 		// ---------------------------------------------------------------------
+		{
+			name: "Error: Explicit Template Missing (Should Fail)",
+			cluster: func() *multigresv1alpha1.MultigresCluster {
+				c := baseCluster.DeepCopy()
+				c.Spec.TemplateDefaults.CoreTemplate = "non-existent-template"
+				return c
+			}(),
+			existingObjects: []client.Object{}, // No templates exist
+			failureConfig:   nil,               // No API failure, just logical failure
+			expectError:     true,              // MUST ERROR NOW
+		},
+		{
+			name: "Error: Explicit Cell Template Missing",
+			cluster: func() *multigresv1alpha1.MultigresCluster {
+				c := baseCluster.DeepCopy()
+				c.Spec.Cells[0].CellTemplate = "missing-cell-tpl"
+				return c
+			}(),
+			existingObjects: []client.Object{coreTpl, shardTpl}, // Missing cellTpl
+			expectError:     true,
+		},
+		{
+			name: "Error: Explicit Shard Template Missing",
+			cluster: func() *multigresv1alpha1.MultigresCluster {
+				c := baseCluster.DeepCopy()
+				c.Spec.Databases[0].TableGroups[0].Shards[0].ShardTemplate = "missing-shard-tpl"
+				return c
+			}(),
+			existingObjects: []client.Object{coreTpl, cellTpl}, // Missing shardTpl
+			expectError:     true,
+		},
 		{
 			name:            "Error: Object Not Found (Clean Exit)",
 			cluster:         baseCluster.DeepCopy(),
@@ -913,6 +984,8 @@ func TestMultigresClusterReconciler_Reconcile(t *testing.T) {
 				c := baseCluster.DeepCopy()
 				c.Spec.TemplateDefaults.CoreTemplate = ""
 				c.Spec.GlobalTopoServer.TemplateRef = "topo-fail-cells"
+				// Clear MultiAdmin to ensure predictable call counts
+				c.Spec.MultiAdmin = multigresv1alpha1.MultiAdminConfig{}
 				return c
 			}(),
 			existingObjects: []client.Object{
@@ -928,8 +1001,8 @@ func TestMultigresClusterReconciler_Reconcile(t *testing.T) {
 					return func(key client.ObjectKey) error {
 						if key.Name == "topo-fail-cells" {
 							count++
-							// Call 1: reconcileGlobalComponents (Succeed)
-							// Call 2: reconcileCells (Fail)
+							// Call 1: reconcileGlobalComponents -> ResolveCoreTemplate (Succeeds to proceed)
+							// Call 2: reconcileCells -> getGlobalTopoRef -> ResolveCoreTemplate (Fails)
 							if count == 2 {
 								return errBoom
 							}
@@ -946,6 +1019,8 @@ func TestMultigresClusterReconciler_Reconcile(t *testing.T) {
 				c := baseCluster.DeepCopy()
 				c.Spec.TemplateDefaults.CoreTemplate = ""
 				c.Spec.GlobalTopoServer.TemplateRef = "topo-fail-db"
+				// Clear MultiAdmin to ensure predictable call counts
+				c.Spec.MultiAdmin = multigresv1alpha1.MultiAdminConfig{}
 				return c
 			}(),
 			existingObjects: []client.Object{
@@ -961,9 +1036,9 @@ func TestMultigresClusterReconciler_Reconcile(t *testing.T) {
 					return func(key client.ObjectKey) error {
 						if key.Name == "topo-fail-db" {
 							count++
-							// Call 1: reconcileGlobalComponents (Succeed)
-							// Call 2: reconcileCells (Succeed)
-							// Call 3: reconcileDatabases (Fail)
+							// Call 1: reconcileGlobalComponents (Succeeds)
+							// Call 2: reconcileCells (Succeeds)
+							// Call 3: reconcileDatabases -> getGlobalTopoRef (Fails)
 							if count == 3 {
 								return errBoom
 							}

pkg/cluster-handler/controller/multigrescluster/template_logic.go

@@ -2,6 +2,7 @@ package multigrescluster
 
 import (
 	"context"
+	"fmt"
 	"reflect"
 
 	multigresv1alpha1 "github.com/numtide/multigres-operator/api/v1alpha1"
@@ -27,21 +28,31 @@ type TemplateResolver struct {
 // 1. The cluster-level default defined in TemplateDefaults.
 // 2. A CoreTemplate named "default" found in the same namespace where MultigresCluster is deployed.
 //
-// If the resolved template is not found, it returns an empty CoreTemplate object and nil error.
+// If an explicit template (param or cluster default) is not found, it returns an error.
+// If the implicit "default" template is not found, it returns an empty object (safe fallback).
+// In this case the default would be applied by the operator via mutating webhook.
 func (r *TemplateResolver) ResolveCoreTemplate(ctx context.Context, templateName string) (*multigresv1alpha1.CoreTemplate, error) {
 	name := templateName
+	isImplicitFallback := false
+
 	if name == "" {
 		name = r.Defaults.CoreTemplate
 	}
 	if name == "" {
 		name = "default"
+		isImplicitFallback = true
 	}
 
 	tpl := &multigresv1alpha1.CoreTemplate{}
 	err := r.Client.Get(ctx, types.NamespacedName{Name: name, Namespace: r.Namespace}, tpl)
 	if err != nil {
 		if errors.IsNotFound(err) {
-			return &multigresv1alpha1.CoreTemplate{}, nil
+			if isImplicitFallback {
+				// It is safe to ignore a missing "default" template
+				return &multigresv1alpha1.CoreTemplate{}, nil
+			}
+			// It is NOT safe to ignore a missing template requested by the user
+			return nil, fmt.Errorf("referenced CoreTemplate '%s' not found", name)
 		}
 		return nil, err
 	}
@@ -51,18 +62,24 @@ func (r *TemplateResolver) ResolveCoreTemplate(ctx context.Context, templateName
 // ResolveCellTemplate fetches and resolves a CellTemplate by name, handling defaults.
 func (r *TemplateResolver) ResolveCellTemplate(ctx context.Context, templateName string) (*multigresv1alpha1.CellTemplate, error) {
 	name := templateName
+	isImplicitFallback := false
+
 	if name == "" {
 		name = r.Defaults.CellTemplate
 	}
 	if name == "" {
 		name = "default"
+		isImplicitFallback = true
 	}
 
 	tpl := &multigresv1alpha1.CellTemplate{}
 	err := r.Client.Get(ctx, types.NamespacedName{Name: name, Namespace: r.Namespace}, tpl)
 	if err != nil {
 		if errors.IsNotFound(err) {
-			return &multigresv1alpha1.CellTemplate{}, nil
+			if isImplicitFallback {
+				return &multigresv1alpha1.CellTemplate{}, nil
+			}
+			return nil, fmt.Errorf("referenced CellTemplate '%s' not found", name)
 		}
 		return nil, err
 	}
@@ -72,18 +89,24 @@ func (r *TemplateResolver) ResolveCellTemplate(ctx context.Context, templateName
 // ResolveShardTemplate fetches and resolves a ShardTemplate by name, handling defaults.
 func (r *TemplateResolver) ResolveShardTemplate(ctx context.Context, templateName string) (*multigresv1alpha1.ShardTemplate, error) {
 	name := templateName
+	isImplicitFallback := false
+
 	if name == "" {
 		name = r.Defaults.ShardTemplate
 	}
 	if name == "" {
 		name = "default"
+		isImplicitFallback = true
 	}
 
 	tpl := &multigresv1alpha1.ShardTemplate{}
 	err := r.Client.Get(ctx, types.NamespacedName{Name: name, Namespace: r.Namespace}, tpl)
 	if err != nil {
 		if errors.IsNotFound(err) {
-			return &multigresv1alpha1.ShardTemplate{}, nil
+			if isImplicitFallback {
+				return &multigresv1alpha1.ShardTemplate{}, nil
+			}
+			return nil, fmt.Errorf("referenced ShardTemplate '%s' not found", name)
 		}
 		return nil, err
 	}