@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 03:37 UTC

main
ts 224 lines 6.83 KB
Raw
1 import type {
2 EnvironmentId,
3 IssueListEntry,
4 IssueListResult,
5 IssueTrackerKind,
6 IssueTrackerSummary,
7 ProjectId,
8 } from "@t3tools/contracts";
9 import { describe, expect, it } from "vite-plus/test";
10
11 import {
12 continueIssuePage,
13 groupIssues,
14 holdIssuePages,
15 issueCursorsForHost,
16 issueFilterScopes,
17 } from "./issueList.ts";
18
19 const environmentId = "env-1" as EnvironmentId;
20 const api = "api" as ProjectId;
21
22 function entry(overrides: Partial<IssueListEntry> & { key: string }): IssueListEntry {
23 return {
24 tracker: "github" as IssueTrackerKind,
25 host: "github.com",
26 scope: "acme/api",
27 displayKey: `#${overrides.key}`,
28 title: `Issue ${overrides.key}`,
29 url: `https://github.com/acme/api/issues/${overrides.key}`,
30 author: null,
31 state: { category: "open", name: "open" },
32 createdAt: "2026-10-01T00:00:00.000Z",
33 updatedAt: "2026-10-01T00:00:00.000Z",
34 closedAt: null,
35 assignees: [],
36 labels: [],
37 commentCount: 0,
38 projectId: api,
39 projectTitle: "api",
40 ...overrides,
41 };
42 }
43
44 function answer(overrides: Partial<IssueListResult>): IssueListResult {
45 return { viewers: {}, trackers: [], entries: [], errors: [], nextCursors: {}, ...overrides };
46 }
47
48 function hold(first: IssueListResult) {
49 return holdIssuePages([[environmentId, first]], new Map()).get(environmentId)!;
50 }
51
52 describe("continueIssuePage", () => {
53 const failure = { projectId: api, projectTitle: "api", message: "rate limited" };
54 const firstPageFailure = { projectId: "web" as ProjectId, projectTitle: "web", message: "boom" };
55 const cursors = { "github.com acme/api": "c1", "linear.app ENG": "l1" };
56
57 it("drops a continuation's error once a retry of the same cursors works", () => {
58 const first = hold(answer({ errors: [firstPageFailure], nextCursors: cursors }));
59 const failed = continueIssuePage(
60 first,
61 answer({ errors: [failure], nextCursors: cursors }),
62 cursors,
63 );
64 expect(failed.errors.map((error) => error.message)).toEqual(["boom", "rate limited"]);
65 const retried = continueIssuePage(failed, answer({ entries: [entry({ key: "2" })] }), cursors);
66 // The first page's failure has no cursor, so no continuation retried it.
67 expect(retried.errors.map((error) => error.message)).toEqual(["boom"]);
68 });
69
70 it("moves only the cursors asked for and keeps the other trackers' errors", () => {
71 const first = hold(answer({ nextCursors: cursors }));
72 const linear = issueCursorsForHost(cursors, "linear.app");
73 expect(linear).toEqual({ "linear.app ENG": "l1" });
74 const linearFailed = continueIssuePage(
75 first,
76 answer({ errors: [failure], nextCursors: linear }),
77 linear,
78 );
79 const github = issueCursorsForHost(linearFailed.nextCursors, "github.com");
80 const next = continueIssuePage(
81 linearFailed,
82 answer({ entries: [entry({ key: "2" })], nextCursors: { "github.com acme/api": "c2" } }),
83 github,
84 );
85 expect(next.nextCursors).toEqual({ "github.com acme/api": "c2", "linear.app ENG": "l1" });
86 expect(next.errors).toEqual([failure]);
87 const done = continueIssuePage(
88 next,
89 answer({}),
90 issueCursorsForHost(next.nextCursors, "github.com"),
91 );
92 expect(done.nextCursors).toEqual({ "linear.app ENG": "l1" });
93 });
94 });
95
96 describe("issueFilterScopes", () => {
97 const tracker = (overrides: Partial<IssueTrackerSummary>): IssueTrackerSummary =>
98 ({
99 tracker: "linear",
100 host: "linear.app",
101 projectCount: 1,
102 capabilities: { labels: true, assignees: true },
103 configured: true,
104 detail: null,
105 ...overrides,
106 }) as IssueTrackerSummary;
107 const linearRow = entry({
108 key: "ENG-1",
109 tracker: "linear" as IssueTrackerKind,
110 host: "linear.app",
111 scope: "ENG",
112 });
113
114 it("offers a bound standalone tracker's scope, named by the rows it listed", () => {
115 const held = new Map([
116 [
117 environmentId,
118 hold(
119 answer({
120 trackers: [tracker({})],
121 entries: [linearRow, { ...linearRow, key: "ENG-2" }],
122 }),
123 ),
124 ],
125 ]);
126 expect(issueFilterScopes(held, [])).toEqual([
127 {
128 environmentId,
129 input: { projectId: api, tracker: "linear", host: "linear.app", scope: "ENG" },
130 },
131 ]);
132 });
133
134 it("offers a bound tracker's scope the answer names when a search matches nothing", () => {
135 const scope = {
136 projectId: api,
137 tracker: "linear" as IssueTrackerKind,
138 host: "linear.app",
139 scope: "ENG",
140 };
141 const held = new Map([
142 [environmentId, hold(answer({ trackers: [tracker({})], entries: [], scopes: [scope] }))],
143 ]);
144 expect(issueFilterScopes(held, [])).toEqual([{ environmentId, input: scope }]);
145 });
146
147 it("skips a tracker that cannot be read", () => {
148 const held = new Map([
149 [
150 environmentId,
151 hold(answer({ trackers: [tracker({ configured: false })], entries: [linearRow] })),
152 ],
153 ]);
154 expect(issueFilterScopes(held, [])).toEqual([]);
155 });
156 });
157
158 describe("groupIssues", () => {
159 it("lists an issue once when two environments hold the same repository", () => {
160 const github = {
161 tracker: "github",
162 host: "github.com",
163 projectCount: 1,
164 capabilities: { labels: true, assignees: true },
165 configured: true,
166 detail: null,
167 } as IssueTrackerSummary;
168 const page = answer({
169 trackers: [github],
170 entries: [entry({ key: "1" }), entry({ key: "2" })],
171 });
172 const held = holdIssuePages(
173 [
174 [environmentId, page],
175 [
176 "env-2" as EnvironmentId,
177 answer({
178 ...page,
179 entries: page.entries.map((row) => ({ ...row, projectId: "other" as ProjectId })),
180 }),
181 ],
182 ],
183 new Map(),
184 );
185 const [group] = groupIssues(held, "", []);
186 expect(group!.rows.map((row) => row.displayKey)).toEqual(["#1", "#2"]);
187 });
188
189 it("keeps same-keyed issues from two Linear workspaces apart", () => {
190 const linear = {
191 tracker: "linear",
192 host: "linear.app",
193 projectCount: 1,
194 capabilities: { labels: true, assignees: true },
195 configured: true,
196 detail: null,
197 } as IssueTrackerSummary;
198 const inWorkspace = (workspace: string) =>
199 answer({
200 trackers: [linear],
201 entries: [
202 entry({
203 tracker: "linear" as IssueTrackerKind,
204 host: "linear.app",
205 scope: "ENG",
206 key: "ENG-1",
207 url: `https://linear.app/${workspace}/issue/ENG-1`,
208 }),
209 ],
210 });
211 const held = holdIssuePages(
212 [
213 [environmentId, inWorkspace("acme")],
214 ["env-2" as EnvironmentId, inWorkspace("globex")],
215 ],
216 new Map(),
217 );
218 const [group] = groupIssues(held, "", []);
219 expect(group!.rows.map((row) => row.url)).toEqual([
220 "https://linear.app/acme/issue/ENG-1",
221 "https://linear.app/globex/issue/ENG-1",
222 ]);
223 });
224 });