@elench/testkit 0.1.6 → 0.1.8

package/infra/neon-up.sh

@@ -106,6 +106,7 @@ if command -v psql &>/dev/null; then
         SELECT tablename FROM pg_tables
         WHERE schemaname = 'public'
         AND tablename NOT LIKE '%migration%'
+        AND tablename NOT LIKE 'goose_%'
         AND tablename NOT LIKE 'drizzle_%'
       ) LOOP
         EXECUTE 'TRUNCATE TABLE public.' || quote_ident(r.tablename) || ' CASCADE';

package/lib/config.mjs

@@ -87,6 +87,14 @@ export function loadConfigs(opts = {}) {
         throw new Error(`Secret "${key}" (service "${name}") not found in env or .env`);
       }
     }
+    // Check dependent secrets
+    for (const dep of tk.depends || []) {
+      for (const key of dep.fly?.secrets || []) {
+        if (!process.env[key]) {
+          throw new Error(`Secret "${key}" (service "${name}", dep "${dep.name}") not found in env or .env`);
+        }
+      }
+    }
 
     // Each service gets its own state dir: .testkit/<service>/
     const stateDir = entries.length === 1
@@ -178,6 +186,14 @@ function validateService(name, svc, manifestPath) {
       optionalStringArray(errors, tk.fly, `${ctx}: testkit.fly.secrets`, "secrets");
     }
 
+    if (tk.migrate !== undefined) {
+      if (!isObject(tk.migrate)) {
+        errors.push(`${ctx}: testkit.migrate must be an object`);
+      } else {
+        requireString(errors, tk.migrate, `${ctx}: testkit.migrate.cmd`, "cmd");
+      }
+    }
+
     if (tk.k6 !== undefined && !isObject(tk.k6)) {
       errors.push(`${ctx}: testkit.k6 must be an object`);
     }
@@ -185,6 +201,30 @@ function validateService(name, svc, manifestPath) {
     if (tk.dal !== undefined && !isObject(tk.dal)) {
       errors.push(`${ctx}: testkit.dal must be an object`);
     }
+
+    if (tk.depends !== undefined) {
+      if (!Array.isArray(tk.depends)) {
+        errors.push(`${ctx}: testkit.depends must be an array`);
+      } else {
+        for (let i = 0; i < tk.depends.length; i++) {
+          const dep = tk.depends[i];
+          const dp = `${ctx}: testkit.depends[${i}]`;
+          if (!isObject(dep)) {
+            errors.push(`${dp} must be an object`);
+            continue;
+          }
+          requireString(errors, dep, `${dp}.name`, "name");
+          requireString(errors, dep, `${dp}.dockerfile`, "dockerfile");
+          if (!isObject(dep.fly)) {
+            errors.push(`${dp}.fly is required and must be an object`);
+          } else {
+            requireString(errors, dep.fly, `${dp}.fly.app`, "app");
+            requireString(errors, dep.fly, `${dp}.fly.org`, "org");
+            optionalStringArray(errors, dep.fly, `${dp}.fly.secrets`, "secrets");
+          }
+        }
+      }
+    }
   }
 
   if (!isObject(svc.suites)) {
@@ -201,6 +241,9 @@ function validateService(name, svc, manifestPath) {
         const prefix = `${ctx}: suites.${type}[${i}]`;
         requireString(errors, suite, `${prefix}.name`, "name");
         requireNonEmptyStringArray(errors, suite, `${prefix}.files`, "files");
+        if (suite.pre !== undefined && (typeof suite.pre !== "string" || suite.pre.length === 0)) {
+          errors.push(`${prefix}.pre must be a non-empty string (shell command)`);
+        }
       }
     }
   }

package/lib/runner.mjs

@@ -96,6 +96,69 @@ export async function flyUp(config) {
   });
 }
 
