@elench/testkit 0.1.16 → 0.1.18

package/lib/database/fingerprint.test.mjs

@@ -0,0 +1,93 @@
+import crypto from "crypto";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  appendFileToHash,
+  appendInputToHash,
+  computeTemplateFingerprint,
+} from "./fingerprint.mjs";
+
+const tempDirs = [];
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+function mkTempDir() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-db-fingerprint-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+describe("database-fingerprint", () => {
+  it("hashes files, directories, and missing paths deterministically", () => {
+    const productDir = mkTempDir();
+    fs.mkdirSync(path.join(productDir, "schema"), { recursive: true });
+    fs.writeFileSync(path.join(productDir, "schema", "001.sql"), "select 1;\n");
+    fs.mkdirSync(path.join(productDir, ".testkit", "ignored"), { recursive: true });
+    fs.writeFileSync(path.join(productDir, ".testkit", "ignored", "skip.sql"), "skip");
+
+    const hashA = crypto.createHash("sha256");
+    appendInputToHash(hashA, productDir, "schema");
+    appendInputToHash(hashA, productDir, "missing");
+    const digestA = hashA.digest("hex");
+
+    const hashB = crypto.createHash("sha256");
+    appendInputToHash(hashB, productDir, "schema");
+    appendInputToHash(hashB, productDir, "missing");
+    const digestB = hashB.digest("hex");
+
+    expect(digestA).toBe(digestB);
+  });
+
+  it("hashes file contents and missing files", () => {
+    const productDir = mkTempDir();
+    const filePath = path.join(productDir, "a.txt");
+    fs.writeFileSync(filePath, "alpha");
+
+    const present = crypto.createHash("sha256");
+    appendFileToHash(present, productDir, filePath);
+    const presentDigest = present.digest("hex");
+
+    const missing = crypto.createHash("sha256");
+    appendFileToHash(missing, productDir, path.join(productDir, "missing.txt"));
+    const missingDigest = missing.digest("hex");
+
+    expect(presentDigest).not.toBe(missingDigest);
+  });
+
+  it("computes template fingerprints from config inputs and env files", async () => {
+    const productDir = mkTempDir();
+    fs.mkdirSync(path.join(productDir, "schema"), { recursive: true });
+    fs.writeFileSync(path.join(productDir, "schema", "001.sql"), "select 1;\n");
+    fs.writeFileSync(path.join(productDir, ".env.testkit"), "TOKEN=alpha\n");
+
+    const config = {
+      productDir,
+      testkit: {
+        database: {
+          provider: "local",
+          selectedBackend: "local",
+          template: {
+            inputs: ["schema"],
+          },
+        },
+        envFiles: [".env.testkit"],
+        migrate: {
+          cmd: "npm run migrate",
+        },
+        seed: null,
+      },
+    };
+
+    const first = await computeTemplateFingerprint(config);
+    fs.writeFileSync(path.join(productDir, ".env.testkit"), "TOKEN=beta\n");
+    const second = await computeTemplateFingerprint(config);
+
+    expect(first).not.toBe(second);
+  });
+});

package/lib/{database.mjs → database/index.mjs}

@@ -1,11 +1,32 @@
-import crypto from "crypto";
 import fs from "fs";
 import path from "path";
 import { execa } from "execa";
-import { requireNeonApiKey, resolveServiceCwd } from "./config.mjs";
-import { runScript } from "./exec.mjs";
-
-const LOCAL_IMAGE = "postgres:16";
+import {
+  appendFileToHash as appendFileToHashModel,
+  appendInputToHash as appendInputToHashModel,
+  computeTemplateFingerprint as computeTemplateFingerprintModel,
+} from "./fingerprint.mjs";
+import {
+  buildContainerName as buildContainerNameModel,
+  buildDatabaseUrl as buildDatabaseUrlModel,
+  buildTemplateDatabaseName as buildTemplateDatabaseNameModel,
+  buildWorkerDatabaseName as buildWorkerDatabaseNameModel,
+  escapeIdentifier as escapeIdentifierModel,
+  escapeSqlLiteral as escapeSqlLiteralModel,
+  hashString as hashStringModel,
+  limitIdentifier as limitIdentifierModel,
+  slugSegment as slugSegmentModel,
+} from "./naming.mjs";
+import {
+  getLocalInfraDir as getLocalInfraDirModel,
+  getLocalLocksDir as getLocalLocksDirModel,
+  getLocalServiceCacheDir as getLocalServiceCacheDirModel,
+  hasRemainingLocalArtifacts as hasRemainingLocalArtifactsModel,
+  readStateValue as readStateValueModel,
+  visitDirs as visitDirsModel,
+} from "./state.mjs";
+
+const LOCAL_IMAGE = "pgvector/pgvector:pg16";
 const LOCAL_USER = "testkit";
 const LOCAL_PASSWORD = "testkit";
 const LOCAL_ADMIN_DB = "postgres";
