91 lines
3.9 KiB
TypeScript
91 lines
3.9 KiB
TypeScript
import { expect } from "vitest";
|
|
import { briefTest, claim, testBrief } from "@openwork/testkit";
|
|
import { normalizeWorkspaceRootPath } from "../../packages/paths/index.mjs";
|
|
import { prepareRuntimeWorkspaceRoot } from "../../apps/desktop/electron/runtime.mjs";
|
|
|
|
briefTest(testBrief({
|
|
behavior: "Windows workspace roots stay within filesystem path boundaries and fail recoverably when unavailable.",
|
|
claims: {
|
|
verbatimNormalization: claim("valid verbatim drive and UNC roots normalize to ordinary Windows filesystem paths", {
|
|
never: "retain a Windows device namespace prefix",
|
|
}),
|
|
deviceRejection: claim("Win32 device namespace roots are rejected", {
|
|
never: "treat named pipes or physical devices as workspaces",
|
|
}),
|
|
disconnectedRetention: claim("a normal disconnected drive root remains unchanged", {
|
|
never: "resolve it against a different drive or consult its availability during normalization",
|
|
}),
|
|
inaccessibleRecovery: claim("an inaccessible root reports workspace_inaccessible and can be retried", {
|
|
never: "surface the injected filesystem error unwrapped or lose the requested workspace path",
|
|
}),
|
|
},
|
|
}), async ({ prove }) => {
|
|
const driveRoot = normalizeWorkspaceRootPath("\\\\?\\C:\\Users\\Ada\\Workspace", { platform: "win32" });
|
|
const uncRoot = normalizeWorkspaceRootPath("\\\\?\\UNC\\server\\share\\Workspace", { platform: "win32" });
|
|
expect(driveRoot).toBe("C:\\Users\\Ada\\Workspace");
|
|
expect(uncRoot).toBe("\\\\server\\share\\Workspace");
|
|
expect(driveRoot).not.toMatch(/^\\\\[?.]\\/);
|
|
expect(uncRoot).not.toMatch(/^\\\\[?.]\\/);
|
|
prove.verbatimNormalization(
|
|
true,
|
|
`The verbatim drive normalized to ${driveRoot} and the verbatim UNC root normalized to ${uncRoot}; neither retained a device namespace prefix.`,
|
|
);
|
|
|
|
const deviceRoots = [
|
|
"\\\\.\\pipe\\openwork",
|
|
"//./PIPE/openwork",
|
|
"\\\\.\\PhysicalDrive0",
|
|
];
|
|
for (const deviceRoot of deviceRoots) {
|
|
let thrown: unknown;
|
|
try {
|
|
normalizeWorkspaceRootPath(deviceRoot, { platform: "win32" });
|
|
} catch (error) {
|
|
thrown = error;
|
|
}
|
|
expect(thrown).toBeInstanceOf(TypeError);
|
|
expect(thrown).toMatchObject({ code: "invalid_workspace_root" });
|
|
}
|
|
prove.deviceRejection(
|
|
true,
|
|
`All ${deviceRoots.length} injected device namespace roots threw TypeError with invalid_workspace_root instead of becoming workspaces.`,
|
|
);
|
|
|
|
const disconnectedRoot = "Z:\\Disconnected\\Workspace";
|
|
const retainedRoot = normalizeWorkspaceRootPath(disconnectedRoot, { platform: "win32" });
|
|
expect(retainedRoot).toBe(disconnectedRoot);
|
|
expect(retainedRoot).not.toMatch(/^C:/i);
|
|
prove.disconnectedRetention(
|
|
true,
|
|
`${disconnectedRoot} was retained byte-for-byte and was not resolved onto the current drive.`,
|
|
);
|
|
|
|
const rawInaccessibleRoot = "\\\\?\\Z:\\Disconnected\\Workspace";
|
|
const normalizedInaccessibleRoot = "Z:\\Disconnected\\Workspace";
|
|
const filesystemError = Object.assign(new Error("drive is unavailable"), { code: "ENOENT" });
|
|
const attemptedRoots: string[] = [];
|
|
await expect(prepareRuntimeWorkspaceRoot(rawInaccessibleRoot, {
|
|
platform: "win32",
|
|
mkdirImpl: async (workspaceRoot: string) => {
|
|
attemptedRoots.push(workspaceRoot);
|
|
throw filesystemError;
|
|
},
|
|
})).rejects.toMatchObject({
|
|
code: "workspace_inaccessible",
|
|
workspacePath: rawInaccessibleRoot,
|
|
cause: filesystemError,
|
|
});
|
|
const retriedRoot = await prepareRuntimeWorkspaceRoot(rawInaccessibleRoot, {
|
|
platform: "win32",
|
|
mkdirImpl: async (workspaceRoot: string) => {
|
|
attemptedRoots.push(workspaceRoot);
|
|
},
|
|
});
|
|
expect(attemptedRoots).toEqual([normalizedInaccessibleRoot, normalizedInaccessibleRoot]);
|
|
expect(retriedRoot).toBe(normalizedInaccessibleRoot);
|
|
prove.inaccessibleRecovery(
|
|
true,
|
|
`The injected ENOENT was wrapped as workspace_inaccessible for ${rawInaccessibleRoot}; a retry targeted ${normalizedInaccessibleRoot} again and succeeded.`,
|
|
);
|
|
});
|