mirror of
https://bitbucket.org/siakitem/my-pi.git
synced 2026-08-28 16:45:22 +00:00
447 lines
17 KiB
TypeScript
447 lines
17 KiB
TypeScript
import { describe, expect, test } from "vitest";
|
|
|
|
import {
|
|
classifyBareTokenCandidate,
|
|
classifyTokenAsPathCandidate,
|
|
classifyTokenAsRuleCandidate,
|
|
} from "#src/access-intent/bash/token-classification";
|
|
import { posixPathFlavor, win32PathFlavor } from "#src/path/path-flavor";
|
|
|
|
// ── Shared rejection behaviour ─────────────────────────────────────────────
|
|
//
|
|
// Both classifiers delegate to the private `rejectNonPathToken` predicate for
|
|
// the six shared rejection cases tested below. Testing via both exports
|
|
// pins that predicate through each caller.
|
|
|
|
describe("classifyTokenAsPathCandidate", () => {
|
|
describe("shared rejection: rejectNonPathToken", () => {
|
|
test("empty string → null", () => {
|
|
expect(classifyTokenAsPathCandidate("")).toBeNull();
|
|
});
|
|
|
|
test("flag (leading dash) → null", () => {
|
|
expect(classifyTokenAsPathCandidate("-r")).toBeNull();
|
|
expect(classifyTokenAsPathCandidate("--recursive")).toBeNull();
|
|
});
|
|
|
|
test("env assignment (= before any /) → null", () => {
|
|
expect(classifyTokenAsPathCandidate("FOO=/bar")).toBeNull();
|
|
expect(classifyTokenAsPathCandidate("HOME=/home/user")).toBeNull();
|
|
});
|
|
|
|
test("env-like token where = comes after / is NOT rejected as assignment", () => {
|
|
// /foo=bar: slashIndex (0) < eqIndex (4) → not an assignment → continues
|
|
// Starts with /, so path candidate accepts it.
|
|
expect(classifyTokenAsPathCandidate("/foo=bar")).toBe("/foo=bar");
|
|
});
|
|
|
|
test("URL → null", () => {
|
|
expect(classifyTokenAsPathCandidate("https://example.com")).toBeNull();
|
|
expect(classifyTokenAsPathCandidate("http://localhost:3000")).toBeNull();
|
|
expect(classifyTokenAsPathCandidate("file:///tmp/foo")).toBeNull();
|
|
expect(
|
|
classifyTokenAsPathCandidate("git+ssh://github.com/a/b"),
|
|
).toBeNull();
|
|
});
|
|
|
|
test("@scope/package → null", () => {
|
|
expect(classifyTokenAsPathCandidate("@foo/bar")).toBeNull();
|
|
expect(classifyTokenAsPathCandidate("@scope/pkg")).toBeNull();
|
|
});
|
|
|
|
test("@/ prefix is NOT rejected (it looks like an absolute-rooted scoped path)", () => {
|
|
// @/ passes the @ guard; then for path candidate it doesn't start with /
|
|
// or ~/, and doesn't contain .., so it returns null anyway from the
|
|
// acceptance gate — but the rejection is not due to the @ guard.
|
|
// This test documents that @/ is not rejected by the shared rejection.
|
|
// The path classifier then rejects it for not matching any acceptance shape.
|
|
expect(classifyTokenAsPathCandidate("@/foo/bar")).toBeNull();
|
|
});
|
|
|
|
test("regex metacharacters → null", () => {
|
|
// REGEX_METACHAR_PATTERN: .*, .+, \|, \(, \), [...], ^/
|
|
expect(classifyTokenAsPathCandidate("foo.*")).toBeNull();
|
|
expect(classifyTokenAsPathCandidate("bar.+")).toBeNull();
|
|
expect(classifyTokenAsPathCandidate("a\\|b")).toBeNull();
|
|
expect(classifyTokenAsPathCandidate("\\(group\\)")).toBeNull();
|
|
expect(classifyTokenAsPathCandidate("[abc]")).toBeNull();
|
|
expect(classifyTokenAsPathCandidate("^/start")).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe("path-candidate acceptance gate", () => {
|
|
test("absolute path (starts with /) → returned as-is", () => {
|
|
expect(classifyTokenAsPathCandidate("/etc/hosts")).toBe("/etc/hosts");
|
|
expect(classifyTokenAsPathCandidate("/tmp")).toBe("/tmp");
|
|
expect(classifyTokenAsPathCandidate("/home/user/file.txt")).toBe(
|
|
"/home/user/file.txt",
|
|
);
|
|
});
|
|
|
|
test("bare-slash token (filesystem root) → returned as-is", () => {
|
|
// `find /` scans the whole filesystem from root — a deliberate
|
|
// external-directory access the gate must see, not drop (#583).
|
|
expect(classifyTokenAsPathCandidate("/")).toBe("/");
|
|
expect(classifyTokenAsPathCandidate("//")).toBe("//");
|
|
expect(classifyTokenAsPathCandidate("///")).toBe("///");
|
|
});
|
|
|
|
test("home-relative path (starts with ~/) → returned as-is", () => {
|
|
expect(classifyTokenAsPathCandidate("~/Documents")).toBe("~/Documents");
|
|
expect(classifyTokenAsPathCandidate("~/.ssh/config")).toBe(
|
|
"~/.ssh/config",
|
|
);
|
|
});
|
|
|
|
test("parent-traversal (contains ..) → returned as-is", () => {
|
|
expect(classifyTokenAsPathCandidate("../../etc/passwd")).toBe(
|
|
"../../etc/passwd",
|
|
);
|
|
expect(classifyTokenAsPathCandidate("../foo")).toBe("../foo");
|
|
expect(classifyTokenAsPathCandidate("..")).toBe("..");
|
|
});
|
|
|
|
test("plain word with no path shape → null", () => {
|
|
expect(classifyTokenAsPathCandidate("hello")).toBeNull();
|
|
expect(classifyTokenAsPathCandidate("myfile.txt")).toBeNull();
|
|
});
|
|
|
|
test("dot-file (starts with .) → null (strict path gate)", () => {
|
|
// Path candidate does NOT accept dot-files; rule candidate does.
|
|
expect(classifyTokenAsPathCandidate(".env")).toBeNull();
|
|
expect(classifyTokenAsPathCandidate(".gitignore")).toBeNull();
|
|
});
|
|
|
|
test("relative path with / but no leading / or ~/ → null (strict path gate)", () => {
|
|
// Path candidate does NOT accept bare relative paths; rule candidate does.
|
|
expect(classifyTokenAsPathCandidate("src/foo.ts")).toBeNull();
|
|
expect(classifyTokenAsPathCandidate("./build")).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe("Windows drive-letter acceptance gate", () => {
|
|
test("forward-slash drive path → returned as-is", () => {
|
|
expect(classifyTokenAsPathCandidate("C:/Windows/win.ini")).toBe(
|
|
"C:/Windows/win.ini",
|
|
);
|
|
expect(classifyTokenAsPathCandidate("D:/secrets/password.txt")).toBe(
|
|
"D:/secrets/password.txt",
|
|
);
|
|
});
|
|
|
|
test("backslash drive path → returned as-is", () => {
|
|
expect(classifyTokenAsPathCandidate("C:\\Windows\\win.ini")).toBe(
|
|
"C:\\Windows\\win.ini",
|
|
);
|
|
expect(classifyTokenAsPathCandidate("D:\\secrets\\password.txt")).toBe(
|
|
"D:\\secrets\\password.txt",
|
|
);
|
|
});
|
|
|
|
test("lowercase drive letter → returned as-is", () => {
|
|
expect(classifyTokenAsPathCandidate("c:/foo")).toBe("c:/foo");
|
|
});
|
|
|
|
test("single-letter scheme with double-slash (c://x) → null (URL_PATTERN fires first)", () => {
|
|
// c:// matches URL_PATTERN before the drive-letter check runs.
|
|
expect(classifyTokenAsPathCandidate("c://x")).toBeNull();
|
|
});
|
|
|
|
test("drive-relative path without separator (C:foo) → null", () => {
|
|
// No / or \ after the colon — not an absolute drive path per node:path.
|
|
expect(classifyTokenAsPathCandidate("C:foo")).toBeNull();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("classifyTokenAsRuleCandidate", () => {
|
|
describe("shared rejection: rejectNonPathToken", () => {
|
|
test("empty string → null", () => {
|
|
expect(classifyTokenAsRuleCandidate("", posixPathFlavor)).toBeNull();
|
|
});
|
|
|
|
test("flag (leading dash) → null", () => {
|
|
expect(classifyTokenAsRuleCandidate("-r", posixPathFlavor)).toBeNull();
|
|
expect(
|
|
classifyTokenAsRuleCandidate("--recursive", posixPathFlavor),
|
|
).toBeNull();
|
|
});
|
|
|
|
test("env assignment (= before any /) → null", () => {
|
|
expect(
|
|
classifyTokenAsRuleCandidate("FOO=/bar", posixPathFlavor),
|
|
).toBeNull();
|
|
expect(
|
|
classifyTokenAsRuleCandidate("HOME=/home/user", posixPathFlavor),
|
|
).toBeNull();
|
|
});
|
|
|
|
test("env-like token where = comes after / is NOT rejected as assignment", () => {
|
|
// /foo=bar: slashIndex (0) < eqIndex (4) → not an assignment → continues.
|
|
// Contains /, so rule candidate accepts it.
|
|
expect(classifyTokenAsRuleCandidate("/foo=bar", posixPathFlavor)).toBe(
|
|
"/foo=bar",
|
|
);
|
|
});
|
|
|
|
test("URL → null", () => {
|
|
expect(
|
|
classifyTokenAsRuleCandidate("https://example.com", posixPathFlavor),
|
|
).toBeNull();
|
|
expect(
|
|
classifyTokenAsRuleCandidate("http://localhost:3000", posixPathFlavor),
|
|
).toBeNull();
|
|
expect(
|
|
classifyTokenAsRuleCandidate("file:///tmp/foo", posixPathFlavor),
|
|
).toBeNull();
|
|
});
|
|
|
|
test("@scope/package → null", () => {
|
|
expect(
|
|
classifyTokenAsRuleCandidate("@foo/bar", posixPathFlavor),
|
|
).toBeNull();
|
|
expect(
|
|
classifyTokenAsRuleCandidate("@scope/pkg", posixPathFlavor),
|
|
).toBeNull();
|
|
});
|
|
|
|
test("regex metacharacters → null", () => {
|
|
expect(classifyTokenAsRuleCandidate("foo.*", posixPathFlavor)).toBeNull();
|
|
expect(classifyTokenAsRuleCandidate("bar.+", posixPathFlavor)).toBeNull();
|
|
expect(classifyTokenAsRuleCandidate("a\\|b", posixPathFlavor)).toBeNull();
|
|
expect(classifyTokenAsRuleCandidate("[abc]", posixPathFlavor)).toBeNull();
|
|
expect(
|
|
classifyTokenAsRuleCandidate("^/start", posixPathFlavor),
|
|
).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe("rule-candidate acceptance gate (broader than path)", () => {
|
|
test("absolute path (starts with /) → returned as-is", () => {
|
|
expect(classifyTokenAsRuleCandidate("/etc/hosts", posixPathFlavor)).toBe(
|
|
"/etc/hosts",
|
|
);
|
|
});
|
|
|
|
test("bare-slash token (filesystem root) → returned as-is", () => {
|
|
// Root is a path-shaped token via `hasPathSeparator`; a `path` rule for
|
|
// `/` must be able to match it, same as any other absolute (#583).
|
|
expect(classifyTokenAsRuleCandidate("/", posixPathFlavor)).toBe("/");
|
|
expect(classifyTokenAsRuleCandidate("//", posixPathFlavor)).toBe("//");
|
|
});
|
|
|
|
test("home-relative path (starts with ~/) → returned as-is", () => {
|
|
expect(classifyTokenAsRuleCandidate("~/Documents", posixPathFlavor)).toBe(
|
|
"~/Documents",
|
|
);
|
|
});
|
|
|
|
test("parent-traversal (contains ..) → returned as-is", () => {
|
|
expect(classifyTokenAsRuleCandidate("../foo", posixPathFlavor)).toBe(
|
|
"../foo",
|
|
);
|
|
expect(classifyTokenAsRuleCandidate("..", posixPathFlavor)).toBe("..");
|
|
});
|
|
|
|
test("dot-file (starts with .) → returned as-is", () => {
|
|
// Rule candidate accepts dot-files; path candidate does not.
|
|
expect(classifyTokenAsRuleCandidate(".env", posixPathFlavor)).toBe(
|
|
".env",
|
|
);
|
|
expect(classifyTokenAsRuleCandidate(".gitignore", posixPathFlavor)).toBe(
|
|
".gitignore",
|
|
);
|
|
});
|
|
|
|
test("current-dir relative (starts with ./) → returned as-is", () => {
|
|
expect(classifyTokenAsRuleCandidate("./src", posixPathFlavor)).toBe(
|
|
"./src",
|
|
);
|
|
expect(
|
|
classifyTokenAsRuleCandidate("./build/output.js", posixPathFlavor),
|
|
).toBe("./build/output.js");
|
|
});
|
|
|
|
test("relative path containing / → returned as-is", () => {
|
|
// Rule candidate accepts any token with / (not already rejected).
|
|
expect(classifyTokenAsRuleCandidate("src/foo.ts", posixPathFlavor)).toBe(
|
|
"src/foo.ts",
|
|
);
|
|
expect(
|
|
classifyTokenAsRuleCandidate(
|
|
"packages/pi-foo/index.ts",
|
|
posixPathFlavor,
|
|
),
|
|
).toBe("packages/pi-foo/index.ts");
|
|
});
|
|
|
|
test("plain word with no path shape → null", () => {
|
|
expect(classifyTokenAsRuleCandidate("hello", posixPathFlavor)).toBeNull();
|
|
expect(
|
|
classifyTokenAsRuleCandidate("myfile.txt", posixPathFlavor),
|
|
).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe("Windows drive-letter acceptance gate", () => {
|
|
test("forward-slash drive path → returned as-is", () => {
|
|
// Forward-slash form was already accepted via token.includes("/").
|
|
// The explicit branch makes it first-class and order-independent.
|
|
expect(
|
|
classifyTokenAsRuleCandidate("C:/Windows/win.ini", posixPathFlavor),
|
|
).toBe("C:/Windows/win.ini");
|
|
});
|
|
|
|
test("backslash drive path → returned as-is (new: no forward slash)", () => {
|
|
// Previously dropped by both classifiers; the backslash form has no /
|
|
// so the includes("/") branch could not catch it.
|
|
expect(
|
|
classifyTokenAsRuleCandidate(
|
|
"D:\\secrets\\password.txt",
|
|
posixPathFlavor,
|
|
),
|
|
).toBe("D:\\secrets\\password.txt");
|
|
expect(
|
|
classifyTokenAsRuleCandidate("C:\\Windows\\win.ini", posixPathFlavor),
|
|
).toBe("C:\\Windows\\win.ini");
|
|
});
|
|
|
|
test("lowercase drive letter (backslash) → returned as-is", () => {
|
|
expect(classifyTokenAsRuleCandidate("c:\\foo", posixPathFlavor)).toBe(
|
|
"c:\\foo",
|
|
);
|
|
});
|
|
|
|
test("drive-relative path without separator (C:foo) → null", () => {
|
|
expect(classifyTokenAsRuleCandidate("C:foo", posixPathFlavor)).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe("Windows backslash-relative acceptance gate (win32 flavor, #520)", () => {
|
|
test("backslash-relative token accepted under the win32 flavor", () => {
|
|
expect(classifyTokenAsRuleCandidate("dir\\file", win32PathFlavor)).toBe(
|
|
"dir\\file",
|
|
);
|
|
});
|
|
|
|
test("backslash-relative token rejected under the posix flavor", () => {
|
|
expect(
|
|
classifyTokenAsRuleCandidate("dir\\file", posixPathFlavor),
|
|
).toBeNull();
|
|
});
|
|
|
|
test("backslash regex-metacharacter token still rejected under the win32 flavor", () => {
|
|
// rejectNonPathToken's REGEX_METACHAR_PATTERN fires before the separator
|
|
// branch is reached, regardless of flavor.
|
|
expect(classifyTokenAsRuleCandidate("a\\|b", win32PathFlavor)).toBeNull();
|
|
expect(
|
|
classifyTokenAsRuleCandidate("\\(group\\)", win32PathFlavor),
|
|
).toBeNull();
|
|
});
|
|
|
|
test("backslash traversal accepted regardless of flavor (already via ..)", () => {
|
|
expect(classifyTokenAsRuleCandidate("..\\secret", posixPathFlavor)).toBe(
|
|
"..\\secret",
|
|
);
|
|
expect(classifyTokenAsRuleCandidate("..\\secret", win32PathFlavor)).toBe(
|
|
"..\\secret",
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("rule-vs-path divergence", () => {
|
|
const dotFiles = [".env", ".gitignore", ".eslintrc"];
|
|
const relPaths = ["src/index.ts", "lib/utils.js", "config/settings.json"];
|
|
|
|
for (const tok of dotFiles) {
|
|
test(`dot-file "${tok}": rule accepts, path rejects`, () => {
|
|
expect(classifyTokenAsRuleCandidate(tok, posixPathFlavor)).toBe(tok);
|
|
expect(classifyTokenAsPathCandidate(tok)).toBeNull();
|
|
});
|
|
}
|
|
|
|
for (const tok of relPaths) {
|
|
test(`relative path "${tok}": rule accepts, path rejects`, () => {
|
|
expect(classifyTokenAsRuleCandidate(tok, posixPathFlavor)).toBe(tok);
|
|
expect(classifyTokenAsPathCandidate(tok)).toBeNull();
|
|
});
|
|
}
|
|
|
|
const sharedAccepted = ["/etc/hosts", "~/docs", "../sibling"];
|
|
for (const tok of sharedAccepted) {
|
|
test(`"${tok}": both classifiers accept`, () => {
|
|
expect(classifyTokenAsRuleCandidate(tok, posixPathFlavor)).toBe(tok);
|
|
expect(classifyTokenAsPathCandidate(tok)).toBe(tok);
|
|
});
|
|
}
|
|
|
|
const winDrivePaths = [
|
|
"C:/Windows/win.ini",
|
|
"D:\\secrets\\password.txt",
|
|
"c:/foo",
|
|
];
|
|
for (const tok of winDrivePaths) {
|
|
test(`Windows drive path "${tok}": both classifiers accept`, () => {
|
|
expect(classifyTokenAsRuleCandidate(tok, posixPathFlavor)).toBe(tok);
|
|
expect(classifyTokenAsPathCandidate(tok)).toBe(tok);
|
|
});
|
|
}
|
|
|
|
const sharedRejected = ["hello", "--flag", "FOO=/bar", "https://x.com"];
|
|
for (const tok of sharedRejected) {
|
|
test(`"${tok}": both classifiers reject`, () => {
|
|
expect(classifyTokenAsRuleCandidate(tok, posixPathFlavor)).toBeNull();
|
|
expect(classifyTokenAsPathCandidate(tok)).toBeNull();
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("classifyBareTokenCandidate", () => {
|
|
// Prelude-only: returns the token when nothing about its *shape* rules out
|
|
// being a path. Whether it names a real entry is the existence probe's
|
|
// question, decided by the resolver (ADR 0009), not by this classifier.
|
|
|
|
test("bare word → returned unchanged", () => {
|
|
expect(classifyBareTokenCandidate("id_rsa")).toBe("id_rsa");
|
|
expect(classifyBareTokenCandidate("key.pem")).toBe("key.pem");
|
|
expect(classifyBareTokenCandidate("outside-link")).toBe("outside-link");
|
|
});
|
|
|
|
test("bare word that names no file is still returned — existence is not its question", () => {
|
|
expect(classifyBareTokenCandidate("status")).toBe("status");
|
|
expect(classifyBareTokenCandidate("build")).toBe("build");
|
|
});
|
|
|
|
test("consults no policy — identical result for every token of the same shape", () => {
|
|
expect(classifyBareTokenCandidate("anything")).toBe("anything");
|
|
});
|
|
|
|
describe("shared rejection prelude", () => {
|
|
test("flag (leading dash) → null", () => {
|
|
expect(classifyBareTokenCandidate("-r")).toBeNull();
|
|
expect(classifyBareTokenCandidate("--recursive")).toBeNull();
|
|
});
|
|
|
|
test("env assignment → null", () => {
|
|
expect(classifyBareTokenCandidate("FOO=/bar")).toBeNull();
|
|
});
|
|
|
|
test("URL → null", () => {
|
|
expect(classifyBareTokenCandidate("https://example.com")).toBeNull();
|
|
});
|
|
|
|
test("@scope/package → null", () => {
|
|
expect(classifyBareTokenCandidate("@foo/bar")).toBeNull();
|
|
});
|
|
|
|
test("regex metacharacters → null", () => {
|
|
expect(classifyBareTokenCandidate("foo.*")).toBeNull();
|
|
});
|
|
|
|
test("empty string → null", () => {
|
|
expect(classifyBareTokenCandidate("")).toBeNull();
|
|
});
|
|
});
|
|
});
|