import { assert, describe, it } from "@effect/vitest";
import { Effect } from "effect";
import type { RecordedCall } from "../src/index.js";
import { GitHubClient, GitHubError } from "../src/index.js";
import { Repo, RepoRef } from "../src/Repo.js";
import { RepositorySecurity } from "../src/RepositorySecurity.js";
const run = (
effect: Effect.Effect,
request: Record,
) =>
Effect.gen(function* () {
const requested: RecordedCall[] = [];
const value = yield* effect.pipe(
Effect.provide(RepositorySecurity.layer),
Effect.provide(GitHubClient.layerFixture({ request, requested })),
Effect.provide(Repo.layer(RepoRef.make({ owner: "acme", repo: "widget" }))),
);
return { value, requested };
});
const FEATURES = [
{ setter: "setVulnerabilityAlerts", segment: "vulnerability-alerts" },
{ setter: "setAutomatedSecurityFixes", segment: "automated-security-fixes" },
{ setter: "setPrivateVulnerabilityReporting", segment: "private-vulnerability-reporting" },
] as const;
describe("RepositorySecurity setters", () => {
for (const { setter, segment } of FEATURES) {
it.effect(`${setter}(true) PUTs and (false) DELETEs /${segment}`, () =>
Effect.gen(function* () {
// The HTTP verb IS the value; there is no body either way.
const on = yield* run(
Effect.flatMap(RepositorySecurity, (s) => s[setter](true)),
{ [`PUT /repos/{owner}/{repo}/${segment}`]: {} },
);
assert.strictEqual(on.requested[0]?.route, `PUT /repos/{owner}/{repo}/${segment}`);
assert.deepStrictEqual(on.requested[0]?.params, { owner: "acme", repo: "widget" });
const off = yield* run(
Effect.flatMap(RepositorySecurity, (s) => s[setter](false)),
{ [`DELETE /repos/{owner}/{repo}/${segment}`]: {} },
);
assert.strictEqual(off.requested[0]?.route, `DELETE /repos/{owner}/{repo}/${segment}`);
assert.deepStrictEqual(off.requested[0]?.params, { owner: "acme", repo: "widget" });
}),
);
}
});
describe("RepositorySecurity.vulnerabilityAlerts", () => {
it.effect("reports true when the read succeeds", () =>
Effect.gen(function* () {
const { value, requested } = yield* run(
Effect.flatMap(RepositorySecurity, (s) => s.vulnerabilityAlerts()),
{ "GET /repos/{owner}/{repo}/vulnerability-alerts": {} },
);
// 204, no payload — enabled is the ABSENCE of a 404.
assert.strictEqual(value, true);
assert.deepStrictEqual(requested[0]?.params, { owner: "acme", repo: "widget" });
}),
);
it.effect("reports false on 404, because that is how GitHub says disabled", () =>
Effect.gen(function* () {
const { value } = yield* run(
Effect.flatMap(RepositorySecurity, (s) => s.vulnerabilityAlerts()),
{
"GET /repos/{owner}/{repo}/vulnerability-alerts": GitHubError.notFound("test", "vulnerability alerts"),
},
);
assert.strictEqual(value, false);
}),
);
it.effect("does NOT absorb any other failure", () =>
Effect.gen(function* () {
const error = yield* run(
Effect.flatMap(RepositorySecurity, (s) => s.vulnerabilityAlerts()),
{
// A mis-scoped token is not "disabled". A blanket catch here would
// report a permissions problem as a feature being off, and the sync
// that follows would try to turn it "on" forever.
"GET /repos/{owner}/{repo}/vulnerability-alerts": new GitHubError({
kind: "unauthorized",
operation: "test",
reason: "the token lacks the required scope",
status: 403,
}),
},
).pipe(Effect.flip);
// Assert the failure VALUE, not a serialisation of the Exit. A
// JSON.stringify check depends on the shape of Exit and GitHubError, and
// "unauthorized" appears in the fixture too — so it would pass even if
// the error surfaced with a different kind, which is the whole subject
// of this test.
assert.instanceOf(error, GitHubError);
assert.strictEqual(error.kind, "unauthorized");
}),
);
});
describe("RepositorySecurity flag reads", () => {
for (const [method, segment] of [
["automatedSecurityFixes", "automated-security-fixes"],
["privateVulnerabilityReporting", "private-vulnerability-reporting"],
] as const) {
it.effect(`${method} reads the enabled flag both ways`, () =>
Effect.gen(function* () {
// These two answer 200 with a payload either way — the opposite of
// vulnerability-alerts, and the reason the 404 mapping is not applied
// uniformly.
const on = yield* run(
Effect.flatMap(RepositorySecurity, (s) => s[method]()),
{ [`GET /repos/{owner}/{repo}/${segment}`]: { enabled: true } },
);
assert.strictEqual(on.value, true);
const off = yield* run(
Effect.flatMap(RepositorySecurity, (s) => s[method]()),
{ [`GET /repos/{owner}/{repo}/${segment}`]: { enabled: false } },
);
assert.strictEqual(off.value, false);
// A response with no flag at all is not "enabled".
const missing = yield* run(
Effect.flatMap(RepositorySecurity, (s) => s[method]()),
{ [`GET /repos/{owner}/{repo}/${segment}`]: {} },
);
assert.strictEqual(missing.value, false);
}),
);
}
});