OpenAI's Codex Security CLI and TypeScript SDK for finding, validating, and fixing security vulnerabilities. npm: https://www.npmjs.com/package/@openai/codex-security
TypeScript ai-securityapplication-securityclicode-scanningcodexcodex-securitycybersecuritydevsecopsnodejsnpmopenaisdksecuritytypescriptvulnerability-scanning
import { nodeCommand, gitText } from "./support/shell.js";
import { execFileSync } from "node:child_process";
import {
chmod,
cp,
mkdir,
readFile,
readdir,
rename,
rm,
stat,
symlink,
writeFile,
} from "node:fs/promises";
import { dirname, join, relative } from "node:path";
import { fileURLToPath, pathToFileURL } from "node:url";
import { afterEach, describe, expect, spyOn, test, mock } from "bun:test";
import * as artifactExport from "../src/artifact-export.js";
import {
inspectSecurityPolicySources,
readSecurityPolicy,
resolveSecurityPolicyGuidance,
resolveSecurityPolicyTarget,
securityPolicyDiff,
securityPolicyProtectedRoots,
type SecurityPolicyStage,
} from "../src/security-policy.js";
import { PLUGIN_ROOT } from "./plugin-root.js";
import { preparePersistentOutputRoot } from "../src/runtime.js";
import { runTestInSubprocess } from "./support/test-subprocess.js";
import {
POLICY,
PYTHON,
addPolicySubmodule,
createPolicyTestFixtures,
policyGit,
policyGitDirectory,
stageResult,
} from "./support/security-policy.js";
const { fixture, cleanup } = createPolicyTestFixtures();
afterEach(cleanup);
function createPolicyWorktree(repository: string, root: string, name: string) {
policyGit(repository, "init", "--quiet");
policyGit(repository, "config", "--local", "core.autocrlf", "false");
policyGit(repository, "commit", "--allow-empty", "--quiet", "-m", "initial");
const linked = join(root, name);
policyGit(
repository,
"worktree",
"add",
"--quiet",
"--detach",
linked,
"HEAD",
);
return linked;
}
describe("security policy generation", () => {
test("stores policy drafts separately from scans and rejects linked state children", async () => {
const f = await fixture();
const state = join(f.root, "state");
const directory = await preparePersistentOutputRoot(
state,
"policies",
"sample project",
);
expect(directory).toBe(join(state, "policies", "sample-project"));
if (process.platform !== "win32")
expect((await stat(directory)).mode & 0o777).toBe(0o700);
await symlink(
f.repository,
join(state, "policies", "linked"),
process.platform === "win32" ? "junction" : "dir",
);
await expect(
preparePersistentOutputRoot(state, "policies", "linked"),
).rejects.toThrow("Persistent policy output must use real directories");
expect(await readdir(f.repository)).toEqual([]);
});
test("keeps architecture, threat model, and policy separate and leaves source unchanged", async () => {
const f = await fixture();
const original = "# Existing policy\n\nReport privately.\n";
await writeFile(join(f.repository, "SECURITY.md"), original);
const reportingPolicy = join(f.repository, ".github", "SECURITY.md");
await mkdir(join(f.repository, ".github"));
await symlink("../SECURITY.md", reportingPolicy, "file");
const stages: SecurityPolicyStage[] = [];
const prompts: string[] = [];
const draft = await f.generate({
answerQuestions: async (questions) => {
expect(questions).toEqual(["Is this service internet-facing?"]);
return "Only authenticated clients can reach it.";
},
run: async (stage, prompt) => {
stages.push(stage);
prompts.push(prompt);
if (stage === "threat_model")
expect(
await readFile(join(f.outputDir, "project-spec.md"), "utf8"),
).toContain("src/service.ts:1");
if (stage === "policy")
expect(
await readFile(join(f.outputDir, "threatmodel.md"), "utf8"),
).toContain("src/service.ts:1");
return stageResult(stage);
},
});
expect(stages).toEqual(["architecture", "threat_model", "policy"]);
expect(prompts[0]).toContain("Synthetic inherited guidance");
expect(prompts[1]).toContain("Only authenticated clients can reach it.");
expect(prompts[2]).toContain("Only authenticated clients can reach it.");
expect(await readFile(draft.targetPath, "utf8")).toBe(original);
expect(await readFile(reportingPolicy, "utf8")).toBe(original);
expect(draft.previousContent).toBe(original);
expect(await readFile(draft.draftPath, "utf8")).toBe(POLICY);
if (process.platform !== "win32")
expect((await stat(draft.draftPath)).mode & 0o777).toBe(0o600);
});
test("keeps generated artifacts readable and editable under a restrictive umask", async () => {
if (
runTestInSubprocess(
import.meta.path,
"keeps generated artifacts readable and editable under a restrictive umask",
)
)
return;
const f = await fixture();
const pluginRoot = join(f.root, "plugin");
await cp(PLUGIN_ROOT, pluginRoot, { recursive: true });
await mkdir(join(pluginRoot, "scripts", "__pycache__"), {
recursive: true,
mode: 0o700,
});
const previous = process.umask(0o600);
try {
await f.generate({
pluginRoot,
run: async (stage) => {
if (stage !== "architecture")
expect(
await readFile(join(f.outputDir, "project-spec.md"), "utf8"),
).toContain("src/service.ts:1");
return stageResult(stage);
},
});
} finally {
process.umask(previous);
}
await cp(PLUGIN_ROOT, join(f.root, "following-plugin-copy"), {
recursive: true,
});
for (const name of await readdir(f.outputDir)) {
const path = join(f.outputDir, name);
expect((await stat(path)).mode & 0o600).toBe(0o600);
if (process.platform !== "win32")
expect((await stat(path)).mode & 0o077).toBe(0);
await writeFile(path, await readFile(path));
}
});
test("infers the Git root while keeping a component as the policy scope", async () => {
const f = await fixture();
execFileSync("git", ["init", "--quiet", f.repository]);
const component = join(f.repository, "services", "api");
await mkdir(component, { recursive: true });
await writeFile(
join(f.repository, "SECURITY.md"),
"# Root policy\nRoot invariant.\n",
);
const target = await resolveSecurityPolicyTarget(component);
expect(target).toEqual({
repository: f.repository,
scope: "services/api",
targetPath: join(component, "SECURITY.md"),
});
expect(await resolveSecurityPolicyGuidance(target, PLUGIN_ROOT)).toContain(
"Root invariant.",
);
expect(
await resolveSecurityPolicyTarget(f.repository, "services/api"),
).toEqual(target);
});
test("rejects a nested checkout that is re-rooted after target resolution", async () => {
const f = await fixture();
policyGit(f.repository, "init", "--quiet");
const nested = join(f.repository, "nested");
await mkdir(nested);
policyGit(nested, "init", "--quiet");
const target = await resolveSecurityPolicyTarget(nested);
await rm(join(nested, ".git"), { recursive: true, force: true });
await expect(securityPolicyProtectedRoots(target)).rejects.toThrow(
"Git metadata changed",
);
});
test("does not complete a draft after its Git binding changes during generation", async () => {
const f = await fixture();
policyGit(f.repository, "init", "--quiet");
await expect(
f.generate({
run: async (stage) => {
if (stage === "policy")
await rename(
join(f.repository, ".git"),
join(f.root, "previous-git"),
);
return stageResult(stage);
},
}),
).rejects.toThrow("Git metadata changed");
expect((await readdir(f.outputDir)).sort()).toEqual([
"SECURITY.md",
"policy-draft.json",
"previous-SECURITY.md",
"project-spec.md",
"threatmodel.md",
]);
});
test("rejects Git configuration that redirects the selected checkout", async () => {
for (const indirect of [false, true]) {
for (const location of ["sibling", "ancestor"]) {
const f = await fixture();
const outside = join(f.root, "outside");
await mkdir(outside);
execFileSync("git", [
"init",
"--quiet",
...(indirect ? ["--separate-git-dir", join(f.root, "git-data")] : []),
f.repository,
]);
execFileSync("git", [
"-C",
f.repository,
"config",
"core.worktree",
location === "sibling" ? outside : f.root,
]);
await expect(resolveSecurityPolicyTarget(f.repository)).rejects.toThrow(
"does not match the selected checkout",
);
expect(await readdir(f.outputDir)).toEqual([]);
}
}
});
test("requires a worktree binding for a separate Git directory outside the checkout", async () => {
for (const external of [false, true]) {
const f = await fixture();
const metadata = join(external ? f.root : f.repository, "git-data");
policyGit(
f.repository,
"init",
"--quiet",
"--separate-git-dir",
metadata,
);
if (external) {
await expect(resolveSecurityPolicyTarget(f.repository)).rejects.toThrow(
"core.worktree",
);
policyGit(f.repository, "config", "core.worktree", f.repository);
}
expect(await resolveSecurityPolicyTarget(f.repository)).toEqual({
repository: f.repository,
scope: ".",
targetPath: join(f.repository, "SECURITY.md"),
});
}
});
test("rejects policy targets inside Git metadata", async () => {
for (const kind of ["traditional", "separate", "bare"]) {
const f = await fixture();
const metadata =
kind === "traditional"
? join(f.repository, ".git")
: join(f.root, "git-data");
execFileSync("git", [
"init",
"--quiet",
...(kind === "bare"
? ["--bare", metadata]
: [
...(kind === "separate" ? ["--separate-git-dir", metadata] : []),
f.repository,
]),
]);
const refs = join(metadata, "refs", "heads");
await expect(resolveSecurityPolicyTarget(refs)).rejects.toThrow(
"inside Git metadata",
);
await expect(
resolveSecurityPolicyTarget(metadata, "refs/heads"),
).rejects.toThrow("inside Git metadata");
if (kind === "traditional")
await expect(
resolveSecurityPolicyTarget(f.repository, ".git/refs/heads"),
).rejects.toThrow("inside Git metadata");
expect(await readdir(refs)).toEqual([]);
}
});
test("excludes separately named Git directories from policy discovery", async () => {
for (const nested of [false, true]) {
const f = await fixture();
const checkout = nested ? join(f.repository, "a-checkout") : f.repository;
const metadata = join(f.repository, nested ? "docs" : ".metadata");
if (nested) {
policyGit(f.repository, "init", "--quiet");
await mkdir(checkout);
}
policyGit(checkout, "init", "--quiet", "--separate-git-dir", metadata);
if (nested) policyGit(checkout, "config", "core.worktree", checkout);
await writeFile(join(f.repository, "SECURITY.md"), POLICY);
if (nested) await writeFile(join(checkout, "SECURITY.md"), POLICY);
await writeFile(join(metadata, "SECURITY.md"), "Not policy guidance\n");
await writeFile(
join(metadata, "refs", "heads", "SECURITY.md"),
"Not policy guidance\n",
);
expect(
(
await inspectSecurityPolicySources(
await resolveSecurityPolicyTarget(f.repository),
)
).policyPaths,
).toEqual(
nested ? ["SECURITY.md", "a-checkout/SECURITY.md"] : ["SECURITY.md"],
);
}
});
test.each([
"detached",
"explicit worktree",
"malformed config",
"malformed config in checkout",
])("excludes %s Git metadata without a worktree marker", async (kind) => {
const f = await fixture();
const metadata = join(f.repository, "saved-metadata");
if (kind === "malformed config in checkout")
policyGit(f.repository, "init", "--quiet");
policyGit(f.repository, "init", "--quiet", "--bare", metadata);
policyGit(metadata, "config", "core.bare", "false");
if (kind === "explicit worktree")
policyGit(metadata, "config", "core.worktree", f.repository);
if (kind.startsWith("malformed config"))
await writeFile(join(metadata, "config"), "[malformed config\n");
const originalConfig = await readFile(join(metadata, "config"));
await writeFile(join(f.repository, "SECURITY.md"), POLICY);
await writeFile(join(metadata, "SECURITY.md"), "Git metadata fixture");
const inventory = await inspectSecurityPolicySources(
await resolveSecurityPolicyTarget(f.repository),
);
expect(inventory.policyPaths).toEqual(["SECURITY.md"]);
expect(inventory.gitMetadataPaths).toContain(metadata);
expect(await readFile(join(metadata, "config"))).toEqual(originalConfig);
});
test("excludes copied linked-worktree metadata", async () => {
const f = await fixture();
const linked = createPolicyWorktree(f.repository, f.root, "linked");
const original = policyGitDirectory(linked);
const archived = join(f.repository, "archived-admin");
const common = join(f.repository, "shared-data");
await cp(join(f.repository, ".git"), common, { recursive: true });
await rm(join(common, "HEAD"));
await cp(original, archived, { recursive: true });
await writeFile(join(archived, "commondir"), `${common}\r\n`);
await writeFile(join(archived, "SECURITY.md"), "Git metadata fixture");
await writeFile(join(common, "SECURITY.md"), "Shared Git metadata fixture");
const inventory = await inspectSecurityPolicySources(
await resolveSecurityPolicyTarget(f.repository),
);
expect(inventory.policyPaths).toEqual([]);
expect(inventory.gitMetadataPaths).toContain(archived);
expect(inventory.gitMetadataPaths).toContain(common);
});
test("keeps source with Git-like names in the policy inventory", async () => {
const f = await fixture();
await writeFile(join(f.repository, "HEAD"), "Ordinary source\n");
await mkdir(join(f.repository, "objects"));
await mkdir(join(f.repository, "refs"));
await writeFile(join(f.repository, "objects", "SECURITY.md"), POLICY);
const inventory = await inspectSecurityPolicySources(
await resolveSecurityPolicyTarget(f.repository),
);
expect(inventory.policyPaths).toEqual(["objects/SECURITY.md"]);
expect(inventory.gitMetadataPaths).toEqual([]);
});
test.skipIf(process.platform === "win32" || process.getuid?.() === 0)(
"inventories policies when an unrelated leaf directory only permits listing",
async () => {
const f = await fixture();
policyGit(f.repository, "init", "--quiet");
const leaf = join(f.repository, "data");
await mkdir(leaf);
await writeFile(join(leaf, "sample.txt"), "fixture\n");
await writeFile(join(f.repository, "SECURITY.md"), POLICY);
const target = await resolveSecurityPolicyTarget(f.repository);
try {
await chmod(leaf, 0o400);
expect(
(await inspectSecurityPolicySources(target)).policyPaths,
).toEqual(["SECURITY.md"]);
await chmod(leaf, 0o700);
await writeFile(join(leaf, "SECURITY.md"), POLICY);
await chmod(leaf, 0o400);
await expect(
inspectSecurityPolicySources(target),
).rejects.toMatchObject({
code: "EACCES",
});
} finally {
await chmod(leaf, 0o700);
}
},
);
test.skipIf(process.platform !== "linux")(
"keeps a tracked policy distinct from an ignored non-UTF-8 filename",
async () => {
const f = await fixture();
policyGit(f.repository, "init", "--quiet");
const directory = "dependency-\uFFFD";
const policy = `${directory}/SECURITY.md`;
await mkdir(join(f.repository, directory));
await writeFile(join(f.repository, policy), POLICY);
policyGit(f.repository, "add", "--", policy);
await writeFile(join(f.repository, ".gitignore"), "dependency-*\n");
const ignored = Buffer.concat([
Buffer.from(join(f.repository, "dependency-")),
Buffer.from([0xff]),
]);
await writeFile(ignored, "ignored file\n");
try {
const inventory = await inspectSecurityPolicySources(
await resolveSecurityPolicyTarget(f.repository),
);
expect(inventory.policyPaths).toEqual([policy]);
} finally {
await rm(ignored);
}
},
);
test("leaves Git-ignored dependencies out of the policy inventory", async () => {
const f = await fixture();
policyGit(f.repository, "init", "--quiet");
await writeFile(
join(f.repository, ".gitignore"),
"/SECURITY.md\nnode_modules/\n.venv/\n",
);
await writeFile(join(f.repository, "SECURITY.md"), POLICY);
for (const directory of [
"node_modules/dependency",
"node_modules/tracked",
".venv/src/dependency",
"services/api",
]) {
await mkdir(join(f.repository, directory), { recursive: true });
await writeFile(join(f.repository, directory, "SECURITY.md"), POLICY);
}
policyGit(join(f.repository, ".venv/src/dependency"), "init", "--quiet");
policyGit(f.repository, "add", "--force", "node_modules/tracked");
const inventory = await inspectSecurityPolicySources(
await resolveSecurityPolicyTarget(f.repository),
);
expect(inventory.policyPaths).toEqual([
"SECURITY.md",
"node_modules/tracked/SECURITY.md",
"services/api/SECURITY.md",
]);
const selectedDependency = await inspectSecurityPolicySources(
await resolveSecurityPolicyTarget(
f.repository,
"node_modules/dependency",
),
);
expect(selectedDependency.policyPaths).toEqual([
"node_modules/dependency/SECURITY.md",
]);
});
test("recognizes shared Git storage without HEAD during policy discovery", async () => {
const f = await fixture();
const metadata = join(f.repository, "shared-data");
policyGit(f.repository, "init", "--quiet", "--bare", metadata);
await rm(join(metadata, "HEAD"));
const inventory = await inspectSecurityPolicySources(
await resolveSecurityPolicyTarget(f.repository),
);
expect(inventory.gitMetadataPaths).toContain(metadata);
expect(inventory.policyPaths).toEqual([]);
});
test("keeps ordinary source with config, objects and refs directories", async () => {
const f = await fixture();
await writeFile(join(f.repository, "config"), "[app]\nname = example\n");
await mkdir(join(f.repository, "objects"));
await mkdir(join(f.repository, "refs"));
await writeFile(join(f.repository, "objects", "SECURITY.md"), POLICY);
const inventory = await inspectSecurityPolicySources(
await resolveSecurityPolicyTarget(f.repository),
);
expect(inventory.policyPaths).toEqual(["objects/SECURITY.md"]);
expect(inventory.gitMetadataPaths).toEqual([]);
});
test("protects relative and recursive alternate Git object stores", async () => {
const f = await fixture();
policyGit(f.repository, "init", "--quiet");
const primary = join(f.repository, ".git", "objects");
const first = join(f.repository, "object-cache-\u00e9");
const second = join(f.root, "shared-object-cache");
for (const directory of [first, second]) {
await mkdir(join(directory, "info"), { recursive: true });
await mkdir(join(directory, "pack"));
}
await writeFile(
join(primary, "info", "alternates"),
`# Shared object storage\nmissing-store\n${relative(primary, first)}\n`,
);
await writeFile(join(first, "info", "alternates"), `${second}\n`);
await writeFile(join(second, "info", "alternates"), `${first}\n`);
await writeFile(join(first, "SECURITY.md"), "Object-store fixture\n");
const target = await resolveSecurityPolicyTarget(f.repository);
const inventory = await inspectSecurityPolicySources(target);
expect(inventory.gitMetadataPaths).toContain(first);
expect(inventory.gitMetadataPaths).toContain(second);
expect(inventory.policyPaths).toEqual([]);
expect(await securityPolicyProtectedRoots(target)).toEqual(
expect.arrayContaining([first, second]),
);
});
test.each([
"object store",
"object-\u00e9",
...(process.platform === "win32"
? []
: [
"object\nstore",
"object\tstore",
'object"store',
"object\\001",
"object\u0001",
"object\u0007",
"object\u000b",
]),
])("preserves alternate Git object-store path %j", async (name) => {
const f = await fixture();
policyGit(f.repository, "init", "--quiet");
const alternate = join(f.repository, name);
await mkdir(join(alternate, "info"), { recursive: true });
await mkdir(join(alternate, "pack"));
const quoted = JSON.stringify(alternate)
.replaceAll("\u00e9", "\\303\\251")
.replace(/\\u00([0-9a-f]{2})/gu, (_escape, hex: string) =>
hex === "07"
? "\\a"
: hex === "0b"
? "\\v"
: `\\${Number.parseInt(hex, 16).toString(8).padStart(3, "0")}`,
);
await writeFile(
join(f.repository, ".git", "objects", "info", "alternates"),
`${quoted}\n`,
);
const listed = gitText(["-C", f.repository, "count-objects", "--verbose"]);
expect(
listed.split("\n").filter((line) => line.startsWith("alternate: ")),
).toHaveLength(1);
if (name.includes("\\")) {
// Bun's POSIX realpath misreads backslashes; verify the supported Node runtime.
const build = await Bun.build({
entrypoints: [
fileURLToPath(new URL("../src/targets.ts", import.meta.url)),
],
target: "node",
format: "esm",
});
expect(build.success).toBe(true);
const module = join(f.root, "targets.mjs");
await writeFile(module, await build.outputs[0]!.text());
const output = execFileSync(
"node",
[
"--input-type=module",
"--eval",
`import { gitObjectDirectories } from ${JSON.stringify(pathToFileURL(module).href)}; console.log(JSON.stringify(await gitObjectDirectories([${JSON.stringify(join(f.repository, ".git"))}])));`,
],
{ encoding: "utf8" },
);
expect(JSON.parse(output)).toContain(alternate);
return;
}
const target = await resolveSecurityPolicyTarget(f.repository);
expect(
(await inspectSecurityPolicySources(target)).gitMetadataPaths,
).toContain(alternate);
});
test.each(["bare", "headless", "archived"])(
"protects alternate object stores for nested %s metadata",
async (kind) => {
const f = await fixture();
const metadata = join(f.repository, "metadata");
const alternate = join(f.repository, "zz-object-cache");
policyGit(f.repository, "init", "--quiet", "--bare", metadata);
if (kind === "archived") {
const administrative = join(f.repository, "archived-admin");
await mkdir(administrative);
await writeFile(
join(administrative, "HEAD"),
await readFile(join(metadata, "HEAD")),
);
await writeFile(join(administrative, "commondir"), `${metadata}\n`);
}
if (kind !== "bare") await rm(join(metadata, "HEAD"));
await mkdir(join(alternate, "info"), { recursive: true });
await mkdir(join(alternate, "pack"));
await writeFile(
join(metadata, "objects", "info", "alternates"),
`${alternate}\n`,
);
await writeFile(join(alternate, "SECURITY.md"), "Object-store fixture\n");
const inventory = await inspectSecurityPolicySources(
await resolveSecurityPolicyTarget(f.repository),
);
expect(inventory.gitMetadataPaths).toContain(alternate);
expect(inventory.policyPaths).toEqual([]);
},
);
test.each(["worktree", "headless"])(
"protects a relocated primary Git object store for %s metadata",
async (kind) => {
const f = await fixture();
const metadata = join(
f.repository,
kind === "worktree" ? ".git" : "metadata",
);
if (kind === "worktree") policyGit(f.repository, "init", "--quiet");
else {
policyGit(f.repository, "init", "--quiet", "--bare", metadata);
await rm(join(metadata, "HEAD"));
}
const primary = join(metadata, "objects");
const relocated = join(f.repository, "object-cache");
await rename(primary, relocated);
await symlink(
relocated,
primary,
process.platform === "win32" ? "junction" : "dir",
);
const target = await resolveSecurityPolicyTarget(f.repository);
expect(
(await inspectSecurityPolicySources(target)).gitMetadataPaths,
).toContain(relocated);
if (kind === "worktree")
expect(await securityPolicyProtectedRoots(target)).toContain(relocated);
},
);
test("keeps linked worktrees and submodules as their own policy roots", async () => {
const f = await fixture();
const linked = createPolicyWorktree(
f.repository,
f.root,
"linked-worktree",
);
await mkdir(join(linked, "component"));
expect(
await resolveSecurityPolicyTarget(join(linked, "component")),
).toEqual({
repository: linked,
scope: "component",
targetPath: join(linked, "component", "SECURITY.md"),
});
const linkedMetadata = policyGitDirectory(linked);
const backlink = join(linkedMetadata, "gitdir");
const originalBacklink = await readFile(backlink);
await writeFile(
backlink,
`${relative(linkedMetadata, join(linked, ".git"))}\n`,
);
expect((await resolveSecurityPolicyTarget(linked)).repository).toBe(linked);
await writeFile(backlink, originalBacklink);
const submodule = await addPolicySubmodule(
f.repository,
join(f.root, "submodule-source"),
);
await writeFile(join(f.repository, "SECURITY.md"), "# Parent policy\n");
await writeFile(join(submodule, "SECURITY.md"), "# Submodule policy\n");
const direct = await resolveSecurityPolicyTarget(submodule);
expect(direct).toEqual({
repository: submodule,
scope: ".",
targetPath: join(submodule, "SECURITY.md"),
});
expect(
await resolveSecurityPolicyTarget(f.repository, "services/api"),
).toEqual(direct);
const guidance = await resolveSecurityPolicyGuidance(direct, PLUGIN_ROOT);
expect(guidance).toContain("Submodule policy");
expect(guidance).not.toContain("Parent policy");
await mkdir(join(submodule, "component"));
expect(
await resolveSecurityPolicyTarget(f.repository, "services/api/component"),
).toEqual({
repository: submodule,
scope: "component",
targetPath: join(submodule, "component", "SECURITY.md"),
});
});
test("does not silently drop inherited policies when Git is unavailable", async () => {
const name =
"does not silently drop inherited policies when Git is unavailable";
if (runTestInSubprocess(import.meta.path, name)) return;
const checkout = await fixture();
const standalone = await fixture();
execFileSync("git", ["init", "--quiet", checkout.repository]);
policyGit(
standalone.repository,
"init",
"--quiet",
"--bare",
join(standalone.repository, "cache.git"),
);
const component = join(checkout.repository, "component");
await mkdir(component);
await writeFile(join(checkout.repository, "SECURITY.md"), POLICY);
const pathEntries = Object.entries(process.env).filter(
([key]) => key.toUpperCase() === "PATH",
);
try {
for (const [key] of pathEntries) delete process.env[key];
process.env["PATH"] = "";
await expect(resolveSecurityPolicyTarget(component)).rejects.toThrow(
"Could not determine the Git worktree root",
);
const target = await resolveSecurityPolicyTarget(standalone.repository);
expect(target.repository).toBe(standalone.repository);
await expect(inspectSecurityPolicySources(target)).rejects.toThrow(
"Git is not available on a trusted PATH",
);
} finally {
delete process.env["PATH"];
for (const [key, value] of pathEntries) process.env[key] = value;
}
});
test("asks every material owner question in groups of at most three", async () => {
const f = await fixture();
const questions = [
"Which endpoints are public?",
"Who can deploy the service?",
"Who can read backups?",
"Which operators are trusted?",
"Are tenants isolated?",
"Who controls the identity provider?",
"Which data needs retention limits?",
];
const batches: string[][] = [];
const draft = await f.generate({
answerQuestions: async (batch) => {
batches.push([...batch]);
return ["yes", undefined, "no"][batches.length - 1];
},
run: async (stage, prompt) => {
if (stage === "architecture")
return { ...stageResult(stage), questions };
for (const question of questions) expect(prompt).toContain(question);
expect(prompt).toContain(
JSON.stringify([
{ questions: questions.slice(0, 3), answer: "yes" },
{ questions: questions.slice(6), answer: "no" },
]),
);
return stageResult(stage);
},
});
expect(batches).toEqual([
questions.slice(0, 3),
questions.slice(3, 6),
questions.slice(6),
]);
for (const question of questions)
expect(draft.reviewNotes).toContain(question);
});
test("carries unanswered questions and review decisions into the final policy", async () => {
const f = await fixture();
const draft = await f.generate({
run: async (stage, prompt) => {
if (stage === "architecture") {
return {
...stageResult(stage),
questions: ["Who can deploy the service?"],
reviewNotes: ["Confirm the operator trust boundary."],
};
}
expect(prompt).toContain("Who can deploy the service?");
expect(prompt).toContain("Confirm the operator trust boundary.");
if (stage === "threat_model") {
return {
...stageResult(stage),
questions: ["Are backups isolated by tenant?"],
reviewNotes: ["Review backup access."],
};
}
expect(prompt).toContain("Are backups isolated by tenant?");
expect(prompt).toContain("Review backup access.");
return {
...stageResult(stage),
questions: ["Confirm backup isolation."],
reviewNotes: [
"Review deployment scope.",
"Confirm backup isolation.",
],
};
},
});
expect(draft.reviewNotes).toEqual([
"Review deployment scope.",
"Confirm backup isolation.",
"Confirm the operator trust boundary.",
"Who can deploy the service?",
"Review backup access.",
"Are backups isolated by tenant?",
]);
expect(
JSON.parse(await readFile(join(f.outputDir, "policy-draft.json"), "utf8"))
.reviewNotes,
).toEqual(draft.reviewNotes);
});
test("rejects files, outside paths, and outside directory links", async () => {
const f = await fixture();
await writeFile(join(f.repository, "source.ts"), "export {};\n");
await symlink(
f.outputDir,
join(f.repository, "external"),
process.platform === "win32" ? "junction" : "dir",
);
await expect(
resolveSecurityPolicyTarget(f.repository, "source.ts"),
).rejects.toThrow("must be a directory");
await expect(
resolveSecurityPolicyTarget(f.repository, ".."),
).rejects.toThrow("outside the repository");
await expect(
resolveSecurityPolicyTarget(f.repository, "external"),
).rejects.toThrow("outside the repository");
});
test("retains completed evidence when a later stage is interrupted", async () => {
const f = await fixture();
const controller = new AbortController();
await expect(
f.generate({
signal: controller.signal,
run: async (stage) => {
if (stage === "threat_model") controller.abort(new Error("stop"));
return stageResult(stage);
},
}),
).rejects.toThrow("stop");
expect(
await readFile(join(f.outputDir, "project-spec.md"), "utf8"),
).toContain("src/service.ts:1");
expect(await readdir(f.repository)).toEqual([]);
expect(await readdir(f.outputDir)).not.toContain("policy-draft.json");
});
test("retains the canonical model before a later policy failure", async () => {
const f = await fixture();
policyGit(f.repository, "init", "--quiet");
await expect(
f.generate({
run: async (stage) => {
if (stage === "policy") {
const checkpoint = JSON.parse(
await readFile(join(f.outputDir, "policy-draft.json"), "utf8"),
);
expect(checkpoint.status).toBe("threat_model_ready");
expect(checkpoint.threatModel).toEqual({
format: "markdown",
content: stageResult("threat_model").markdown,
scope: { includePaths: ["."], excludePaths: [] },
origin: "generated",
});
throw new Error("Synthetic policy failure");
}
return stageResult(stage);
},
}),
).rejects.toThrow("Synthetic policy failure");
const checkpoint = JSON.parse(
await readFile(join(f.outputDir, "policy-draft.json"), "utf8"),
);
expect(checkpoint.threatModel.content).toBe(
stageResult("threat_model").markdown,
);
expect(
await readFile(join(f.outputDir, "threatmodel.md"), "utf8"),
).toContain(stageResult("threat_model").markdown);
});
test("preserves a valid model returned by a blocked threat-model stage", async () => {
const f = await fixture();
policyGit(f.repository, "init", "--quiet");
await expect(
f.generate({
run: async (stage) => ({
...stageResult(stage),
...(stage === "threat_model"
? { blockedReason: "Synthetic unavailable deployment evidence" }
: {}),
}),
}),
).rejects.toThrow("Synthetic unavailable deployment evidence");
const saved = JSON.parse(
await readFile(join(f.outputDir, "policy-draft.json"), "utf8"),
);
expect(saved.status).toBe("blocked");
expect(saved.threatModel.content).toBe(
stageResult("threat_model").markdown,
);
expect(
await readFile(join(f.outputDir, "threatmodel.md"), "utf8"),
).toContain(stageResult("threat_model").markdown);
expect(await readdir(f.outputDir)).not.toContain("SECURITY.md");
});
test("finishes a policy when its optional model document cannot be written", async () => {
const f = await fixture();
policyGit(f.repository, "init", "--quiet");
const warnings: string[] = [];
const draft = await f.generate({
onWarning: (warning) => warnings.push(warning),
run: async (stage, prompt) => {
if (stage === "threat_model")
await mkdir(join(f.outputDir, "threatmodel.md"));
if (stage === "policy") expect(prompt).toContain("policy-draft.json");
return stageResult(stage);
},
});
expect(draft.threatModelPath).toBeNull();
expect(draft.threatModel).toMatchObject({
format: "markdown",
content: stageResult("threat_model").markdown,
});
expect(draft.content).toBe(POLICY);
expect(warnings.length).toBeGreaterThan(0);
for (const warning of warnings) {
expect(warning).toStartWith("Automatic threat model save failed:");
expect(warning).toContain("--artifact threat-model");
}
const saved = JSON.parse(
await readFile(join(f.outputDir, "policy-draft.json"), "utf8"),
);
expect(saved.status).toBe("completed");
expect(saved.threatModel).toEqual(draft.threatModel);
});
for (const outcome of ["cancellation", "write failure"] as const) {
const name = `handles ${outcome} during the final policy model save`;
test(name, async () => {
if (runTestInSubprocess(import.meta.path, name)) return;
const f = await fixture();
policyGit(f.repository, "init", "--quiet");
const controller = new AbortController();
const original = artifactExport.writeThreatModel;
let writes = 0;
const writer = spyOn(
artifactExport,
"writeThreatModel",
).mockImplementation(async (...args) => {
if (++writes === 1) return original(...args);
if (outcome === "cancellation") {
controller.abort(new Error("Synthetic final-save cancellation"));
throw controller.signal.reason;
}
return "Synthetic final projection failure";
});
try {
const generation = f.generate({ signal: controller.signal });
if (outcome === "cancellation")
await expect(generation).rejects.toThrow(
"Synthetic final-save cancellation",
);
else {
const draft = await generation;
expect(draft.threatModelPath).toBeNull();
expect(draft.threatModel.content).toBe(
stageResult("threat_model").markdown,
);
}
expect(writes).toBe(2);
expect(
await readFile(join(f.outputDir, "threatmodel.md"), "utf8"),
).toContain("provisional");
const saved = JSON.parse(
await readFile(join(f.outputDir, "policy-draft.json"), "utf8"),
);
expect(saved.threatModel.content).toBe(
stageResult("threat_model").markdown,
);
} finally {
writer.mockRestore();
}
});
}
test("retains completed evidence without saving invalid policy documents", async () => {
for (const markdown of ["", " \n\t", "# Policy\n\ud800"]) {
const f = await fixture();
await expect(
f.generate({
run: async (stage) => stageResult(stage, markdown),
}),
).rejects.toThrow();
expect(await readdir(f.repository)).toEqual([]);
expect((await readdir(f.outputDir)).sort()).toEqual([
"policy-draft.json",
"previous-SECURITY.md",
"project-spec.md",
"threatmodel.md",
]);
}
});
test.each([".", "component"])(
"reads and generates policies larger than 1 MiB at %s",
async (scope) => {
const f = await fixture();
const directory = join(f.repository, scope);
await mkdir(directory, { recursive: true });
const target = join(directory, "SECURITY.md");
const previous = `# Existing policy\n${"é".repeat(1024 * 1024)}\n`;
const proposed = `# Proposed policy\n${"λ".repeat(1024 * 1024)}\n`;
await writeFile(target, previous);
expect(await readSecurityPolicy(target)).toBe(previous);
const draft = await f.generate({
path: scope,
run: async (stage) => stageResult(stage, proposed),
});
expect(draft.previousContent).toBe(previous);
expect(
await readFile(join(f.outputDir, "previous-SECURITY.md"), "utf8"),
).toBe(previous);
expect(draft.content).toBe(proposed);
expect(await readFile(draft.draftPath, "utf8")).toBe(proposed);
expect(await readSecurityPolicy(target)).toBe(previous);
},
);
test.each(["architecture", "threat_model"] as const)(
"rejects malformed Unicode in %s evidence before saving it",
async (invalidStage) => {
const f = await fixture();
const stages = mock(async (stage: SecurityPolicyStage) => {
return {
...stageResult(stage),
...(stage === invalidStage ? { markdown: "# Evidence\n\ud800" } : {}),
};
});
await expect(
f.generate({
run: stages,
}),
).rejects.toThrow("valid Unicode");
expect(stages.mock.calls.map(([value]) => value).at(-1)).toBe(
invalidStage,
);
expect((await readdir(f.outputDir)).sort()).toEqual(
invalidStage === "architecture"
? ["previous-SECURITY.md"]
: ["previous-SECURITY.md", "project-spec.md"],
);
expect(await readdir(f.repository)).toEqual([]);
},
);
test("preserves supporting evidence larger than 1 MiB", async () => {
const f = await fixture();
const document = `# Evidence\n${"x".repeat(1024 * 1024)}`;
const draft = await f.generate({
run: async (stage) => ({
...stageResult(stage),
...(stage === "policy" ? {} : { markdown: document }),
}),
});
expect(await readFile(draft.specificationPath, "utf8")).toBe(document);
expect(await readFile(draft.threatModelPath!, "utf8")).toStartWith(
document,
);
expect(draft.threatModel).toMatchObject({
format: "markdown",
content: document,
});
expect(draft.content).toBe(POLICY);
});
});
describe("security policy preview", () => {
test("accepts policy Markdown without a hash-style heading", async () => {
for (const content of [
"Security policy\n===============\n\nReport vulnerabilities privately.\n",
"Report vulnerabilities privately.\n",
]) {
const f = await fixture();
const draft = await f.generate({
run: async (stage) => stageResult(stage, content),
});
expect(draft.content).toBe(content);
expect(await readFile(draft.draftPath, "utf8")).toBe(content);
expect(await securityPolicyDiff(draft, PYTHON)).toContain(
"+Report vulnerabilities privately.",
);
expect(await readdir(f.repository)).toEqual([]);
}
});
test("previews the exact proposed policy without changing source", async () => {
const f = await fixture();
const draft = await f.generate();
const diff = await securityPolicyDiff(draft, PYTHON);
expect(diff).toContain("--- /dev/null\n+++ b/SECURITY.md\n");
expect(diff).toContain("+Requests must be authorized");
expect(await readdir(f.repository)).toEqual([]);
});
test.each([null, "", "# Old policy\n"])(
"preserves missing and empty policy behavior (%j)",
async (before) => {
const f = await fixture();
if (before !== null)
await writeFile(join(f.repository, "SECURITY.md"), before);
const draft = await f.generate();
const diff = await securityPolicyDiff({ ...draft, content: "" });
expect(diff).toBe(
before
? "--- a/SECURITY.md\n+++ b/SECURITY.md\n@@ -1 +0,0 @@\n-# Old policy\n"
: "",
);
if (before === "") {
expect(await securityPolicyDiff(draft)).toStartWith(
"--- a/SECURITY.md\n+++ b/SECURITY.md\n",
);
}
expect(await readSecurityPolicy(draft.targetPath)).toBe(before);
},
);
test("rejects preview after a component changes Git roots", async () => {
for (const change of ["add", "remove"] as const) {
const f = await fixture();
policyGit(f.repository, "init", "--quiet");
const component = join(f.repository, "component");
await mkdir(component);
if (change === "remove") policyGit(component, "init", "--quiet");
const draft = await f.generate({ path: "component" });
if (change === "add") policyGit(component, "init", "--quiet");
else await rename(join(component, ".git"), join(f.root, "previous-git"));
await expect(securityPolicyDiff(draft, PYTHON)).rejects.toThrow(
"destination changed",
);
expect(await readSecurityPolicy(draft.targetPath)).toBe(null);
}
});
test("shows missing final newlines in the exact diff", async () => {
const f = await fixture();
await writeFile(join(f.repository, "SECURITY.md"), "# Old policy");
const draft = await f.generate({
run: async (stage) => stageResult(stage, "# New policy"),
});
const diff = await securityPolicyDiff(draft, PYTHON);
expect(diff).toContain("-# Old policy\n\\ No newline at end of file\n");
expect(diff).toContain("+# New policy\n\\ No newline at end of file\n");
});
test("keeps non-LF separators inside their original diff lines", async () => {
const f = await fixture();
const before = "Old\rpolicy\u0085with\u2028separators\u2029";
const after = "New\rpolicy\u0085with\u2028separators\u2029";
await writeFile(join(f.repository, "SECURITY.md"), before);
const draft = await f.generate({
run: async (stage) => stageResult(stage, after),
});
const diff = await securityPolicyDiff(draft, PYTHON);
expect(diff).toContain("@@ -1 +1 @@\n");
expect(diff).toContain(`-${before}\n\\ No newline at end of file\n`);
expect(diff).toContain(`+${after}\n\\ No newline at end of file\n`);
expect(diff.match(/No newline at end of file/gu)).toHaveLength(2);
});
test("previews with Python unavailable in a Node process", async () => {
const f = await fixture();
const draft = await f.generate();
const source = new URL("../src/security-policy.ts", import.meta.url);
const module = join(f.root, "policy.mjs");
// Repeated in-process Bun builds can misread dependency files on macOS.
execFileSync(process.execPath, [
"build",
fileURLToPath(source),
"--target=node",
"--format=esm",
"--define",
`import.meta.url=${JSON.stringify(source.href)}`,
`--outfile=${module}`,
]);
const missingPython = join(f.root, "missing-python");
const result = JSON.parse(
execFileSync(
nodeCommand().command,
[
"--input-type=module",
"--eval",
`
import { readFileSync } from "node:fs";
const { securityPolicyDiff } = await import(process.argv[1]);
const draft = JSON.parse(readFileSync(0, "utf8"));
const defaultDiff = await securityPolicyDiff(draft);
const explicitDiff = await securityPolicyDiff(draft, process.env.PYTHON);
console.log(JSON.stringify({ defaultDiff, explicitDiff }));`,
pathToFileURL(module).href,
],
{
encoding: "utf8",
input: JSON.stringify(draft),
env: {
...process.env,
PATH: "",
PYTHON: missingPython,
CODEX_SECURITY_PYTHON_COMMAND: missingPython,
},
timeout: 20_000,
},
),
);
expect(result.defaultDiff).toContain("--- /dev/null\n+++ b/SECURITY.md\n");
expect(result.explicitDiff).toBe(result.defaultDiff);
expect(await readdir(f.repository)).toEqual([]);
});
test("awaits explicit legacy resolvers and propagates their errors", async () => {
const f = await fixture();
const draft = await f.generate();
const resolver = mock(async () => join(f.root, "missing-python"));
expect(await securityPolicyDiff(draft, resolver)).toBe(
await securityPolicyDiff(draft),
);
expect(resolver).toHaveBeenCalledTimes(1);
const failure = new Error("Synthetic resolver failure");
await expect(
securityPolicyDiff(draft, async () => {
throw failure;
}),
).rejects.toBe(failure);
});
test("honors cancellation supplied through the public diff API", async () => {
const f = await fixture();
const draft = await f.generate();
const controller = new AbortController();
const reason = new Error("Preview cancelled");
await expect(
securityPolicyDiff(
draft,
async () => {
controller.abort(reason);
return "unused-python";
},
controller.signal,
),
).rejects.toBe(reason);
});
test("preserves UTF-8 text and CRLF content", async () => {
const f = await fixture();
await writeFile(
join(f.repository, "SECURITY.md"),
"# Policy\r\n\r\nOld naïve 🔒\r\n",
);
const draft = await f.generate({
run: async (stage) => stageResult(stage, "# Policy\r\n\r\nNew π 🛡️\r\n"),
});
const diff = await securityPolicyDiff(draft, PYTHON);
expect(diff).toContain("--- a/SECURITY.md\n+++ b/SECURITY.md\n");
expect(diff).toContain("-Old naïve 🔒\r\n");
expect(diff).toContain("+New π 🛡️\r\n");
expect(diff).not.toContain("\r\r\n");
});
test.skipIf(process.platform === "win32")(
"quotes control characters in repository-controlled diff labels",
async () => {
const f = await fixture();
const scope = "component\n+++ forged\tname";
await mkdir(join(f.repository, scope));
const draft = await f.generate({ path: scope });
const diff = await securityPolicyDiff(draft, PYTHON);
expect(diff).toContain(
`+++ ${JSON.stringify(`b/${scope}/SECURITY.md`)}\n`,
);
expect(diff).not.toContain("\n+++ forged");
expect(diff).not.toContain("\tname");
},
);
test("escapes every Unicode direction control in diff labels", async () => {
const f = await fixture();
const controls =
"\u061c\u200e\u200f\u202a\u202b\u202c\u202d\u202e\u2066\u2067\u2068\u2069";
const scope = `component${controls}name`;
await mkdir(join(f.repository, scope));
const draft = await f.generate({ path: scope });
const diff = await securityPolicyDiff(draft, PYTHON);
expect(diff).not.toMatch(/\p{Bidi_Control}/u);
for (const character of controls)
expect(diff).toContain(
`\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`,
);
});
test("checks source freshness even for an unchanged draft", async () => {
const f = await fixture();
await writeFile(join(f.repository, "SECURITY.md"), POLICY);
const draft = await f.generate();
expect(
await securityPolicyDiff(draft, async () => {
throw new Error("An unchanged preview must not resolve Python");
}),
).toBe("");
await writeFile(draft.targetPath, "# Concurrent policy\n");
await expect(securityPolicyDiff(draft, PYTHON)).rejects.toThrow(
"changed after",
);
});
test("rejects changes made while preparing a policy diff", async () => {
for (const changed of ["target", "inherited"]) {
const f = await fixture();
await mkdir(join(f.repository, "component"));
const rootPolicy = join(f.repository, "SECURITY.md");
await writeFile(rootPolicy, "# Original root policy\n");
const draft = await f.generate({ path: "component" });
await expect(
securityPolicyDiff(draft, async () => {
await writeFile(
changed === "target" ? draft.targetPath : rootPolicy,
"# Concurrent policy\n",
);
return PYTHON;
}),
).rejects.toThrow("changed after");
}
});
test("invalidates component previews when inherited policies change", async () => {
for (const change of ["edit", "add", "remove"] as const) {
const f = await fixture();
const component = join(f.repository, "services", "api");
const rootPolicy = join(f.repository, "SECURITY.md");
await mkdir(component, { recursive: true });
await writeFile(rootPolicy, "# Root policy\n");
if (change === "edit")
await writeFile(join(component, "SECURITY.md"), POLICY);
const draft = await f.generate({ path: "services/api" });
if (change === "edit") await writeFile(rootPolicy, "# New root policy\n");
else if (change === "add")
await writeFile(
join(f.repository, "services", "SECURITY.md"),
"# New intermediate policy\n",
);
else await rm(rootPolicy);
await expect(securityPolicyDiff(draft, "missing-python")).rejects.toThrow(
"inherited SECURITY.md changed",
);
expect(await readSecurityPolicy(draft.targetPath)).toBe(
draft.previousContent,
);
}
});
test("rejects inherited aliases that would widen the policy scope", async () => {
for (const [ancestor, existing, chained, name] of [
[".", false, false, "SECURITY.md"],
[".", true, false, "SECURITY.md"],
["services", true, true, "SECURITY.md"],
["services", false, true, "\u017fECURITY.md"],
] as const) {
const f = await fixture();
const component = join(f.repository, "services", "api");
await mkdir(component, { recursive: true });
if (existing)
await writeFile(join(component, "SECURITY.md"), "# Original policy\n");
let destination = join(component, name);
if (chained) {
const intermediate = join(f.repository, "policy-link.md");
await symlink(destination, intermediate, "file");
destination = intermediate;
}
await symlink(
destination,
join(f.repository, ancestor, "SECURITY.md"),
"file",
);
await expect(f.generate({ path: "services/api" })).rejects.toThrow(
"outside the selected component",
);
expect(await readdir(f.outputDir)).toEqual([]);
}
});
test("tracks safe inherited policy links and rejects outside links", async () => {
const f = await fixture();
const linkedPolicy = join(f.repository, ".github", "SECURITY.md");
await mkdir(dirname(linkedPolicy));
await mkdir(join(f.repository, "component"));
await writeFile(linkedPolicy, "# Owner policy\n");
await symlink(linkedPolicy, join(f.repository, "SECURITY.md"), "file");
const draft = await f.generate({ path: "component" });
expect(await securityPolicyDiff(draft, PYTHON)).toContain(
"b/component/SECURITY.md",
);
await writeFile(linkedPolicy, "# Changed owner policy\n");
await expect(securityPolicyDiff(draft, PYTHON)).rejects.toThrow(
"inherited SECURITY.md changed",
);
const outside = await fixture();
await mkdir(join(outside.repository, "component"));
const outsidePolicy = join(outside.root, "outside-policy.md");
await writeFile(outsidePolicy, "# Outside policy\n");
await symlink(
outsidePolicy,
join(outside.repository, "SECURITY.md"),
"file",
);
await expect(outside.generate({ path: "component" })).rejects.toThrow(
"outside the repository",
);
expect(await readdir(outside.outputDir)).toEqual([]);
});
test("treats inherited links through regular files as absent", async () => {
const f = await fixture();
policyGit(f.repository, "init", "--quiet");
await mkdir(join(f.repository, "component"));
await writeFile(join(f.repository, "not-a-directory"), "source\n");
await symlink(
join(f.repository, "not-a-directory", "policy.md"),
join(f.repository, "SECURITY.md"),
"file",
);
const draft = await f.generate({ path: "component" });
expect(await securityPolicyDiff(draft, PYTHON)).toContain(
"b/component/SECURITY.md",
);
});
test("invalidates component drafts when inherited links change", async () => {
for (const change of ["add", "remove", "retarget", "dangle"] as const) {
const f = await fixture();
const component = join(f.repository, "component");
const target = join(component, "SECURITY.md");
const inherited = join(f.repository, "SECURITY.md");
const ownerPolicy = join(f.repository, ".github", "SECURITY.md");
const intermediate = join(f.repository, "policy-link.md");
await mkdir(dirname(ownerPolicy));
await mkdir(component);
await writeFile(target, "# Original policy\n");
await writeFile(ownerPolicy, "# Owner policy\n");
if (change !== "add") await symlink(ownerPolicy, inherited, "file");
const draft = await f.generate({ path: "component" });
if (change === "add") await symlink(ownerPolicy, inherited, "file");
if (change === "remove") await rm(inherited);
if (change === "retarget") {
await symlink(ownerPolicy, intermediate, "file");
await rm(inherited);
await symlink(intermediate, inherited, "file");
}
if (change === "dangle") await rm(ownerPolicy);
await expect(securityPolicyDiff(draft, "missing-python")).rejects.toThrow(
"inherited SECURITY.md changed",
);
expect(await readFile(target, "utf8")).toBe("# Original policy\n");
}
});
test("rejects cycles in inherited policy links", async () => {
const f = await fixture();
await mkdir(join(f.repository, "component"));
const inherited = join(f.repository, "SECURITY.md");
const intermediate = join(f.repository, "policy-link.md");
await symlink(intermediate, inherited, "file");
await symlink(inherited, intermediate, "file");
await expect(f.generate({ path: "component" })).rejects.toThrow("cycle");
expect(await readdir(f.outputDir)).toEqual([]);
});
});