Skip to content

Commit a2fa095

Browse files
committed
test(checks): add unit tests for workflow filters and fork fallback
Cover isWorkflowRunWaiting, isWorkflowRunPending, and matchesActionsConclusionFilter in tests/lib/filters.test.ts (including non-terminal exclusion on terminal conclusion filters and action_required exclusion under conclusion="other") and verify 3-way rollup classification and partial-error salvage in runForkPRFallback in tests/services/api.test.ts.
1 parent d73a9c4 commit a2fa095

2 files changed

Lines changed: 250 additions & 2 deletions

File tree

‎tests/lib/filters.test.ts‎

Lines changed: 115 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,16 @@
11
import { describe, it, expect } from "vitest";
2-
import { isIssueVisible, isPrVisible, isRunVisible } from "../../src/app/lib/filters";
2+
import {
3+
isIssueVisible,
4+
isPrVisible,
5+
isRunVisible,
6+
isWorkflowRunPending,
7+
isWorkflowRunWaiting,
8+
matchesActionsConclusionFilter,
9+
} from "../../src/app/lib/filters";
10+
import { KNOWN_CONCLUSIONS } from "../../src/app/components/shared/filterTypes";
311
import { makeIssue, makePullRequest, makeWorkflowRun } from "../helpers/index";
412

5-
// All three predicates are pure functions — no reactive root or store setup needed.
13+
// All predicates are pure functions — no reactive root or store setup needed.
614