+/**
+ * Build a dependent service's Docker image.
+ */
+async function buildDep(config, dep) {
+  const { productDir, stateDir } = config;
+  const depStateDir = path.join(stateDir, "deps", dep.name);
+  fs.mkdirSync(depStateDir, { recursive: true });
+  await runScript("fly-build.sh", {
+    FLY_APP: dep.fly.app,
+    FLY_ORG: dep.fly.org,
+    API_DIR: productDir,
+    DOCKERFILE_DIR: path.join(productDir, dep.dockerfile),
+    STATE_DIR: depStateDir,
+  });
+}
+
+/**
+ * Deploy a dependent service's Fly machine.
+ * Copies database_url from primary, generates fly-env.sh, calls fly-up.sh.
+ */
+async function flyUpDep(config, dep) {
+  const { stateDir } = config;
+  const depStateDir = path.join(stateDir, "deps", dep.name);
+  fs.mkdirSync(depStateDir, { recursive: true });
+
+  // Copy database_url from primary state dir
+  const primaryDbUrl = path.join(stateDir, "database_url");
+  if (fs.existsSync(primaryDbUrl)) {
+    fs.copyFileSync(primaryDbUrl, path.join(depStateDir, "database_url"));
+  }
+
+  // Generate fly-env.sh for dependent
+  const envLines = [];
+  for (const [k, v] of Object.entries(dep.fly.env || {})) {
+    envLines.push(`  --env ${k}=${v}`);
+  }
+  for (const k of dep.fly.secrets || []) {
+    envLines.push(`  --env ${k}=$${k}`);  // shell substitution at source-time
+  }
+  const flyEnvPath = path.join(depStateDir, "fly-env.sh");
+  fs.writeFileSync(flyEnvPath, `FLY_ENV_FLAGS="\n${envLines.join("\n")}\n"\n`);
+
+  await runScript("fly-up.sh", {
+    FLY_APP: dep.fly.app,
+    FLY_ORG: dep.fly.org,
+    FLY_REGION: dep.fly.region || "lhr",
+    FLY_PORT: dep.fly.port,
+    FLY_ENV_FILE: flyEnvPath,
+    STATE_DIR: depStateDir,
+  });
+}
+
+/**
+ * Stop a dependent service's Fly machine.
+ */
+async function flyDownDep(config, dep) {
+  const depStateDir = path.join(config.stateDir, "deps", dep.name);
+  await runScript("fly-down.sh", {
+    FLY_APP: dep.fly.app,
+    STATE_DIR: depStateDir,
+  });
+}
+
 /**
  * Stop the Fly machine (preserved for reuse).
  */
