pkg/readiness: Make AllChecks injectable so TestRunAllMixedResults tests real RunAll

AllChecks was a func, so the mixed-results test had to reimplement
the RunAll orchestration loop manually — missing goroutine scheduling,
timeouts, and status aggregation. Make AllChecks a var so tests can
swap in fake checks and exercise the real RunAll path.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: harche

pkg/readiness/check.go

@@ -63,7 +63,7 @@ const (
 // Checks are split into two categories:
 //   - cluster_conditions: reads CVO's already-computed state (no re-querying)
 //   - everything else: gathers NEW data that CVO doesn't already track
-func AllChecks() []Check {
+var AllChecks = func() []Check {
 	return []Check{
 		&ClusterConditionsCheck{},    // reads existing CVO conditions — no duplication
 		&OperatorHealthCheck{},       // per-CO detail + MCPs (CVO only aggregates)

pkg/readiness/check_test.go

@@ -148,71 +148,47 @@ func TestSectionError(t *testing.T) {
 }
 
 func TestRunAllMixedResults(t *testing.T) {
-	okCheck := &fakeCheck{name: "passing", data: map[string]any{"healthy": true}}
-	failCheck := &fakeCheck{name: "failing", err: errors.New("something broke")}
-	partialCheck := &fakeCheck{name: "partial", data: map[string]any{"partial": true}, err: errors.New("partial failure")}
-
-	origAllChecks := AllChecks
-	// We can't override AllChecks directly since it's a function, so test RunAll
-	// indirectly through the real checks. Instead, test the orchestration logic
-	// by running checks manually and verifying the output structure.
-
-	_ = origAllChecks // satisfy usage
-
-	// Simulate RunAll behavior manually with our fake checks
-	checks := []Check{okCheck, failCheck, partialCheck}
-	results := make(map[string]CheckResult, len(checks))
-	ok := 0
-	errored := 0
-
-	for _, ch := range checks {
-		data, err := ch.Run(context.Background(), nil, "4.21.5", "4.21.8")
-		result := CheckResult{Elapsed: 0.1}
-		if err != nil {
-			result.Status = "error"
-			result.Error = err.Error()
-			if data != nil {
-				result.Data = data
-			} else {
-				result.Data = map[string]any{}
-			}
-			errored++
-		} else {
-			result.Status = "ok"
-			result.Data = data
-			ok++
+	orig := AllChecks
+	defer func() { AllChecks = orig }()
+
+	AllChecks = func() []Check {
+		return []Check{
+			&fakeCheck{name: "passing", data: map[string]any{"healthy": true}},
+			&fakeCheck{name: "failing", err: errors.New("something broke")},
+			&fakeCheck{name: "partial", data: map[string]any{"partial": true}, err: errors.New("partial failure")},
 		}
-		results[ch.Name()] = result
 	}
 
-	if ok != 1 {
-		t.Errorf("ok count = %d, want 1", ok)
+	output := RunAll(context.Background(), nil, "4.21.5", "4.21.8")
+
+	if output.Meta.TotalChecks != 3 {
+		t.Errorf("TotalChecks = %d, want 3", output.Meta.TotalChecks)
+	}
+	if output.Meta.ChecksOK != 1 {
+		t.Errorf("ChecksOK = %d, want 1", output.Meta.ChecksOK)
 	}
-	if errored != 2 {
-		t.Errorf("errored count = %d, want 2", errored)
+	if output.Meta.ChecksErrored != 2 {
+		t.Errorf("ChecksErrored = %d, want 2", output.Meta.ChecksErrored)
 	}
 
-	// Verify passing check
-	passing := results["passing"]
-	if passing.Status != "ok" {
+	passing := output.Checks["passing"]
+	if passing.Status != StatusOK {
 		t.Errorf("passing.Status = %q, want ok", passing.Status)
 	}
 	if passing.Data["healthy"] != true {
 		t.Errorf("passing.Data[healthy] = %v", passing.Data["healthy"])
 	}
 
-	// Verify failing check
-	failing := results["failing"]
-	if failing.Status != "error" {
+	failing := output.Checks["failing"]
+	if failing.Status != StatusError {
 		t.Errorf("failing.Status = %q, want error", failing.Status)
 	}
 	if failing.Error != "something broke" {
 		t.Errorf("failing.Error = %q", failing.Error)
 	}
 
-	// Verify partial failure preserves data
-	partial := results["partial"]
-	if partial.Status != "error" {
+	partial := output.Checks["partial"]
+	if partial.Status != StatusError {
 		t.Errorf("partial.Status = %q, want error", partial.Status)
 	}
 	if partial.Data["partial"] != true {