import { assert, describe, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Context from "effect/Context";
import * as Layer from "effect/Layer";
import * as Schema from "effect/Schema";
import * as FetchHttpClient from "effect/http/FetchHttpClient";
import * as HttpClient from "effect/http/HttpClient";
import type * as HttpClientRequest from "effect/http/HttpClientRequest";
import * as HttpClientResponse from "effect/http/HttpClientResponse";
import * as HostProcess from "@t3tools/shared/HostProcess";
import * as TestSourceControlHost from "@t3tools/source-control-testing/TestSourceControlHost";
import * as GitCafeApi from "./GitCafeApi.ts";
import * as GitCafeCredentials from "./GitCafeCredentials.ts";
import * as GitCafePullRequestProvider from "./GitCafePullRequestProvider.ts";
const encodeJson = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
const decodeJson = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown));
interface SentRequest {
readonly method: string;
readonly path: string;
readonly query: URLSearchParams;
readonly host: string;
readonly body: unknown;
readonly redirect: string | undefined;
}
function fakeGitCafe(
routes: Record<string, unknown | ((request: SentRequest) => unknown)>,
options: { readonly status?: number; readonly env?: NodeJS.ProcessEnv } = {},
) {
const sent: Array<SentRequest> = [];
const client = HttpClient.make(
(request: HttpClientRequest.HttpClientRequest, _url, _signal, fiber) => {
const url = new URL(request.url);
assert.isTrue(url.pathname.startsWith("/api/"), url.pathname);
assert.strictEqual(request.headers.authorization, "Bearer env-token");
const entry: SentRequest = {
method: request.method,
path: url.pathname.slice("/api".length),
query: url.searchParams,
host: url.host,
body:
request.body._tag === "Uint8Array"
? decodeJson(new TextDecoder().decode(request.body.body))
: undefined,
redirect: Context.getOrUndefined(fiber.context, FetchHttpClient.RequestInit)?.redirect,
};
sent.push(entry);
const route = routes[`${entry.method} ${entry.path}`];
const response =
route === undefined
? new Response(encodeJson({ type: "https://cafe.sh/errors/not-found" }), { status: 404 })
: route instanceof Response
? route
: new Response(encodeJson(typeof route === "function" ? route(entry) : route), {
status: options.status ?? 200,
});
return Effect.succeed(HttpClientResponse.fromWeb(request, response));
},
);
const layer = GitCafeApi.layer.pipe(
Layer.provide(GitCafeCredentials.layer),
Layer.provide(TestSourceControlHost.layer()),
Layer.provide(
Layer.succeed(HostProcess.Environment, options.env ?? { CAFE_TOKEN: "env-token" }),
),
Layer.provide(Layer.succeed(HostProcess.WorkingDirectory, "/server")),
Layer.provide(Layer.succeed(HttpClient.HttpClient, client)),
);
const writes = () =>
sent.filter((request) => request.method !== "GET").map((r) => `${r.method} ${r.path}`);
return { layer, sent, writes };
}
const target = { cwd: "/repo", host: "git.cafe", repository: "owner/repo", number: 7 };
const timestamp = "2026-09-12T12:00:00Z";
const headOid = "0123456789abcdef0123456789abcdef01234567";
const baseOid = "89abcdef0123456789abcdef0123456789abcdef";
const actor = {
kind: "local",
actorId: "act_one",
handle: "alice",
displayName: null,
avatarUrl: "/avatars/one",
};
const pull = {
id: "pr_one",
number: 7,
title: "Change",
state: "open",
draft: false,
sourceBranch: "feature",
targetBranch: "main",
headOid,
observedBaseOid: baseOid,
mergeRoute: "provider",
author: actor,
createdAt: timestamp,
updatedAt: timestamp,
version: 4,
description: "Body",
closedAt: null,
mergedAt: null,
sourceRepo: null,
capabilities: { comment: true, review: true, merge: true, edit: true, moderate: true },
};
const labels = [
{ id: "label_bug", name: "bug", color: "#d73a4a", description: null },
{ id: "label_docs", name: "docs", color: "#0075ca", description: "Documentation" },
];
const root = {
id: "root",
threadId: "root",
version: 2,
author: actor,
body: "Review",
path: "file.ts",
line: 3,
side: "right",
createdAt: timestamp,
commitOid: headOid,
resolvedAt: null,
capabilities: {
edit: true,
hide: false,
unhide: false,
delete: false,
resolve: true,
unresolve: false,
},
};
const stack = (
members: ReadonlyArray<{ number: number; headOid: string; state?: string }>,
): Record<string, unknown> => ({
"GET /repos/owner/repo/pulls/7/stack": {
stack: {
id: "stack-one",
number: 3,
revision: 5,
landingBase: "main",
members: members.map((member, index) => ({
pullRequestNumber: member.number,
title: `Layer ${member.number}`,
state: member.state ?? "open",
draft: false,
sourceBranch: `layer-${member.number}`,
position: index + 1,
})),
},
},
...Object.fromEntries(
members.map((member) => [
`GET /repos/owner/repo/pulls/${member.number}`,
{ ...pull, number: member.number, headOid: member.headOid },
]),
),
});
const assertRequestId = (body: unknown) =>
assert.match(
(body as { readonly requestId?: unknown } | undefined)?.requestId as string,
/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u,
);
describe("GitCafePullRequestProvider changed paths", () => {
const snapshot = { version: pull.version, headOid, comparisonBaseOid: baseOid };
it.effect("pages changed paths without fetching diff-file hunks", () => {
const server = fakeGitCafe({
"GET /repos/owner/repo/pulls/7": pull,
"GET /repos/owner/repo/pulls/7/changes": (request: SentRequest) => ({
...snapshot,
items: request.query.has("after")
? [{ path: "gone.ts", status: "deleted" }]
: [{ path: "new name.ts", oldPath: "old name.ts", status: "renamed" }],
next: request.query.has("after") ? null : "next-page",
}),
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const first = yield* provider.getDiffFilePaths!(target);
const second = yield* provider.getDiffFilePaths!({ ...target, cursor: first.nextCursor! });
assert.deepStrictEqual(first.files, [{ oldPath: "old name.ts", newPath: "new name.ts" }]);
assert.deepStrictEqual(second, {
files: [{ oldPath: "gone.ts", newPath: "gone.ts" }],
nextCursor: null,
});
assert.isFalse(server.sent.some((request) => request.path.includes("/diff-file")));
}).pipe(Effect.provide(server.layer));
});
it.effect.each(["getDiff", "getDiffFilePaths"] as const)(
"%s rejects a repeated continuation cursor",
(method) => {
const server = fakeGitCafe({
"GET /repos/owner/repo/pulls/7": pull,
"GET /repos/owner/repo/pulls/7/changes": { ...snapshot, items: [], next: "same-page" },
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const first = yield* provider[method]!(target);
const input = { ...target, cursor: first.nextCursor! };
const result =
method === "getDiff"
? yield* provider.getDiff(input).pipe(Effect.result)
: yield* provider.getDiffFilePaths!(input).pipe(Effect.result);
assert.strictEqual(result._tag, "Failure");
}).pipe(Effect.provide(server.layer));
},
);
// getDiff cases guard parity with the existing patch path; getDiffFilePaths must refuse the same pages.
it.effect.each(
(["getDiff", "getDiffFilePaths"] as const).flatMap((method) =>
[{ version: 5 }, { headOid: baseOid }, { comparisonBaseOid: headOid }].map((changed) => ({
method,
changed,
})),
),
)(
"$method refuses a continuation from a different revision ($changed)",
({ method, changed }) => {
const server = fakeGitCafe({
"GET /repos/owner/repo/pulls/7": pull,
"GET /repos/owner/repo/pulls/7/changes": (request: SentRequest) => ({
...snapshot,
...(request.query.has("after") ? changed : {}),
items: [],
next: request.query.has("after") ? null : "next-page",
}),
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const read = (cursor?: string) =>
method === "getDiff"
? provider.getDiff({ ...target, ...(cursor === undefined ? {} : { cursor }) })
: provider.getDiffFilePaths!({
...target,
...(cursor === undefined ? {} : { cursor }),
});
const first = yield* read();
const input = { ...target, cursor: first.nextCursor! };
const result =
method === "getDiff"
? yield* provider.getDiff(input).pipe(Effect.result)
: yield* provider.getDiffFilePaths!(input).pipe(Effect.result);
assert.strictEqual(result._tag, "Failure");
}).pipe(Effect.provide(server.layer));
},
);
it.effect.each(["getDiff", "getDiffFilePaths"] as const)(
"%s reads a pull that reports no head yet",
(method) => {
const server = fakeGitCafe({
"GET /repos/owner/repo/pulls/7": { ...pull, headOid: null },
"GET /repos/owner/repo/pulls/7/changes": { ...snapshot, items: [], next: null },
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const result = yield* provider[method]!(target);
assert.isNull(result.nextCursor);
}).pipe(Effect.provide(server.layer));
},
);
it.effect.each([{ version: 5 }, { headOid: baseOid }])(
"refuses initial changed paths from a different pull revision (%j)",
(changed) => {
const server = fakeGitCafe({
"GET /repos/owner/repo/pulls/7": pull,
"GET /repos/owner/repo/pulls/7/changes": { ...snapshot, ...changed, items: [], next: null },
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const result = yield* provider.getDiffFilePaths!(target).pipe(Effect.result);
assert.strictEqual(result._tag, "Failure");
}).pipe(Effect.provide(server.layer));
},
);
});
describe("GitCafePullRequestProvider source contents", () => {
const comparisonBase = "a".repeat(40);
const snapshot = { version: pull.version, headOid, comparisonBaseOid: comparisonBase };
const input = {
...target,
changeType: "rename-changed" as const,
oldPath: "old name.ts",
newPath: "src/new #name.ts",
};
const blob = (request: SentRequest) => ({
commit: request.query.get("oid"),
oid: "b".repeat(40),
path: request.query.get("path"),
size: 16,
binary: false,
content: "const value = 1;",
});
const routes = {
"GET /repos/owner/repo/pulls/7": pull,
"GET /repos/owner/repo/pulls/7/changes": snapshot,
"GET /repos/owner/repo/blob": blob,
};
it.effect(
"pins rename source to the comparison base and fork head, without reading branches",
() => {
const server = fakeGitCafe({
...routes,
"GET /repos/owner/repo/pulls/7": {
...pull,
sourceRepo: { owner: "fork", name: "project" },
},
"GET /repos/fork/project/blob": blob,
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const result = yield* provider.getDiffFileContents!(input);
assert.deepStrictEqual(result, {
oldContents: "const value = 1;",
newContents: "const value = 1;",
});
const changes = server.sent.find((request) => request.path.endsWith("/changes"))!;
assert.strictEqual(changes.query.get("expectedVersion"), "4");
assert.strictEqual(changes.query.get("limit"), "1");
assert.deepStrictEqual(
server.sent
.filter((request) => request.path.endsWith("/blob"))
.map((request) => ({
path: request.path,
oid: request.query.get("oid"),
file: request.query.get("path"),
ref: request.query.get("ref"),
})),
[
{ path: "/repos/owner/repo/blob", oid: comparisonBase, file: input.oldPath, ref: null },
{ path: "/repos/fork/project/blob", oid: headOid, file: input.newPath, ref: null },
],
);
assert.deepStrictEqual(server.writes(), []);
}).pipe(Effect.provide(server.layer));
},
);
it.effect.each(["new", "deleted"] as const)(
"skips the absent side of a %s file",
(changeType) => {
const server = fakeGitCafe(routes);
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const result = yield* provider.getDiffFileContents!({ ...input, changeType });
assert.strictEqual(result[changeType === "new" ? "oldContents" : "newContents"], "");
assert.lengthOf(
server.sent.filter((request) => request.path.endsWith("/blob")),
1,
);
}).pipe(Effect.provide(server.layer));
},
);
it.effect.each([
{ ...snapshot, version: 5 },
{ ...snapshot, headOid: baseOid },
{ ...snapshot, comparisonBaseOid: "main" },
])("refuses a changed or nonimmutable comparison snapshot", (response) => {
const server = fakeGitCafe({ ...routes, "GET /repos/owner/repo/pulls/7/changes": response });
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const result = yield* provider.getDiffFileContents!(input).pipe(Effect.result);
assert.strictEqual(result._tag, "Failure");
assert.isFalse(server.sent.some((request) => request.path.endsWith("/blob")));
}).pipe(Effect.provide(server.layer));
});
it.effect.each([
{ binary: true, content: null },
{ content: "binary\0data" },
{ size: 1_048_577 },
{ size: 1, content: "x".repeat(1_048_577) },
{ size: 1, content: "é".repeat(524_289) },
{ commit: baseOid },
{ path: "another.ts" },
{ content: null },
])("refuses unavailable, oversized, binary, or mismatched blobs", (fields) => {
const server = fakeGitCafe({
...routes,
"GET /repos/owner/repo/blob": (request: SentRequest) => ({ ...blob(request), ...fields }),
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const result = yield* provider.getDiffFileContents!(input).pipe(Effect.result);
assert.strictEqual(result._tag, "Failure");
assert.deepStrictEqual(server.writes(), []);
}).pipe(Effect.provide(server.layer));
});
it.effect.each([
[413, "oversized"],
[501, "unavailable"],
] as const)("marks HTTP %s blob refusals permanently unavailable", ([status, reason]) => {
const server = fakeGitCafe({
...routes,
"GET /repos/owner/repo/blob": new Response("{}", { status }),
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const error = yield* provider.getDiffFileContents!({ ...input, changeType: "new" }).pipe(
Effect.flip,
);
assert.deepInclude(error.cause as object, {
_tag: "GitCafeDiffSourceUnavailableError",
reason,
});
}).pipe(Effect.provide(server.layer));
});
it.effect("preserves authentication failures from blob access", () => {
const server = fakeGitCafe({
...routes,
"GET /repos/owner/repo/blob": new Response("{}", { status: 401 }),
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const error = yield* provider.getDiffFileContents!({ ...input, changeType: "new" }).pipe(
Effect.flip,
);
assert.strictEqual(error.reason, "unauthenticated");
assert.strictEqual(error.operation, "getDiffFileContents");
}).pipe(Effect.provide(server.layer));
});
it.effect(
"refuses commit-specific contents consistently with unsupported GitCafe commit diffs",
() => {
const server = fakeGitCafe({});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const result = yield* provider.getDiffFileContents!({ ...input, commit: headOid }).pipe(
Effect.result,
);
assert.strictEqual(result._tag, "Failure");
assert.deepStrictEqual(server.sent, []);
}).pipe(Effect.provide(server.layer));
},
);
});
describe("GitCafePullRequestProvider", () => {
it.effect("keeps a staging repository's requests and links on staging", () => {
const server = fakeGitCafe(
{ "GET /repos/owner/repo/pulls/7": pull },
{ env: { CAFE_TOKEN: "env-token", CAFE_HOST: "staging.git.cafe" } },
);
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const input = {
...target,
host: "staging.git.cafe",
};
const preview = yield* provider.getChangeRequestPreview!(input);
assert.deepInclude(preview, {
number: 7,
title: "Change",
url: "https://staging.git.cafe/owner/repo/pulls/7",
author: { login: "alice", name: null, avatarUrl: "https://staging.git.cafe/avatars/one" },
state: "open",
isDraft: false,
createdAt: timestamp,
});
const summary = yield* provider.getChangeRequestSummary!(input);
assert.strictEqual(summary.url, "https://staging.git.cafe/owner/repo/pulls/7");
assert.isTrue(server.sent.every((request) => request.host === "staging.git.cafe"));
assert.deepStrictEqual(
server.sent.map((request) => `${request.method} ${request.path}`),
[
"GET /repos/owner/repo/pulls/7",
"GET /repos/owner/repo/pulls/7",
"GET /repos/owner/repo/pulls/7/changes",
],
);
}).pipe(Effect.provide(server.layer));
});
it.effect("refuses a repository outside GitCafe's hosts before sending anything", () => {
const server = fakeGitCafe({});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const result = yield* provider
.getChangeRequest({ ...target, host: "github.com" })
.pipe(Effect.result);
assert.strictEqual(result._tag, "Failure");
assert.deepStrictEqual(server.sent, []);
}).pipe(Effect.provide(server.layer));
});
it.effect("reports a refused token as unauthenticated and a limit as rate-limited", () =>
Effect.gen(function* () {
for (const [status, reason] of [
[401, "unauthenticated"],
[429, "rate-limited"],
] as const) {
const server = fakeGitCafe(
{ "GET /repos/owner/repo/pulls/7/stack": { stack: null } },
{
status,
},
);
const error = yield* GitCafePullRequestProvider.make.pipe(
Effect.flatMap((provider) => provider.getChangeRequestStack!(target)),
Effect.flip,
Effect.provide(server.layer),
);
assert.strictEqual(error.reason, reason);
}
}),
);
it.effect("never lets fetch follow a redirect with the token", () => {
const server = fakeGitCafe({ "GET /repos/owner/repo/pulls/7/stack": { stack: null } });
return GitCafePullRequestProvider.make.pipe(
Effect.flatMap((provider) => provider.getChangeRequestStack!(target)),
Effect.tap(() =>
Effect.sync(() =>
assert.deepStrictEqual(
server.sent.map((r) => r.redirect),
["manual"],
),
),
),
Effect.provide(server.layer),
);
});
it.effect("follows a renumbered pull request's redirect only within the host's API", () =>
Effect.gen(function* () {
const moved = (location: string) =>
new Response(null, { status: 301, headers: { location } });
const renumbered = fakeGitCafe({
"GET /repos/owner/repo/pulls/7/stack": moved("/api/repos/owner/repo/pulls/8/stack"),
"GET /repos/owner/repo/pulls/8/stack": { stack: null },
});
yield* GitCafePullRequestProvider.make.pipe(
Effect.flatMap((provider) => provider.getChangeRequestStack!(target)),
Effect.provide(renumbered.layer),
);
assert.deepStrictEqual(
renumbered.sent.map((r) => `${r.host}${r.path}`),
["git.cafe/repos/owner/repo/pulls/7/stack", "git.cafe/repos/owner/repo/pulls/8/stack"],
);
for (const location of [
"https://evil.example/api/repos/owner/repo/pulls/8/stack",
"//evil.example/api/repos/owner/repo/pulls/8/stack",
"https://staging.git.cafe/api/repos/owner/repo/pulls/8/stack",
"/repos/owner/repo/pulls/8/stack",
]) {
const elsewhere = fakeGitCafe({ "GET /repos/owner/repo/pulls/7/stack": moved(location) });
const error = yield* GitCafePullRequestProvider.make.pipe(
Effect.flatMap((provider) => provider.getChangeRequestStack!(target)),
Effect.flip,
Effect.provide(elsewhere.layer),
);
assert.strictEqual(error.detail, "GitCafe answered HTTP 301.");
assert.strictEqual(elsewhere.sent.length, 1);
}
}),
);
it.effect("reads the stack a pull request belongs to, with each open layer's head", () => {
const { "GET /repos/owner/repo/pulls/6": _merged, ...routes } = stack([
{ number: 6, headOid: baseOid, state: "merged" },
{ number: 7, headOid },
]);
const server = fakeGitCafe(routes);
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const result = yield* provider.getChangeRequestStack!(target);
assert.strictEqual(result?.number, 3);
assert.deepStrictEqual(
result?.layers.map((layer) => [layer.number, layer.headSha]),
[
[6, undefined],
[7, headOid],
],
);
}).pipe(Effect.provide(server.layer));
});
it.effect("resolves a thread through its root at the root's version", () => {
const server = fakeGitCafe({
"GET /repos/owner/repo/pulls/7/comments": { items: [root], next: null },
"POST /repos/owner/repo/pulls/7/comments/root/resolve": {
id: "root",
threadId: "root",
version: 3,
},
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
yield* provider.setThreadResolution({ ...target, threadId: "root", resolved: true });
assert.deepStrictEqual(server.writes(), [
"POST /repos/owner/repo/pulls/7/comments/root/resolve",
]);
assert.deepStrictEqual(server.sent.at(-1)?.body, { expectedVersion: 2 });
}).pipe(Effect.provide(server.layer));
});
it.effect("keeps the timeline when GitCafe no longer has the head's commits", () => {
const comment = { ...root, id: "c1", threadId: "c1", body: "Looks good", path: null };
const server = fakeGitCafe({
"GET /repos/owner/repo/pulls/7": { ...pull, state: "closed", closedAt: timestamp },
"GET /repos/owner/repo/pulls/7/comments": { items: [comment], next: null },
"GET /repos/owner/repo/pulls/7/reviews": { items: [], next: null },
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const activity = yield* provider.getChangeRequestActivity(target);
assert.deepStrictEqual(
activity.comments.map((entry) => entry.body),
["Looks good"],
);
}).pipe(Effect.provide(server.layer));
});
it.effect("submits a review against the pull request's current head", () => {
const server = fakeGitCafe({
"GET /repos/owner/repo/pulls/7": pull,
"POST /repos/owner/repo/pulls/7/reviews": { id: "review-1" },
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
yield* provider.submitReview({
...target,
verdict: "request-changes",
body: "Please fix",
comments: [],
});
assert.deepStrictEqual(server.writes(), ["POST /repos/owner/repo/pulls/7/reviews"]);
assert.deepInclude(server.sent.at(-1)?.body as object, {
verdict: "request_changes",
body: "Please fix",
commitOid: headOid,
});
assertRequestId(server.sent.at(-1)?.body);
// GitCafe rejects a null body; an empty review leaves it out.
yield* provider.submitReview({ ...target, verdict: "approve", body: "", comments: [] });
assert.notProperty(server.sent.at(-1)?.body as object, "body");
assertRequestId(server.sent.at(-1)?.body);
}).pipe(Effect.provide(server.layer));
});
it.effect.each([
["completed", true],
["failed", false],
] as const)("merges synchronously and reads a %s outcome", ([state, succeeds]) => {
const server = fakeGitCafe({
"GET /repos/owner/repo/pulls/7": pull,
"POST /repos/owner/repo/pulls/7/merge": { id: "merge-1", state, reason: "Blocked" },
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const result = yield* provider
.runAction({ ...target, action: "merge", mergeMethod: "squash" })
.pipe(Effect.result);
assert.strictEqual(result._tag, succeeds ? "Success" : "Failure");
assert.deepStrictEqual(server.writes(), ["POST /repos/owner/repo/pulls/7/merge"]);
assert.deepInclude(server.sent.at(-1)?.body as object, {
strategy: "squash",
headOid,
expectedVersion: 4,
});
assertRequestId(server.sent.at(-1)?.body);
}).pipe(Effect.provide(server.layer));
});
it.effect(
"lands a stack through a layer only while its heads are the ones the reader saw",
() => {
const layers = [
{ number: 6, headOid: baseOid },
{ number: 7, headOid },
];
const server = fakeGitCafe({
...stack(layers),
"POST /repos/owner/repo/pulls/stacks/3/land-through": {
id: "land-1",
state: "completed",
landedCount: 2,
stepCount: 2,
stopReason: null,
error: null,
steps: [],
},
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const heads = layers.map((layer) => ({ number: layer.number, headSha: layer.headOid }));
const stale = yield* provider
.runAction({
...target,
action: "merge",
stackNumber: 3,
expectedStackHeads: [heads[0]!, { number: 7, headSha: baseOid }],
})
.pipe(Effect.result);
assert.strictEqual(stale._tag, "Failure");
assert.deepStrictEqual(server.writes(), []);
yield* provider.runAction({
...target,
action: "merge",
stackNumber: 3,
expectedStackHeads: heads,
mergeMethod: "merge",
});
assert.deepStrictEqual(server.writes(), [
"POST /repos/owner/repo/pulls/stacks/3/land-through",
]);
assert.deepInclude(server.sent.at(-1)?.body as object, {
expectedRevision: 5,
throughPullRequestNumber: 7,
strategy: "merge",
});
assertRequestId(server.sent.at(-1)?.body);
}).pipe(Effect.provide(server.layer));
},
);
it.effect.each([
["authored", "authors"],
["reviewing", "reviewers"],
] as const)("filters %s pull requests by the viewer's actor on GitCafe", ([involvement, key]) => {
const server = fakeGitCafe({
"GET /auth/principal": { actorId: "act_one", handle: "Alice" },
"GET /repos/owner/repo/pulls": { items: [pull], next: null },
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const page = yield* provider.listChangeRequests({
...target,
state: "open",
involvement,
viewer: "alice",
limit: 10,
});
assert.strictEqual(server.sent.at(-1)?.query.get(key), '["act_one"]');
assert.strictEqual(
page.items[0]?.reviewRequestLogins.includes("alice"),
involvement === "reviewing",
);
}).pipe(Effect.provide(server.layer));
});
it.effect("narrows a listing on GitCafe by label ids, draft state and the author's actor", () => {
const server = fakeGitCafe({
"GET /repos/owner/repo/labels": { items: labels, next: null },
"GET /users/bob": { actorId: "act_bob", handle: "bob" },
"GET /repos/owner/repo/pulls": { items: [pull], next: null },
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
yield* provider.listChangeRequests({
...target,
state: "open",
involvement: "all",
viewer: "alice",
limit: 10,
filters: {
draft: "hide",
labels: [["missing"], ["Bug", "docs"]],
excludedLabels: ["docs", "missing"],
author: "bob",
},
});
const listing = server.sent.at(-1)!;
assert.strictEqual(listing.path, "/repos/owner/repo/pulls");
assert.strictEqual(listing.query.get("labels"), '["label_bug","label_docs"]');
assert.strictEqual(listing.query.get("labelNots"), '["label_docs"]');
assert.strictEqual(listing.query.get("stateNots"), '["draft"]');
assert.strictEqual(listing.query.get("authors"), '["act_bob"]');
}).pipe(Effect.provide(server.layer));
});
it.effect("finds a GitHub-synced author's actor on their pull requests to narrow by it", () => {
const synced = {
...pull,
number: 8,
author: { kind: "github", actorId: "act_synced", login: "Synced", avatarUrl: null },
};
const server = fakeGitCafe({
"GET /repos/owner/repo/pulls": (request: SentRequest) =>
request.query.get("authors") === '["act_synced"]'
? { items: [synced], next: null }
: request.query.get("after") === null
? { items: [pull], next: "o1" }
: { items: [synced], next: null },
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const list = (author: string) =>
provider.listChangeRequests({
...target,
state: "open",
involvement: "all",
viewer: "alice",
limit: 10,
filters: { author },
});
const page = yield* list("synced");
assert.deepStrictEqual(
page.items.map((item) => item.number),
[8],
);
assert.strictEqual(server.sent.at(-1)!.query.get("authors"), '["act_synced"]');
// Once seen, the actor is narrowed by straight away.
const sentBefore = server.sent.length;
yield* list("synced");
assert.deepStrictEqual(
server.sent.slice(sentBefore).map((request) => request.query.get("authors")),
[null, '["act_synced"]'],
);
// An author on none of the pages it reads gets nothing rather than unnarrowed rows a
// continuation would count against a different listing.
const missing = yield* list("nobody");
assert.deepStrictEqual(missing, { items: [], truncated: false, continues: false });
}).pipe(Effect.provide(server.layer));
});
it.effect("carries a listing on after the last row delivered when rows above it close", () => {
const created = (number: number) => `2026-09-12T12:00:0${9 - number}Z`;
let pulls = [1, 2, 3, 4, 5].map((number) => ({ ...pull, number, createdAt: created(number) }));
const server = fakeGitCafe({
"GET /repos/owner/repo/pulls": (request: SentRequest) => {
const offset = Number(request.query.get("after")?.slice(1) ?? 0);
const end = offset + Number(request.query.get("limit"));
return { items: pulls.slice(offset, end), next: end < pulls.length ? `o${end}` : null };
},
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const list = (cursor?: { readonly resumeAfter?: string }) =>
provider.listChangeRequests({
...target,
state: "open",
involvement: "all",
viewer: "alice",
limit: 2,
...(cursor === undefined
? {}
: { cursor: { updatedBefore: timestamp, delivered: 2, ...cursor } }),
});
const first = yield* list();
assert.deepStrictEqual(
first.items.map((item) => item.number),
[1, 2],
);
pulls = pulls.filter((candidate) => candidate.number !== 1);
const next = yield* list({ resumeAfter: first.resumeAfter! });
assert.deepStrictEqual(
next.items.map((item) => item.number),
[3, 4],
);
assert.isTrue(next.truncated);
assert.isTrue(next.continues);
}).pipe(Effect.provide(server.layer));
});
it.effect("lists nothing for a viewer the token does not belong to", () => {
const server = fakeGitCafe({
"GET /auth/principal": { actorId: "act_two", handle: "bob" },
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const page = yield* provider.listChangeRequests({
...target,
state: "open",
involvement: "authored",
viewer: "alice",
limit: 10,
});
assert.deepStrictEqual(page.items, []);
assert.deepStrictEqual(
server.sent.map((request) => request.path),
["/auth/principal"],
);
}).pipe(Effect.provide(server.layer));
});
it.effect.each(["authored", "reviewing"] as const)(
"lists %s unnarrowed when GitCafe can't say who the viewer is",
(involvement) => {
const server = fakeGitCafe({ "GET /repos/owner/repo/pulls": { items: [pull], next: null } });
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const page = yield* provider.listChangeRequests({
...target,
state: "open",
involvement,
viewer: "alice",
limit: 10,
});
const listing = server.sent.find((request) => request.path === "/repos/owner/repo/pulls");
assert.isDefined(listing);
assert.isNull(listing!.query.get(involvement === "reviewing" ? "reviewers" : "authors"));
assert.notInclude(page.items[0]?.reviewRequestLogins ?? [], "alice");
}).pipe(Effect.provide(server.layer));
},
);
it.effect("reads line counts, open merge strategies, reviewers and labels", () => {
const snapshot = { version: 4, headOid, comparisonBaseOid: baseOid };
const files = (from: number, count: number) =>
Array.from({ length: count }, (_, index) => ({ path: `f${from + index}.ts` }));
let changePage = 0;
const server = fakeGitCafe({
"GET /repos/owner/repo/pulls/7": pull,
"GET /repos/owner/repo/pulls/7/reviewers": { items: [{ id: "act_one", actor }], next: null },
"GET /repos/owner/repo/pulls/7/labels": { items: [labels[0]], next: null },
"GET /repos/owner/repo/pulls/7/status": {
merge: {
conflicts: "none",
fastForward: true,
strategies: ["merge", "squash", "rebase"],
blockers: [{ blockedStrategies: ["squash"] }, {}],
},
checks: { pending: 0, failing: 0, total: 0 },
},
[`GET /repos/owner/repo/commits/${headOid}/checks`]: (request: SentRequest) => ({
items: [
{
name: request.query.has("after") ? "late" : "early",
status: "completed",
conclusion: request.query.has("after") ? "failure" : "success",
summary: null,
detailsUrl: null,
},
],
next: request.query.has("after") ? null : "checks-1",
}),
"GET /repos/owner/repo/pulls/7/changes": () =>
changePage++ === 0
? { ...snapshot, items: files(0, 2), next: "cursor-1" }
: { ...snapshot, items: files(2, 1), next: null },
"POST /repos/owner/repo/pulls/7/diff-files": (request: SentRequest) => ({
...snapshot,
items: (request.body as { paths: ReadonlyArray<string> }).paths.map((path) => ({
path,
additions: 2,
deletions: 1,
})),
}),
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const detail = yield* provider.getChangeRequest(target);
assert.deepInclude(detail, {
additions: 6,
deletions: 3,
changedFiles: 3,
mergeability: "mergeable",
});
assert.strictEqual(
server.sent.filter((request) => request.path.endsWith("/changes"))[1]?.query.get("after"),
"cursor-1",
);
assert.deepStrictEqual(detail.mergeCapabilities, {
merge: true,
squash: false,
rebase: true,
});
assert.deepStrictEqual(
detail.checks.map((check) => check.name),
["late", "early"],
);
assert.deepStrictEqual(
detail.reviewers.map((reviewer) => reviewer.login),
["alice"],
);
assert.deepStrictEqual(detail.reviewRequestLogins, ["alice"]);
assert.deepStrictEqual(detail.labels, [{ name: "bug", color: "#d73a4a" }]);
}).pipe(Effect.provide(server.layer));
});
it.effect("reads the checks state from each check's newest run", () => {
const run = (id: string, conclusion: string) => ({
id,
name: "Check",
status: "completed",
conclusion,
summary: null,
detailsUrl: null,
});
const items = [run("120859457782", "success"), run("120857059247", "failure")];
const detailWith = (checks: (request: SentRequest) => unknown) => {
const server = fakeGitCafe({
"GET /repos/owner/repo/pulls/7": pull,
"GET /repos/owner/repo/pulls/7/reviewers": { items: [], next: null },
"GET /repos/owner/repo/pulls/7/labels": { items: [], next: null },
"GET /repos/owner/repo/pulls/7/status": {
merge: { conflicts: "none", fastForward: null, strategies: [] },
// GitCafe counts the cancelled run's failure beside the re-run that passed.
checks: { pending: 0, failing: 1, total: 2 },
},
[`GET /repos/owner/repo/commits/${headOid}/checks`]: checks,
"GET /repos/owner/repo/pulls/7/changes": {
version: 4,
headOid,
comparisonBaseOid: baseOid,
items: [],
next: null,
},
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
return yield* provider.getChangeRequest(target);
}).pipe(Effect.provide(server.layer));
};
return Effect.gen(function* () {
const detail = yield* detailWith(() => ({ items, next: null }));
assert.deepStrictEqual(
detail.checks.map((check) => [check.name, check.status]),
[["Check", "success"]],
);
assert.strictEqual(detail.checksState, "passing");
// A listing cut off at the page limit may hide a failure, so GitCafe's counts decide.
const truncated = yield* detailWith((request) => ({
items,
next: String(Number(request.query.get("after") ?? 0) + 1),
}));
assert.strictEqual(truncated.checksState, "failing");
});
});
it.effect("still reads a pull request whose reviewers the token may not see", () => {
const server = fakeGitCafe({
"GET /repos/owner/repo/pulls/7": { ...pull, headOid: null },
"GET /repos/owner/repo/pulls/7/reviewers": new Response(
encodeJson({ type: "https://cafe.sh/errors/forbidden" }),
{ status: 403 },
),
"GET /repos/owner/repo/pulls/7/labels": { items: [labels[0]], next: null },
"GET /repos/owner/repo/pulls/7/status": {
merge: { conflicts: "unknown", fastForward: null, strategies: [] },
checks: { pending: 0, failing: 0, total: 0 },
},
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const detail = yield* provider.getChangeRequest(target);
assert.deepStrictEqual(detail.reviewers, []);
assert.deepStrictEqual(detail.labels, [{ name: "bug", color: "#d73a4a" }]);
}).pipe(Effect.provide(server.layer));
});
it.effect("fails the detail rather than hide reviewers GitCafe could not serve", () => {
const server = fakeGitCafe({
"GET /repos/owner/repo/pulls/7": { ...pull, headOid: null },
"GET /repos/owner/repo/pulls/7/reviewers": new Response("", { status: 503 }),
"GET /repos/owner/repo/pulls/7/labels": { items: [], next: null },
"GET /repos/owner/repo/pulls/7/status": {
merge: { conflicts: "unknown", fastForward: null, strategies: [] },
checks: { pending: 0, failing: 0, total: 0 },
},
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const result = yield* provider.getChangeRequest(target).pipe(Effect.result);
assert.strictEqual(result._tag, "Failure");
}).pipe(Effect.provide(server.layer));
});
const detailWith = (overrides: Record<string, unknown>, reasons: ReadonlyArray<string> = []) =>
fakeGitCafe({
"GET /repos/owner/repo/pulls/7": { ...pull, headOid: null, ...overrides },
"GET /repos/owner/repo/pulls/7/reviewers": { items: [], next: null },
"GET /repos/owner/repo/pulls/7/labels": { items: [], next: null },
"GET /repos/owner/repo/pulls/7/status": {
merge: { conflicts: "none", fastForward: null, strategies: ["squash"], reasons },
checks: { pending: 0, failing: 0, total: 0 },
},
});
it.effect("shows a merge GitCafe accepted as armed until it lands", () => {
const server = detailWith({}, ["provider-merge-pending"]);
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const detail = yield* provider.getChangeRequest(target);
assert.strictEqual(detail.autoMergeEnabled, true);
assert.notInclude(detail.viewerPermissions?.actions ?? [], "merge");
}).pipe(Effect.provide(server.layer));
});
it.effect("reads a pull request GitHub merged as merged before the sync reports it", () => {
const mergedAt = "2026-09-12T13:00:00Z";
const server = detailWith({ providerMerge: { mergedAt } });
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const detail = yield* provider.getChangeRequest(target);
assert.strictEqual(detail.state, "merged");
assert.strictEqual(detail.mergedAt, mergedAt);
const preview = yield* provider.getChangeRequestPreview!(target);
assert.strictEqual(preview.state, "merged");
}).pipe(Effect.provide(server.layer));
});
it.effect.each([
["their own pull request", actor],
[
"the pull request GitHub sync opened for them",
{
kind: "github",
actorId: "act_github",
login: "alice",
avatarUrl: null,
linkedProfile: { handle: "alice", actorId: "act_one" },
},
],
] as const)("leaves the author only a comment on %s", ([, author]) => {
const server = detailWith({ author, viewerActorId: "act_one" });
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const detail = yield* provider.getChangeRequest(target);
assert.deepStrictEqual(detail.viewerPermissions?.verdicts, ["comment"]);
}).pipe(Effect.provide(server.layer));
});
it.effect("requests and withdraws reviewers by rewriting the whole list", () => {
const bob = { ...actor, actorId: "act_two", handle: "bob" };
let requested = [{ id: "act_two", actor: bob }];
const server = fakeGitCafe({
"GET /repos/owner/repo/pulls/7": pull,
"GET /repos/owner/repo/pulls/7/reviewer-candidates": {
items: [
{ id: "act_one", actor },
{ id: "act_two", actor: bob },
{ id: "act_bot", actor: { ...actor, actorId: "act_bot", handle: "lint", bot: true } },
],
next: null,
},
"GET /repos/owner/repo/pulls/7/reviewers": () => ({ items: requested, next: null }),
"PUT /repos/owner/repo/pulls/7/reviewers": { version: 5, items: [] },
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const list = yield* provider.listReviewerCandidates(target);
// The author, alice, cannot review her own pull request.
assert.deepStrictEqual(
list.candidates.map((c) => [c.id, c.login, c.isRequested, c.isBot ?? false]),
[
["act_two", "bob", true, false],
["act_bot", "lint", false, true],
],
);
const set = (id: string, on: boolean) =>
provider.setReviewerRequest({
...target,
reviewers: [{ id, kind: "user" }],
requested: on,
});
yield* set("act_bot", true);
assert.deepStrictEqual(server.sent.at(-1)?.body, {
expectedVersion: 4,
actorIds: ["act_two", "act_bot"],
});
yield* set("act_two", false);
assert.deepStrictEqual(server.sent.at(-1)?.body, { expectedVersion: 4, actorIds: [] });
requested = [];
yield* set("act_two", false);
assert.strictEqual(server.writes().length, 2);
}).pipe(Effect.provide(server.layer));
});
it.effect("names the missing scopes when the token may not request reviewers", () => {
const server = fakeGitCafe({
"GET /repos/owner/repo/pulls/7": pull,
"GET /repos/owner/repo/pulls/7/reviewer-candidates": new Response("", { status: 403 }),
"GET /repos/owner/repo/pulls/7/reviewers": { items: [], next: null },
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const error = yield* Effect.flip(provider.listReviewerCandidates(target));
assert.match(error.detail, /pr:reviewers:write/u);
}).pipe(Effect.provide(server.layer));
});
it.effect("applies and removes labels by name through their ids", () => {
const server = fakeGitCafe({
"GET /repos/owner/repo/pulls/7": pull,
"GET /repos/owner/repo/labels": { items: labels, next: null },
"GET /repos/owner/repo/pulls/7/labels": { items: [labels[0]], next: null },
"PUT /repos/owner/repo/pulls/7/labels": { version: 5, items: [] },
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const list = yield* provider.listLabelCandidates!(target);
assert.deepStrictEqual(
list.candidates.map((label) => [label.name, label.isApplied]),
[
["bug", true],
["docs", false],
],
);
yield* provider.setLabels!({ ...target, labels: ["docs"], applied: true });
assert.deepStrictEqual(server.sent.at(-1)?.body, {
expectedVersion: 4,
labelIds: ["label_bug", "label_docs"],
});
yield* provider.setLabels!({ ...target, labels: ["bug"], applied: false });
assert.deepStrictEqual(server.sent.at(-1)?.body, { expectedVersion: 4, labelIds: [] });
const missing = yield* provider.setLabels!({
...target,
labels: ["nope"],
applied: true,
}).pipe(Effect.result);
assert.strictEqual(missing._tag, "Failure");
assert.strictEqual(server.writes().length, 2);
}).pipe(Effect.provide(server.layer));
});
it.effect("recounts summary lines only when the compared commits move", () => {
const landedBase = "fedcba9876543210fedcba9876543210fedcba98";
const mainTip = "0123012301230123012301230123012301230123";
let comparisonBaseOid = baseOid;
let tips = { targetBranch: "main", observedBaseOid: baseOid };
let pullReads = 0;
let listingCut = true;
let hunksDown = false;
const hunks = (request: SentRequest) => ({
version: 4,
headOid,
comparisonBaseOid,
items: (request.body as { paths: ReadonlyArray<string> }).paths.map((path) => ({
path,
additions: comparisonBaseOid === baseOid ? 3 : 1,
deletions: 1,
})),
});
const server = fakeGitCafe({
// A comment moves the version without moving the compared commits.
"GET /repos/owner/repo/pulls/7": () => ({ ...pull, ...tips, version: 4 + pullReads++ }),
"GET /repos/owner/repo/pulls/7/changes": (request: SentRequest) => ({
version: 4,
headOid,
comparisonBaseOid,
...(!listingCut
? { items: [{ path: "a.ts" }, { path: "b.ts" }], next: null }
: request.query.has("after")
? { items: [], next: "more" }
: { items: [{ path: "a.ts" }], next: "more" }),
}),
get "POST /repos/owner/repo/pulls/7/diff-files"() {
return hunksDown
? new Response(encodeJson({ type: "https://cafe.sh/errors/conflict" }), { status: 409 })
: hunks;
},
});
const reads = (suffix: string) =>
server.sent.filter((request) => request.path.endsWith(suffix)).length;
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
// A listing that stops before its last page holds nothing for its commits.
yield* provider.getChangeRequestSummary!(target);
listingCut = false;
hunksDown = true;
// Unread hunks leave the lines unknown, and are read again next time.
const unread = yield* provider.getChangeRequestSummary!(target);
assert.strictEqual(unread.additions, undefined);
hunksDown = false;
const first = yield* provider.getChangeRequestSummary!(target);
const second = yield* provider.getChangeRequestSummary!(target);
assert.deepInclude(first, { additions: 6, deletions: 2, changedFiles: 2 });
assert.deepInclude(second, { additions: 6, deletions: 2, changedFiles: 2 });
// Neither the head nor the target tip moved, so the file list is not read again.
assert.deepStrictEqual([reads("/changes"), reads("/diff-files")], [4, 3]);
// The target branch advancing keeps the merge base, so only the file list is read.
tips = { ...tips, observedBaseOid: mainTip };
const third = yield* provider.getChangeRequestSummary!(target);
assert.deepInclude(third, { additions: 6, deletions: 2, changedFiles: 2 });
assert.deepStrictEqual([reads("/changes"), reads("/diff-files")], [5, 3]);
// A landed parent layer retargets the pull and moves the comparison base under the same head.
comparisonBaseOid = landedBase;
tips = { targetBranch: "trunk", observedBaseOid: mainTip };
const fourth = yield* provider.getChangeRequestSummary!(target);
assert.deepInclude(fourth, { additions: 2, deletions: 2, changedFiles: 2 });
assert.deepStrictEqual([reads("/changes"), reads("/diff-files")], [6, 4]);
}).pipe(Effect.provide(server.layer));
});
it.effect("fences a native merge on the target branch's current commit", () => {
const branchOid = "fedcba9876543210fedcba9876543210fedcba98";
const server = fakeGitCafe({
"GET /repos/owner/repo/pulls/7": { ...pull, mergeRoute: "native", observedBaseOid: null },
"GET /repos/owner/repo/commit": { oid: branchOid },
"POST /repos/owner/repo/pulls/7/merge": { id: "merge-1", state: "completed" },
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
yield* provider.runAction({ ...target, action: "merge" });
const branchRead = server.sent.find((request) => request.path === "/repos/owner/repo/commit");
assert.strictEqual(branchRead?.query.get("ref"), "refs/heads/main");
assert.deepInclude(server.sent.at(-1)?.body as object, { baseOid: branchOid, headOid });
}).pipe(Effect.provide(server.layer));
});
it.effect("refuses to drop a reaction whose id it cannot address", () => {
const server = fakeGitCafe({
"GET /repos/owner/repo/pulls/7/reactions/": {
items: [
{
subject: { kind: "pull_request_comment", id: "root" },
emoji: { kind: "unicode", value: "🚀" },
count: 1,
viewerReactionId: "../escape",
reactors: [actor],
},
],
next: null,
},
});
return Effect.gen(function* () {
const provider = yield* GitCafePullRequestProvider.make;
const result = yield* provider
.setReaction({ ...target, subjectId: "root", content: "rocket", reacted: false })
.pipe(Effect.result);
assert.strictEqual(result._tag, "Failure");
assert.deepStrictEqual(server.writes(), []);
}).pipe(Effect.provide(server.layer));
});
});