114 lines
5.6 KiB
TypeScript
114 lines
5.6 KiB
TypeScript
import { execFileSync } from "node:child_process";
|
|
import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
|
|
import { mkdtemp } from "node:fs/promises";
|
|
import { tmpdir } from "node:os";
|
|
import { join } from "node:path";
|
|
import { afterEach, expect, test } from "vitest";
|
|
import {
|
|
main,
|
|
migrateLegacyWorkspace,
|
|
writeMigratedWorkspace,
|
|
} from "../src/workspaces/migrate-legacy.js";
|
|
import * as workspaceSchema from "../src/workspaces/schema.js";
|
|
import { parseWorkspaceYaml } from "../src/workspaces/schema.js";
|
|
|
|
const temporaryRoots: string[] = [];
|
|
|
|
afterEach(() => {
|
|
temporaryRoots.splice(0).forEach((root) => rmSync(root, { recursive: true, force: true }));
|
|
});
|
|
|
|
function readFixture(name: string): string {
|
|
return readFileSync(new URL(`../../harness/workspaces/${name}`, import.meta.url), "utf8");
|
|
}
|
|
|
|
test("migrates the current local PSD descriptor without copying secret values", () => {
|
|
const result = migrateLegacyWorkspace(readFixture("local.yaml"), { id: "local", collection: "local" });
|
|
|
|
expect(result.workspace.workspace).toMatchObject({ id: "local", schema_version: 3, language: "it" });
|
|
expect(JSON.stringify(result)).not.toMatch(/password:|api_key:|\$\{THT_/i);
|
|
});
|
|
|
|
test("migrates a legacy descriptor only with an explicit target collection into schema v3", () => {
|
|
const result = migrateLegacyWorkspace(readFixture("tht.example.yaml"), { id: "example", collection: "shared" });
|
|
const isOperationalWorkspace = (workspaceSchema as { isOperationalWorkspace?: unknown }).isOperationalWorkspace;
|
|
|
|
expect(result.workspace.workspace.schema_version).toBe(3);
|
|
expect(parseWorkspaceYaml(result.source).workspace.schema_version).toBe(3);
|
|
expect(isOperationalWorkspace).toBeTypeOf("function");
|
|
expect((isOperationalWorkspace as (workspace: ReturnType<typeof parseWorkspaceYaml>) => boolean)(
|
|
parseWorkspaceYaml(result.source),
|
|
)).toBe(true);
|
|
expect(parseWorkspaceYaml(result.source)).toMatchObject({
|
|
semantic_index: { vector_store: { engine: "qdrant", collection: "shared" } },
|
|
});
|
|
});
|
|
|
|
test("requires an explicit target collection for legacy migration", () => {
|
|
expect(() => migrateLegacyWorkspace(readFixture("local.yaml"), { id: "local" } as never)).toThrow(
|
|
/collection/i,
|
|
);
|
|
});
|
|
|
|
test("writes versioned repository artifacts atomically without replacing a prior migration", async () => {
|
|
const root = await mkdtemp(join(tmpdir(), "thoth-workspace-migrate-"));
|
|
temporaryRoots.push(root);
|
|
const migration = migrateLegacyWorkspace(readFixture("local.yaml"), { id: "local", collection: "local" });
|
|
|
|
const destination = await writeMigratedWorkspace(migration, root);
|
|
|
|
expect(destination).toBe(join(root, "workspaces", "local.yaml"));
|
|
expect(parseWorkspaceYaml(readFileSync(destination, "utf8"))).toMatchObject({ workspace: { id: "local" } });
|
|
await expect(writeMigratedWorkspace(migration, root)).rejects.toThrow(/already exists/i);
|
|
expect(existsSync(destination)).toBe(true);
|
|
});
|
|
|
|
test("CLI accepts an explicit valid ID when a legacy filename contains dots", async () => {
|
|
const root = await mkdtemp(join(tmpdir(), "thoth-workspace-migrate-"));
|
|
temporaryRoots.push(root);
|
|
const input = join(root, "psd.clinical.yaml");
|
|
writeFileSync(input, readFixture("local.yaml"));
|
|
|
|
await main(["--input", input, "--output", root, "--id", "psd-clinical", "--collection", "psd-clinical"]);
|
|
|
|
const destination = join(root, "workspaces", "psd-clinical.yaml");
|
|
expect(parseWorkspaceYaml(readFileSync(destination, "utf8"))).toMatchObject({
|
|
workspace: { id: "psd-clinical", schema_version: 3 },
|
|
});
|
|
});
|
|
|
|
test("declares a durable isolated registry volume and only read-only Git credential mounts", () => {
|
|
const compose = readFileSync(new URL("../../compose.yaml", import.meta.url), "utf8");
|
|
const development = readFileSync(new URL("../../docker-compose.dev.yml", import.meta.url), "utf8");
|
|
const gitHttps = readFileSync(new URL("../../deploy/compose.git-https.yaml", import.meta.url), "utf8");
|
|
const gitSsh = readFileSync(new URL("../../deploy/compose.git-ssh.yaml", import.meta.url), "utf8");
|
|
const dockerfile = readFileSync(new URL("../../docker/core.Dockerfile", import.meta.url), "utf8");
|
|
const smoke = readFileSync(new URL("../../scripts/workspace-registry-smoke.sh", import.meta.url), "utf8");
|
|
|
|
for (const source of [compose, development]) {
|
|
expect(source).toContain("THT_WORKSPACE_REGISTRY_ROOT: /data/workspace-registry");
|
|
expect(source).toContain("THT_WORKSPACE_GIT_REMOTE: ${THT_WORKSPACE_GIT_REMOTE:?set THT_WORKSPACE_GIT_REMOTE}");
|
|
expect(source).toContain("workspace-registry:/data/workspace-registry");
|
|
}
|
|
expect(compose).not.toMatch(/workspace-registry-git-(?:credentials|ca|ssh-key|known-hosts):ro/);
|
|
expect(gitHttps).toMatch(/workspace-registry-git-credentials:ro/);
|
|
expect(gitHttps).toMatch(/workspace-registry-git-ca:ro/);
|
|
expect(gitSsh).toMatch(/workspace-registry-git-ssh-key:ro/);
|
|
expect(gitSsh).toMatch(/workspace-registry-git-known-hosts:ro/);
|
|
expect(dockerfile).toMatch(/mkdir -p[^\n]*\/data\/workspace-registry/);
|
|
expect(dockerfile).toMatch(/chown -R thoth:thoth \/home\/thoth\/\.pi \/data/);
|
|
expect(smoke).toContain('core_remote="/fixtures/offline.git"');
|
|
expect(smoke).toContain('"degraded":true');
|
|
expect(smoke).toContain('core_remote="/fixtures/remote.git"');
|
|
});
|
|
|
|
test("workspace registry smoke image cleanup is scoped to the per-run image identity", () => {
|
|
const output = execFileSync("bash", ["scripts/workspace-registry-smoke.sh"], {
|
|
cwd: new URL("../..", import.meta.url),
|
|
env: { ...process.env, WORKSPACE_REGISTRY_SMOKE_SELF_TEST: "image-cleanup-identity" },
|
|
encoding: "utf8",
|
|
});
|
|
|
|
expect(output).toContain("workspace registry smoke image cleanup identity self-test passed");
|
|
});
|