Archived
556 lines
22 KiB
TypeScript
556 lines
22 KiB
TypeScript
import { constants } from "node:fs";
|
|
import {
|
|
access,
|
|
appendFile,
|
|
copyFile,
|
|
link as createHardLink,
|
|
lstat,
|
|
mkdtemp,
|
|
mkdir,
|
|
readFile,
|
|
readdir,
|
|
realpath,
|
|
rm,
|
|
unlink,
|
|
writeFile,
|
|
} from "node:fs/promises";
|
|
import { tmpdir } from "node:os";
|
|
import { dirname, join, resolve, sep } from "node:path";
|
|
import { afterEach, describe, expect, it } from "vitest";
|
|
import {
|
|
inspectLegacySessionArchiveMigration,
|
|
migrateLegacySessionArchive,
|
|
type LegacySessionArchiveMigrationOptions,
|
|
} from "./sessionArchiveMigration.js";
|
|
|
|
const tempRoots: string[] = [];
|
|
|
|
describe("legacy session archive migration preflight", () => {
|
|
afterEach(async () => {
|
|
await Promise.all(tempRoots.splice(0).map((path) => rm(path, { recursive: true, force: true })));
|
|
});
|
|
|
|
it("proves the ordinary legacy layout eligible without creating destination state", async () => {
|
|
const fixture = await createLegacyArchiveFixture();
|
|
|
|
await expect(inspectLegacySessionArchiveMigration(fixture.options)).resolves.toEqual({
|
|
status: "eligible",
|
|
legacyIndexPath: fixture.legacyIndexPath,
|
|
destinationIndexPath: fixture.destinationIndexPath,
|
|
archiveFileCount: 1,
|
|
});
|
|
expect(await exists(fixture.destinationRoot)).toBe(false);
|
|
await expect(readFile(fixture.legacyFilePath, "utf8")).resolves.toBe("legacy session\n");
|
|
});
|
|
|
|
it("skips when PI_WEB_DATA_DIR is not explicitly configured", async () => {
|
|
const fixture = await createLegacyArchiveFixture();
|
|
|
|
await expect(migrateLegacySessionArchive({ ...fixture.options, env: {} })).resolves.toEqual({
|
|
status: "skipped",
|
|
reason: "data-dir-not-configured",
|
|
});
|
|
await expectLegacyStateUntouched(fixture);
|
|
expect(await exists(fixture.destinationRoot)).toBe(false);
|
|
});
|
|
|
|
it("skips when the configured data root resolves to the legacy root", async () => {
|
|
const fixture = await createLegacyArchiveFixture();
|
|
|
|
await expect(migrateLegacySessionArchive({
|
|
...fixture.options,
|
|
env: { PI_WEB_DATA_DIR: fixture.legacyRoot },
|
|
})).resolves.toEqual({ status: "skipped", reason: "data-dir-not-distinct" });
|
|
await expectLegacyStateUntouched(fixture);
|
|
});
|
|
|
|
it("skips when no legacy index exists without adopting loose legacy files", async () => {
|
|
const fixture = await createLegacyArchiveFixture();
|
|
await unlink(fixture.legacyIndexPath);
|
|
|
|
await expect(migrateLegacySessionArchive(fixture.options)).resolves.toEqual({
|
|
status: "skipped",
|
|
reason: "legacy-index-missing",
|
|
});
|
|
await expect(readFile(fixture.legacyFilePath, "utf8")).resolves.toBe("legacy session\n");
|
|
await expect(readFile(fixture.activeFilePath, "utf8")).resolves.toBe("active session\n");
|
|
expect(await exists(fixture.destinationRoot)).toBe(false);
|
|
});
|
|
|
|
it("skips malformed legacy indexes without creating destination state", async () => {
|
|
const fixture = await createLegacyArchiveFixture();
|
|
await writeFile(fixture.legacyIndexPath, "not json\n", "utf8");
|
|
|
|
await expect(migrateLegacySessionArchive(fixture.options)).resolves.toEqual({
|
|
status: "skipped",
|
|
reason: "legacy-index-invalid",
|
|
});
|
|
await expect(readFile(fixture.legacyIndexPath, "utf8")).resolves.toBe("not json\n");
|
|
expect(await exists(fixture.destinationRoot)).toBe(false);
|
|
});
|
|
|
|
it("treats inconclusive filesystem inspection as a mutation-free skip", async () => {
|
|
const fixture = await createLegacyArchiveFixture();
|
|
const inspectionError = Object.assign(new Error("inspection denied"), { code: "EACCES" });
|
|
|
|
const result = await migrateLegacySessionArchive({
|
|
...fixture.options,
|
|
fileSystem: {
|
|
lstat: (path) => path === fixture.destinationIndexPath
|
|
? Promise.reject(inspectionError)
|
|
: lstat(path),
|
|
},
|
|
});
|
|
|
|
expect(result).toMatchObject({
|
|
status: "skipped",
|
|
reason: "inspection-failed",
|
|
error: inspectionError,
|
|
});
|
|
await expectLegacyStateUntouched(fixture);
|
|
expect(await exists(fixture.destinationRoot)).toBe(false);
|
|
});
|
|
|
|
it("does not merge with or overwrite an existing destination index", async () => {
|
|
const fixture = await createLegacyArchiveFixture();
|
|
await mkdir(fixture.destinationRoot, { recursive: true });
|
|
await writeFile(fixture.destinationIndexPath, "destination owner\n", "utf8");
|
|
|
|
await expect(migrateLegacySessionArchive(fixture.options)).resolves.toEqual({
|
|
status: "skipped",
|
|
reason: "destination-index-exists",
|
|
});
|
|
await expect(readFile(fixture.destinationIndexPath, "utf8")).resolves.toBe("destination owner\n");
|
|
await expectLegacyStateUntouched(fixture);
|
|
});
|
|
|
|
it("leaves an interrupted pre-commit file untouched instead of adopting a non-empty destination archive", async () => {
|
|
const fixture = await createLegacyArchiveFixture({ createDestinationArchive: true });
|
|
await writeFile(fixture.destinationFilePath, "partial destination copy\n", "utf8");
|
|
|
|
await expect(migrateLegacySessionArchive(fixture.options)).resolves.toEqual({
|
|
status: "skipped",
|
|
reason: "destination-archive-not-empty-or-invalid",
|
|
});
|
|
await expect(readFile(fixture.destinationFilePath, "utf8")).resolves.toBe("partial destination copy\n");
|
|
await expectLegacyStateUntouched(fixture);
|
|
});
|
|
|
|
it("skips archive paths that are not direct regular files in the legacy archive directory", async () => {
|
|
const fixture = await createLegacyArchiveFixture();
|
|
const outsidePath = join(fixture.root, "outside.jsonl");
|
|
await writeFile(outsidePath, "outside\n", "utf8");
|
|
const firstRecord = requiredRecord(fixture.document.sessions, 0);
|
|
const changedDocument = {
|
|
...fixture.document,
|
|
sessions: [{ ...firstRecord, archivePath: outsidePath }, ...fixture.document.sessions.slice(1)],
|
|
};
|
|
await writeArchiveIndex(fixture.legacyIndexPath, changedDocument);
|
|
|
|
await expect(migrateLegacySessionArchive(fixture.options)).resolves.toEqual({
|
|
status: "skipped",
|
|
reason: "legacy-archive-layout-invalid",
|
|
});
|
|
await expect(readFile(outsidePath, "utf8")).resolves.toBe("outside\n");
|
|
await expect(readFile(fixture.legacyFilePath, "utf8")).resolves.toBe("legacy session\n");
|
|
expect(await exists(fixture.destinationRoot)).toBe(false);
|
|
});
|
|
|
|
it("uses Windows case-insensitive path semantics without weakening Linux containment", async () => {
|
|
const fixture = await createLegacyArchiveFixture();
|
|
const casedArchivePath = resolve(fixture.legacyFilePath.toUpperCase());
|
|
const firstRecord = requiredRecord(fixture.document.sessions, 0);
|
|
await writeArchiveIndex(fixture.legacyIndexPath, {
|
|
...fixture.document,
|
|
sessions: [
|
|
{ ...firstRecord, archivePath: casedArchivePath },
|
|
...fixture.document.sessions.slice(1),
|
|
],
|
|
});
|
|
const mapCaseVariant = (path: string): string => path.toLowerCase() === casedArchivePath.toLowerCase()
|
|
? fixture.legacyFilePath
|
|
: path;
|
|
const fileSystem = {
|
|
lstat: (path: string) => lstat(mapCaseVariant(path)),
|
|
realpath: (path: string) => realpath(mapCaseVariant(path)),
|
|
};
|
|
|
|
await expect(inspectLegacySessionArchiveMigration({
|
|
...fixture.options,
|
|
platform: "linux",
|
|
fileSystem,
|
|
})).resolves.toEqual({ status: "skipped", reason: "legacy-archive-layout-invalid" });
|
|
await expect(inspectLegacySessionArchiveMigration({
|
|
...fixture.options,
|
|
platform: "win32",
|
|
fileSystem,
|
|
})).resolves.toEqual({
|
|
status: "eligible",
|
|
legacyIndexPath: fixture.legacyIndexPath,
|
|
destinationIndexPath: fixture.destinationIndexPath,
|
|
archiveFileCount: 1,
|
|
});
|
|
});
|
|
|
|
it("skips legacy directories containing unindexed entries", async () => {
|
|
const fixture = await createLegacyArchiveFixture();
|
|
const unexpectedPath = join(fixture.legacyArchiveDir, "unexpected.tmp");
|
|
await writeFile(unexpectedPath, "unexpected\n", "utf8");
|
|
|
|
await expect(migrateLegacySessionArchive(fixture.options)).resolves.toEqual({
|
|
status: "skipped",
|
|
reason: "legacy-archive-layout-invalid",
|
|
});
|
|
await expect(readFile(unexpectedPath, "utf8")).resolves.toBe("unexpected\n");
|
|
await expectLegacyStateUntouched(fixture);
|
|
expect(await exists(fixture.destinationRoot)).toBe(false);
|
|
});
|
|
|
|
it("skips duplicate session IDs", async () => {
|
|
const fixture = await createLegacyArchiveFixture();
|
|
const firstRecord = requiredRecord(fixture.document.sessions, 0);
|
|
const secondRecord = requiredRecord(fixture.document.sessions, 1);
|
|
await writeArchiveIndex(fixture.legacyIndexPath, {
|
|
...fixture.document,
|
|
sessions: [firstRecord, { ...secondRecord, sessionId: firstRecord["sessionId"] }],
|
|
});
|
|
|
|
await expect(migrateLegacySessionArchive(fixture.options)).resolves.toEqual({
|
|
status: "skipped",
|
|
reason: "archive-record-conflict",
|
|
});
|
|
await expect(readFile(fixture.legacyFilePath, "utf8")).resolves.toBe("legacy session\n");
|
|
expect(await exists(fixture.destinationRoot)).toBe(false);
|
|
});
|
|
|
|
it("skips duplicate source and destination file mappings", async () => {
|
|
const fixture = await createLegacyArchiveFixture();
|
|
const firstRecord = requiredRecord(fixture.document.sessions, 0);
|
|
await writeArchiveIndex(fixture.legacyIndexPath, {
|
|
...fixture.document,
|
|
sessions: [firstRecord, { ...firstRecord, sessionId: "second-file-record" }],
|
|
});
|
|
|
|
await expect(migrateLegacySessionArchive(fixture.options)).resolves.toEqual({
|
|
status: "skipped",
|
|
reason: "archive-record-conflict",
|
|
});
|
|
await expectLegacyStateUntouched({
|
|
...fixture,
|
|
sourceIndexContents: await readFile(fixture.legacyIndexPath, "utf8"),
|
|
});
|
|
expect(await exists(fixture.destinationRoot)).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe("legacy session archive migration execution", () => {
|
|
afterEach(async () => {
|
|
await Promise.all(tempRoots.splice(0).map((path) => rm(path, { recursive: true, force: true })));
|
|
});
|
|
|
|
it("copies across the source boundary, atomically publishes the rewritten index, then removes legacy state", async () => {
|
|
const fixture = await createLegacyArchiveFixture({ createDestinationArchive: true });
|
|
const copies: { source: string; destination: string; mode: number }[] = [];
|
|
const links: { source: string; destination: string }[] = [];
|
|
|
|
await expect(migrateLegacySessionArchive({
|
|
...fixture.options,
|
|
fileSystem: {
|
|
copyFile: async (source, destination, mode) => {
|
|
copies.push({ source, destination, mode });
|
|
await copyFile(source, destination, mode);
|
|
},
|
|
link: async (source, destination) => {
|
|
links.push({ source, destination });
|
|
await createHardLink(source, destination);
|
|
},
|
|
unlink: async (path) => {
|
|
if (path === fixture.legacyFilePath || path === fixture.legacyIndexPath) {
|
|
expect(await exists(fixture.destinationIndexPath)).toBe(true);
|
|
}
|
|
await unlink(path);
|
|
},
|
|
},
|
|
})).resolves.toEqual({ status: "migrated", archiveFileCount: 1, cleanup: "complete" });
|
|
|
|
expect(copies).toHaveLength(2);
|
|
expect(copies[0]).toMatchObject({ source: fixture.legacyFilePath, mode: constants.COPYFILE_EXCL });
|
|
expect(copies[0]?.destination).toContain(".archived-sessions-migration-test-attempt");
|
|
expect(copies[1]).toMatchObject({ destination: fixture.destinationFilePath, mode: constants.COPYFILE_EXCL });
|
|
expect(links).toEqual([{
|
|
source: join(fixture.destinationRoot, ".archived-sessions-migration-test-attempt", "archived-sessions.json"),
|
|
destination: fixture.destinationIndexPath,
|
|
}]);
|
|
await expect(readFile(fixture.destinationFilePath, "utf8")).resolves.toBe("legacy session\n");
|
|
|
|
const migratedDocument: unknown = JSON.parse(await readFile(fixture.destinationIndexPath, "utf8"));
|
|
const firstRecord = requiredRecord(fixture.document.sessions, 0);
|
|
expect(migratedDocument).toEqual({
|
|
...fixture.document,
|
|
sessions: [
|
|
{ ...firstRecord, archivePath: fixture.destinationFilePath },
|
|
requiredRecord(fixture.document.sessions, 1),
|
|
],
|
|
});
|
|
expect(await exists(fixture.legacyIndexPath)).toBe(false);
|
|
expect(await exists(fixture.legacyFilePath)).toBe(false);
|
|
expect(await exists(fixture.legacyArchiveDir)).toBe(false);
|
|
await expect(readFile(fixture.activeFilePath, "utf8")).resolves.toBe("active session\n");
|
|
expect(new Set(await readdir(fixture.destinationRoot))).toEqual(new Set([
|
|
"archived-sessions",
|
|
"archived-sessions.json",
|
|
]));
|
|
});
|
|
|
|
it("retries safely when an interrupted staging-only attempt left an unowned sibling tree", async () => {
|
|
const fixture = await createLegacyArchiveFixture();
|
|
const abandonedFile = join(
|
|
fixture.destinationRoot,
|
|
".archived-sessions-migration-interrupted-attempt",
|
|
"files",
|
|
"abandoned.jsonl",
|
|
);
|
|
await mkdir(dirname(abandonedFile), { recursive: true });
|
|
await writeFile(abandonedFile, "unowned staging data\n", "utf8");
|
|
|
|
await expect(migrateLegacySessionArchive(fixture.options)).resolves.toEqual({
|
|
status: "migrated",
|
|
archiveFileCount: 1,
|
|
cleanup: "complete",
|
|
});
|
|
|
|
await expect(readFile(abandonedFile, "utf8")).resolves.toBe("unowned staging data\n");
|
|
await expect(readFile(fixture.destinationFilePath, "utf8")).resolves.toBe("legacy session\n");
|
|
expect(await exists(fixture.destinationIndexPath)).toBe(true);
|
|
expect(await exists(fixture.legacyIndexPath)).toBe(false);
|
|
});
|
|
|
|
it("rolls back destination artifacts and preserves all legacy state when staged-copy verification fails", async () => {
|
|
const fixture = await createLegacyArchiveFixture();
|
|
|
|
const result = await migrateLegacySessionArchive({
|
|
...fixture.options,
|
|
fileSystem: {
|
|
copyFile: async (source, destination, mode) => {
|
|
await copyFile(source, destination, mode);
|
|
if (source === fixture.legacyFilePath) await appendFile(destination, "corrupt", "utf8");
|
|
},
|
|
},
|
|
});
|
|
|
|
expect(result).toMatchObject({ status: "failed", phase: "stage", rollbackErrors: [] });
|
|
await expectLegacyStateUntouched(fixture);
|
|
expect(await exists(fixture.destinationIndexPath)).toBe(false);
|
|
await expect(readdir(fixture.destinationRoot)).resolves.toEqual([]);
|
|
});
|
|
|
|
it("revalidates source files before commit and rolls back if one changes during migration", async () => {
|
|
const fixture = await createLegacyArchiveFixture();
|
|
|
|
const result = await migrateLegacySessionArchive({
|
|
...fixture.options,
|
|
fileSystem: {
|
|
copyFile: async (source, destination, mode) => {
|
|
await copyFile(source, destination, mode);
|
|
if (destination === fixture.destinationFilePath) {
|
|
await appendFile(fixture.legacyFilePath, "changed during migration\n", "utf8");
|
|
}
|
|
},
|
|
},
|
|
});
|
|
|
|
expect(result).toMatchObject({ status: "failed", phase: "commit-index", rollbackErrors: [] });
|
|
await expect(readFile(fixture.legacyIndexPath, "utf8")).resolves.toBe(fixture.sourceIndexContents);
|
|
await expect(readFile(fixture.legacyFilePath, "utf8")).resolves.toBe(
|
|
"legacy session\nchanged during migration\n",
|
|
);
|
|
await expect(readFile(fixture.activeFilePath, "utf8")).resolves.toBe("active session\n");
|
|
expect(await exists(fixture.destinationIndexPath)).toBe(false);
|
|
expect(await exists(fixture.destinationArchiveDir)).toBe(false);
|
|
});
|
|
|
|
it("rolls back published files but never source state when atomic index publication fails", async () => {
|
|
const fixture = await createLegacyArchiveFixture();
|
|
const publicationError = Object.assign(new Error("link failed"), { code: "EIO" });
|
|
|
|
const result = await migrateLegacySessionArchive({
|
|
...fixture.options,
|
|
fileSystem: {
|
|
link: () => Promise.reject(publicationError),
|
|
},
|
|
});
|
|
|
|
expect(result).toMatchObject({
|
|
status: "failed",
|
|
phase: "commit-index",
|
|
error: publicationError,
|
|
rollbackErrors: [],
|
|
});
|
|
await expectLegacyStateUntouched(fixture);
|
|
expect(await exists(fixture.destinationIndexPath)).toBe(false);
|
|
expect(await exists(fixture.destinationArchiveDir)).toBe(false);
|
|
await expect(readdir(fixture.destinationRoot)).resolves.toEqual([]);
|
|
});
|
|
|
|
it("does not overwrite a destination index that appears at the atomic commit boundary", async () => {
|
|
const fixture = await createLegacyArchiveFixture();
|
|
const publicationError = Object.assign(new Error("destination index won the race"), { code: "EEXIST" });
|
|
|
|
const result = await migrateLegacySessionArchive({
|
|
...fixture.options,
|
|
fileSystem: {
|
|
link: async (_source, destination) => {
|
|
await writeFile(destination, "destination owner\n", { encoding: "utf8", flag: "wx" });
|
|
throw publicationError;
|
|
},
|
|
},
|
|
});
|
|
|
|
expect(result).toMatchObject({
|
|
status: "failed",
|
|
phase: "commit-index",
|
|
error: publicationError,
|
|
rollbackErrors: [],
|
|
});
|
|
await expect(readFile(fixture.destinationIndexPath, "utf8")).resolves.toBe("destination owner\n");
|
|
expect(await exists(fixture.destinationArchiveDir)).toBe(false);
|
|
await expectLegacyStateUntouched(fixture);
|
|
});
|
|
|
|
it("keeps the committed destination authoritative when legacy cleanup fails", async () => {
|
|
const fixture = await createLegacyArchiveFixture();
|
|
const cleanupError = Object.assign(new Error("source cleanup failed"), { code: "EACCES" });
|
|
|
|
const result = await migrateLegacySessionArchive({
|
|
...fixture.options,
|
|
fileSystem: {
|
|
unlink: async (path) => {
|
|
if (path === fixture.legacyFilePath) throw cleanupError;
|
|
await unlink(path);
|
|
},
|
|
},
|
|
});
|
|
|
|
expect(result).toMatchObject({
|
|
status: "migrated",
|
|
cleanup: "incomplete",
|
|
cleanupErrors: [cleanupError],
|
|
});
|
|
await expect(readFile(fixture.destinationFilePath, "utf8")).resolves.toBe("legacy session\n");
|
|
expect(await exists(fixture.destinationIndexPath)).toBe(true);
|
|
await expectLegacyStateUntouched(fixture);
|
|
});
|
|
});
|
|
|
|
interface LegacyArchiveFixture {
|
|
root: string;
|
|
legacyRoot: string;
|
|
legacyIndexPath: string;
|
|
legacyArchiveDir: string;
|
|
legacyFilePath: string;
|
|
activeFilePath: string;
|
|
destinationRoot: string;
|
|
destinationIndexPath: string;
|
|
destinationArchiveDir: string;
|
|
destinationFilePath: string;
|
|
sourceIndexContents: string;
|
|
document: { marker: string; sessions: Record<string, unknown>[] };
|
|
options: LegacySessionArchiveMigrationOptions;
|
|
}
|
|
|
|
async function createLegacyArchiveFixture(
|
|
setup: { createDestinationArchive?: boolean } = {},
|
|
): Promise<LegacyArchiveFixture> {
|
|
const root = await mkdtemp(join(tmpdir(), "pi-web-archive-migration-"));
|
|
tempRoots.push(root);
|
|
const homeDir = join(root, "home");
|
|
const legacyRoot = join(homeDir, ".pi-web");
|
|
const legacyIndexPath = join(legacyRoot, "archived-sessions.json");
|
|
const legacyArchiveDir = join(legacyRoot, "archived-sessions");
|
|
const legacyFilePath = join(legacyArchiveDir, "2026-01-01_file-session.jsonl");
|
|
const activeFilePath = join(root, "active", "2026-01-01_file-session.jsonl");
|
|
const destinationRoot = join(root, "managed-state");
|
|
const destinationIndexPath = join(destinationRoot, "archived-sessions.json");
|
|
const destinationArchiveDir = join(destinationRoot, "archived-sessions");
|
|
const destinationFilePath = join(destinationArchiveDir, "2026-01-01_file-session.jsonl");
|
|
const document = {
|
|
marker: "preserve root metadata",
|
|
sessions: [
|
|
{
|
|
sessionId: "file-session",
|
|
cwd: `${join(root, "workspace")}${sep}..${sep}workspace`,
|
|
archivedAt: "2026-01-01T00:02:00.000Z",
|
|
originalPath: activeFilePath,
|
|
archivePath: legacyFilePath,
|
|
created: "2026-01-01T00:00:00.000Z",
|
|
modified: "2026-01-01T00:01:00.000Z",
|
|
messageCount: 2,
|
|
firstMessage: "hello",
|
|
name: "Legacy file session",
|
|
customMetadata: { preserved: true },
|
|
},
|
|
{
|
|
sessionId: "metadata-only",
|
|
cwd: "/workspace",
|
|
archivedAt: "2026-01-02T00:00:00.000Z",
|
|
name: "Metadata only",
|
|
},
|
|
],
|
|
};
|
|
|
|
await mkdir(legacyArchiveDir, { recursive: true });
|
|
await mkdir(join(root, "active"), { recursive: true });
|
|
await writeFile(legacyFilePath, "legacy session\n", "utf8");
|
|
await writeFile(activeFilePath, "active session\n", "utf8");
|
|
const sourceIndexContents = await writeArchiveIndex(legacyIndexPath, document);
|
|
if (setup.createDestinationArchive === true) await mkdir(destinationArchiveDir, { recursive: true });
|
|
|
|
return {
|
|
root,
|
|
legacyRoot,
|
|
legacyIndexPath,
|
|
legacyArchiveDir,
|
|
legacyFilePath,
|
|
activeFilePath,
|
|
destinationRoot,
|
|
destinationIndexPath,
|
|
destinationArchiveDir,
|
|
destinationFilePath,
|
|
sourceIndexContents,
|
|
document,
|
|
options: {
|
|
env: { PI_WEB_DATA_DIR: destinationRoot },
|
|
cwd: root,
|
|
homeDir,
|
|
createAttemptId: () => "test-attempt",
|
|
},
|
|
};
|
|
}
|
|
|
|
async function writeArchiveIndex(path: string, document: unknown): Promise<string> {
|
|
const contents = `${JSON.stringify(document, null, 2)}\n`;
|
|
await writeFile(path, contents, "utf8");
|
|
return contents;
|
|
}
|
|
|
|
async function expectLegacyStateUntouched(fixture: LegacyArchiveFixture): Promise<void> {
|
|
await expect(readFile(fixture.legacyIndexPath, "utf8")).resolves.toBe(fixture.sourceIndexContents);
|
|
await expect(readFile(fixture.legacyFilePath, "utf8")).resolves.toBe("legacy session\n");
|
|
await expect(readFile(fixture.activeFilePath, "utf8")).resolves.toBe("active session\n");
|
|
}
|
|
|
|
function requiredRecord(records: Record<string, unknown>[], index: number): Record<string, unknown> {
|
|
const record = records[index];
|
|
if (record === undefined) throw new Error(`Missing fixture record ${index.toString()}`);
|
|
return record;
|
|
}
|
|
|
|
async function exists(path: string): Promise<boolean> {
|
|
try {
|
|
await access(path, constants.F_OK);
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|