Skip to content
Source
Sign inSign up
pingdotgg/t3code
Open History to see the last commit

GitCafePullRequestProvider.test.ts

1,338 lines52.0 KB

1import { assert, describe, it } from "@effect/vitest";
2import * as Effect from "effect/Effect";
3import * as Context from "effect/Context";
4import * as Layer from "effect/Layer";
5import * as Schema from "effect/Schema";
6import * as FetchHttpClient from "effect/http/FetchHttpClient";
7import * as HttpClient from "effect/http/HttpClient";
8import type * as HttpClientRequest from "effect/http/HttpClientRequest";
9import * as HttpClientResponse from "effect/http/HttpClientResponse";
10import * as HostProcess from "@t3tools/shared/HostProcess";
11import * as TestSourceControlHost from "@t3tools/source-control-testing/TestSourceControlHost";
12​
13import * as GitCafeApi from "./GitCafeApi.ts";
14import * as GitCafeCredentials from "./GitCafeCredentials.ts";
15import * as GitCafePullRequestProvider from "./GitCafePullRequestProvider.ts";
16​
17const encodeJson = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
18const decodeJson = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown));
19​
20interface SentRequest {
21 readonly method: string;
22 readonly path: string;
23 readonly query: URLSearchParams;
24 readonly host: string;
25 readonly body: unknown;
26 readonly redirect: string | undefined;
28​
29function fakeGitCafe(
30 routes: Record<string, unknown | ((request: SentRequest) => unknown)>,
31 options: { readonly status?: number; readonly env?: NodeJS.ProcessEnv } = {},
32) {
33 const sent: Array<SentRequest> = [];
34 const client = HttpClient.make(
35 (request: HttpClientRequest.HttpClientRequest, _url, _signal, fiber) => {
36 const url = new URL(request.url);
37 assert.isTrue(url.pathname.startsWith("/api/"), url.pathname);
38 assert.strictEqual(request.headers.authorization, "Bearer env-token");
39 const entry: SentRequest = {
40 method: request.method,
41 path: url.pathname.slice("/api".length),
42 query: url.searchParams,
43 host: url.host,
44 body:
45 request.body._tag === "Uint8Array"
46 ? decodeJson(new TextDecoder().decode(request.body.body))
47 : undefined,
48 redirect: Context.getOrUndefined(fiber.context, FetchHttpClient.RequestInit)?.redirect,
49 };
50 sent.push(entry);
51 const route = routes[`${entry.method} ${entry.path}`];
52 const response =
53 route === undefined
54 ? new Response(encodeJson({ type: "https://cafe.sh/errors/not-found" }), { status: 404 })
55 : route instanceof Response
56 ? route
57 : new Response(encodeJson(typeof route === "function" ? route(entry) : route), {
58 status: options.status ?? 200,
59 });
60 return Effect.succeed(HttpClientResponse.fromWeb(request, response));
61 },
62 );
63 const layer = GitCafeApi.layer.pipe(
64 Layer.provide(GitCafeCredentials.layer),
65 Layer.provide(TestSourceControlHost.layer()),
66 Layer.provide(
67 Layer.succeed(HostProcess.Environment, options.env ?? { CAFE_TOKEN: "env-token" }),
68 ),
69 Layer.provide(Layer.succeed(HostProcess.WorkingDirectory, "/server")),
70 Layer.provide(Layer.succeed(HttpClient.HttpClient, client)),
71 );
72 const writes = () =>
73 sent.filter((request) => request.method !== "GET").map((r) => `${r.method} ${r.path}`);
74 return { layer, sent, writes };
76​
77const target = { cwd: "/repo", host: "git.cafe", repository: "owner/repo", number: 7 };
78const timestamp = "2026-09-12T12:00:00Z";
79const headOid = "0123456789abcdef0123456789abcdef01234567";
80const baseOid = "89abcdef0123456789abcdef0123456789abcdef";
81const actor = {
82 kind: "local",
83 actorId: "act_one",
84 handle: "alice",
85 displayName: null,
86 avatarUrl: "/avatars/one",
87};
88const pull = {
89 id: "pr_one",
90 number: 7,
91 title: "Change",
92 state: "open",
93 draft: false,
94 sourceBranch: "feature",
95 targetBranch: "main",
96 headOid,
97 observedBaseOid: baseOid,
98 mergeRoute: "provider",
99 author: actor,
100 createdAt: timestamp,
101 updatedAt: timestamp,
102 version: 4,
103 description: "Body",
104 closedAt: null,
105 mergedAt: null,
106 sourceRepo: null,
107 capabilities: { comment: true, review: true, merge: true, edit: true, moderate: true },
108};
109const labels = [
110 { id: "label_bug", name: "bug", color: "#d73a4a", description: null },
111 { id: "label_docs", name: "docs", color: "#0075ca", description: "Documentation" },
112];
113const root = {
114 id: "root",
115 threadId: "root",
116 version: 2,
117 author: actor,
118 body: "Review",
119 path: "file.ts",
120 line: 3,
121 side: "right",
122 createdAt: timestamp,
123 commitOid: headOid,
124 resolvedAt: null,
125 capabilities: {
126 edit: true,
127 hide: false,
128 unhide: false,
129 delete: false,
130 resolve: true,
131 unresolve: false,
132 },
133};
134const stack = (
135 members: ReadonlyArray<{ number: number; headOid: string; state?: string }>,
136): Record<string, unknown> => ({
137 "GET /repos/owner/repo/pulls/7/stack": {
138 stack: {
139 id: "stack-one",
140 number: 3,
141 revision: 5,
142 landingBase: "main",
143 members: members.map((member, index) => ({
144 pullRequestNumber: member.number,
145 title: `Layer ${member.number}`,
146 state: member.state ?? "open",
147 draft: false,
148 sourceBranch: `layer-${member.number}`,
149 position: index + 1,
150 })),
151 },
152 },
153 ...Object.fromEntries(
154 members.map((member) => [
155 `GET /repos/owner/repo/pulls/${member.number}`,
156 { ...pull, number: member.number, headOid: member.headOid },
157 ]),
158 ),
159});
160​
161const assertRequestId = (body: unknown) =>
162 assert.match(
163 (body as { readonly requestId?: unknown } | undefined)?.requestId as string,
164 /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u,
165 );
166​
167describe("GitCafePullRequestProvider changed paths", () => {
168 const snapshot = { version: pull.version, headOid, comparisonBaseOid: baseOid };
169​
170 it.effect("pages changed paths without fetching diff-file hunks", () => {
171 const server = fakeGitCafe({
172 "GET /repos/owner/repo/pulls/7": pull,
173 "GET /repos/owner/repo/pulls/7/changes": (request: SentRequest) => ({
174 ...snapshot,
175 items: request.query.has("after")
176 ? [{ path: "gone.ts", status: "deleted" }]
177 : [{ path: "new name.ts", oldPath: "old name.ts", status: "renamed" }],
178 next: request.query.has("after") ? null : "next-page",
179 }),
180 });
181 return Effect.gen(function* () {
182 const provider = yield* GitCafePullRequestProvider.make;
183 const first = yield* provider.getDiffFilePaths!(target);
184 const second = yield* provider.getDiffFilePaths!({ ...target, cursor: first.nextCursor! });
185 assert.deepStrictEqual(first.files, [{ oldPath: "old name.ts", newPath: "new name.ts" }]);
186 assert.deepStrictEqual(second, {
187 files: [{ oldPath: "gone.ts", newPath: "gone.ts" }],
188 nextCursor: null,
189 });
190 assert.isFalse(server.sent.some((request) => request.path.includes("/diff-file")));
191 }).pipe(Effect.provide(server.layer));
192 });
193​
194 it.effect.each(["getDiff", "getDiffFilePaths"] as const)(
195 "%s rejects a repeated continuation cursor",
196 (method) => {
197 const server = fakeGitCafe({
198 "GET /repos/owner/repo/pulls/7": pull,
199 "GET /repos/owner/repo/pulls/7/changes": { ...snapshot, items: [], next: "same-page" },
200 });
201 return Effect.gen(function* () {
202 const provider = yield* GitCafePullRequestProvider.make;
203 const first = yield* provider[method]!(target);
204 const input = { ...target, cursor: first.nextCursor! };
205 const result =
206 method === "getDiff"
207 ? yield* provider.getDiff(input).pipe(Effect.result)
208 : yield* provider.getDiffFilePaths!(input).pipe(Effect.result);
209 assert.strictEqual(result._tag, "Failure");
210 }).pipe(Effect.provide(server.layer));
211 },
212 );
213​
214 // getDiff cases guard parity with the existing patch path; getDiffFilePaths must refuse the same pages.
215 it.effect.each(
216 (["getDiff", "getDiffFilePaths"] as const).flatMap((method) =>
217 [{ version: 5 }, { headOid: baseOid }, { comparisonBaseOid: headOid }].map((changed) => ({
218 method,
219 changed,
220 })),
221 ),
222 )(
223 "$method refuses a continuation from a different revision ($changed)",
224 ({ method, changed }) => {
225 const server = fakeGitCafe({
226 "GET /repos/owner/repo/pulls/7": pull,
227 "GET /repos/owner/repo/pulls/7/changes": (request: SentRequest) => ({
228 ...snapshot,
229 ...(request.query.has("after") ? changed : {}),
230 items: [],
231 next: request.query.has("after") ? null : "next-page",
232 }),
233 });
234 return Effect.gen(function* () {
235 const provider = yield* GitCafePullRequestProvider.make;
236 const read = (cursor?: string) =>
237 method === "getDiff"
238 ? provider.getDiff({ ...target, ...(cursor === undefined ? {} : { cursor }) })
239 : provider.getDiffFilePaths!({
240 ...target,
241 ...(cursor === undefined ? {} : { cursor }),
242 });
243 const first = yield* read();
244 const input = { ...target, cursor: first.nextCursor! };
245 const result =
246 method === "getDiff"
247 ? yield* provider.getDiff(input).pipe(Effect.result)
248 : yield* provider.getDiffFilePaths!(input).pipe(Effect.result);
249 assert.strictEqual(result._tag, "Failure");
250 }).pipe(Effect.provide(server.layer));
251 },
252 );
253​
254 it.effect.each(["getDiff", "getDiffFilePaths"] as const)(
255 "%s reads a pull that reports no head yet",
256 (method) => {
257 const server = fakeGitCafe({
258 "GET /repos/owner/repo/pulls/7": { ...pull, headOid: null },
259 "GET /repos/owner/repo/pulls/7/changes": { ...snapshot, items: [], next: null },
260 });
261 return Effect.gen(function* () {
262 const provider = yield* GitCafePullRequestProvider.make;
263 const result = yield* provider[method]!(target);
264 assert.isNull(result.nextCursor);
265 }).pipe(Effect.provide(server.layer));
266 },
267 );
268​
269 it.effect.each([{ version: 5 }, { headOid: baseOid }])(
270 "refuses initial changed paths from a different pull revision (%j)",
271 (changed) => {
272 const server = fakeGitCafe({
273 "GET /repos/owner/repo/pulls/7": pull,
274 "GET /repos/owner/repo/pulls/7/changes": { ...snapshot, ...changed, items: [], next: null },
275 });
276 return Effect.gen(function* () {
277 const provider = yield* GitCafePullRequestProvider.make;
278 const result = yield* provider.getDiffFilePaths!(target).pipe(Effect.result);
279 assert.strictEqual(result._tag, "Failure");
280 }).pipe(Effect.provide(server.layer));
281 },
282 );
283});
284​
285describe("GitCafePullRequestProvider source contents", () => {
286 const comparisonBase = "a".repeat(40);
287 const snapshot = { version: pull.version, headOid, comparisonBaseOid: comparisonBase };
288 const input = {
289 ...target,
290 changeType: "rename-changed" as const,
291 oldPath: "old name.ts",
292 newPath: "src/new #name.ts",
293 };
294 const blob = (request: SentRequest) => ({
295 commit: request.query.get("oid"),
296 oid: "b".repeat(40),
297 path: request.query.get("path"),
298 size: 16,
299 binary: false,
300 content: "const value = 1;",
301 });
302 const routes = {
303 "GET /repos/owner/repo/pulls/7": pull,
304 "GET /repos/owner/repo/pulls/7/changes": snapshot,
305 "GET /repos/owner/repo/blob": blob,
306 };
307​
308 it.effect(
309 "pins rename source to the comparison base and fork head, without reading branches",
310 () => {
311 const server = fakeGitCafe({
312 ...routes,
313 "GET /repos/owner/repo/pulls/7": {
314 ...pull,
315 sourceRepo: { owner: "fork", name: "project" },
316 },
317 "GET /repos/fork/project/blob": blob,
318 });
319 return Effect.gen(function* () {
320 const provider = yield* GitCafePullRequestProvider.make;
321 const result = yield* provider.getDiffFileContents!(input);
322 assert.deepStrictEqual(result, {
323 oldContents: "const value = 1;",
324 newContents: "const value = 1;",
325 });
326 const changes = server.sent.find((request) => request.path.endsWith("/changes"))!;
327 assert.strictEqual(changes.query.get("expectedVersion"), "4");
328 assert.strictEqual(changes.query.get("limit"), "1");
329 assert.deepStrictEqual(
330 server.sent
331 .filter((request) => request.path.endsWith("/blob"))
332 .map((request) => ({
333 path: request.path,
334 oid: request.query.get("oid"),
335 file: request.query.get("path"),
336 ref: request.query.get("ref"),
337 })),
338 [
339 { path: "/repos/owner/repo/blob", oid: comparisonBase, file: input.oldPath, ref: null },
340 { path: "/repos/fork/project/blob", oid: headOid, file: input.newPath, ref: null },
341 ],
342 );
343 assert.deepStrictEqual(server.writes(), []);
344 }).pipe(Effect.provide(server.layer));
345 },
346 );
347​
348 it.effect.each(["new", "deleted"] as const)(
349 "skips the absent side of a %s file",
350 (changeType) => {
351 const server = fakeGitCafe(routes);
352 return Effect.gen(function* () {
353 const provider = yield* GitCafePullRequestProvider.make;
354 const result = yield* provider.getDiffFileContents!({ ...input, changeType });
355 assert.strictEqual(result[changeType === "new" ? "oldContents" : "newContents"], "");
356 assert.lengthOf(
357 server.sent.filter((request) => request.path.endsWith("/blob")),
358 1,
359 );
360 }).pipe(Effect.provide(server.layer));
361 },
362 );
363​
364 it.effect.each([
365 { ...snapshot, version: 5 },
366 { ...snapshot, headOid: baseOid },
367 { ...snapshot, comparisonBaseOid: "main" },
368 ])("refuses a changed or nonimmutable comparison snapshot", (response) => {
369 const server = fakeGitCafe({ ...routes, "GET /repos/owner/repo/pulls/7/changes": response });
370 return Effect.gen(function* () {
371 const provider = yield* GitCafePullRequestProvider.make;
372 const result = yield* provider.getDiffFileContents!(input).pipe(Effect.result);
373 assert.strictEqual(result._tag, "Failure");
374 assert.isFalse(server.sent.some((request) => request.path.endsWith("/blob")));
375 }).pipe(Effect.provide(server.layer));
376 });
377​
378 it.effect.each([
379 { binary: true, content: null },
380 { content: "binary\0data" },
381 { size: 1_048_577 },
382 { size: 1, content: "x".repeat(1_048_577) },
383 { size: 1, content: "é".repeat(524_289) },
384 { commit: baseOid },
385 { path: "another.ts" },
386 { content: null },
387 ])("refuses unavailable, oversized, binary, or mismatched blobs", (fields) => {
388 const server = fakeGitCafe({
389 ...routes,
390 "GET /repos/owner/repo/blob": (request: SentRequest) => ({ ...blob(request), ...fields }),
391 });
392 return Effect.gen(function* () {
393 const provider = yield* GitCafePullRequestProvider.make;
394 const result = yield* provider.getDiffFileContents!(input).pipe(Effect.result);
395 assert.strictEqual(result._tag, "Failure");
396 assert.deepStrictEqual(server.writes(), []);
397 }).pipe(Effect.provide(server.layer));
398 });
399​
400 it.effect.each([
401 [413, "oversized"],
402 [501, "unavailable"],
403 ] as const)("marks HTTP %s blob refusals permanently unavailable", ([status, reason]) => {
404 const server = fakeGitCafe({
405 ...routes,
406 "GET /repos/owner/repo/blob": new Response("{}", { status }),
407 });
408 return Effect.gen(function* () {
409 const provider = yield* GitCafePullRequestProvider.make;
410 const error = yield* provider.getDiffFileContents!({ ...input, changeType: "new" }).pipe(
411 Effect.flip,
412 );
413 assert.deepInclude(error.cause as object, {
414 _tag: "GitCafeDiffSourceUnavailableError",
415 reason,
416 });
417 }).pipe(Effect.provide(server.layer));
418 });
419​
420 it.effect("preserves authentication failures from blob access", () => {
421 const server = fakeGitCafe({
422 ...routes,
423 "GET /repos/owner/repo/blob": new Response("{}", { status: 401 }),
424 });
425 return Effect.gen(function* () {
426 const provider = yield* GitCafePullRequestProvider.make;
427 const error = yield* provider.getDiffFileContents!({ ...input, changeType: "new" }).pipe(
428 Effect.flip,
429 );
430 assert.strictEqual(error.reason, "unauthenticated");
431 assert.strictEqual(error.operation, "getDiffFileContents");
432 }).pipe(Effect.provide(server.layer));
433 });
434​
435 it.effect(
436 "refuses commit-specific contents consistently with unsupported GitCafe commit diffs",
437 () => {
438 const server = fakeGitCafe({});
439 return Effect.gen(function* () {
440 const provider = yield* GitCafePullRequestProvider.make;
441 const result = yield* provider.getDiffFileContents!({ ...input, commit: headOid }).pipe(
442 Effect.result,
443 );
444 assert.strictEqual(result._tag, "Failure");
445 assert.deepStrictEqual(server.sent, []);
446 }).pipe(Effect.provide(server.layer));
447 },
448 );
449});
450​
451describe("GitCafePullRequestProvider", () => {
452 it.effect("keeps a staging repository's requests and links on staging", () => {
453 const server = fakeGitCafe(
454 { "GET /repos/owner/repo/pulls/7": pull },
455 { env: { CAFE_TOKEN: "env-token", CAFE_HOST: "staging.git.cafe" } },
456 );
457 return Effect.gen(function* () {
458 const provider = yield* GitCafePullRequestProvider.make;
459 const input = {
460 ...target,
461 host: "staging.git.cafe",
462 };
463 const preview = yield* provider.getChangeRequestPreview!(input);
464 assert.deepInclude(preview, {
465 number: 7,
466 title: "Change",
467 url: "https://staging.git.cafe/owner/repo/pulls/7",
468 author: { login: "alice", name: null, avatarUrl: "https://staging.git.cafe/avatars/one" },
469 state: "open",
470 isDraft: false,
471 createdAt: timestamp,
472 });
473 const summary = yield* provider.getChangeRequestSummary!(input);
474 assert.strictEqual(summary.url, "https://staging.git.cafe/owner/repo/pulls/7");
475 assert.isTrue(server.sent.every((request) => request.host === "staging.git.cafe"));
476 assert.deepStrictEqual(
477 server.sent.map((request) => `${request.method} ${request.path}`),
478 [
479 "GET /repos/owner/repo/pulls/7",
480 "GET /repos/owner/repo/pulls/7",
481 "GET /repos/owner/repo/pulls/7/changes",
482 ],
483 );
484 }).pipe(Effect.provide(server.layer));
485 });
486​
487 it.effect("refuses a repository outside GitCafe's hosts before sending anything", () => {
488 const server = fakeGitCafe({});
489 return Effect.gen(function* () {
490 const provider = yield* GitCafePullRequestProvider.make;
491 const result = yield* provider
492 .getChangeRequest({ ...target, host: "github.com" })
493 .pipe(Effect.result);
494 assert.strictEqual(result._tag, "Failure");
495 assert.deepStrictEqual(server.sent, []);
496 }).pipe(Effect.provide(server.layer));
497 });
498​
499 it.effect("reports a refused token as unauthenticated and a limit as rate-limited", () =>
500 Effect.gen(function* () {
501 for (const [status, reason] of [
502 [401, "unauthenticated"],
503 [429, "rate-limited"],
504 ] as const) {
505 const server = fakeGitCafe(
506 { "GET /repos/owner/repo/pulls/7/stack": { stack: null } },
507 {
508 status,
509 },
510 );
511 const error = yield* GitCafePullRequestProvider.make.pipe(
512 Effect.flatMap((provider) => provider.getChangeRequestStack!(target)),
513 Effect.flip,
514 Effect.provide(server.layer),
515 );
516 assert.strictEqual(error.reason, reason);
517 }
518 }),
519 );
520​
521 it.effect("never lets fetch follow a redirect with the token", () => {
522 const server = fakeGitCafe({ "GET /repos/owner/repo/pulls/7/stack": { stack: null } });
523 return GitCafePullRequestProvider.make.pipe(
524 Effect.flatMap((provider) => provider.getChangeRequestStack!(target)),
525 Effect.tap(() =>
526 Effect.sync(() =>
527 assert.deepStrictEqual(
528 server.sent.map((r) => r.redirect),
529 ["manual"],
530 ),
531 ),
532 ),
533 Effect.provide(server.layer),
534 );
535 });
536​
537 it.effect("follows a renumbered pull request's redirect only within the host's API", () =>
538 Effect.gen(function* () {
539 const moved = (location: string) =>
540 new Response(null, { status: 301, headers: { location } });
541 const renumbered = fakeGitCafe({
542 "GET /repos/owner/repo/pulls/7/stack": moved("/api/repos/owner/repo/pulls/8/stack"),
543 "GET /repos/owner/repo/pulls/8/stack": { stack: null },
544 });
545 yield* GitCafePullRequestProvider.make.pipe(
546 Effect.flatMap((provider) => provider.getChangeRequestStack!(target)),
547 Effect.provide(renumbered.layer),
548 );
549 assert.deepStrictEqual(
550 renumbered.sent.map((r) => `${r.host}${r.path}`),
551 ["git.cafe/repos/owner/repo/pulls/7/stack", "git.cafe/repos/owner/repo/pulls/8/stack"],
552 );
553​
554 for (const location of [
555 "https://evil.example/api/repos/owner/repo/pulls/8/stack",
556 "//evil.example/api/repos/owner/repo/pulls/8/stack",
557 "https://staging.git.cafe/api/repos/owner/repo/pulls/8/stack",
558 "/repos/owner/repo/pulls/8/stack",
559 ]) {
560 const elsewhere = fakeGitCafe({ "GET /repos/owner/repo/pulls/7/stack": moved(location) });
561 const error = yield* GitCafePullRequestProvider.make.pipe(
562 Effect.flatMap((provider) => provider.getChangeRequestStack!(target)),
563 Effect.flip,
564 Effect.provide(elsewhere.layer),
565 );
566 assert.strictEqual(error.detail, "GitCafe answered HTTP 301.");
567 assert.strictEqual(elsewhere.sent.length, 1);
568 }
569 }),
570 );
571​
572 it.effect("reads the stack a pull request belongs to, with each open layer's head", () => {
573 const { "GET /repos/owner/repo/pulls/6": _merged, ...routes } = stack([
574 { number: 6, headOid: baseOid, state: "merged" },
575 { number: 7, headOid },
576 ]);
577 const server = fakeGitCafe(routes);
578 return Effect.gen(function* () {
579 const provider = yield* GitCafePullRequestProvider.make;
580 const result = yield* provider.getChangeRequestStack!(target);
581 assert.strictEqual(result?.number, 3);
582 assert.deepStrictEqual(
583 result?.layers.map((layer) => [layer.number, layer.headSha]),
584 [
585 [6, undefined],
586 [7, headOid],
587 ],
588 );
589 }).pipe(Effect.provide(server.layer));
590 });
591​
592 it.effect("resolves a thread through its root at the root's version", () => {
593 const server = fakeGitCafe({
594 "GET /repos/owner/repo/pulls/7/comments": { items: [root], next: null },
595 "POST /repos/owner/repo/pulls/7/comments/root/resolve": {
596 id: "root",
597 threadId: "root",
598 version: 3,
599 },
600 });
601 return Effect.gen(function* () {
602 const provider = yield* GitCafePullRequestProvider.make;
603 yield* provider.setThreadResolution({ ...target, threadId: "root", resolved: true });
604 assert.deepStrictEqual(server.writes(), [
605 "POST /repos/owner/repo/pulls/7/comments/root/resolve",
606 ]);
607 assert.deepStrictEqual(server.sent.at(-1)?.body, { expectedVersion: 2 });
608 }).pipe(Effect.provide(server.layer));
609 });
610​
611 it.effect("keeps the timeline when GitCafe no longer has the head's commits", () => {
612 const comment = { ...root, id: "c1", threadId: "c1", body: "Looks good", path: null };
613 const server = fakeGitCafe({
614 "GET /repos/owner/repo/pulls/7": { ...pull, state: "closed", closedAt: timestamp },
615 "GET /repos/owner/repo/pulls/7/comments": { items: [comment], next: null },
616 "GET /repos/owner/repo/pulls/7/reviews": { items: [], next: null },
617 });
618 return Effect.gen(function* () {
619 const provider = yield* GitCafePullRequestProvider.make;
620 const activity = yield* provider.getChangeRequestActivity(target);
621 assert.deepStrictEqual(
622 activity.comments.map((entry) => entry.body),
623 ["Looks good"],
624 );
625 }).pipe(Effect.provide(server.layer));
626 });
627​
628 it.effect("submits a review against the pull request's current head", () => {
629 const server = fakeGitCafe({
630 "GET /repos/owner/repo/pulls/7": pull,
631 "POST /repos/owner/repo/pulls/7/reviews": { id: "review-1" },
632 });
633 return Effect.gen(function* () {
634 const provider = yield* GitCafePullRequestProvider.make;
635 yield* provider.submitReview({
636 ...target,
637 verdict: "request-changes",
638 body: "Please fix",
639 comments: [],
640 });
641 assert.deepStrictEqual(server.writes(), ["POST /repos/owner/repo/pulls/7/reviews"]);
642 assert.deepInclude(server.sent.at(-1)?.body as object, {
643 verdict: "request_changes",
644 body: "Please fix",
645 commitOid: headOid,
646 });
647 assertRequestId(server.sent.at(-1)?.body);
648​
649 // GitCafe rejects a null body; an empty review leaves it out.
650 yield* provider.submitReview({ ...target, verdict: "approve", body: "", comments: [] });
651 assert.notProperty(server.sent.at(-1)?.body as object, "body");
652 assertRequestId(server.sent.at(-1)?.body);
653 }).pipe(Effect.provide(server.layer));
654 });
655​
656 it.effect.each([
657 ["completed", true],
658 ["failed", false],
659 ] as const)("merges synchronously and reads a %s outcome", ([state, succeeds]) => {
660 const server = fakeGitCafe({
661 "GET /repos/owner/repo/pulls/7": pull,
662 "POST /repos/owner/repo/pulls/7/merge": { id: "merge-1", state, reason: "Blocked" },
663 });
664 return Effect.gen(function* () {
665 const provider = yield* GitCafePullRequestProvider.make;
666 const result = yield* provider
667 .runAction({ ...target, action: "merge", mergeMethod: "squash" })
668 .pipe(Effect.result);
669 assert.strictEqual(result._tag, succeeds ? "Success" : "Failure");
670 assert.deepStrictEqual(server.writes(), ["POST /repos/owner/repo/pulls/7/merge"]);
671 assert.deepInclude(server.sent.at(-1)?.body as object, {
672 strategy: "squash",
673 headOid,
674 expectedVersion: 4,
675 });
676 assertRequestId(server.sent.at(-1)?.body);
677 }).pipe(Effect.provide(server.layer));
678 });
679​
680 it.effect(
681 "lands a stack through a layer only while its heads are the ones the reader saw",
682 () => {
683 const layers = [
684 { number: 6, headOid: baseOid },
685 { number: 7, headOid },
686 ];
687 const server = fakeGitCafe({
688 ...stack(layers),
689 "POST /repos/owner/repo/pulls/stacks/3/land-through": {
690 id: "land-1",
691 state: "completed",
692 landedCount: 2,
693 stepCount: 2,
694 stopReason: null,
695 error: null,
696 steps: [],
697 },
698 });
699 return Effect.gen(function* () {
700 const provider = yield* GitCafePullRequestProvider.make;
701 const heads = layers.map((layer) => ({ number: layer.number, headSha: layer.headOid }));
702 const stale = yield* provider
703 .runAction({
704 ...target,
705 action: "merge",
706 stackNumber: 3,
707 expectedStackHeads: [heads[0]!, { number: 7, headSha: baseOid }],
708 })
709 .pipe(Effect.result);
710 assert.strictEqual(stale._tag, "Failure");
711 assert.deepStrictEqual(server.writes(), []);
712​
713 yield* provider.runAction({
714 ...target,
715 action: "merge",
716 stackNumber: 3,
717 expectedStackHeads: heads,
718 mergeMethod: "merge",
719 });
720 assert.deepStrictEqual(server.writes(), [
721 "POST /repos/owner/repo/pulls/stacks/3/land-through",
722 ]);
723 assert.deepInclude(server.sent.at(-1)?.body as object, {
724 expectedRevision: 5,
725 throughPullRequestNumber: 7,
726 strategy: "merge",
727 });
728 assertRequestId(server.sent.at(-1)?.body);
729 }).pipe(Effect.provide(server.layer));
730 },
731 );
732​
733 it.effect.each([
734 ["authored", "authors"],
735 ["reviewing", "reviewers"],
736 ] as const)("filters %s pull requests by the viewer's actor on GitCafe", ([involvement, key]) => {
737 const server = fakeGitCafe({
738 "GET /auth/principal": { actorId: "act_one", handle: "Alice" },
739 "GET /repos/owner/repo/pulls": { items: [pull], next: null },
740 });
741 return Effect.gen(function* () {
742 const provider = yield* GitCafePullRequestProvider.make;
743 const page = yield* provider.listChangeRequests({
744 ...target,
745 state: "open",
746 involvement,
747 viewer: "alice",
748 limit: 10,
749 });
750 assert.strictEqual(server.sent.at(-1)?.query.get(key), '["act_one"]');
751 assert.strictEqual(
752 page.items[0]?.reviewRequestLogins.includes("alice"),
753 involvement === "reviewing",
754 );
755 }).pipe(Effect.provide(server.layer));
756 });
757​
758 it.effect("narrows a listing on GitCafe by label ids, draft state and the author's actor", () => {
759 const server = fakeGitCafe({
760 "GET /repos/owner/repo/labels": { items: labels, next: null },
761 "GET /users/bob": { actorId: "act_bob", handle: "bob" },
762 "GET /repos/owner/repo/pulls": { items: [pull], next: null },
763 });
764 return Effect.gen(function* () {
765 const provider = yield* GitCafePullRequestProvider.make;
766 yield* provider.listChangeRequests({
767 ...target,
768 state: "open",
769 involvement: "all",
770 viewer: "alice",
771 limit: 10,
772 filters: {
773 draft: "hide",
774 labels: [["missing"], ["Bug", "docs"]],
775 excludedLabels: ["docs", "missing"],
776 author: "bob",
777 },
778 });
779 const listing = server.sent.at(-1)!;
780 assert.strictEqual(listing.path, "/repos/owner/repo/pulls");
781 assert.strictEqual(listing.query.get("labels"), '["label_bug","label_docs"]');
782 assert.strictEqual(listing.query.get("labelNots"), '["label_docs"]');
783 assert.strictEqual(listing.query.get("stateNots"), '["draft"]');
784 assert.strictEqual(listing.query.get("authors"), '["act_bob"]');
785 }).pipe(Effect.provide(server.layer));
786 });
787​
788 it.effect("finds a GitHub-synced author's actor on their pull requests to narrow by it", () => {
789 const synced = {
790 ...pull,
791 number: 8,
792 author: { kind: "github", actorId: "act_synced", login: "Synced", avatarUrl: null },
793 };
794 const server = fakeGitCafe({
795 "GET /repos/owner/repo/pulls": (request: SentRequest) =>
796 request.query.get("authors") === '["act_synced"]'
797 ? { items: [synced], next: null }
798 : request.query.get("after") === null
799 ? { items: [pull], next: "o1" }
800 : { items: [synced], next: null },
801 });
802 return Effect.gen(function* () {
803 const provider = yield* GitCafePullRequestProvider.make;
804 const list = (author: string) =>
805 provider.listChangeRequests({
806 ...target,
807 state: "open",
808 involvement: "all",
809 viewer: "alice",
810 limit: 10,
811 filters: { author },
812 });
813 const page = yield* list("synced");
814 assert.deepStrictEqual(
815 page.items.map((item) => item.number),
816 [8],
817 );
818 assert.strictEqual(server.sent.at(-1)!.query.get("authors"), '["act_synced"]');
819 // Once seen, the actor is narrowed by straight away.
820 const sentBefore = server.sent.length;
821 yield* list("synced");
822 assert.deepStrictEqual(
823 server.sent.slice(sentBefore).map((request) => request.query.get("authors")),
824 [null, '["act_synced"]'],
825 );
826 // An author on none of the pages it reads gets nothing rather than unnarrowed rows a
827 // continuation would count against a different listing.
828 const missing = yield* list("nobody");
829 assert.deepStrictEqual(missing, { items: [], truncated: false, continues: false });
830 }).pipe(Effect.provide(server.layer));
831 });
832​
833 it.effect("carries a listing on after the last row delivered when rows above it close", () => {
834 const created = (number: number) => `2026-09-12T12:00:0${9 - number}Z`;
835 let pulls = [1, 2, 3, 4, 5].map((number) => ({ ...pull, number, createdAt: created(number) }));
836 const server = fakeGitCafe({
837 "GET /repos/owner/repo/pulls": (request: SentRequest) => {
838 const offset = Number(request.query.get("after")?.slice(1) ?? 0);
839 const end = offset + Number(request.query.get("limit"));
840 return { items: pulls.slice(offset, end), next: end < pulls.length ? `o${end}` : null };
841 },
842 });
843 return Effect.gen(function* () {
844 const provider = yield* GitCafePullRequestProvider.make;
845 const list = (cursor?: { readonly resumeAfter?: string }) =>
846 provider.listChangeRequests({
847 ...target,
848 state: "open",
849 involvement: "all",
850 viewer: "alice",
851 limit: 2,
852 ...(cursor === undefined
853 ? {}
854 : { cursor: { updatedBefore: timestamp, delivered: 2, ...cursor } }),
855 });
856 const first = yield* list();
857 assert.deepStrictEqual(
858 first.items.map((item) => item.number),
859 [1, 2],
860 );
861 pulls = pulls.filter((candidate) => candidate.number !== 1);
862 const next = yield* list({ resumeAfter: first.resumeAfter! });
863 assert.deepStrictEqual(
864 next.items.map((item) => item.number),
865 [3, 4],
866 );
867 assert.isTrue(next.truncated);
868 assert.isTrue(next.continues);
869 }).pipe(Effect.provide(server.layer));
870 });
871​
872 it.effect("lists nothing for a viewer the token does not belong to", () => {
873 const server = fakeGitCafe({
874 "GET /auth/principal": { actorId: "act_two", handle: "bob" },
875 });
876 return Effect.gen(function* () {
877 const provider = yield* GitCafePullRequestProvider.make;
878 const page = yield* provider.listChangeRequests({
879 ...target,
880 state: "open",
881 involvement: "authored",
882 viewer: "alice",
883 limit: 10,
884 });
885 assert.deepStrictEqual(page.items, []);
886 assert.deepStrictEqual(
887 server.sent.map((request) => request.path),
888 ["/auth/principal"],
889 );
890 }).pipe(Effect.provide(server.layer));
891 });
892​
893 it.effect.each(["authored", "reviewing"] as const)(
894 "lists %s unnarrowed when GitCafe can't say who the viewer is",
895 (involvement) => {
896 const server = fakeGitCafe({ "GET /repos/owner/repo/pulls": { items: [pull], next: null } });
897 return Effect.gen(function* () {
898 const provider = yield* GitCafePullRequestProvider.make;
899 const page = yield* provider.listChangeRequests({
900 ...target,
901 state: "open",
902 involvement,
903 viewer: "alice",
904 limit: 10,
905 });
906 const listing = server.sent.find((request) => request.path === "/repos/owner/repo/pulls");
907 assert.isDefined(listing);
908 assert.isNull(listing!.query.get(involvement === "reviewing" ? "reviewers" : "authors"));
909 assert.notInclude(page.items[0]?.reviewRequestLogins ?? [], "alice");
910 }).pipe(Effect.provide(server.layer));
911 },
912 );
913​
914 it.effect("reads line counts, open merge strategies, reviewers and labels", () => {
915 const snapshot = { version: 4, headOid, comparisonBaseOid: baseOid };
916 const files = (from: number, count: number) =>
917 Array.from({ length: count }, (_, index) => ({ path: `f${from + index}.ts` }));
918 let changePage = 0;
919 const server = fakeGitCafe({
920 "GET /repos/owner/repo/pulls/7": pull,
921 "GET /repos/owner/repo/pulls/7/reviewers": { items: [{ id: "act_one", actor }], next: null },
922 "GET /repos/owner/repo/pulls/7/labels": { items: [labels[0]], next: null },
923 "GET /repos/owner/repo/pulls/7/status": {
924 merge: {
925 conflicts: "none",
926 fastForward: true,
927 strategies: ["merge", "squash", "rebase"],
928 blockers: [{ blockedStrategies: ["squash"] }, {}],
929 },
930 checks: { pending: 0, failing: 0, total: 0 },
931 },
932 [`GET /repos/owner/repo/commits/${headOid}/checks`]: (request: SentRequest) => ({
933 items: [
934 {
935 name: request.query.has("after") ? "late" : "early",
936 status: "completed",
937 conclusion: request.query.has("after") ? "failure" : "success",
938 summary: null,
939 detailsUrl: null,
940 },
941 ],
942 next: request.query.has("after") ? null : "checks-1",
943 }),
944 "GET /repos/owner/repo/pulls/7/changes": () =>
945 changePage++ === 0
946 ? { ...snapshot, items: files(0, 2), next: "cursor-1" }
947 : { ...snapshot, items: files(2, 1), next: null },
948 "POST /repos/owner/repo/pulls/7/diff-files": (request: SentRequest) => ({
949 ...snapshot,
950 items: (request.body as { paths: ReadonlyArray<string> }).paths.map((path) => ({
951 path,
952 additions: 2,
953 deletions: 1,
954 })),
955 }),
956 });
957 return Effect.gen(function* () {
958 const provider = yield* GitCafePullRequestProvider.make;
959 const detail = yield* provider.getChangeRequest(target);
960 assert.deepInclude(detail, {
961 additions: 6,
962 deletions: 3,
963 changedFiles: 3,
964 mergeability: "mergeable",
965 });
966 assert.strictEqual(
967 server.sent.filter((request) => request.path.endsWith("/changes"))[1]?.query.get("after"),
968 "cursor-1",
969 );
970 assert.deepStrictEqual(detail.mergeCapabilities, {
971 merge: true,
972 squash: false,
973 rebase: true,
974 });
975 assert.deepStrictEqual(
976 detail.checks.map((check) => check.name),
977 ["late", "early"],
978 );
979 assert.deepStrictEqual(
980 detail.reviewers.map((reviewer) => reviewer.login),
981 ["alice"],
982 );
983 assert.deepStrictEqual(detail.reviewRequestLogins, ["alice"]);
984 assert.deepStrictEqual(detail.labels, [{ name: "bug", color: "#d73a4a" }]);
985 }).pipe(Effect.provide(server.layer));
986 });
987​
988 it.effect("reads the checks state from each check's newest run", () => {
989 const run = (id: string, conclusion: string) => ({
990 id,
991 name: "Check",
992 status: "completed",
993 conclusion,
994 summary: null,
995 detailsUrl: null,
996 });
997 const items = [run("120859457782", "success"), run("120857059247", "failure")];
998 const detailWith = (checks: (request: SentRequest) => unknown) => {
999 const server = fakeGitCafe({
1000 "GET /repos/owner/repo/pulls/7": pull,
1001 "GET /repos/owner/repo/pulls/7/reviewers": { items: [], next: null },
1002 "GET /repos/owner/repo/pulls/7/labels": { items: [], next: null },
1003 "GET /repos/owner/repo/pulls/7/status": {
1004 merge: { conflicts: "none", fastForward: null, strategies: [] },
1005 // GitCafe counts the cancelled run's failure beside the re-run that passed.
1006 checks: { pending: 0, failing: 1, total: 2 },
1007 },
1008 [`GET /repos/owner/repo/commits/${headOid}/checks`]: checks,
1009 "GET /repos/owner/repo/pulls/7/changes": {
1010 version: 4,
1011 headOid,
1012 comparisonBaseOid: baseOid,
1013 items: [],
1014 next: null,
1015 },
1016 });
1017 return Effect.gen(function* () {
1018 const provider = yield* GitCafePullRequestProvider.make;
1019 return yield* provider.getChangeRequest(target);
1020 }).pipe(Effect.provide(server.layer));
1021 };
1022 return Effect.gen(function* () {
1023 const detail = yield* detailWith(() => ({ items, next: null }));
1024 assert.deepStrictEqual(
1025 detail.checks.map((check) => [check.name, check.status]),
1026 [["Check", "success"]],
1027 );
1028 assert.strictEqual(detail.checksState, "passing");
1029​
1030 // A listing cut off at the page limit may hide a failure, so GitCafe's counts decide.
1031 const truncated = yield* detailWith((request) => ({
1032 items,
1033 next: String(Number(request.query.get("after") ?? 0) + 1),
1034 }));
1035 assert.strictEqual(truncated.checksState, "failing");
1036 });
1037 });
1038​
1039 it.effect("still reads a pull request whose reviewers the token may not see", () => {
1040 const server = fakeGitCafe({
1041 "GET /repos/owner/repo/pulls/7": { ...pull, headOid: null },
1042 "GET /repos/owner/repo/pulls/7/reviewers": new Response(
1043 encodeJson({ type: "https://cafe.sh/errors/forbidden" }),
1044 { status: 403 },
1045 ),
1046 "GET /repos/owner/repo/pulls/7/labels": { items: [labels[0]], next: null },
1047 "GET /repos/owner/repo/pulls/7/status": {
1048 merge: { conflicts: "unknown", fastForward: null, strategies: [] },
1049 checks: { pending: 0, failing: 0, total: 0 },
1050 },
1051 });
1052 return Effect.gen(function* () {
1053 const provider = yield* GitCafePullRequestProvider.make;
1054 const detail = yield* provider.getChangeRequest(target);
1055 assert.deepStrictEqual(detail.reviewers, []);
1056 assert.deepStrictEqual(detail.labels, [{ name: "bug", color: "#d73a4a" }]);
1057 }).pipe(Effect.provide(server.layer));
1058 });
1059​
1060 it.effect("fails the detail rather than hide reviewers GitCafe could not serve", () => {
1061 const server = fakeGitCafe({
1062 "GET /repos/owner/repo/pulls/7": { ...pull, headOid: null },
1063 "GET /repos/owner/repo/pulls/7/reviewers": new Response("", { status: 503 }),
1064 "GET /repos/owner/repo/pulls/7/labels": { items: [], next: null },
1065 "GET /repos/owner/repo/pulls/7/status": {
1066 merge: { conflicts: "unknown", fastForward: null, strategies: [] },
1067 checks: { pending: 0, failing: 0, total: 0 },
1068 },
1069 });
1070 return Effect.gen(function* () {
1071 const provider = yield* GitCafePullRequestProvider.make;
1072 const result = yield* provider.getChangeRequest(target).pipe(Effect.result);
1073 assert.strictEqual(result._tag, "Failure");
1074 }).pipe(Effect.provide(server.layer));
1075 });
1076​
1077 const detailWith = (overrides: Record<string, unknown>, reasons: ReadonlyArray<string> = []) =>
1078 fakeGitCafe({
1079 "GET /repos/owner/repo/pulls/7": { ...pull, headOid: null, ...overrides },
1080 "GET /repos/owner/repo/pulls/7/reviewers": { items: [], next: null },
1081 "GET /repos/owner/repo/pulls/7/labels": { items: [], next: null },
1082 "GET /repos/owner/repo/pulls/7/status": {
1083 merge: { conflicts: "none", fastForward: null, strategies: ["squash"], reasons },
1084 checks: { pending: 0, failing: 0, total: 0 },
1085 },
1086 });
1087​
1088 it.effect("shows a merge GitCafe accepted as armed until it lands", () => {
1089 const server = detailWith({}, ["provider-merge-pending"]);
1090 return Effect.gen(function* () {
1091 const provider = yield* GitCafePullRequestProvider.make;
1092 const detail = yield* provider.getChangeRequest(target);
1093 assert.strictEqual(detail.autoMergeEnabled, true);
1094 assert.notInclude(detail.viewerPermissions?.actions ?? [], "merge");
1095 }).pipe(Effect.provide(server.layer));
1096 });
1097​
1098 it.effect("reads a pull request GitHub merged as merged before the sync reports it", () => {
1099 const mergedAt = "2026-09-12T13:00:00Z";
1100 const server = detailWith({ providerMerge: { mergedAt } });
1101 return Effect.gen(function* () {
1102 const provider = yield* GitCafePullRequestProvider.make;
1103 const detail = yield* provider.getChangeRequest(target);
1104 assert.strictEqual(detail.state, "merged");
1105 assert.strictEqual(detail.mergedAt, mergedAt);
1106 const preview = yield* provider.getChangeRequestPreview!(target);
1107 assert.strictEqual(preview.state, "merged");
1108 }).pipe(Effect.provide(server.layer));
1109 });
1110​
1111 it.effect.each([
1112 ["their own pull request", actor],
1114 "the pull request GitHub sync opened for them",
1116 kind: "github",
1117 actorId: "act_github",
1118 login: "alice",
1119 avatarUrl: null,
1120 linkedProfile: { handle: "alice", actorId: "act_one" },
1121 },
1122 ],
1123 ] as const)("leaves the author only a comment on %s", ([, author]) => {
1124 const server = detailWith({ author, viewerActorId: "act_one" });
1125 return Effect.gen(function* () {
1126 const provider = yield* GitCafePullRequestProvider.make;
1127 const detail = yield* provider.getChangeRequest(target);
1128 assert.deepStrictEqual(detail.viewerPermissions?.verdicts, ["comment"]);
1129 }).pipe(Effect.provide(server.layer));
1130 });
1131​
1132 it.effect("requests and withdraws reviewers by rewriting the whole list", () => {
1133 const bob = { ...actor, actorId: "act_two", handle: "bob" };
1134 let requested = [{ id: "act_two", actor: bob }];
1135 const server = fakeGitCafe({
1136 "GET /repos/owner/repo/pulls/7": pull,
1137 "GET /repos/owner/repo/pulls/7/reviewer-candidates": {
1138 items: [
1139 { id: "act_one", actor },
1140 { id: "act_two", actor: bob },
1141 { id: "act_bot", actor: { ...actor, actorId: "act_bot", handle: "lint", bot: true } },
1142 ],
1143 next: null,
1144 },
1145 "GET /repos/owner/repo/pulls/7/reviewers": () => ({ items: requested, next: null }),
1146 "PUT /repos/owner/repo/pulls/7/reviewers": { version: 5, items: [] },
1147 });
1148 return Effect.gen(function* () {
1149 const provider = yield* GitCafePullRequestProvider.make;
1150 const list = yield* provider.listReviewerCandidates(target);
1151 // The author, alice, cannot review her own pull request.
1152 assert.deepStrictEqual(
1153 list.candidates.map((c) => [c.id, c.login, c.isRequested, c.isBot ?? false]),
1155 ["act_two", "bob", true, false],
1156 ["act_bot", "lint", false, true],
1157 ],
1158 );
1159​
1160 const set = (id: string, on: boolean) =>
1161 provider.setReviewerRequest({
1162 ...target,
1163 reviewers: [{ id, kind: "user" }],
1164 requested: on,
1165 });
1166 yield* set("act_bot", true);
1167 assert.deepStrictEqual(server.sent.at(-1)?.body, {
1168 expectedVersion: 4,
1169 actorIds: ["act_two", "act_bot"],
1170 });
1171 yield* set("act_two", false);
1172 assert.deepStrictEqual(server.sent.at(-1)?.body, { expectedVersion: 4, actorIds: [] });
1173​
1174 requested = [];
1175 yield* set("act_two", false);
1176 assert.strictEqual(server.writes().length, 2);
1177 }).pipe(Effect.provide(server.layer));
1178 });
1179​
1180 it.effect("names the missing scopes when the token may not request reviewers", () => {
1181 const server = fakeGitCafe({
1182 "GET /repos/owner/repo/pulls/7": pull,
1183 "GET /repos/owner/repo/pulls/7/reviewer-candidates": new Response("", { status: 403 }),
1184 "GET /repos/owner/repo/pulls/7/reviewers": { items: [], next: null },
1185 });
1186 return Effect.gen(function* () {
1187 const provider = yield* GitCafePullRequestProvider.make;
1188 const error = yield* Effect.flip(provider.listReviewerCandidates(target));
1189 assert.match(error.detail, /pr:reviewers:write/u);
1190 }).pipe(Effect.provide(server.layer));
1191 });
1192​
1193 it.effect("applies and removes labels by name through their ids", () => {
1194 const server = fakeGitCafe({
1195 "GET /repos/owner/repo/pulls/7": pull,
1196 "GET /repos/owner/repo/labels": { items: labels, next: null },
1197 "GET /repos/owner/repo/pulls/7/labels": { items: [labels[0]], next: null },
1198 "PUT /repos/owner/repo/pulls/7/labels": { version: 5, items: [] },
1199 });
1200 return Effect.gen(function* () {
1201 const provider = yield* GitCafePullRequestProvider.make;
1202 const list = yield* provider.listLabelCandidates!(target);
1203 assert.deepStrictEqual(
1204 list.candidates.map((label) => [label.name, label.isApplied]),
1206 ["bug", true],
1207 ["docs", false],
1208 ],
1209 );
1210​
1211 yield* provider.setLabels!({ ...target, labels: ["docs"], applied: true });
1212 assert.deepStrictEqual(server.sent.at(-1)?.body, {
1213 expectedVersion: 4,
1214 labelIds: ["label_bug", "label_docs"],
1215 });
1216 yield* provider.setLabels!({ ...target, labels: ["bug"], applied: false });
1217 assert.deepStrictEqual(server.sent.at(-1)?.body, { expectedVersion: 4, labelIds: [] });
1218​
1219 const missing = yield* provider.setLabels!({
1220 ...target,
1221 labels: ["nope"],
1222 applied: true,
1223 }).pipe(Effect.result);
1224 assert.strictEqual(missing._tag, "Failure");
1225 assert.strictEqual(server.writes().length, 2);
1226 }).pipe(Effect.provide(server.layer));
1227 });
1228​
1229 it.effect("recounts summary lines only when the compared commits move", () => {
1230 const landedBase = "fedcba9876543210fedcba9876543210fedcba98";
1231 const mainTip = "0123012301230123012301230123012301230123";
1232 let comparisonBaseOid = baseOid;
1233 let tips = { targetBranch: "main", observedBaseOid: baseOid };
1234 let pullReads = 0;
1235 let listingCut = true;
1236 let hunksDown = false;
1237 const hunks = (request: SentRequest) => ({
1238 version: 4,
1239 headOid,
1240 comparisonBaseOid,
1241 items: (request.body as { paths: ReadonlyArray<string> }).paths.map((path) => ({
1242 path,
1243 additions: comparisonBaseOid === baseOid ? 3 : 1,
1244 deletions: 1,
1245 })),
1246 });
1247 const server = fakeGitCafe({
1248 // A comment moves the version without moving the compared commits.
1249 "GET /repos/owner/repo/pulls/7": () => ({ ...pull, ...tips, version: 4 + pullReads++ }),
1250 "GET /repos/owner/repo/pulls/7/changes": (request: SentRequest) => ({
1251 version: 4,
1252 headOid,
1253 comparisonBaseOid,
1254 ...(!listingCut
1255 ? { items: [{ path: "a.ts" }, { path: "b.ts" }], next: null }
1256 : request.query.has("after")
1257 ? { items: [], next: "more" }
1258 : { items: [{ path: "a.ts" }], next: "more" }),
1259 }),
1260 get "POST /repos/owner/repo/pulls/7/diff-files"() {
1261 return hunksDown
1262 ? new Response(encodeJson({ type: "https://cafe.sh/errors/conflict" }), { status: 409 })
1263 : hunks;
1264 },
1265 });
1266 const reads = (suffix: string) =>
1267 server.sent.filter((request) => request.path.endsWith(suffix)).length;
1268 return Effect.gen(function* () {
1269 const provider = yield* GitCafePullRequestProvider.make;
1270 // A listing that stops before its last page holds nothing for its commits.
1271 yield* provider.getChangeRequestSummary!(target);
1272 listingCut = false;
1273 hunksDown = true;
1274 // Unread hunks leave the lines unknown, and are read again next time.
1275 const unread = yield* provider.getChangeRequestSummary!(target);
1276 assert.strictEqual(unread.additions, undefined);
1277 hunksDown = false;
1278 const first = yield* provider.getChangeRequestSummary!(target);
1279 const second = yield* provider.getChangeRequestSummary!(target);
1280 assert.deepInclude(first, { additions: 6, deletions: 2, changedFiles: 2 });
1281 assert.deepInclude(second, { additions: 6, deletions: 2, changedFiles: 2 });
1282 // Neither the head nor the target tip moved, so the file list is not read again.
1283 assert.deepStrictEqual([reads("/changes"), reads("/diff-files")], [4, 3]);
1284 // The target branch advancing keeps the merge base, so only the file list is read.
1285 tips = { ...tips, observedBaseOid: mainTip };
1286 const third = yield* provider.getChangeRequestSummary!(target);
1287 assert.deepInclude(third, { additions: 6, deletions: 2, changedFiles: 2 });
1288 assert.deepStrictEqual([reads("/changes"), reads("/diff-files")], [5, 3]);
1289 // A landed parent layer retargets the pull and moves the comparison base under the same head.
1290 comparisonBaseOid = landedBase;
1291 tips = { targetBranch: "trunk", observedBaseOid: mainTip };
1292 const fourth = yield* provider.getChangeRequestSummary!(target);
1293 assert.deepInclude(fourth, { additions: 2, deletions: 2, changedFiles: 2 });
1294 assert.deepStrictEqual([reads("/changes"), reads("/diff-files")], [6, 4]);
1295 }).pipe(Effect.provide(server.layer));
1296 });
1297​
1298 it.effect("fences a native merge on the target branch's current commit", () => {
1299 const branchOid = "fedcba9876543210fedcba9876543210fedcba98";
1300 const server = fakeGitCafe({
1301 "GET /repos/owner/repo/pulls/7": { ...pull, mergeRoute: "native", observedBaseOid: null },
1302 "GET /repos/owner/repo/commit": { oid: branchOid },
1303 "POST /repos/owner/repo/pulls/7/merge": { id: "merge-1", state: "completed" },
1304 });
1305 return Effect.gen(function* () {
1306 const provider = yield* GitCafePullRequestProvider.make;
1307 yield* provider.runAction({ ...target, action: "merge" });
1308 const branchRead = server.sent.find((request) => request.path === "/repos/owner/repo/commit");
1309 assert.strictEqual(branchRead?.query.get("ref"), "refs/heads/main");
1310 assert.deepInclude(server.sent.at(-1)?.body as object, { baseOid: branchOid, headOid });
1311 }).pipe(Effect.provide(server.layer));
1312 });
1313​
1314 it.effect("refuses to drop a reaction whose id it cannot address", () => {
1315 const server = fakeGitCafe({
1316 "GET /repos/owner/repo/pulls/7/reactions/": {
1317 items: [
1319 subject: { kind: "pull_request_comment", id: "root" },
1320 emoji: { kind: "unicode", value: "🚀" },
1321 count: 1,
1322 viewerReactionId: "../escape",
1323 reactors: [actor],
1324 },
1325 ],
1326 next: null,
1327 },
1328 });
1329 return Effect.gen(function* () {
1330 const provider = yield* GitCafePullRequestProvider.make;
1331 const result = yield* provider
1332 .setReaction({ ...target, subjectId: "root", content: "rocket", reacted: false })
1333 .pipe(Effect.result);
1334 assert.strictEqual(result._tag, "Failure");
1335 assert.deepStrictEqual(server.writes(), []);
1336 }).pipe(Effect.provide(server.layer));
1337 });
1338});