@@ -109,10 +172,20 @@ export async function flyDown(config) {
 
 /**
  * Destroy machine + neon branch + state.
+ * Destroys dependent machines first, then primary.
  */
 export async function destroy(config) {
   const { stateDir, manifest } = config;
   const tk = manifest.testkit;
+
+  // Destroy dependents first
+  for (const dep of tk.depends || []) {
+    const depStateDir = path.join(stateDir, "deps", dep.name);
+    if (fs.existsSync(depStateDir)) {
+      await runScript("fly-destroy.sh", { FLY_APP: dep.fly.app, STATE_DIR: depStateDir });
+    }
+  }
+
   await runScript("fly-destroy.sh", { FLY_APP: tk.fly.app, STATE_DIR: stateDir });
   await runScript("neon-down.sh", {
     NEON_PROJECT_ID: tk.neon.projectId,
@@ -181,6 +254,66 @@ export async function runDalTests(config, files) {
   return { failed };
 }
 
+/**
+ * Delete the Neon branch (so neonUp creates a fresh fork from prod).
+ */
+async function neonReset(config) {
+  const { stateDir, manifest } = config;
+  const tk = manifest.testkit;
+  console.log("Deleting Neon branch for fresh fork...");
+  await runScript("neon-down.sh", {
+    NEON_PROJECT_ID: tk.neon.projectId,
+    STATE_DIR: stateDir,
+  });
+  // Clear branch state so neonUp creates a new one
+  const branchFile = path.join(stateDir, "neon_branch_id");
+  if (fs.existsSync(branchFile)) fs.unlinkSync(branchFile);
+  const dbUrlFile = path.join(stateDir, "database_url");
+  if (fs.existsSync(dbUrlFile)) fs.unlinkSync(dbUrlFile);
+}
+
+/**
+ * Run database migrations from local source against the test branch.
+ * If migrations fail, nukes the Neon branch and retries on a fresh fork.
+ * A second failure means a real migration bug — throws.
+ */
+async function migrate(config) {
+  const { productDir, stateDir, manifest } = config;
+  const migrateCmd = manifest.testkit.migrate?.cmd;
+  if (!migrateCmd) return;
+
+  const dbUrlPath = path.join(stateDir, "database_url");
+  const env = { ...process.env };
+  if (fs.existsSync(dbUrlPath)) {
+    env.DATABASE_URL = fs.readFileSync(dbUrlPath, "utf8").trim();
+  }
+
+  const execOpts = { stdio: "inherit", cwd: productDir, env, shell: true };
+
+  console.log("\n── migrate ──");
+  try {
+    await execaCommand(migrateCmd, execOpts);
+    return;
+  } catch (err) {
+    console.log("\nMigration failed — resetting Neon branch and retrying...\n");
+  }
+
+  // Nuke and retry: fresh fork from prod, clean goose state
+  await neonReset(config);
+  await neonUp(config);
+
+  // Re-read DATABASE_URL from fresh branch
+  if (fs.existsSync(dbUrlPath)) {
+    env.DATABASE_URL = fs.readFileSync(dbUrlPath, "utf8").trim();
+  }
+
+  try {
+    await execaCommand(migrateCmd, execOpts);
+  } catch (retryErr) {
+    throw new Error(`Migration failed on fresh branch — likely a bug in your migration SQL:\n${retryErr.message}`);
+  }
+}
+
 /**
  * Show state directory contents.
  */
@@ -197,6 +330,39 @@ export function showStatus(config) {
     const val = fs.readFileSync(filePath, "utf8").trim();
     console.log(`  ${file}: ${val}`);
   }
+
+  // Show dependent state dirs
+  const depsDir = path.join(stateDir, "deps");
+  if (fs.existsSync(depsDir)) {
+    for (const depName of fs.readdirSync(depsDir)) {
+      const depDir = path.join(depsDir, depName);
+      if (!fs.statSync(depDir).isDirectory()) continue;
+      console.log(`  ── dep: ${depName} ──`);
+      for (const file of fs.readdirSync(depDir)) {
+        if (file === "fly-env.sh") continue;
+        const filePath = path.join(depDir, file);
+        if (fs.statSync(filePath).isDirectory()) continue;
+        const val = fs.readFileSync(filePath, "utf8").trim();
+        console.log(`    ${file}: ${val}`);
+      }
+    }
+  }
+}
+
+/**
+ * Run a suite's `pre` command if defined.
+ * Executes in the product directory with DATABASE_URL available.
+ */
+async function runSuitePre(config, suite) {
+  if (!suite.pre) return;
+  const { productDir, stateDir } = config;
+  const dbUrlPath = path.join(stateDir, "database_url");
+  const env = { ...process.env };
+  if (fs.existsSync(dbUrlPath)) {
+    env.DATABASE_URL = fs.readFileSync(dbUrlPath, "utf8").trim();
+  }
+  console.log(`\n── pre: ${suite.name} ──`);
+  await execaCommand(suite.pre, { stdio: "inherit", cwd: productDir, env, shell: true });
 }
 
 /**
@@ -206,25 +372,28 @@ export function showStatus(config) {
 async function runService(config, suiteType, suiteNames, opts) {
   const { manifest, stateDir } = config;
 
-  // Collect test files from manifest, partitioned by flow
+  // Collect suites from manifest, partitioned by flow
   const types = suiteType === "all"
     ? Object.keys(manifest.suites)
     : [suiteType === "int" ? "integration" : suiteType];
 
-  let httpFiles = [];
-  let dalFiles = [];
+  let httpSuites = [];
+  let dalSuites = [];
   for (const type of types) {
     const suites = manifest.suites[type] || [];
     for (const suite of suites) {
       if (suiteNames.length && !suiteNames.includes(suite.name)) continue;
       if (type === "dal") {
-        dalFiles.push(...suite.files);
+        dalSuites.push(suite);
       } else {
-        httpFiles.push(...suite.files);
+        httpSuites.push(suite);
       }
     }
   }
 
+  const httpFiles = httpSuites.flatMap((s) => s.files);
+  const dalFiles = dalSuites.flatMap((s) => s.files);
+
   if (!httpFiles.length && !dalFiles.length) {
     console.log(`No test files for ${config.name} type="${suiteType}" suites=${suiteNames.join(",") || "all"} — skipping`);
     return false;
@@ -235,26 +404,56 @@ async function runService(config, suiteType, suiteNames, opts) {
   let failed = false;
   let neonReady = false;
 
-  // HTTP flow: build → neon → fly → run → fly down
+  // HTTP flow: build → neon → migrate → fly → run → fly down
   if (httpFiles.length) {
     requireFlyToken(config.name);
-    if (opts.build) await build(config);
+    const deps = manifest.testkit.depends || [];
+
+    // Phase 1: Build primary + deps in parallel
+    if (opts.build) {
+      await Promise.all([
+        build(config),
+        ...deps.map(dep => buildDep(config, dep)),
+      ]);
+    }
+
+    // Phase 2: Database (unchanged)
     await neonUp(config);
+    await migrate(config);
     neonReady = true;
-    await flyUp(config);
+
+    // Phase 3: Deploy primary + deps in parallel
+    await Promise.all([
+      flyUp(config),
+      ...deps.map(dep => flyUpDep(config, dep)),
+    ]);
+
     try {
+      for (const suite of httpSuites) {
+        await runSuitePre(config, suite);
+      }
       const result = await runTests(config, httpFiles);
       if (result?.failed) failed = true;
     } finally {
-      await flyDown(config);
+      // Phase 5: Teardown primary + deps in parallel
+      await Promise.allSettled([
+        flyDown(config),
+        ...deps.map(dep => flyDownDep(config, dep)),
+      ]);
     }
   }
 
-  // DAL flow: neon (idempotent) → run DAL tests
+  // DAL flow: neon → migrate → run suite pre hooks → run DAL tests
   if (dalFiles.length) {
-    if (!neonReady) await neonUp(config);
-    const result = await runDalTests(config, dalFiles);
-    if (result?.failed) failed = true;
+    if (!neonReady) {
+      await neonUp(config);
+      await migrate(config);
+    }
+    for (const suite of dalSuites) {
+      await runSuitePre(config, suite);
+      const result = await runDalTests(config, suite.files);
+      if (result?.failed) failed = true;
+    }
   }
 
   return failed;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "CLI for running k6 tests against real, ephemeral infrastructure",
   "type": "module",
   "bin": {