@gotgenes/pi-permission-system 16.2.1 → 17.1.0

package/test/access-intent/access-path.test.ts

@@ -21,7 +21,7 @@ vi.mock("node:fs", () => ({
 
 import { AccessPath } from "#src/access-intent/access-path";
 
-describe("AccessPath.forExternalDirectory", () => {
+describe("AccessPath.forPath", () => {
   const cwd = "/projects/my-app";
 
   beforeEach(() => {
@@ -36,19 +36,25 @@ describe("AccessPath.forExternalDirectory", () => {
         p.startsWith("/tmp") ? `/private${p}` : p,
       );
       expect(
-        AccessPath.forExternalDirectory("/tmp/x", cwd).matchValues(),
+        AccessPath.forPath("/tmp/x", { cwd, platform: "linux" }).matchValues(),
       ).toEqual(["/tmp/x", "/private/tmp/x"]);
     });
 
     test("deduplicates when the canonical form equals the lexical form", () => {
       expect(
-        AccessPath.forExternalDirectory("/etc/hosts", cwd).matchValues(),
+        AccessPath.forPath("/etc/hosts", {
+          cwd,
+          platform: "linux",
+        }).matchValues(),
       ).toEqual(["/etc/hosts"]);
     });
 
     test("keeps the relative aliases for an in-cwd token without duplicating", () => {
       expect(
-        AccessPath.forExternalDirectory("src/foo.ts", cwd).matchValues(),
+        AccessPath.forPath("src/foo.ts", {
+          cwd,
+          platform: "linux",
+        }).matchValues(),
       ).toEqual(["/projects/my-app/src/foo.ts", "src/foo.ts"]);
     });
 
@@ -56,9 +62,68 @@ describe("AccessPath.forExternalDirectory", () => {
       // Force canonicalizePath to return the original (no-op symlink resolution
       // effectively means canonical === lexical, handled by dedup).
       expect(
-        AccessPath.forExternalDirectory("/etc/hosts", cwd).matchValues(),
+        AccessPath.forPath("/etc/hosts", {
+          cwd,
+          platform: "linux",
+        }).matchValues(),
       ).not.toHaveLength(0);
     });
+
+    test("resolves a relative token against an explicit resolveBase", () => {
+      // The cd-folded effective base differs from cwd (the bash-path case).
+      expect(
+        AccessPath.forPath("foo.ts", {
+          cwd,
+          resolveBase: "/projects/my-app/sub",
+          platform: "linux",
+        }).matchValues(),
+      ).toEqual(["/projects/my-app/sub/foo.ts", "sub/foo.ts", "foo.ts"]);
+    });
+
+    test("adds the canonical alias resolved against resolveBase", () => {
+      realpathSync.mockImplementation((p: string) =>
+        p === "/projects/my-app/sub/foo.ts" ? "/real/foo.ts" : p,
+      );
+      expect(
+        AccessPath.forPath("foo.ts", {
+          cwd,
+          resolveBase: "/projects/my-app/sub",
+          platform: "linux",
+        }).matchValues(),
+      ).toEqual([
+        "/projects/my-app/sub/foo.ts",
+        "sub/foo.ts",
+        "foo.ts",
+        "/real/foo.ts",
+      ]);
+    });
+  });
+
+  describe("platform option", () => {
+    test("win32: builds lexical/match/boundary values with win32 rules", () => {
+      const ap = AccessPath.forPath("src\\foo.ts", {
+        cwd: "C:\\Projects\\App",
+        platform: "win32",
+      });
+      expect(ap.value()).toBe("c:\\projects\\app\\src\\foo.ts");
+      expect(ap.boundaryValue()).toBe("c:\\projects\\app\\src\\foo.ts");
+      expect(ap.matchValues()).toEqual([
+        "c:\\projects\\app\\src\\foo.ts",
+        "src\\foo.ts",
+      ]);
+    });
+
+    test("win32: lowercases the symlink-resolved boundary value", () => {
+      realpathSync.mockImplementation((p: string) =>
+        p === "c:\\projects\\app\\link" ? "C:\\Real\\App" : p,
+      );
+      expect(
+        AccessPath.forPath("link", {
+          cwd: "C:\\Projects\\App",
+          platform: "win32",
+        }).boundaryValue(),
+      ).toBe("c:\\real\\app");
+    });
   });
 
   describe("boundaryValue()", () => {
@@ -67,18 +132,26 @@ describe("AccessPath.forExternalDirectory", () => {
         p.startsWith("/tmp") ? `/private${p}` : p,
       );
       expect(
-        AccessPath.forExternalDirectory("/tmp/x", cwd).boundaryValue(),
+        AccessPath.forPath("/tmp/x", {
+          cwd,
+          platform: "linux",
+        }).boundaryValue(),
       ).toBe("/private/tmp/x");
     });
 
     test("returns the lexical form when path has no symlinks", () => {
       expect(
-        AccessPath.forExternalDirectory("/etc/hosts", cwd).boundaryValue(),
+        AccessPath.forPath("/etc/hosts", {
+          cwd,
+          platform: "linux",
+        }).boundaryValue(),
       ).toBe("/etc/hosts");
     });
 
     test("returns empty string for empty input", () => {
-      expect(AccessPath.forExternalDirectory("", cwd).boundaryValue()).toBe("");
+      expect(
+        AccessPath.forPath("", { cwd, platform: "linux" }).boundaryValue(),
+      ).toBe("");
     });
   });
 
@@ -88,20 +161,56 @@ describe("AccessPath.forExternalDirectory", () => {
         p.startsWith("/tmp") ? `/private${p}` : p,
       );
       // Even when the path resolves to a different canonical, value() stays lexical.
-      expect(AccessPath.forExternalDirectory("/tmp/x", cwd).value()).toBe(
-        "/tmp/x",
-      );
+      expect(
+        AccessPath.forPath("/tmp/x", { cwd, platform: "linux" }).value(),
+      ).toBe("/tmp/x");
     });
 
     test("normalizes the path against cwd", () => {
       // A relative path becomes an absolute lexical value.
-      expect(AccessPath.forExternalDirectory("src/foo.ts", cwd).value()).toBe(
-        "/projects/my-app/src/foo.ts",
-      );
+      expect(
+        AccessPath.forPath("src/foo.ts", { cwd, platform: "linux" }).value(),
+      ).toBe("/projects/my-app/src/foo.ts");
+    });
+
+    test("normalizes a relative path against an explicit resolveBase", () => {
+      expect(
+        AccessPath.forPath("foo.ts", {
+          cwd,
+          resolveBase: "/projects/my-app/sub",
+          platform: "linux",
+        }).value(),
+      ).toBe("/projects/my-app/sub/foo.ts");
     });
 
     test("returns empty string for empty input", () => {
-      expect(AccessPath.forExternalDirectory("", cwd).value()).toBe("");
+      expect(AccessPath.forPath("", { cwd, platform: "linux" }).value()).toBe(
+        "",
+      );
     });
   });
 });
+
+describe("AccessPath.forLiteral", () => {
+  beforeEach(() => {
+    realpathSync.mockReset();
+    realpathSync.mockImplementation((p: string) => p);
+  });
+
+  test("matchValues() carries only the literal — no canonical, no absolute", () => {
+    expect(AccessPath.forLiteral("foo.ts").matchValues()).toEqual(["foo.ts"]);
+  });
+
+  test("boundaryValue() is empty (no outside-cwd notion for an unknown base)", () => {
+    expect(AccessPath.forLiteral("foo.ts").boundaryValue()).toBe("");
+  });
+
+  test("value() returns the literal", () => {
+    expect(AccessPath.forLiteral("foo.ts").value()).toBe("foo.ts");
+  });
+
+  test("an empty literal yields no match values", () => {
+    expect(AccessPath.forLiteral("").matchValues()).toEqual([]);
+    expect(AccessPath.forLiteral("").value()).toBe("");
+  });
+});