@@ -17,10 +38,6 @@ export async function prepareDatabaseRuntime(config, hooks = {}) {
   if (!db) return;
 
   fs.mkdirSync(config.stateDir, { recursive: true });
-  if (db.provider === "neon") {
-    await prepareNeonDatabase(config, hooks);
-    return;
-  }
   if (db.provider === "local") {
     await prepareLocalDatabase(config, hooks);
     return;
@@ -31,14 +48,8 @@ export async function prepareDatabaseRuntime(config, hooks = {}) {
 
 export async function destroyRuntimeDatabase({ productDir, stateDir }) {
   const backend = readStateValue(path.join(stateDir, "database_backend"));
-  if (!backend || backend === "neon") {
-    await destroyNeonDatabase(stateDir);
-    return;
-  }
-
   if (backend === "local") {
     await destroyLocalRuntimeDatabase(productDir, stateDir);
-    return;
   }
 }
 
@@ -83,11 +94,7 @@ export async function cleanupOrphanedLocalInfrastructure(productDir) {
 
 export function isDatabaseStateDir(dir) {
   if (!fs.existsSync(dir)) return false;
-  return (
-    fs.existsSync(path.join(dir, "database_backend")) ||
-    fs.existsSync(path.join(dir, "neon_branch_id")) ||
-    fs.existsSync(path.join(dir, "neon_project_id"))
-  );
+  return fs.existsSync(path.join(dir, "database_backend"));
 }
 
 export function showServiceDatabaseStatus(productDir, serviceName) {
@@ -108,42 +115,6 @@ export function showServiceDatabaseStatus(productDir, serviceName) {
   return true;
 }
 
-async function prepareNeonDatabase(config, hooks) {
-  const db = config.testkit.database;
-  requireNeonApiKey();
-
-  removeLocalRuntimeState(config.stateDir);
-
-  await runScript("neon-up.sh", {
-    NEON_PROJECT_ID: db.projectId,
-    NEON_DB_NAME: db.dbName,
-    NEON_BRANCH_NAME: db.branchName,
-    NEON_RESET: db.reset === false ? "false" : "true",
-    STATE_DIR: config.stateDir,
-  });
-
-  fs.writeFileSync(path.join(config.stateDir, "database_backend"), "neon");
-  fs.writeFileSync(path.join(config.stateDir, "neon_project_id"), db.projectId);
-
-  const databaseUrl = readStateValue(path.join(config.stateDir, "database_url"));
-  if (hooks.runMigrate) {
-    await hooks.runMigrate(databaseUrl);
-  }
-  if (hooks.runSeed) {
-    await hooks.runSeed(databaseUrl);
-  }
-}
-
-async function destroyNeonDatabase(stateDir) {
-  const projectId = readStateValue(path.join(stateDir, "neon_project_id"));
-  if (!projectId) return;
-
-  await runScript("neon-down.sh", {
-    NEON_PROJECT_ID: projectId,
-    STATE_DIR: stateDir,
-  });
-}
-
 async function prepareLocalDatabase(config, hooks) {
   const db = config.testkit.database;
   const productDir = config.productDir;
@@ -227,7 +198,6 @@ async function ensureWorkerClone(config, infra, cacheDir, templateFingerprint) {
   }
 
   fs.mkdirSync(config.stateDir, { recursive: true });
-  removeNeonRuntimeState(config.stateDir);
   fs.writeFileSync(path.join(config.stateDir, "database_backend"), "local");
   fs.writeFileSync(path.join(config.stateDir, "database_url"), buildDatabaseUrl(infra, desiredDbName));
   fs.writeFileSync(path.join(config.stateDir, "local_database_name"), desiredDbName);
@@ -427,84 +397,31 @@ async function runAdminQuery(infra, args) {
 }
 
 async function computeTemplateFingerprint(config) {
-  const hash = crypto.createHash("sha256");
-  const db = config.testkit.database;
-  hash.update(JSON.stringify({
-    provider: db.provider,
-    selectedBackend: db.selectedBackend,
-    image: db.image || LOCAL_IMAGE,
-    user: db.user || LOCAL_USER,
-    migrate: config.testkit.migrate || null,
-    seed: config.testkit.seed || null,
-  }));
-
-  const rootEnvPath = path.join(config.productDir, ".env");
-  appendFileToHash(hash, config.productDir, rootEnvPath);
-  for (const envFile of config.testkit.envFiles || []) {
-    appendFileToHash(hash, config.productDir, resolveServiceCwd(config.productDir, envFile));
-  }
-  for (const input of db.template.inputs || []) {
-    appendInputToHash(hash, config.productDir, input);
-  }
-
-  return hash.digest("hex");
+  return computeTemplateFingerprintModel(config);
 }
 
 function appendInputToHash(hash, productDir, input) {
-  const absPath = resolveServiceCwd(productDir, input);
-  if (!fs.existsSync(absPath)) {
-    hash.update(`missing:${path.relative(productDir, absPath)}`);
-    return;
-  }
-
-  const stat = fs.statSync(absPath);
-  if (stat.isDirectory()) {
-    hash.update(`dir:${path.relative(productDir, absPath)}`);
-    for (const entry of fs.readdirSync(absPath).sort()) {
-      if (entry === ".git" || entry === "node_modules" || entry === ".testkit") continue;
-      appendInputToHash(hash, productDir, path.join(input, entry));
-    }
-    return;
-  }
-
-  appendFileToHash(hash, productDir, absPath);
+  return appendInputToHashModel(hash, productDir, input);
 }
 
 function appendFileToHash(hash, productDir, absPath) {
-  if (!fs.existsSync(absPath)) {
-    hash.update(`missing:${path.relative(productDir, absPath)}`);
-    return;
-  }
-  const stat = fs.statSync(absPath);
-  if (!stat.isFile()) return;
-
-  hash.update(`file:${path.relative(productDir, absPath)}:${stat.size}:${stat.mtimeMs}`);
-  hash.update(fs.readFileSync(absPath));
+  return appendFileToHashModel(hash, productDir, absPath);
 }
 
 function buildDatabaseUrl(infra, dbName) {
-  return `postgresql://${encodeURIComponent(infra.user)}:${encodeURIComponent(infra.password)}@${infra.host}:${infra.port}/${dbName}?sslmode=disable`;
+  return buildDatabaseUrlModel(infra, dbName);
 }
 
 function buildContainerName(productDir) {
-  return limitIdentifier(
-    `testkit_pg_${slugSegment(path.basename(productDir))}_${hashString(productDir, 10)}`,
-    63
-  );
+  return buildContainerNameModel(productDir);
 }
 
 function buildTemplateDatabaseName(serviceName, fingerprint) {
-  return limitIdentifier(
-    `tk_tpl_${slugSegment(serviceName)}_${fingerprint.slice(0, 16)}`,
-    63
-  );
+  return buildTemplateDatabaseNameModel(serviceName, fingerprint);
 }
 
 function buildWorkerDatabaseName(serviceName, stateDir, fingerprint) {
-  return limitIdentifier(
-    `tk_${slugSegment(serviceName)}_${hashString(stateDir, 10)}_${fingerprint.slice(0, 12)}`,
-    63
-  );
+  return buildWorkerDatabaseNameModel(serviceName, stateDir, fingerprint);
 }
 
 function writeLocalInfraState(infraDir, infra) {
@@ -526,48 +443,23 @@ function writeLocalCacheState(cacheDir, infra, templateDbName, fingerprint) {
 }
 
 function getLocalInfraDir(productDir) {
-  return path.join(productDir, ".testkit", "_infra", "local-postgres");
+  return getLocalInfraDirModel(productDir);
 }
 
 function getLocalLocksDir(productDir) {
-  return path.join(getLocalInfraDir(productDir), "locks");
+  return getLocalLocksDirModel(productDir);
 }
 
 function getLocalServiceCacheDir(productDir, serviceName) {
-  return path.join(productDir, ".testkit", "_dbcache", serviceName);
+  return getLocalServiceCacheDirModel(productDir, serviceName);
 }
 
 function hasRemainingLocalArtifacts(productDir) {
-  const root = path.join(productDir, ".testkit");
-  if (!fs.existsSync(root)) return false;
-
-  let found = false;
-  visitDirs(root, (dir) => {
-    if (found) return;
-    if (dir.includes(`${path.sep}.testkit${path.sep}_infra`)) return;
-    if (readStateValue(path.join(dir, "database_backend")) === "local") {
-      found = true;
-    }
-  });
-
-  if (found) return true;
-
-  const cacheRoot = path.join(productDir, ".testkit", "_dbcache");
-  if (!fs.existsSync(cacheRoot)) return false;
-  return fs.readdirSync(cacheRoot).some((entry) => {
-    const entryPath = path.join(cacheRoot, entry);
-    return fs.statSync(entryPath).isDirectory();
-  });
+  return hasRemainingLocalArtifactsModel(productDir, readStateValue);
 }
 
 function visitDirs(root, visitor) {
-  if (!fs.existsSync(root)) return;
-  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    const dir = path.join(root, entry.name);
-    visitor(dir);
-    visitDirs(dir, visitor);
-  }
+  return visitDirsModel(root, visitor);
 }
 
 function printStateDir(dir, indent) {
@@ -610,28 +502,27 @@ async function withLock(lockPath, fn) {
 }
 
 function hashString(value, length = 12) {
-  return crypto.createHash("sha256").update(value).digest("hex").slice(0, length);
+  return hashStringModel(value, length);
 }
 
 function slugSegment(value) {
-  return value.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "db";
+  return slugSegmentModel(value);
 }
 
 function limitIdentifier(value, maxLength) {
-  return value.length <= maxLength ? value : value.slice(0, maxLength);
+  return limitIdentifierModel(value, maxLength);
 }
 
 function escapeIdentifier(value) {
-  return String(value).replace(/"/g, "\"\"");
+  return escapeIdentifierModel(value);
 }
 
 function escapeSqlLiteral(value) {
-  return String(value).replace(/'/g, "''");
+  return escapeSqlLiteralModel(value);
 }
 
 function readStateValue(filePath) {
-  if (!fs.existsSync(filePath)) return null;
-  return fs.readFileSync(filePath, "utf8").trim();
+  return readStateValueModel(filePath);
 }
 
 function sleep(ms) {
@@ -648,9 +539,3 @@ function removeLocalRuntimeState(stateDir) {
     fs.rmSync(path.join(stateDir, file), { force: true });
   }
 }
-
-function removeNeonRuntimeState(stateDir) {
-  for (const file of ["neon_project_id", "neon_branch_id"]) {
-    fs.rmSync(path.join(stateDir, file), { force: true });
-  }
-}

package/lib/database/naming.mjs

@@ -0,0 +1,47 @@
+import crypto from "crypto";
+import path from "path";
+
+export function buildDatabaseUrl(infra, dbName) {
+  return `postgresql://${encodeURIComponent(infra.user)}:${encodeURIComponent(infra.password)}@${infra.host}:${infra.port}/${dbName}?sslmode=disable`;
+}
+
+export function buildContainerName(productDir) {
+  return limitIdentifier(
+    `testkit_pg_${slugSegment(path.basename(productDir))}_${hashString(productDir, 10)}`,
+    63
+  );
+}
+
+export function buildTemplateDatabaseName(serviceName, fingerprint) {
+  return limitIdentifier(
+    `tk_tpl_${slugSegment(serviceName)}_${fingerprint.slice(0, 16)}`,
+    63
+  );
+}
+
+export function buildWorkerDatabaseName(serviceName, stateDir, fingerprint) {
+  return limitIdentifier(
+    `tk_${slugSegment(serviceName)}_${hashString(stateDir, 10)}_${fingerprint.slice(0, 12)}`,
+    63
+  );
+}
+
+export function hashString(value, length = 12) {
+  return crypto.createHash("sha256").update(value).digest("hex").slice(0, length);
+}
+
+export function slugSegment(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "db";
+}
+
+export function limitIdentifier(value, maxLength) {
+  return value.length <= maxLength ? value : value.slice(0, maxLength);
+}
+
+export function escapeIdentifier(value) {
+  return String(value).replace(/"/g, "\"\"");
+}
+
+export function escapeSqlLiteral(value) {
+  return String(value).replace(/'/g, "''");
+}

package/lib/database/naming.test.mjs

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildContainerName,
+  buildDatabaseUrl,
+  buildTemplateDatabaseName,
+  buildWorkerDatabaseName,
+  escapeIdentifier,
+  escapeSqlLiteral,
+  slugSegment,
+} from "./naming.mjs";
+
+describe("database-naming", () => {
+  it("builds deterministic names and URLs", () => {
+    expect(buildContainerName("/tmp/My Product")).toMatch(/^testkit_pg_my_product_/);
+    expect(buildTemplateDatabaseName("api", "1234567890abcdef1234")).toBe(
+      "tk_tpl_api_1234567890abcdef"
+    );
+    expect(buildWorkerDatabaseName("api", "/tmp/state", "abcdef1234567890")).toMatch(
+      /^tk_api_[a-f0-9]{10}_abcdef123456$/
+    );
+    expect(
+      buildDatabaseUrl(
+        {
+          user: "a user",
+          password: "p@ss word",
+          host: "127.0.0.1",
+          port: 5432,
+        },
+        "dbname"
+      )
+    ).toContain("postgresql://a%20user:p%40ss%20word@127.0.0.1:5432/dbname");
+  });
+
+  it("escapes identifiers and literals", () => {
+    expect(slugSegment("My API")).toBe("my_api");
+    expect(escapeIdentifier('bad"name')).toBe('bad""name');
+    expect(escapeSqlLiteral("it's")).toBe("it''s");
+  });
+});

package/lib/database/state.mjs

@@ -0,0 +1,52 @@
+import fs from "fs";
+import path from "path";
+
+export function getLocalInfraDir(productDir) {
+  return path.join(productDir, ".testkit", "_infra", "local-postgres");
+}
+
+export function getLocalLocksDir(productDir) {
+  return path.join(getLocalInfraDir(productDir), "locks");
+}
+
+export function getLocalServiceCacheDir(productDir, serviceName) {
+  return path.join(productDir, ".testkit", "_dbcache", serviceName);
+}
+
+export function hasRemainingLocalArtifacts(productDir, readStateValue) {
+  const root = path.join(productDir, ".testkit");
+  if (!fs.existsSync(root)) return false;
+
+  let found = false;
+  visitDirs(root, (dir) => {
+    if (found) return;
+    if (dir.includes(`${path.sep}.testkit${path.sep}_infra`)) return;
+    if (readStateValue(path.join(dir, "database_backend")) === "local") {
+      found = true;
+    }
+  });
+
+  if (found) return true;
+
+  const cacheRoot = path.join(productDir, ".testkit", "_dbcache");
+  if (!fs.existsSync(cacheRoot)) return false;
+  return fs.readdirSync(cacheRoot).some((entry) => {
+    const entryPath = path.join(cacheRoot, entry);
+    return fs.statSync(entryPath).isDirectory();
+  });
+}
+
+export function visitDirs(root, visitor) {
+  if (!fs.existsSync(root)) return;
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const dir = path.join(root, entry.name);
+    visitor(dir);
+    visitDirs(dir, visitor);
+  }
+}
+
+export function readStateValue(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  return fs.readFileSync(filePath, "utf8").trim();
+}

package/lib/database/state.test.mjs

@@ -0,0 +1,66 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  getLocalInfraDir,
+  getLocalLocksDir,
+  getLocalServiceCacheDir,
+  hasRemainingLocalArtifacts,
+  readStateValue,
+  visitDirs,
+} from "./state.mjs";
+
+const tempDirs = [];
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+function mkTempDir() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-db-state-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+describe("database-state", () => {
+  it("builds local state paths", () => {
+    expect(getLocalInfraDir("/tmp/product")).toBe("/tmp/product/.testkit/_infra/local-postgres");
+    expect(getLocalLocksDir("/tmp/product")).toBe("/tmp/product/.testkit/_infra/local-postgres/locks");
+    expect(getLocalServiceCacheDir("/tmp/product", "api")).toBe("/tmp/product/.testkit/_dbcache/api");
+  });
+
+  it("reads state values and visits directories", () => {
+    const productDir = mkTempDir();
+    const aDir = path.join(productDir, "a");
+    const bDir = path.join(aDir, "b");
+    fs.mkdirSync(bDir, { recursive: true });
+    fs.writeFileSync(path.join(aDir, "value"), " hello \n");
+
+    const visited = [];
+    visitDirs(productDir, (dir) => visited.push(path.relative(productDir, dir)));
+
+    expect(visited).toEqual(["a", path.join("a", "b")]);
+    expect(readStateValue(path.join(aDir, "value"))).toBe("hello");
+    expect(readStateValue(path.join(aDir, "missing"))).toBeNull();
+  });
+
+  it("detects remaining local artifacts", () => {
+    const productDir = mkTempDir();
+    const runtimeDir = path.join(productDir, ".testkit", "api");
+    fs.mkdirSync(runtimeDir, { recursive: true });
+    fs.writeFileSync(path.join(runtimeDir, "database_backend"), "local");
+
+    expect(hasRemainingLocalArtifacts(productDir, readStateValue)).toBe(true);
+
+    fs.rmSync(path.join(productDir, ".testkit"), { recursive: true, force: true });
+    fs.mkdirSync(path.join(productDir, ".testkit", "_dbcache", "api"), { recursive: true });
+
+    expect(hasRemainingLocalArtifacts(productDir, readStateValue)).toBe(true);
+
+    fs.rmSync(path.join(productDir, ".testkit"), { recursive: true, force: true });
+    expect(hasRemainingLocalArtifacts(productDir, readStateValue)).toBe(false);
+  });
+});