package github import ( "context" "expvar" "strconv" "strings" "testing" ) // readOutcomeCounter walks the expvar map looking for a key that matches the // supplied prefix. Returns 0 when no key matches. The prefix match keeps the // assertion robust against process-wide test pollution (other tests in the // package may push entries with the same label under -count=1 reruns). func readOutcomeCounter(t *testing.T, m *expvar.Map, prefix string) int64 { t.Helper() var total int64 m.Do(func(kv expvar.KeyValue) { if !strings.HasPrefix(kv.Key, prefix) { return } n, err := strconv.ParseInt(kv.Value.String(), 10, 64) if err != nil { t.Fatalf("counter %q value not int: %s", kv.Key, kv.Value.String()) } total += n }) return total } func TestPRWatchCardinalityCountsCurrentCanonicalState(t *testing.T) { _, _, _, store := setupPollerTest(t) ctx := context.Background() if _, err := store.db.Exec(`CREATE TABLE task_repositories ( id TEXT PRIMARY KEY, task_id TEXT NOT NULL, repository_id TEXT NOT NULL )`); err != nil { t.Fatalf("create task_repositories: %v", err) } if _, err := store.db.Exec(`INSERT INTO task_repositories (id, task_id, repository_id) VALUES ('binding-active', 'task-active', 'repo-attached')`); err != nil { t.Fatalf("seed task_repositories: %v", err) } seedTask(t, store, "task-active", false) seedTask(t, store, "task-archived", true) watches := []*PRWatch{ withTestWorkspace(&PRWatch{ID: "watch-searching", TaskID: "task-active", Branch: "feature/a"}), withTestWorkspace(&PRWatch{ID: "watch-discovered", TaskID: "task-active", Branch: "feature/b", PRNumber: 42}), withTestWorkspace(&PRWatch{ID: "watch-archived", TaskID: "task-archived", Branch: "feature/c"}), withTestWorkspace(&PRWatch{ID: "watch-orphan", TaskID: "task-missing", Branch: "feature/d"}), withTestWorkspace(&PRWatch{ID: "watch-detached", TaskID: "task-active", RepositoryID: "repo-detached", Branch: "feature/e"}), withTestWorkspace(&PRWatch{ID: "watch-attached", TaskID: "task-active", RepositoryID: "repo-attached", Branch: "feature/f"}), } for _, watch := range watches { watch.Owner = "owner" watch.Repo = "repo" if err := store.CreatePRWatch(ctx, watch); err != nil { t.Fatalf("CreatePRWatch(%s): %v", watch.ID, err) } } got, err := store.PRWatchCardinality(ctx) if err != nil { t.Fatalf("PRWatchCardinality: %v", err) } want := (PRWatchCardinality{Active: 4, Searching: 3, Duplicates: 0, Orphans: 2}) if got != want { t.Fatalf("PRWatchCardinality = %+v, want %+v", got, want) } } func TestOutcomeMetricLabel(t *testing.T) { cases := []struct { name string pairs []string want string }{ {"single_pair", []string{"populated", "true"}, "populated=true"}, {"two_pairs", []string{"action", "set", "outcome", "unknown"}, "action=set;outcome=unknown"}, {"odd_args_returns_empty", []string{"populated"}, ""}, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { if got := outcomeMetricLabel(tc.pairs...); got != tc.want { t.Errorf("outcomeMetricLabel(%v) = %q, want %q", tc.pairs, got, tc.want) } }) } } func TestBoolLabel(t *testing.T) { if got := boolLabel(true); got != "true" { t.Errorf("boolLabel(true) = %q, want true", got) } if got := boolLabel(false); got != "false" { t.Errorf("boolLabel(false) = %q, want false", got) } } func TestReviewCleanupMetrics(t *testing.T) { poller, _, _, _, client := setupOpenReviewCleanupRecords(t, CleanupPolicyAlways, 41, 42) client.feedbackErrors[41] = &GitHubAPIError{StatusCode: 401, Endpoint: "/pulls/41"} client.feedbackErrors[42] = &GitHubAPIError{StatusCode: 401, Endpoint: "/pulls/42"} failuresBefore := readOutcomeCounter(t, reviewCleanupFailuresTotal, "scope=workspace;class=auth") skipsBefore := readOutcomeCounter(t, reviewCleanupCircuitSkipsTotal, "scope=workspace;class=auth") poller.checkReviewWatches(context.Background()) poller.checkReviewWatches(context.Background()) if got := readOutcomeCounter(t, reviewCleanupFailuresTotal, "scope=workspace;class=auth"); got <= failuresBefore { t.Fatalf("workspace auth failure metric = %d, want an increment", got) } if got := readOutcomeCounter(t, reviewCleanupCircuitSkipsTotal, "scope=workspace;class=auth"); got <= skipsBefore { t.Fatalf("workspace auth circuit skip metric = %d, want an increment", got) } incReviewCleanupFailure("workspace-id-must-not-be-a-label", reviewCleanupMetricClassAuth) assertBoundedLabels := func(name string, metric *expvar.Map, allowed map[string]bool) { t.Helper() metric.Do(func(kv expvar.KeyValue) { if !allowed[kv.Key] { t.Errorf("%s contains unbounded label key %q", name, kv.Key) } }) } classLabels := []string{reviewCleanupMetricClassAuth, "config", "transient", "rate_limit", reviewCleanupMetricClassOther} var outcomeKeys = make(map[string]bool) for _, scope := range []string{"workspace", "record"} { for _, class := range classLabels { outcomeKeys[outcomeMetricLabel("scope", scope, "class", class)] = true } } assertBoundedLabels("review cleanup failures", reviewCleanupFailuresTotal, outcomeKeys) assertBoundedLabels("review cleanup circuit skips", reviewCleanupCircuitSkipsTotal, outcomeKeys) assertBoundedLabels("review cleanup circuit resets", reviewCleanupCircuitResetsTotal, map[string]bool{ outcomeMetricLabel("scope", "workspace"): true, outcomeMetricLabel("scope", "record"): true, }) } // TestIncTaskPROutcomeSyncRecordsOnExpvarMap covers AC-38: a sync's populated // state is recorded on the outcome-syncs expvar map under the label // incTaskPROutcomeSync builds, so the "did the writer stop populating // outcome fields" canary has raw material to read. func TestIncTaskPROutcomeSyncRecordsOnExpvarMap(t *testing.T) { labelTrue := outcomeMetricLabel("populated", boolLabel(true)) beforeTrue := readOutcomeCounter(t, taskPROutcomeSyncsTotal, labelTrue) incTaskPROutcomeSync(true) afterTrue := readOutcomeCounter(t, taskPROutcomeSyncsTotal, labelTrue) if afterTrue-beforeTrue != 1 { t.Errorf("populated=true counter delta = %d, want 1", afterTrue-beforeTrue) } labelFalse := outcomeMetricLabel("populated", boolLabel(false)) beforeFalse := readOutcomeCounter(t, taskPROutcomeSyncsTotal, labelFalse) incTaskPROutcomeSync(false) afterFalse := readOutcomeCounter(t, taskPROutcomeSyncsTotal, labelFalse) if afterFalse-beforeFalse != 1 { t.Errorf("populated=false counter delta = %d, want 1", afterFalse-beforeFalse) } } // TestOutcomeExpvarMapsPublishedAtKnownNames guards the /debug/vars names // AC-38 promises: a rename here silently breaks any external dashboard // scraping the names directly. func TestOutcomeExpvarMapsPublishedAtKnownNames(t *testing.T) { expected := []string{ "github_task_pr_outcome_syncs_total", "github_pr_watch_active", "github_pr_watch_searching", "github_pr_watch_duplicates", "github_pr_watch_orphans", "github_pr_watch_canonical_poll_requests_total", "github_review_cleanup_circuit_skips_total", "github_review_cleanup_circuit_resets_total", "github_review_cleanup_failures_total", "github_review_cleanup_core_quota_skips_total", } for _, name := range expected { if expvar.Get(name) == nil { t.Errorf("expvar %q not published — /debug/vars consumers will miss it", name) } } } func TestPRWatchOperationalMetricsRecordAggregateValues(t *testing.T) { recordPRWatchCardinality(PRWatchCardinality{Active: 7, Searching: 3, Duplicates: 1, Orphans: 2}) if got := prWatchActive.Value(); got != 7 { t.Fatalf("active watch gauge = %d, want 7", got) } if got := prWatchSearching.Value(); got != 3 { t.Fatalf("searching watch gauge = %d, want 3", got) } if got := prWatchDuplicates.Value(); got != 1 { t.Fatalf("duplicate watch gauge = %d, want 1", got) } if got := prWatchOrphans.Value(); got != 2 { t.Fatalf("orphan watch gauge = %d, want 2", got) } before := canonicalPollRequests.Value() incCanonicalPollRequests(4) if got := canonicalPollRequests.Value() - before; got != 4 { t.Fatalf("canonical poll request delta = %d, want 4", got) } }