🧪 test: add operator reconcile coverage

operator/internal/resources/common_test.go

@@ -21,6 +21,7 @@ func TestHeapMB(t *testing.T) {
 		{"out of range falls back", 1024, 150, "819M"},
 		{"floor applies to tiny limits", 128, 80, "256M"},
 		{"full allocation", 1000, 100, "1000M"},
+		{"zero limit uses default memory", 0, 80, "1638M"},
 	}
 
 	for _, tt := range tests {
@@ -49,6 +50,29 @@ func TestResourceRequirements(t *testing.T) {
 		}
 	})
 
+	t.Run("zero memory uses default", func(t *testing.T) {
+		got := ResourceRequirements(v1alpha1.Resources{})
+		want := resource.MustParse("2048Mi")
+		if got.Limits.Memory().Cmp(want) != 0 {
+			t.Errorf("limit memory = %v, want %v", got.Limits.Memory(), &want)
+		}
+	})
+
+	t.Run("explicit request below limit is kept", func(t *testing.T) {
+		got := ResourceRequirements(v1alpha1.Resources{MemoryLimitMB: 4096, MemoryRequestMB: 1024})
+		want := resource.MustParse("1024Mi")
+		if got.Requests.Memory().Cmp(want) != 0 {
+			t.Errorf("request memory = %v, want %v", got.Requests.Memory(), &want)
+		}
+	})
+
+	t.Run("valid cpu request is kept", func(t *testing.T) {
+		got := ResourceRequirements(v1alpha1.Resources{MemoryLimitMB: 1024, CPURequest: "250m"})
+		if got.Requests.Cpu().String() != "250m" {
+			t.Errorf("cpu request = %v, want 250m", got.Requests.Cpu())
+		}
+	})
+
 	t.Run("invalid cpu strings are dropped", func(t *testing.T) {
 		got := ResourceRequirements(v1alpha1.Resources{
 			MemoryLimitMB: 1024,
@@ -84,3 +108,88 @@ func TestUserEnvOverridesDefaults(t *testing.T) {
 		t.Errorf("TYPE = %q, want PAPER", got[0].Value)
 	}
 }
+
+func TestUserEnvClearsValueFromOnOverride(t *testing.T) {
+	base := []corev1.EnvVar{{
+		Name: "MINIKURA_API_KEY",
+		ValueFrom: &corev1.EnvVarSource{
+			SecretKeyRef: &corev1.SecretKeySelector{Key: "api-key"},
+		},
+	}}
+	got := UserEnv(base, []v1alpha1.EnvVar{{Name: "MINIKURA_API_KEY", Value: "inline"}})
+	if got[0].Value != "inline" {
+		t.Errorf("value = %q, want inline", got[0].Value)
+	}
+	if got[0].ValueFrom != nil {
+		t.Error("ValueFrom should be cleared when overridden")
+	}
+}
+
+func TestUserEnvAppendsUnknownKeys(t *testing.T) {
+	base := []corev1.EnvVar{{Name: "TYPE", Value: "PAPER"}}
+	got := UserEnv(base, []v1alpha1.EnvVar{{Name: "EXTRA", Value: "1"}})
+	if len(got) != 2 {
+		t.Fatalf("len = %d, want 2", len(got))
+	}
+}
+
+func TestJVMEnv(t *testing.T) {
+	env := JVMEnv(v1alpha1.JVMOptions{
+		Opts:            "-XX:+UseG1GC",
+		UseAikarFlags:   true,
+		UseMeowIceFlags: true,
+		HeapPercent:     70,
+	}, 2048)
+
+	want := map[string]string{
+		"MEMORY":            "1433M",
+		"JVM_OPTS":          "-XX:+UseG1GC",
+		"USE_AIKAR_FLAGS":   "true",
+		"USE_MEOWICE_FLAGS": "true",
+	}
+	for key, value := range want {
+		got, ok := envValue(env, key)
+		if !ok || got != value {
+			t.Errorf("%s = %q, %v; want %q", key, got, ok, value)
+		}
+	}
+}
+
+func TestJVMEnvOmitsOptionalFlags(t *testing.T) {
+	env := JVMEnv(v1alpha1.JVMOptions{}, 1024)
+	if _, ok := envValue(env, "JVM_OPTS"); ok {
+		t.Error("JVM_OPTS should be omitted")
+	}
+	if _, ok := envValue(env, "USE_AIKAR_FLAGS"); ok {
+		t.Error("USE_AIKAR_FLAGS should be omitted")
+	}
+}
+
+func TestTCPProbeDefaultsPort(t *testing.T) {
+	probe := TCPProbe(15, 0)
+	if probe.TCPSocket.Port.IntVal != ContainerPort {
+		t.Errorf("port = %d, want %d", probe.TCPSocket.Port.IntVal, ContainerPort)
+	}
+	if probe.InitialDelaySeconds != 15 {
+		t.Errorf("initialDelay = %d", probe.InitialDelaySeconds)
+	}
+}
+
+func TestBoolValue(t *testing.T) {
+	if !BoolValue(nil, true) {
+		t.Error("nil should use fallback true")
+	}
+	f := false
+	if BoolValue(&f, true) {
+		t.Error("explicit false should win")
+	}
+}
+
+func TestServiceTypeLoadBalancer(t *testing.T) {
+	if got := ServiceType(v1alpha1.ExposureLoadBalancer, corev1.ServiceTypeClusterIP); got != corev1.ServiceTypeLoadBalancer {
+		t.Errorf("got %v", got)
+	}
+	if got := ServiceType(v1alpha1.ExposureClusterIP, corev1.ServiceTypeLoadBalancer); got != corev1.ServiceTypeClusterIP {
+		t.Errorf("got %v", got)
+	}
+}