import { SourceControlProviderKind } from "@t3tools/contracts";
import { assert, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Schema from "effect/Schema";
import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
import * as HttpClient from "effect/http/HttpClient";
import * as HttpClientRequest from "effect/http/HttpClientRequest";
import * as HttpClientResponse from "effect/http/HttpClientResponse";
import { VcsProcessSpawnError } from "@t3tools/contracts";
import { firstNonEmptyLine } from "@t3tools/source-control-core/server/discovery";
import * as HostProcess from "@t3tools/shared/HostProcess";
import * as TestSourceControlHost from "@t3tools/source-control-testing/TestSourceControlHost";
import * as ForgejoCli from "./ForgejoCli.ts";
import * as ForgejoPullRequestProvider from "./ForgejoPullRequestProvider.ts";
import * as ForgejoSourceControlProvider from "./ForgejoSourceControlProvider.ts";
import { markRequiredForgejoChecks } from "./forgejoRequiredChecks.ts";
const processOutput = TestSourceControlHost.processOutput;
const encodeJson = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
const decodeJson = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown));
const requestJson = (request: HttpClientRequest.HttpClientRequest): unknown => {
assert.strictEqual(request.body._tag, "Uint8Array");
return request.body._tag === "Uint8Array"
? decodeJson(new TextDecoder().decode(request.body.body))
: undefined;
};
const encodeJsonEffect = Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown));
it.effect("reads clone URLs on the given host rather than the checkout's", () => {
const urls: string[] = [];
const client = HttpClient.make((request) => {
urls.push(request.url);
return Effect.succeed(
HttpClientResponse.fromWeb(
request,
new Response(
encodeJson({
full_name: "maria/project",
clone_url: "https://forgejo.test/maria/project.git",
ssh_url: "git@forgejo.test:maria/project.git",
}),
),
),
);
});
return Effect.gen(function* () {
const cli = yield* ForgejoCli.make;
const provider = yield* ForgejoSourceControlProvider.make.pipe(
Effect.provideService(ForgejoCli.ForgejoCli, cli),
);
const cloneUrls = yield* provider.getRepositoryCloneUrls({
cwd: "/repo",
repository: "maria/project",
host: "forgejo.test",
});
assert.strictEqual(cloneUrls.url, "https://forgejo.test/maria/project.git");
assert.deepStrictEqual(urls, ["https://forgejo.test/api/v1/repos/maria/project"]);
}).pipe(
Effect.provideService(HttpClient.HttpClient, client),
Effect.provideService(
FileSystem.FileSystem,
FileSystem.makeNoop({
exists: () => Effect.succeed(true),
readFileString: () =>
Effect.succeed(
encodeJson({
hosts: {
"forgejo.test": { type: "Application", token: "test-token" },
"code.example": { type: "Application", token: "other-token" },
},
}),
),
}),
),
Effect.provide(
TestSourceControlHost.layer({
process: {
run: (input) => {
if (input.command === "git") {
assert.deepStrictEqual(input.args, ["remote", "-v"]);
// The checkout is on another Forgejo server with a same-named repository.
return Effect.succeed(
processOutput("origin\thttps://code.example/maria/project.git (fetch)"),
);
}
assert.strictEqual(input.command, "fj");
assert.deepStrictEqual(input.args, ["--host", "https://forgejo.test", "whoami"]);
return Effect.succeed(processOutput(""));
},
},
}),
),
);
});
const requiredChecksPullRequest = {
number: 7,
title: "Required checks",
body: "",
html_url: "https://forgejo.test/acme/web/pulls/7",
user: { login: "maria" },
state: "open",
merged: false,
head: { ref: "feature", sha: "head", repo: null },
base: { ref: "release/1.x", sha: "base", repo: null },
created_at: "2026-10-12T00:00:00Z",
updated_at: "2026-10-12T00:00:00Z",
closed_at: null,
merged_at: null,
labels: [],
};
const requiredChecksStatuses = [
["ci/required-build", "success"],
["ci/optional-lint", "failure"],
].map(([context, status]) => ({
context,
status,
description: null,
target_url: null,
updated_at: "2026-10-12T00:00:00Z",
}));
const requiredChecksInput = {
cwd: "/repo",
repository: "acme/web",
host: "forgejo.test",
number: 7,
};
const requiredChecksLayer = (
branch: Effect.Effect<unknown, ForgejoCli.ForgejoCliError>,
statuses = requiredChecksStatuses,
) =>
Layer.mock(ForgejoCli.ForgejoCli)({
api: (input) => {
const [path, query] = input.path.split("?");
const respond = (response: unknown) =>
encodeJsonEffect(response).pipe(Effect.orDie, Effect.map(processOutput));
switch (path) {
case "repos/acme/web/pulls/7":
return respond(requiredChecksPullRequest);
case "repos/acme/web/statuses/head":
return respond(new URLSearchParams(query).get("page") === "1" ? statuses : []);
case "repos/acme/web/branches/release/1.x":
return Effect.flatMap(branch, respond);
case "repos/acme/web":
return respond({ full_name: "acme/web", permissions: { push: true, admin: false } });
case "user":
return respond({ login: "maria" });
default:
return Effect.die(`Unexpected Forgejo request: ${input.path}`);
}
},
});
it.effect.each([
["ci/required-deploy", true],
["test-*", true],
["ci/[ab]", false],
] as const)("keeps missing required pattern %s pending (supported: %s)", ([missing, supported]) =>
Effect.gen(function* () {
const provider = yield* ForgejoPullRequestProvider.make;
const readChecks = provider.getChangeRequestChecks;
if (readChecks === undefined) return yield* Effect.die("checks read missing");
const summary = yield* readChecks(requiredChecksInput);
const detail = yield* provider.getChangeRequest(requiredChecksInput);
for (const checks of [summary.checks, detail.checks]) {
assert.deepStrictEqual(
checks.map((check) => [check.name, check.status, check.required]),
supported
? [
["ci/optional-lint", "failure", undefined],
["ci/required-build", "success", true],
[missing, "pending", true],
]
: [
["ci/required-build", "success", undefined],
["ci/optional-lint", "success", undefined],
[missing, "pending", undefined],
],
);
if (!supported) {
assert.strictEqual(
checks.at(-1)?.description,
"Required check pattern cannot be evaluated.",
);
}
}
}).pipe(
Effect.provide(
requiredChecksLayer(
Effect.succeed({
name: "release/1.x",
protected: true,
enable_status_check: true,
status_check_contexts: ["ci/required-*", missing, missing],
}),
supported
? requiredChecksStatuses
: requiredChecksStatuses.map((status) => ({ ...status, status: "success" })),
),
),
),
);
it("matches many-wildcard required patterns against long check names without backtracking", () => {
const checks = ["a".repeat(200), `${"a".repeat(199)}b`, "x?y\nz"].map((name) => ({
name,
status: "success" as const,
description: null,
url: null,
}));
const marked = markRequiredForgejoChecks(checks, {
enable_status_check: true,
status_check_contexts: [`${"*a".repeat(12)}b`, "x*?y?z"],
});
assert.deepStrictEqual(
marked.map((check) => [check.name.slice(-3), check.required]),
[
["aaa", undefined],
["aab", true],
["y\nz", true],
],
);
});
it("treats a required pattern's `*` as a wildcard even when the check name has one", () => {
const checks = ["*build", "ci/*lint"].map((name) => ({
name,
status: "success" as const,
description: null,
url: null,
}));
const marked = markRequiredForgejoChecks(checks, {
enable_status_check: true,
status_check_contexts: ["*build", "ci/*"],
});
assert.deepStrictEqual(
marked.map((check) => [check.name, check.required]),
[
["*build", true],
["ci/*lint", true],
],
);
});
const tiedStatuses = [
{ id: 15, status: "success" },
{ id: 14, status: "pending" },
].map(({ id, status }) => ({
id,
context: "ci/required-build",
status,
description: null,
target_url: null,
updated_at: "2026-10-12T10:14:29Z",
}));
it.effect.each([
["newest first", tiedStatuses],
["oldest first", tiedStatuses.toReversed()],
] as const)("reads the status created last when two share a second, listed %s", ([, statuses]) =>
Effect.gen(function* () {
const provider = yield* ForgejoPullRequestProvider.make;
const readChecks = provider.getChangeRequestChecks;
if (readChecks === undefined) return yield* Effect.die("checks read missing");
const summary = yield* readChecks(requiredChecksInput);
const detail = yield* provider.getChangeRequest(requiredChecksInput);
for (const checks of [summary.checks, detail.checks]) {
assert.deepStrictEqual(
checks.map((check) => [check.name, check.status]),
[["ci/required-build", "success"]],
);
}
}).pipe(Effect.provide(requiredChecksLayer(Effect.succeed({}), statuses))),
);
const forgejoMergeProvider = (repository: Effect.Effect<string, ForgejoCli.ForgejoCliError>) => {
const writes: Array<ForgejoCli.ForgejoApiInput> = [];
const provider = ForgejoPullRequestProvider.make.pipe(
Effect.provide(
Layer.mock(ForgejoCli.ForgejoCli)({
api: (input) => {
if (input.method !== undefined && input.method !== "GET") writes.push(input);
return (input.path === "repos/reviewer/project" ? repository : Effect.succeed("")).pipe(
Effect.map((stdout) => ({
exitCode: ChildProcessSpawner.ExitCode(0),
stdout,
stderr: "",
stdoutTruncated: false,
stderrTruncated: false,
})),
);
},
}),
),
);
return { provider, writes };
};
const forgejoMergeInput = {
cwd: "/forgejo",
repository: "reviewer/project",
host: "forge.example:3000",
number: 1,
action: "merge",
mergeMethod: "squash",
} as const;
it.effect("follows the Forgejo repository's delete-branch-after-merge setting", () =>
Effect.gen(function* () {
for (const [setting, deleteBranch] of [
[{ default_delete_branch_after_merge: true }, true],
[{ default_delete_branch_after_merge: false }, false],
[{}, false],
] as const) {
const { provider, writes } = forgejoMergeProvider(
Effect.succeed(JSON.stringify({ full_name: "reviewer/project", ...setting })),
);
yield* (yield* provider).runAction(forgejoMergeInput);
assert.deepStrictEqual(
writes.map((write) => [write.path, write.body]),
[
[
"repos/reviewer/project/pulls/1/merge",
{ Do: "squash", delete_branch_after_merge: deleteBranch },
],
],
`repository setting ${JSON.stringify(setting)}`,
);
}
}),
);
it.effect("does not merge on Forgejo when the repository settings cannot be read", () =>
Effect.gen(function* () {
const { provider, writes } = forgejoMergeProvider(
Effect.fail(
new ForgejoCli.ForgejoCliError({
command: "tea",
cwd: "/forgejo",
detail: "Forgejo is unavailable.",
}),
),
);
const exit = yield* Effect.exit((yield* provider).runAction(forgejoMergeInput));
assert.deepStrictEqual(
writes.map((write) => write.path),
[],
"merged without knowing whether to delete the source branch",
);
assert.isTrue(Exit.isFailure(exit));
}),
);
it.effect.each([
[true, false],
[false, true],
] as const)(
"reports a Forgejo merge whose branch deletion was refused by whether it merged (merged: %s)",
([merged, fails]) => {
const refused = new ForgejoCli.ForgejoCliError({
command: "fj",
cwd: "/repo",
detail: "branch is protected",
httpStatus: 403,
reason: "forbidden",
});
return Effect.gen(function* () {
const provider = yield* ForgejoPullRequestProvider.make;
const exit = yield* Effect.exit(
provider.runAction({ ...requiredChecksInput, action: "merge", mergeMethod: "merge" }),
);
assert.strictEqual(exit._tag === "Failure", fails);
}).pipe(
Effect.provide(
Layer.mock(ForgejoCli.ForgejoCli)({
api: (input) => {
const respond = (response: unknown) =>
encodeJsonEffect(response).pipe(Effect.orDie, Effect.map(processOutput));
switch (input.path) {
case "repos/acme/web":
return respond({ full_name: "acme/web", default_delete_branch_after_merge: true });
case "repos/acme/web/pulls/7/merge":
return Effect.fail(refused);
case "repos/acme/web/pulls/7":
return respond({ ...requiredChecksPullRequest, merged });
default:
return Effect.die(`Unexpected Forgejo request: ${input.path}`);
}
},
}),
),
);
},
);
// regression: #18775 a failed branch-protection read surfaces; only 403/404 are treated as no policy
it.effect.each([
["rate limit", { reason: "rate-limit", httpStatus: 429 }, "rate-limited"],
["authentication failure", { reason: "authentication", httpStatus: 401 }, "unauthenticated"],
["network failure", {}, "failed"],
] as const)("propagates branch metadata %s", ([detail, fields, reason]) => {
const cause = new ForgejoCli.ForgejoCliError({ command: "fj", cwd: "/repo", detail, ...fields });
return Effect.gen(function* () {
const provider = yield* ForgejoPullRequestProvider.make;
const readChecks = provider.getChangeRequestChecks;
if (readChecks === undefined) return yield* Effect.die("checks read missing");
for (const read of [readChecks, provider.getChangeRequest]) {
const error = yield* read(requiredChecksInput).pipe(Effect.flip);
assert.strictEqual(error.reason, reason);
assert.strictEqual(error.cause, cause);
}
}).pipe(Effect.provide(requiredChecksLayer(Effect.fail(cause))));
});
it.effect("reads Forgejo jobs that did not run as finished checks", () =>
Effect.gen(function* () {
const provider = yield* ForgejoPullRequestProvider.make;
const read = provider.getChangeRequestChecks;
if (read === undefined) return yield* Effect.die("checks read missing");
const result = yield* read({
cwd: "/repo",
repository: "acme/web",
host: "forgejo.test",
number: 1,
});
assert.deepStrictEqual(
result.checks.map((check) => [check.name, check.status]),
[
["deploy", "skipped"],
["audit", "neutral"],
["docs", "pending"],
],
);
}).pipe(
Effect.provide(
Layer.mock(ForgejoCli.ForgejoCli)({
api: (input) => {
if (input.path.endsWith("branches/main")) {
return encodeJsonEffect({}).pipe(Effect.orDie, Effect.map(processOutput));
}
const status = (context: string, state: string) => ({
context,
status: state,
description: null,
target_url: null,
updated_at: "2026-10-11T00:00:00Z",
});
const body = input.path.endsWith("branches/main")
? {}
: input.path.endsWith("pulls/1")
? {
number: 1,
title: "Checks",
body: "",
html_url: "https://forgejo.test/acme/web/pulls/1",
user: null,
state: "open",
merged: false,
head: { ref: "feature", sha: "head", repo: null },
base: { ref: "main", sha: "base", repo: null },
created_at: "2026-10-11T00:00:00Z",
updated_at: "2026-10-11T00:00:00Z",
closed_at: null,
merged_at: null,
labels: [],
}
: input.path.endsWith("page=1")
? [
status("deploy", "skipped"),
status("audit", "warning"),
status("docs", "future-state"),
]
: [];
return encodeJsonEffect(body).pipe(Effect.orDie, Effect.map(processOutput));
},
}),
),
),
);
it.effect("opens Forgejo Actions check links on the pull request's server", () =>
Effect.gen(function* () {
const provider = yield* ForgejoPullRequestProvider.make;
const read = provider.getChangeRequestChecks;
if (read === undefined) return yield* Effect.die("checks read missing");
const result = yield* read({
cwd: "/repo",
repository: "acme/web",
host: "forgejo.test",
number: 1,
});
assert.deepStrictEqual(
result.checks.map((check) => [check.name, check.url]),
[
["actions", "https://forgejo.test/git/acme/web/actions/runs/7/jobs/2"],
["external", "https://ci.example/build/9"],
["none", null],
],
);
}).pipe(
Effect.provide(
Layer.mock(ForgejoCli.ForgejoCli)({
api: (input) => {
const status = (context: string, target_url: string | null) => ({
context,
status: "success",
description: null,
target_url,
updated_at: "2026-10-11T00:00:00Z",
});
const body = input.path.endsWith("branches/main")
? {}
: input.path.endsWith("pulls/1")
? {
number: 1,
title: "Checks",
body: "",
html_url: "https://forgejo.test/git/acme/web/pulls/1",
user: null,
state: "open",
merged: false,
head: { ref: "feature", sha: "head", repo: null },
base: { ref: "main", sha: "base", repo: null },
created_at: "2026-10-11T00:00:00Z",
updated_at: "2026-10-11T00:00:00Z",
closed_at: null,
merged_at: null,
labels: [],
}
: input.path.endsWith("page=1")
? [
// Forgejo includes any sub-path mount in the relative links it reports.
status("actions", "/git/acme/web/actions/runs/7/jobs/2"),
status("external", "https://ci.example/build/9"),
status("none", null),
]
: [];
return encodeJsonEffect(body).pipe(Effect.orDie, Effect.map(processOutput));
},
}),
),
),
);
it.effect.each([
["Ready", false, true, false, "mergeable"],
["Draft", true, false, true, "unknown"],
["WIP: Legacy draft", undefined, false, true, "unknown"],
["WIP: Explicitly ready", false, false, false, "unknown"],
] as const)(
"reads Forgejo mergeability for %s (draft=%s, mergeable=%s) across list, summary and detail",
([title, draft, mergeable, isDraft, mergeability]) => {
const pr = {
number: 42,
title,
body: "",
html_url: "https://forgejo.test/maria/project/pulls/42",
user: { login: "maria" },
state: "open",
merged: false,
...(draft === undefined ? {} : { draft }),
...(mergeable === undefined ? {} : { mergeable }),
head: { ref: "feature", sha: "head", repo: null },
base: { ref: "main", sha: "base", repo: null },
created_at: "2026-09-16T00:00:00Z",
updated_at: "2026-09-16T00:00:00Z",
closed_at: null,
merged_at: null,
labels: [],
};
const requests: string[] = [];
return Effect.gen(function* () {
const provider = yield* ForgejoPullRequestProvider.make;
const readSummary = provider.getChangeRequestSummary;
if (readSummary === undefined) return yield* Effect.die("summary read missing");
const readPreview = provider.getChangeRequestPreview;
if (readPreview === undefined) return yield* Effect.die("preview read missing");
const input = { cwd: "/repo", repository: "maria/project", host: "forgejo.test", number: 42 };
const preview = yield* readPreview(input);
assert.deepStrictEqual(requests, ["repos/maria/project/pulls/42"]);
assert.strictEqual(preview.isDraft, isDraft);
assert.strictEqual(preview.title, title);
assert.strictEqual(preview.state, "open");
assert.strictEqual(preview.number, 42);
assert.strictEqual(preview.url, pr.html_url);
assert.deepStrictEqual(preview.author, { login: "maria", name: null, avatarUrl: null });
assert.strictEqual(preview.createdAt, "2026-09-16T00:00:00.000Z");
const list = yield* provider.listChangeRequests({
...input,
state: "open",
involvement: "all",
viewer: "maria",
limit: 10,
});
const summary = yield* readSummary(input);
const detail = yield* provider.getChangeRequest(input);
assert.strictEqual(list.items.length, 1);
assert.strictEqual(detail.headSha, "head");
for (const result of [list.items[0]!, summary, detail]) {
assert.strictEqual(result.mergeability, mergeability);
assert.strictEqual(result.isDraft, isDraft);
}
}).pipe(
Effect.provide(
Layer.mock(ForgejoCli.ForgejoCli)({
api: (input) => {
requests.push(input.path);
const [path, query] = input.path.split("?");
let response: unknown;
switch (path) {
case "repos/maria/project/pulls":
response = new URLSearchParams(query).get("page") === "1" ? [pr] : [];
break;
case "repos/maria/project/pulls/42":
response = pr;
break;
case "repos/maria/project":
response = { full_name: "maria/project", permissions: { push: true, admin: true } };
break;
case "user":
response = pr.user;
break;
case "repos/maria/project/statuses/head":
response = [];
break;
case "repos/maria/project/branches/main":
response = { name: "main", protected: false };
break;
default:
return Effect.die(`Unexpected Forgejo request: ${input.path}`);
}
return encodeJsonEffect(response).pipe(Effect.orDie, Effect.map(processOutput));
},
}),
),
);
},
);
it.effect("asks Forgejo for one required label by id and the author by login", () => {
const paths: Array<string> = [];
return Effect.gen(function* () {
const provider = yield* ForgejoPullRequestProvider.make;
yield* provider.listChangeRequests({
cwd: "/repo",
repository: "maria/project",
host: "forgejo.test",
state: "open",
involvement: "all",
viewer: "maria",
limit: 10,
filters: { labels: [["size:S", "size:M"], ["Bug"]], author: "@me" },
});
const listing = paths.find((path) => path.startsWith("repos/maria/project/pulls?"));
const params = new URLSearchParams(listing?.split("?")[1]);
assert.deepStrictEqual(params.getAll("labels"), ["7"]);
assert.strictEqual(params.get("poster"), "maria");
}).pipe(
Effect.provide(
Layer.mock(ForgejoCli.ForgejoCli)({
api: (input) => {
paths.push(input.path);
const response = input.path.startsWith("repos/maria/project/labels")
? [{ id: 7, name: "bug" }]
: [];
return encodeJsonEffect(response).pipe(Effect.orDie, Effect.map(processOutput));
},
}),
),
);
});
it.effect("lists nothing for an author Forgejo has no account for", () =>
Effect.gen(function* () {
const provider = yield* ForgejoPullRequestProvider.make;
const page = yield* provider.listChangeRequests({
cwd: "/repo",
repository: "maria/project",
host: "forgejo.test",
state: "open",
involvement: "all",
viewer: "maria",
limit: 10,
filters: { author: "nobody" },
});
assert.deepStrictEqual(page, { items: [], truncated: false, continues: false });
}).pipe(
Effect.provide(
Layer.mock(ForgejoCli.ForgejoCli)({
api: (input) =>
Effect.fail(
new ForgejoCli.ForgejoCliError({
command: "fj",
cwd: input.cwd,
httpStatus: 400,
detail: "Forgejo API request failed (HTTP 400): Poster not found",
}),
),
}),
),
),
);
it.effect.each([
{ query: undefined, count: 3 },
{ query: "", count: 3 },
{ query: " \t ", count: 3 },
{ query: "", count: 101 },
])("reads all $count assignees once for author query '$query'", ({ query, count }) => {
const paths: string[] = [];
const users = Array.from({ length: count }, (_, index) => ({ login: `dev-${index}` }));
return Effect.gen(function* () {
const provider = yield* ForgejoPullRequestProvider.make;
const search = provider.searchRepositoryAuthors;
if (search === undefined) return yield* Effect.die("author search missing");
const found = yield* search({
cwd: "/repo",
repository: "maria/project",
host: "forgejo.test",
...(query === undefined ? {} : { query }),
});
assert.strictEqual(paths.length, 1);
assert.deepStrictEqual(found, {
items: users.map(({ login }) => ({ login, name: null, avatarUrl: null })),
truncated: false,
});
}).pipe(
Effect.provide(
Layer.mock(ForgejoCli.ForgejoCli)({
api: (input) => {
paths.push(input.path);
assert.strictEqual(input.path.split("?")[0], "repos/maria/project/assignees");
// Forgejo ignores paging here: every page is the full list, with no Link header.
return encodeJsonEffect(users).pipe(Effect.orDie, Effect.map(processOutput));
},
}),
),
);
});
it.effect("says an author search was cut short by a server that pages below its limit", () =>
Effect.gen(function* () {
const provider = yield* ForgejoPullRequestProvider.make;
const search = provider.searchRepositoryAuthors;
if (search === undefined) return yield* Effect.die("author search missing");
const found = yield* search({
cwd: "/repo",
repository: "maria/project",
host: "forgejo.test",
query: "dev",
});
assert.strictEqual(found.items.length, 30);
assert.isTrue(found.truncated);
}).pipe(
Effect.provide(
Layer.mock(ForgejoCli.ForgejoCli)({
api: () =>
encodeJsonEffect({
ok: true,
data: Array.from({ length: 30 }, (_, index) => ({ login: `dev-${index}` })),
}).pipe(
Effect.orDie,
Effect.map((stdout) =>
processOutput(stdout, {
stderr:
'HTTP/1.1 200\nlink: <https://forgejo.test/api/v1/users/search?page=2>; rel="next"\n',
}),
),
),
}),
),
),
);
it.effect("gives Forgejo identities the browser URL of the login that serves them", () =>
Effect.gen(function* () {
const provider = yield* ForgejoSourceControlProvider.make;
const refine = provider.refineRepositoryIdentity;
assert.isDefined(refine);
const identity = (remoteUrl: string, provider?: string) => ({
canonicalKey: "forge.test/team/repo",
locator: { source: "git-remote" as const, remoteName: "origin", remoteUrl },
rootPath: "/repo",
...(provider === undefined ? {} : { provider: SourceControlProviderKind.make(provider) }),
});
const served = (baseUrl: string) => () =>
Effect.succeed({
provider: {
kind: SourceControlProviderKind.make("forgejo"),
name: "Forgejo / Gitea",
baseUrl,
},
remoteName: "origin",
remoteUrl: "",
});
assert.deepStrictEqual(
yield* refine!({
identity: identity("http://forge.test:3000/git/team/repo.git"),
resolveContext: served("http://forge.test:3000/git/"),
}),
{
...identity("http://forge.test:3000/git/team/repo.git"),
provider: SourceControlProviderKind.make("forgejo"),
webUrl: "http://forge.test:3000/git/team/repo",
},
);
assert.strictEqual(
(yield* refine!({
identity: identity("ssh://git@ssh.forge.test/team/repo.git"),
resolveContext: served("http://forge.test:3000/git"),
})).webUrl,
"http://forge.test:3000/git/team/repo",
);
const github = identity("https://github.com/team/repo.git", "github");
assert.strictEqual(
yield* refine!({ identity: github, resolveContext: () => Effect.die("not asked") }),
github,
);
const unserved = identity("http://forge.test:3000/team/repo.git");
assert.strictEqual(
yield* refine!({ identity: unserved, resolveContext: () => Effect.succeed(null) }),
unserved,
);
}).pipe(
Effect.provide(
Layer.mergeAll(
Layer.succeed(FileSystem.FileSystem, FileSystem.makeNoop({})),
TestSourceControlHost.layer(),
Layer.mock(ForgejoCli.ForgejoCli)({}),
),
),
),
);
it.effect("names the web server behind an SSH alias from the login that serves it", () =>
Effect.gen(function* () {
const provider = yield* ForgejoSourceControlProvider.make;
const resolveWebHost = provider.resolveRemoteWebHost!;
const asked: Array<string | undefined> = [];
const context = (remoteUrl: string) => ({
provider: {
kind: SourceControlProviderKind.make("forgejo"),
name: "Forgejo",
baseUrl: "https://ssh.forge.test",
},
remoteName: "origin",
remoteUrl,
requestedHost: "forge.test:3000",
});
const served = (input: {
readonly context: { readonly requestedHost?: string; readonly provider: { kind: string } };
}) =>
Effect.sync(() => {
asked.push(input.context.requestedHost);
assert.strictEqual(input.context.provider.kind, "unknown");
return {
provider: {
kind: SourceControlProviderKind.make("forgejo"),
name: "Forgejo / Gitea",
baseUrl: "http://forge.test:3000/git",
},
remoteName: "origin",
remoteUrl: "",
};
});
assert.strictEqual(
yield* resolveWebHost({
cwd: "/repo",
context: context("git@ssh.forge.test:team/repo.git"),
resolveContext: served,
}),
"forge.test:3000",
);
assert.deepStrictEqual(asked, ["forge.test:3000"]);
assert.strictEqual(
yield* resolveWebHost({
cwd: "/repo",
context: context("https://forge.test:3000/team/repo.git"),
resolveContext: () => Effect.die("an HTTP remote names its own web host"),
}),
null,
);
assert.strictEqual(
yield* resolveWebHost({
cwd: "/repo",
context: context("git@ssh.forge.test:team/repo.git"),
resolveContext: () => Effect.succeed(null),
}),
null,
);
}).pipe(
Effect.provide(
Layer.mergeAll(
Layer.succeed(FileSystem.FileSystem, FileSystem.makeNoop({})),
TestSourceControlHost.layer(),
Layer.mock(ForgejoCli.ForgejoCli)({}),
),
),
),
);
it.effect("loads Forgejo pull request references from files and commits views", () =>
Effect.gen(function* () {
const provider = yield* ForgejoSourceControlProvider.make;
for (const reference of [
"42",
"#42",
"https://forgejo.test/maria/project/pulls/42",
"https://forgejo.test/maria/project/pulls/42/",
"https://forgejo.test/maria/project/pulls/42/files?w=1#diff-1",
"http://forgejo.test:3000/git/maria/project/pulls/42/commits",
]) {
const result = yield* provider.getChangeRequest({ cwd: "/repo", reference });
assert.strictEqual(result.number, 42);
assert.strictEqual(result.title, "Forgejo view reference");
assert.strictEqual(result.headSha, "head");
}
const invalid = yield* provider
.getChangeRequest({
cwd: "/repo",
reference: "https://forgejo.test/maria/project/pulls/42invalid/files",
})
.pipe(Effect.result);
assert.strictEqual(invalid._tag, "Failure");
}).pipe(
Effect.provide(
Layer.mergeAll(
Layer.succeed(FileSystem.FileSystem, FileSystem.makeNoop({})),
TestSourceControlHost.layer({ process: {} }),
Layer.mock(ForgejoCli.ForgejoCli)({
resolveRepository: () =>
Effect.succeed({
login: "work",
repository: "maria/project",
baseUrl: "https://forgejo.test",
}),
api: (input) => {
assert.strictEqual(input.path, "repos/maria/project/pulls/42");
return encodeJsonEffect({
number: 42,
title: "Forgejo view reference",
html_url: "https://forgejo.test/maria/project/pulls/42",
state: "open",
merged: false,
base: { ref: "main", sha: "base", repo: null },
head: { ref: "feature", sha: "head", repo: null },
}).pipe(Effect.orDie, Effect.map(processOutput));
},
}),
),
),
),
);
it.effect(
"loads Forgejo reactions on comments, reviews and inline threads and resolves review mutations",
() => {
const user = { login: "maria" };
const review = {
id: 8,
body: "review body",
user,
state: "COMMENT",
submitted_at: "2026-09-12T00:00:00Z",
html_url: "https://forgejo.test/maria/project/pulls/2#issuecomment-37",
comments_count: 1,
};
const comment = { id: 12, body: "ordinary", user, created_at: review.submitted_at };
const responses: Record<string, unknown> = {
user,
"repos/maria/project/issues/2/comments": [comment],
"repos/maria/project/pulls/2/reviews": [review],
"repos/maria/project/pulls/2/reviews/8": review,
"repos/maria/project/pulls/2/reviews/9": { ...review, id: 9, html_url: "" },
"repos/maria/project/pulls/2/commits": [],
"repos/maria/project/issues/2/reactions": [],
"repos/maria/project/pulls/2/reviews/8/comments": [
{
...comment,
id: 38,
body: "inline",
path: "file.ts",
position: 1,
original_position: 1,
commit_id: "head",
original_commit_id: "head",
resolver: null,
},
],
"repos/maria/project/issues/comments/12/reactions": [{ content: "+1", user }],
"repos/maria/project/issues/comments/37/reactions": [{ content: "heart", user }],
"repos/maria/project/issues/comments/38/reactions": [
{ content: "rocket", user: { login: "reviewer" } },
],
};
const writes: ForgejoCli.ForgejoApiInput[] = [];
let reactionReads = 0;
return Effect.gen(function* () {
const provider = yield* ForgejoPullRequestProvider.make;
const input = { cwd: "/repo", repository: "maria/project", host: "forgejo.test", number: 2 };
const activity = yield* provider.getChangeRequestActivity(input);
assert.deepStrictEqual(
activity.comments.map((entry) => ({
id: entry.id,
kind: entry.kind,
reactions: entry.reactions,
})),
[
{
id: "12",
kind: "issue-comment",
reactions: [{ content: "thumbs-up", count: 1, actors: [], viewerHasReacted: true }],
},
{
id: "review:8",
kind: "review",
reactions: [{ content: "heart", count: 1, actors: [], viewerHasReacted: true }],
},
{
id: "38",
kind: "review-comment",
reactions: [
{ content: "rocket", count: 1, actors: ["reviewer"], viewerHasReacted: false },
],
},
],
);
const inlineComment = activity.comments[2];
assert.ok(inlineComment);
assert.deepStrictEqual(activity.reviewThreads[0]?.comments, [inlineComment]);
for (const reacted of [true, false]) {
yield* provider.setReaction({ ...input, subjectId: "review:8", content: "heart", reacted });
yield* provider.setReaction({ ...input, subjectId: "38", content: "rocket", reacted });
}
assert.deepStrictEqual(
writes.map(({ path, method, body }) => ({ path, method, body })),
[
{
path: "repos/maria/project/issues/comments/37/reactions",
method: "POST",
body: { content: "heart" },
},
{
path: "repos/maria/project/issues/comments/38/reactions",
method: "POST",
body: { content: "rocket" },
},
{
path: "repos/maria/project/issues/comments/37/reactions",
method: "DELETE",
body: { content: "heart" },
},
{
path: "repos/maria/project/issues/comments/38/reactions",
method: "DELETE",
body: { content: "rocket" },
},
],
);
const missing = yield* provider
.setReaction({ ...input, subjectId: "review:9", content: "heart", reacted: true })
.pipe(Effect.result);
assert.strictEqual(missing._tag, "Failure");
if (missing._tag === "Failure") assert.include(missing.failure.detail, "comment ID");
assert.strictEqual(writes.length, 4);
responses["repos/maria/project/pulls/2/reviews/8/comments"] = Array.from(
{ length: 501 },
(_, index) => ({
...comment,
id: 1000 + index,
path: "file.ts",
position: 1,
original_position: 1,
commit_id: "head",
original_commit_id: "head",
resolver: null,
}),
);
for (let index = 0; index < 500; index++) {
responses[`repos/maria/project/issues/comments/${1000 + index}/reactions`] = [];
}
reactionReads = 0;
const bounded = yield* provider.getChangeRequestActivity(input);
assert.strictEqual(bounded.reviewThreads.length, 500);
assert.strictEqual(
bounded.comments.filter((entry) => entry.kind === "review-comment").length,
500,
);
assert.strictEqual(bounded.commentsTruncated, true);
assert.strictEqual(reactionReads, 502);
}).pipe(
Effect.provide(
Layer.mock(ForgejoCli.ForgejoCli)({
api: (input) => {
if (input.method) {
writes.push(input);
return Effect.succeed(processOutput("{}"));
}
const path = input.path.split("?")[0]!;
if (/\/issues\/comments\/\d+\/reactions$/.test(path)) reactionReads++;
assert.ok(Object.hasOwn(responses, path), `Unexpected Forgejo request: ${path}`);
const page = Number(new URLSearchParams(input.path.split("?")[1]).get("page"));
return encodeJsonEffect(page > 1 ? [] : responses[path]).pipe(
Effect.orDie,
Effect.map(processOutput),
);
},
}),
),
);
},
);
it.effect("lists each Forgejo assignee once as a reviewer candidate", () => {
const paths: string[] = [];
return Effect.gen(function* () {
const provider = yield* ForgejoPullRequestProvider.make;
const result = yield* provider.listReviewerCandidates(requiredChecksInput);
assert.deepStrictEqual(
result.candidates.map((candidate) => [candidate.id, candidate.isRequested]),
[
["ana", true],
["noor", false],
],
);
assert.strictEqual(result.truncated, false);
assert.strictEqual(paths.filter((path) => path.includes("/assignees")).length, 1);
}).pipe(
Effect.provide(
Layer.mock(ForgejoCli.ForgejoCli)({
api: (input) => {
paths.push(input.path);
const respond = (response: unknown) =>
encodeJsonEffect(response).pipe(Effect.orDie, Effect.map(processOutput));
switch (input.path.split("?")[0]) {
case "repos/acme/web/pulls/7":
return respond({
...requiredChecksPullRequest,
requested_reviewers: [{ login: "ana" }],
});
// Forgejo ignores paging here: every page is the full list, with no Link header.
case "repos/acme/web/assignees":
return respond([{ login: "maria" }, { login: "ana" }, { login: "noor" }]);
default:
return Effect.die(`Unexpected Forgejo request: ${input.path}`);
}
},
}),
),
);
});
it.effect("discovers Forgejo accounts and retains the server port", () =>
Effect.gen(function* () {
const auth = ForgejoSourceControlProvider.discovery.parseAuth(
processOutput(
yield* encodeJsonEffect([
{
name: "work",
url: "http://forgejo.local:3000",
ssh_host: "git.forgejo.local",
user: "maria",
default: "true",
valid: "true",
},
]),
),
);
assert.deepStrictEqual(
firstNonEmptyLine("\u001b[1mtea version 0.16.0\u001b[0m\n"),
Option.some("tea version 0.16.0"),
);
assert.strictEqual(auth.status, "authenticated");
assert.deepStrictEqual(auth.account, Option.some("maria"));
assert.deepStrictEqual(auth.host, Option.some("forgejo.local:3000"));
const revoked = ForgejoSourceControlProvider.discovery.parseAuth(
processOutput(
encodeJson([
{
name: "work",
url: "http://forgejo.local:3000",
user: "maria",
default: "true",
valid: "false",
},
]),
),
);
assert.strictEqual(revoked.status, "unauthenticated");
const refined = ForgejoSourceControlProvider.discovery.refineUnknownRemote({
cwd: "/repo",
context: {
provider: {
kind: SourceControlProviderKind.make("unknown"),
name: "git.forgejo.local",
baseUrl: "https://git.forgejo.local",
},
remoteName: "origin",
remoteUrl: "git@git.forgejo.local:maria/project.git",
},
auth: processOutput(
yield* encodeJsonEffect([
{
name: "work",
url: "http://forgejo.local:3000",
ssh_host: "git.forgejo.local",
user: "maria",
default: "true",
},
]),
),
});
assert.deepStrictEqual(refined, {
kind: SourceControlProviderKind.make("forgejo"),
name: "Forgejo / Gitea",
baseUrl: "http://forgejo.local:3000",
});
}),
);
it.effect("does not choose a default Forgejo login across ambiguous SSH server ports", () =>
Effect.gen(function* () {
const logins = ForgejoCli.parseForgejoLogins(
yield* encodeJsonEffect([
{
name: "one",
url: "http://forgejo.local:3000",
ssh_host: "forgejo.local",
user: "maria",
default: "true",
},
{
name: "two",
url: "http://forgejo.local:4000",
ssh_host: "forgejo.local",
user: "maria",
default: "false",
},
]),
);
const remote = ForgejoCli.parseForgejoRemote("git@forgejo.local:maria/project.git");
assert.isNotNull(remote);
assert.deepStrictEqual(
ForgejoCli.parseForgejoRemote("forgejo.local:maria/project.git"),
remote,
);
assert.isUndefined(ForgejoCli.matchForgejoLogin(logins, remote!));
assert.strictEqual(
ForgejoCli.matchForgejoLogin(logins, remote!, "forgejo.local:4000")?.name,
"two",
);
assert.isUndefined(ForgejoCli.matchForgejoLogin(logins, remote!, "other.local:4000"));
const alias = ForgejoCli.parseForgejoRemote("git@ssh.forgejo.local:maria/project.git");
assert.isNotNull(alias);
assert.isUndefined(ForgejoCli.matchForgejoLogin(logins, alias!, "forgejo.local:4000"));
const refined = ForgejoSourceControlProvider.discovery.refineUnknownRemote({
cwd: "/repo",
context: {
provider: {
kind: SourceControlProviderKind.make("unknown"),
name: "Forgejo",
baseUrl: "https://forgejo.local",
},
remoteName: "origin",
remoteUrl: "git@forgejo.local:maria/project.git",
requestedHost: "forgejo.local:4000",
},
auth: processOutput(yield* encodeJsonEffect(logins)),
});
assert.strictEqual(refined?.baseUrl, "http://forgejo.local:4000");
const https = ForgejoCli.parseForgejoRemote("http://forgejo.local:4000/maria/project.git");
assert.isNotNull(https);
assert.strictEqual(ForgejoCli.matchForgejoLogin(logins, https!)?.name, "two");
const hostOnly = ForgejoCli.parseForgejoRemote("http://forgejo.local:4000");
assert.strictEqual(
ForgejoCli.matchForgejoLogin(logins, hostOnly!, undefined, true)?.name,
"two",
);
const mounted = logins.map((login) => ({
...login,
url: `http://forgejo.local:4000/${login.name}`,
}));
assert.isUndefined(ForgejoCli.matchForgejoLogin(mounted, hostOnly!, undefined, true));
}),
);
it.effect("rejects HTTP failures even when tea exits successfully", () =>
Effect.gen(function* () {
const cli = yield* ForgejoCli.make;
const result = yield* cli
.api({
cwd: "/repo",
repository: "http://forgejo.local:3000/maria/project",
path: "repos/maria/project/pulls/42",
method: "PATCH",
body: { state: "closed" },
})
.pipe(Effect.result);
assert.strictEqual(result._tag, "Failure");
if (result._tag === "Failure")
assert.strictEqual(
result.failure.detail,
"Forgejo repository or pull request was not found.",
);
}).pipe(
Effect.provideService(
FileSystem.FileSystem,
FileSystem.makeNoop({
exists: () => Effect.succeed(false),
}),
),
Effect.provideService(
HttpClient.HttpClient,
HttpClient.make(() => {
throw new Error("tea must handle its own HTTP request");
}),
),
Effect.provide(
TestSourceControlHost.layer({
process: {
run: (input) => {
if (input.args[0] === "api") {
assert.strictEqual(input.stdin, '{"state":"closed"}');
assert.include(input.args, "work");
assert.include(
input.args,
"http://forgejo.local:3000/api/v1/repos/maria/project/pulls/42",
);
}
return Effect.succeed(
input.args[0] === "login"
? processOutput(
encodeJson([
{
name: "work",
url: "http://forgejo.local:3000",
ssh_host: "forgejo.local",
user: "maria",
default: "true",
},
]),
)
: processOutput('{"message":"not found"}', { stderr: "HTTP/1.1 404 Not Found\n" }),
);
},
},
}),
),
),
);
it.effect("routes mounted Forgejo repositories without repeating the mount in API paths", () =>
Effect.gen(function* () {
const cli = yield* ForgejoCli.make;
const viewer = yield* cli.api({ cwd: "/upstream-only", host: "code.test", path: "user" });
assert.strictEqual(viewer.stdout, "[]");
const mountedRepository = yield* cli.resolveRepository({
cwd: "/upstream-only",
host: "code.test",
repository: "maria/project",
});
assert.strictEqual(mountedRepository.baseUrl, "https://code.test/forgejo");
assert.strictEqual(mountedRepository.repository, "maria/project");
for (const path of [
"repos/forgejo/maria/project/pulls?state=open",
"repos/forgejo/maria/project",
"repos/reviewer/project/contents/file.ts",
]) {
const result = yield* cli.api({
cwd: "/repo",
repository: "forgejo/maria/project",
context: {
provider: {
kind: SourceControlProviderKind.make("forgejo"),
name: "Forgejo",
baseUrl: "https://code.test/forgejo",
},
remoteName: "origin",
remoteUrl: "https://code.test/forgejo/maria/project.git",
},
path,
});
assert.strictEqual(result.stdout, "[]");
}
const sameOwnerAsMount = yield* cli.resolveRepository({
cwd: "/repo",
repository: "forgejo/project",
context: {
provider: {
kind: SourceControlProviderKind.make("forgejo"),
name: "Forgejo",
baseUrl: "https://code.test/forgejo",
},
remoteName: "origin",
remoteUrl: "ssh://git@code.test/forgejo/project.git",
},
});
assert.strictEqual(sameOwnerAsMount.command, "tea");
assert.strictEqual(sameOwnerAsMount.repository, "forgejo/project");
}).pipe(
Effect.provideService(
FileSystem.FileSystem,
FileSystem.makeNoop({
exists: () => Effect.succeed(true),
readFileString: () =>
Effect.succeed(
encodeJson({
hosts: { "code.test/forgejo": { type: "Application", token: "test-token" } },
}),
),
}),
),
Effect.provideService(
HttpClient.HttpClient,
HttpClient.make(() => {
throw new Error("tea must handle its own HTTP request");
}),
),
Effect.provide(
TestSourceControlHost.layer({
process: {
run: (input) => {
if (input.command === "git")
return Effect.succeed(
processOutput("", { exitCode: ChildProcessSpawner.ExitCode(2) }),
);
if (input.args[0] === "login")
return Effect.succeed(
processOutput(
encodeJson([
{
name: "mounted",
url: "https://code.test/forgejo",
ssh_host: "code.test",
user: "maria",
default: "true",
},
]),
),
);
const supported = [
"https://code.test/forgejo/api/v1/user",
"https://code.test/forgejo/api/v1/repos/maria/project/pulls?state=open",
"https://code.test/forgejo/api/v1/repos/maria/project",
"https://code.test/forgejo/api/v1/repos/reviewer/project/contents/file.ts",
];
if (input.args.at(-1)?.endsWith("/user")) assert.notInclude(input.args, "--repo");
assert.strictEqual(input.command, "tea");
return Effect.succeed(
supported.includes(input.args.at(-1) ?? "")
? processOutput("[]", { stderr: "HTTP/1.1 200 OK\n" })
: processOutput("{}", { stderr: "HTTP/1.1 404 Not Found\n" }),
);
},
},
}),
),
),
);
it.effect("prefers fj for HTTP and ported SSH aliases on root servers", () => {
const commands: string[] = [];
const requests: string[] = [];
let repositoryCwd = "";
return Effect.gen(function* () {
const cli = yield* ForgejoCli.make;
for (const remoteUrl of [
"http://forgejo.local:3000/maria/project.git",
"ssh://git@ssh.forgejo.local:2222/maria/project.git",
"ssh://git@forgejo.local:2222/maria/project.git",
]) {
const result = yield* cli.api({
cwd: "/repo",
repository: "maria/project",
context: {
provider: {
kind: SourceControlProviderKind.make("forgejo"),
name: "Forgejo",
baseUrl: "http://forgejo.local:3000",
},
remoteName: "origin",
remoteUrl,
requestedHost: "forgejo.local:3000",
},
path: "repos/maria/project/issues/42/comments",
method: "POST",
body: { body: "verified through fj" },
});
assert.strictEqual(result.stdout, '{"id":99}');
}
assert.deepStrictEqual(commands, ["fj"]);
assert.deepStrictEqual(requests, [
"http://forgejo.local:3000/api/v1/repos/maria/project/issues/42/comments",
"http://forgejo.local:3000/api/v1/repos/maria/project/issues/42/comments",
"http://forgejo.local:3000/api/v1/repos/maria/project/issues/42/comments",
]);
const viewer = yield* cli.api({
cwd: "/no-remotes",
host: "forgejo.local:3000",
path: "user",
});
assert.strictEqual(viewer.stdout, '{"login":"maria"}');
assert.strictEqual(requests.at(-1), "https://forgejo.local:3000/api/v1/user");
const upstreamViewer = yield* cli.api({
cwd: "/upstream-only",
host: "forgejo.local:3000",
path: "user",
});
assert.strictEqual(upstreamViewer.stdout, '{"login":"maria"}');
assert.strictEqual(requests.at(-1), "http://forgejo.local:3000/api/v1/user");
const upstreamRepository = yield* cli.resolveRepository({
cwd: "/upstream-only",
host: "forgejo.local:3000",
repository: "maria/project",
});
assert.strictEqual(upstreamRepository.baseUrl, "http://forgejo.local:3000");
assert.strictEqual(upstreamRepository.repository, "maria/project");
const httpViewer = yield* cli.api({ cwd: "/repo", host: "forgejo.local:3000", path: "user" });
assert.strictEqual(httpViewer.stdout, '{"login":"maria"}');
assert.strictEqual(requests.at(-1), "http://forgejo.local:3000/api/v1/user");
}).pipe(
Effect.provideService(
FileSystem.FileSystem,
FileSystem.makeNoop({
exists: () => Effect.succeed(true),
readFileString: () =>
Effect.succeed(
encodeJson({
hosts: {
"forgejo.local:3000": { type: "Application", token: "test-token" },
"forgejo.local:4000": { type: "Application", token: "other-token" },
},
aliases: { "ssh.forgejo.local:2222": "forgejo.local:3000" },
}),
),
}),
),
Effect.provideService(
HttpClient.HttpClient,
HttpClient.make((request) => {
requests.push(request.url);
if (request.url.endsWith("/user")) {
assert.strictEqual(request.method, "GET");
assert.strictEqual(request.headers.authorization, "token test-token");
return Effect.succeed(
HttpClientResponse.fromWeb(request, new Response('{"login":"maria"}')),
);
}
assert.strictEqual(request.method, "POST");
assert.strictEqual(request.headers.authorization, "token test-token");
assert.deepStrictEqual(requestJson(request), { body: "verified through fj" });
return Effect.succeed(
HttpClientResponse.fromWeb(request, new Response('{"id":99}', { status: 201 })),
);
}),
),
Effect.provide(
TestSourceControlHost.layer({
process: {
run: (input) => {
commands.push(input.command);
if (input.command === "git") {
repositoryCwd = input.cwd;
return Effect.succeed(
input.cwd === "/no-remotes"
? processOutput("", { exitCode: ChildProcessSpawner.ExitCode(2) })
: processOutput(
input.cwd === "/upstream-only"
? "upstream\thttp://forgejo.local:3000/maria/project.git (fetch) [blob:none]\nother\thttp://forgejo.local:3000/maria/other.git (fetch) [blob:none]\nunrelated\thttp://other.local:3000/maria/project.git (fetch) [blob:none]"
: "origin\thttp://forgejo.local:3000/maria/project.git (fetch)\nother\thttp://forgejo.local:3000/maria/other.git (fetch)\nunrelated\thttp://other.local:3000/maria/project.git (fetch)",
),
);
}
assert.strictEqual(input.command, "fj");
assert.deepStrictEqual(input.args, [
"--host",
repositoryCwd === "/no-remotes"
? "https://forgejo.local:3000"
: "http://forgejo.local:3000",
"whoami",
]);
return Effect.succeed(processOutput(""));
},
},
}),
),
);
});
it.effect("loads later fj review pages when the server caps pages below the requested size", () => {
const pages: number[] = [];
let issueCommentRequests = 0;
return Effect.gen(function* () {
const cli = yield* ForgejoCli.make;
const provider = yield* ForgejoPullRequestProvider.make.pipe(
Effect.provideService(ForgejoCli.ForgejoCli, cli),
);
const activity = yield* provider.getChangeRequestActivity({
cwd: "/repo",
repository: "maria/project",
host: "forgejo.test",
number: 42,
});
assert.strictEqual(activity.commentCount, 42);
assert.strictEqual(activity.comments.at(-1)?.id, "review:41");
assert.strictEqual(activity.commentsTruncated, false);
assert.deepStrictEqual(pages, [1, 2, 3]);
assert.strictEqual(issueCommentRequests, 1);
}).pipe(
Effect.provideService(
FileSystem.FileSystem,
FileSystem.makeNoop({
exists: () => Effect.succeed(true),
readFileString: () =>
Effect.succeed(
encodeJson({ hosts: { "forgejo.test": { type: "Application", token: "test-token" } } }),
),
}),
),
Effect.provideService(
HttpClient.HttpClient,
HttpClient.make((request) => {
const url = new URL(request.url);
if (url.pathname === "/api/v1/repos/maria/project/issues/42/comments") {
issueCommentRequests++;
return Effect.succeed(
HttpClientResponse.fromWeb(
request,
new Response(
encodeJson([
{
id: 100,
body: "Unpaginated issue comment",
user: { login: "maria" },
created_at: "2026-09-13T00:00:00Z",
},
]),
),
),
);
}
if (url.pathname.endsWith("/reviews")) {
const page = Number(url.searchParams.get("page"));
pages.push(page);
assert.ok(page >= 1 && page <= 3);
const reviews = Array.from({ length: page < 3 ? 20 : 1 }, (_, index) => ({
id: (page - 1) * 20 + index + 1,
body: "Review from a capped page",
user: { login: "maria" },
state: "COMMENT",
submitted_at: "2026-09-13T00:00:00Z",
comments_count: 0,
}));
return Effect.succeed(
HttpClientResponse.fromWeb(
request,
new Response(encodeJson(reviews), {
headers:
page === 2
? {}
: {
Link:
page === 1
? `<${url.origin}${url.pathname}?limit=50&page=2>; rel="next"`
: `<${url.origin}${url.pathname}?limit=50&page=1>; rel="prev"`,
},
}),
),
);
}
return Effect.succeed(
HttpClientResponse.fromWeb(
request,
new Response(encodeJson(url.pathname === "/api/v1/user" ? { login: "maria" } : [])),
),
);
}),
),
Effect.provide(
TestSourceControlHost.layer({
process: {
run: (input) => {
if (input.command === "git") {
assert.deepStrictEqual(input.args, ["remote", "-v"]);
return Effect.succeed(
processOutput("origin\thttps://forgejo.test/maria/project.git (fetch)"),
);
}
assert.strictEqual(input.command, "fj");
assert.deepStrictEqual(input.args, ["--host", "https://forgejo.test", "whoami"]);
assert.strictEqual(input.cwd, "/home/maria");
return Effect.succeed(processOutput(""));
},
},
}),
),
Effect.provideService(HostProcess.HomeDirectory, "/home/maria"),
);
});
it.effect("handles fj mutation statuses without retrying failures or reading absent bodies", () =>
Effect.gen(function* () {
for (const status of [204, 205, 302, 401, 403, 404, 429, 500]) {
let writes = 0;
yield* Effect.gen(function* () {
const cli = yield* ForgejoCli.make;
const result = yield* cli
.api({
cwd: "/repo",
repository: "https://forgejo.local/maria/project",
path: "repos/maria/project/issues/42/comments",
method: "POST",
body: { body: "only once" },
})
.pipe(Effect.result);
assert.strictEqual(result._tag, status < 300 ? "Success" : "Failure");
if (result._tag === "Success") assert.strictEqual(result.success.stdout, "");
if (result._tag === "Failure") {
assert.strictEqual(result.failure.command, "fj");
assert.strictEqual(result.failure.httpStatus, status);
}
assert.strictEqual(writes, 1);
}).pipe(
Effect.provideService(
FileSystem.FileSystem,
FileSystem.makeNoop({
exists: () => Effect.succeed(true),
readFileString: () =>
Effect.succeed(
encodeJson({
hosts: {
"forgejo.local": { type: "Application", token: "test-token" },
},
}),
),
}),
),
Effect.provideService(
HttpClient.HttpClient,
HttpClient.make((request) => {
writes++;
assert.strictEqual(
request.url,
"https://forgejo.local/api/v1/repos/maria/project/issues/42/comments",
);
return Effect.succeed(
HttpClientResponse.fromWeb(
request,
new Response(status < 300 ? null : "", {
status,
headers: { location: "https://other.local/" },
}),
),
);
}),
),
Effect.provide(
TestSourceControlHost.layer({
process: {
run: (input) => {
assert.strictEqual(
input.command,
"fj",
"a failed mutation must never switch accounts or CLI",
);
return Effect.succeed(processOutput(""));
},
},
}),
),
);
}
}),
);
it.effect(
"discovers fj first and retains configured authentication failures instead of switching accounts",
() =>
Effect.gen(function* () {
for (const scenario of ["authenticated", "revoked", "missing", "invalid-storage"] as const) {
const commands: string[] = [];
yield* Effect.gen(function* () {
const spec = yield* ForgejoSourceControlProvider.makeDiscovery;
assert.strictEqual(spec.type, "managed-cli");
if (spec.type !== "managed-cli") return;
const result = yield* spec.probe("/repo");
assert.strictEqual(result.executable, scenario === "missing" ? "tea" : "fj");
assert.strictEqual(
result.auth.status,
scenario === "revoked"
? "unauthenticated"
: scenario === "invalid-storage"
? "unknown"
: "authenticated",
);
if (scenario !== "revoked" && scenario !== "invalid-storage")
assert.deepStrictEqual(result.auth.host, Option.some("forgejo.local:3000"));
assert.deepStrictEqual(
result.auth.account,
scenario === "authenticated" || scenario === "missing"
? Option.some("maria")
: Option.none(),
);
assert.strictEqual(
commands.some((command) => command.startsWith("tea ")),
scenario === "missing",
);
assert.include(commands, "fj version");
}).pipe(
Effect.provide(
Layer.mergeAll(
Layer.mock(ForgejoCli.ForgejoCli)({
getAccount: (input) => {
assert.strictEqual(scenario, "authenticated");
assert.deepStrictEqual(input, {