Files
reverse-engineering-anything/src/cliJsonPaths.test.ts
T
morlutoandCursor Agent be14c9d475 test: own temporary directories through createTestTempDirectory in src/ tests (#12725)
Give per-test temporary directories to the shared helper so Vitest removes
them after the case. Keep directories whose lifetime is the assertion, or
that are shared from beforeAll, on their existing cleanup.

Co-authored-by: Cursor Agent <cursoragent@cursor.com>
2026-11-20 04:10:06 +00:00

152 lines
5.0 KiB
TypeScript

import { mkdir, symlink } from "node:fs/promises";
import { join, resolve } from "node:path";
import { describe, expect, it } from "vitest";
import { createTestTempDirectory } from "../tests/fixtures/temporaryDirectory.js";
import {
cliJsonCallerPathSchema,
resolveCliJsonPaths,
} from "./cli/cliJsonInput.js";
import { electronActiveObservationInputSchema } from "./domain/javascript/electronActiveObservation.js";
const paths = [
["executable_path"],
["application_path"],
["application_root"],
] as const;
describe("CLI JSON path normalization", () => {
it.each([" ", "\t\r\n", "\u00a0", "\u2003", "\ufeff"])(
"refuses blank caller path %j before normalization",
(path) => {
expect(cliJsonCallerPathSchema.safeParse(path).success).toBe(false);
expect(resolveCliJsonPaths({ executable_path: path }, paths)).toEqual({
executable_path: path,
});
},
);
it.each([
["executable_path", ""],
["executable_path", " \t "],
["application_path", ""],
["application_path", " \t "],
["application_root", ""],
["application_root", " \t "],
])(
"keeps blank %s (%j) invalid at the shared input boundary",
(field, value) => {
const input = {
executable_path: "/synthetic/electron",
application_path: "/synthetic/app",
application_root: "/synthetic",
[field]: value,
};
const parsed = electronActiveObservationInputSchema.safeParse(
resolveCliJsonPaths(input, paths),
);
expect(parsed.success).toBe(false);
if (parsed.success) throw new Error("Expected blank path rejection");
expect(parsed.error.issues).toEqual(
expect.arrayContaining([expect.objectContaining({ path: [field] })]),
);
expect(input).toHaveProperty(field, value);
},
);
it("resolves selected relative paths without trimming names or changing unrelated fields", () => {
const input = {
browser: { executable_path: " browser ", label: "relative-label" },
application_path: "app",
};
expect(
resolveCliJsonPaths(input, [["browser", "executable_path"]]),
).toEqual({
browser: {
executable_path: resolve(" browser "),
label: "relative-label",
},
application_path: "app",
});
expect(input.browser.executable_path).toBe(" browser ");
});
it.skipIf(process.platform === "win32")(
"keeps POSIX symlink-parent traversal for each selected JSON path",
async () => {
const root = await createTestTempDirectory("rea-json-caller-path-");
const originalCwd = process.cwd();
try {
await mkdir(join(root, "real/inner"), { recursive: true });
await symlink(join(root, "real/inner"), join(root, "link"));
process.chdir(root);
const electronInput = {
executable_path: "link/../tool",
application_path: "link/../app",
application_root: "link/../root",
};
const normalizedElectron = resolveCliJsonPaths(electronInput, paths);
expect(normalizedElectron).toEqual({
executable_path: `${root}/link/../tool`,
application_path: `${root}/link/../app`,
application_root: `${root}/link/../root`,
});
expect(electronInput.executable_path).toBe("link/../tool");
expect(
electronActiveObservationInputSchema.safeParse(normalizedElectron)
.success,
).toBe(true);
const browserInput = {
browser: { executable_path: "link/../browser", label: "keep" },
};
expect(
resolveCliJsonPaths(browserInput, [["browser", "executable_path"]]),
).toEqual({
browser: {
executable_path: `${root}/link/../browser`,
label: "keep",
},
});
expect(browserInput.browser.executable_path).toBe("link/../browser");
} finally {
process.chdir(originalCwd);
}
},
);
it.each([
"file:///opt/electron",
"FILE:electron",
"https://example.test/app",
])("keeps URL %j distinguishable from a local path", (value) => {
const expected = {
executable_path: value,
application_path: resolve("/synthetic/app"),
};
const input = { ...expected };
const normalized = resolveCliJsonPaths(input, paths);
expect(normalized).toEqual(expected);
expect(input).toEqual(expected);
const parsed = electronActiveObservationInputSchema.safeParse(normalized);
expect(parsed.success).toBe(false);
if (parsed.success) throw new Error("Expected URL path rejection");
expect(parsed.error.issues).toEqual([
expect.objectContaining({
path: ["executable_path"],
code: "invalid_format",
format: "regex",
}),
]);
});
it.each([
"bin/electron",
"release:v1/electron",
"C:\\Electron\\electron.exe",
])("keeps resolving local path %j", (value) => {
expect(resolveCliJsonPaths({ executable_path: value }, paths)).toEqual({
executable_path: resolve(value),
});
});
});