715
describe("isIssueVisible", () => {
816
describe("ignoredIds", () => {
@@ -234,3 +242,108 @@ describe("isRunVisible", () => {
234242
});
235243
});
236244
});
245+
246+
describe("isWorkflowRunWaiting", () => {
247+
it("returns true for waiting and action_required statuses and completed action_required conclusion", () => {
248+
expect(isWorkflowRunWaiting({ status: "waiting", conclusion: null })).toBe(true);
249+
expect(isWorkflowRunWaiting({ status: "action_required", conclusion: null })).toBe(true);
250+
expect(isWorkflowRunWaiting({ status: "completed", conclusion: "action_required" })).toBe(true);
251+
});
252+
253+
it("returns false for running, pending, and other completed conclusions", () => {
254+
expect(isWorkflowRunWaiting({ status: "in_progress", conclusion: null })).toBe(false);
255+
expect(isWorkflowRunWaiting({ status: "queued", conclusion: null })).toBe(false);
256+
expect(isWorkflowRunWaiting({ status: "pending", conclusion: null })).toBe(false);
257+
expect(isWorkflowRunWaiting({ status: "requested", conclusion: null })).toBe(false);
258+
expect(isWorkflowRunWaiting({ status: "completed", conclusion: "success" })).toBe(false);
259+
expect(isWorkflowRunWaiting({ status: "completed", conclusion: "failure" })).toBe(false);
260+
expect(isWorkflowRunWaiting({ status: "completed", conclusion: null })).toBe(false);
261+
});
262+
});
263+
264+
describe("isWorkflowRunPending", () => {
265+
it("returns true for queued, pending, and requested statuses", () => {
266+
expect(isWorkflowRunPending({ status: "queued" })).toBe(true);
267+
expect(isWorkflowRunPending({ status: "pending" })).toBe(true);
268+
expect(isWorkflowRunPending({ status: "requested" })).toBe(true);
269+
});
270+
271+
it("returns false for running, waiting, action_required, and completed statuses", () => {
272+
expect(isWorkflowRunPending({ status: "in_progress" })).toBe(false);
273+
expect(isWorkflowRunPending({ status: "waiting" })).toBe(false);
274+
expect(isWorkflowRunPending({ status: "action_required" })).toBe(false);
275+
expect(isWorkflowRunPending({ status: "completed" })).toBe(false);
276+
});
277+
});
278+
279+
describe("matchesActionsConclusionFilter", () => {
280+
it("matches all runs when conclusionFilter is 'all'", () => {
281+
expect(matchesActionsConclusionFilter({ status: "in_progress", conclusion: null }, "all", KNOWN_CONCLUSIONS)).toBe(true);
282+
expect(matchesActionsConclusionFilter({ status: "waiting", conclusion: null }, "all", KNOWN_CONCLUSIONS)).toBe(true);
283+
expect(matchesActionsConclusionFilter({ status: "queued", conclusion: null }, "all", KNOWN_CONCLUSIONS)).toBe(true);
284+
expect(matchesActionsConclusionFilter({ status: "completed", conclusion: "success" }, "all", KNOWN_CONCLUSIONS)).toBe(true);
285+
});
286+
287+
it("matches only in_progress runs when conclusionFilter is 'running'", () => {
288+
expect(matchesActionsConclusionFilter({ status: "in_progress", conclusion: null }, "running", KNOWN_CONCLUSIONS)).toBe(true);
289+
expect(matchesActionsConclusionFilter({ status: "waiting", conclusion: null }, "running", KNOWN_CONCLUSIONS)).toBe(false);
290+
expect(matchesActionsConclusionFilter({ status: "queued", conclusion: null }, "running", KNOWN_CONCLUSIONS)).toBe(false);
291+
expect(matchesActionsConclusionFilter({ status: "completed", conclusion: "success" }, "running", KNOWN_CONCLUSIONS)).toBe(false);
292+
});
293+
294+
it("matches waiting and action_required runs when conclusionFilter is 'waiting'", () => {
295+
expect(matchesActionsConclusionFilter({ status: "waiting", conclusion: null }, "waiting", KNOWN_CONCLUSIONS)).toBe(true);
296+
expect(matchesActionsConclusionFilter({ status: "action_required", conclusion: null }, "waiting", KNOWN_CONCLUSIONS)).toBe(true);
297+
expect(matchesActionsConclusionFilter({ status: "completed", conclusion: "action_required" }, "waiting", KNOWN_CONCLUSIONS)).toBe(true);
298+
expect(matchesActionsConclusionFilter({ status: "in_progress", conclusion: null }, "waiting", KNOWN_CONCLUSIONS)).toBe(false);
299+
expect(matchesActionsConclusionFilter({ status: "queued", conclusion: null }, "waiting", KNOWN_CONCLUSIONS)).toBe(false);
300+
expect(matchesActionsConclusionFilter({ status: "completed", conclusion: "failure" }, "waiting", KNOWN_CONCLUSIONS)).toBe(false);
301+
});
302+
303+
it("matches queued, pending, and requested runs when conclusionFilter is 'pending'", () => {
304+
expect(matchesActionsConclusionFilter({ status: "queued", conclusion: null }, "pending", KNOWN_CONCLUSIONS)).toBe(true);
305+
expect(matchesActionsConclusionFilter({ status: "pending", conclusion: null }, "pending", KNOWN_CONCLUSIONS)).toBe(true);
306+
expect(matchesActionsConclusionFilter({ status: "requested", conclusion: null }, "pending", KNOWN_CONCLUSIONS)).toBe(true);
307+
expect(matchesActionsConclusionFilter({ status: "in_progress", conclusion: null }, "pending", KNOWN_CONCLUSIONS)).toBe(false);
308+
expect(matchesActionsConclusionFilter({ status: "waiting", conclusion: null }, "pending", KNOWN_CONCLUSIONS)).toBe(false);
309+
expect(matchesActionsConclusionFilter({ status: "completed", conclusion: "success" }, "pending", KNOWN_CONCLUSIONS)).toBe(false);
310+
});
311+
312+
it("excludes non-terminal and waiting runs from terminal conclusion filters ('success', 'failure', 'cancelled', 'other')", () => {
313+
const nonTerminalRuns = [
314+
{ status: "in_progress", conclusion: "success" },
315+
{ status: "in_progress", conclusion: "skipped" },
316+
{ status: "waiting", conclusion: "failure" },
317+
{ status: "action_required", conclusion: "cancelled" },
318+
{ status: "completed", conclusion: "action_required" },
319+
{ status: "queued", conclusion: "success" },
320+
{ status: "pending", conclusion: "failure" },
321+
{ status: "requested", conclusion: "skipped" },
322+
];
323+
324+
for (const run of nonTerminalRuns) {
325+
expect(matchesActionsConclusionFilter(run, "success", KNOWN_CONCLUSIONS)).toBe(false);
326+
expect(matchesActionsConclusionFilter(run, "failure", KNOWN_CONCLUSIONS)).toBe(false);
327+
expect(matchesActionsConclusionFilter(run, "cancelled", KNOWN_CONCLUSIONS)).toBe(false);
328+
expect(matchesActionsConclusionFilter(run, "other", KNOWN_CONCLUSIONS)).toBe(false);
329+
}
330+
});
331+
332+
it("matches completed runs against exact terminal conclusion filters ('success', 'failure', 'cancelled')", () => {
333+
expect(matchesActionsConclusionFilter({ status: "completed", conclusion: "success" }, "success", KNOWN_CONCLUSIONS)).toBe(true);
334+
expect(matchesActionsConclusionFilter({ status: "completed", conclusion: "failure" }, "success", KNOWN_CONCLUSIONS)).toBe(false);
335+
expect(matchesActionsConclusionFilter({ status: "completed", conclusion: "failure" }, "failure", KNOWN_CONCLUSIONS)).toBe(true);
336+
expect(matchesActionsConclusionFilter({ status: "completed", conclusion: "cancelled" }, "cancelled", KNOWN_CONCLUSIONS)).toBe(true);
337+
});
338+
339+
it("matches completed runs with unknown non-null conclusions under 'other' and excludes KNOWN_CONCLUSIONS including 'action_required'", () => {
340+
expect(matchesActionsConclusionFilter({ status: "completed", conclusion: "skipped" }, "other", KNOWN_CONCLUSIONS)).toBe(true);
341+
expect(matchesActionsConclusionFilter({ status: "completed", conclusion: "timed_out" }, "other", KNOWN_CONCLUSIONS)).toBe(true);
342+
expect(matchesActionsConclusionFilter({ status: "completed", conclusion: "neutral" }, "other", KNOWN_CONCLUSIONS)).toBe(true);
343+
expect(matchesActionsConclusionFilter({ status: "completed", conclusion: null }, "other", KNOWN_CONCLUSIONS)).toBe(false);
344+
expect(matchesActionsConclusionFilter({ status: "completed", conclusion: "success" }, "other", KNOWN_CONCLUSIONS)).toBe(false);
345+
expect(matchesActionsConclusionFilter({ status: "completed", conclusion: "failure" }, "other", KNOWN_CONCLUSIONS)).toBe(false);
346+
expect(matchesActionsConclusionFilter({ status: "completed", conclusion: "cancelled" }, "other", KNOWN_CONCLUSIONS)).toBe(false);
347+
expect(matchesActionsConclusionFilter({ status: "completed", conclusion: "action_required" }, "other", KNOWN_CONCLUSIONS)).toBe(false);
348+
});
349+
});

‎tests/services/api.test.ts‎

Lines changed: 135 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2840,6 +2840,141 @@ describe("fetchIssuesAndPullRequests — settled-PR enrichment cache", () => {
28402840
expect(res2.pullRequests[0].checkStatusStale).toBeUndefined();
28412841
});
28422842

2843+
it("classifies 3-way non-terminal rollups ('running', 'waiting', 'pending') in runForkPRFallback, selects STATUS_CHECK_ROLLUP_FIELDS, and salvages partial fork responses on error", async () => {
2844+
let throwPartialForkError = false;
2845+
const forkQueries: string[] = [];
2846+
2847+
const lightForkPRs = [
2848+
makeLightPR({ id: "PR_fork_1", databaseId: 401, number: 401 }),
2849+
makeLightPR({ id: "PR_fork_2", databaseId: 402, number: 402 }),
2850+
makeLightPR({ id: "PR_fork_3", databaseId: 403, number: 403 }),
2851+
];
2852+
2853+
const heavyForkPRs = [401, 402, 403].map((dbId, idx) =>
2854+
makeHeavyPR({
2855+
id: `PR_fork_${idx + 1}`,
2856+
databaseId: dbId,
2857+
headRefOid: `sha-fork-${dbId}`,
2858+
headRepository: { owner: { login: `fork-user-${idx + 1}` }, nameWithOwner: `fork-user-${idx + 1}/Hello-World` },
2859+
statusCheckRollup: null,
2860+
})
2861+
);
2862+
2863+
const octokit = makeOctokit(
2864+
async () => ({ data: {} }),
2865+
async (query: string, variables?: unknown) => {
2866+
const vars = (variables ?? {}) as Record<string, unknown>;
2867+
if ("ids" in vars) {
2868+
return { nodes: heavyForkPRs };
2869+
}
2870+
if (query.includes("fork0:")) {
2871+
forkQueries.push(query);
2872+
if (throwPartialForkError) {
2873+
throw Object.assign(new Error("Partial fork GraphQL error"), {
2874+
data: {
2875+
fork0: {
2876+
object: {
2877+
statusCheckRollup: {
2878+
state: "PENDING",
2879+
contexts: { checkRunCountsByState: [{ state: "WAITING", count: 1 }] },
2880+
},
2881+
},
2882+
},
2883+
fork1: {
2884+
object: {
2885+
statusCheckRollup: {
2886+
state: "PENDING",
2887+
contexts: { checkRunCountsByState: [{ state: "IN_PROGRESS", count: 2 }] },
2888+
},
2889+
},
2890+
},
2891+
fork2: null,
2892+
rateLimit: { cost: 1, limit: 5000, remaining: 4950, resetAt: "2026-04-23T12:00:00Z" },
2893+
},
2894+
});
2895+
}
2896+
return {
2897+
fork0: {
2898+
object: {
2899+
statusCheckRollup: {
2900+
state: "PENDING",
2901+
contexts: {
2902+
checkRunCountsByState: [
2903+
{ state: "IN_PROGRESS", count: 1 },
2904+
{ state: "WAITING", count: 1 },
2905+
],
2906+
},
2907+
},
2908+
},
2909+
},
2910+
fork1: {
2911+
object: {
2912+
statusCheckRollup: {
2913+
state: "PENDING",
2914+
contexts: {
2915+
checkRunCountsByState: [
2916+
{ state: "IN_PROGRESS", count: 0 },
2917+
{ state: "WAITING", count: 1 },
2918+
],
2919+
},
2920+
},
2921+
},
2922+
},
2923+
fork2: {
2924+
object: {
2925+
statusCheckRollup: {
2926+
state: "PENDING",
2927+
contexts: {
2928+
checkRunCountsByState: [
2929+
{ state: "IN_PROGRESS", count: 0 },
2930+
{ state: "WAITING", count: 0 },
2931+
{ state: "QUEUED", count: 1 },
2932+
],
2933+
},
2934+
},
2935+
},
2936+
},
2937+
rateLimit: { cost: 1, limit: 5000, remaining: 4951, resetAt: "2026-04-23T12:00:00Z" },
2938+
};
2939+
}
2940+
return {
2941+
issues: { issueCount: 0, pageInfo: { hasNextPage: false, endCursor: null }, nodes: [] },
2942+
prInvolves: { issueCount: 3, pageInfo: { hasNextPage: false, endCursor: null }, nodes: lightForkPRs },
2943+
prReviewReq: { issueCount: 0, pageInfo: { hasNextPage: false, endCursor: null }, nodes: [] },
2944+
};
2945+
}
2946+
);
2947+
2948+
// 1. Normal response path: selects STATUS_CHECK_ROLLUP_FIELDS and classifies running / waiting / pending
2949+
const resNormal = await fetchIssuesAndPullRequests(octokit as never, [testRepo], "octocat");
2950+
expect(forkQueries).toHaveLength(1);
2951+
expect(forkQueries[0]).toContain(
2952+
"statusCheckRollup { state contexts { checkRunCountsByState { state count } } }"
2953+
);
2954+
expect(resNormal.pullRequests.find((p) => p.id === 401)?.checkStatus).toBe("running");
2955+
expect(resNormal.pullRequests.find((p) => p.id === 402)?.checkStatus).toBe("waiting");
2956+
expect(resNormal.pullRequests.find((p) => p.id === 403)?.checkStatus).toBe("pending");
2957+
2958+
// 2. Partial-error salvage path: salvages fork0 ("waiting") and fork1 ("running"), marks missing fork2 stale
2959+
throwPartialForkError = true;
2960+
vi.mocked(pushNotification).mockClear();
2961+
const resPartial = await fetchIssuesAndPullRequests(octokit as never, [testRepo], "octocat");
2962+
const pr401 = resPartial.pullRequests.find((p) => p.id === 401)!;
2963+
const pr402 = resPartial.pullRequests.find((p) => p.id === 402)!;
2964+
const pr403 = resPartial.pullRequests.find((p) => p.id === 403)!;
2965+
expect(pr401.checkStatus).toBe("waiting");
2966+
expect(pr401.checkStatusStale).toBeUndefined();
2967+
expect(pr402.checkStatus).toBe("running");
2968+
expect(pr402.checkStatusStale).toBeUndefined();
2969+
expect(pr403.checkStatus).toBeNull();
2970+
expect(pr403.checkStatusStale).toBe(true);
2971+
expect(pushNotification).toHaveBeenCalledWith(
2972+
"graphql",
2973+
"Fork PR check status unavailable — CI status may be missing for some PRs",
2974+
"warning"
2975+
);
2976+
});
2977+
28432978
it("skips runForkPRFallback when a fork PR falls back to LIGHT_PR_BACKFILL_QUERY (checkStatusStale: true)", async () => {
28442979
let forkCalls = 0;
28452980

0 commit comments

Comments
 (0)