@elench/testkit 0.1.10 → 0.1.12

package/lib/config.mjs

@@ -2,6 +2,10 @@ import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
 
+const RUNNER_MANIFEST = "runner.manifest.json";
+const TESTKIT_CONFIG = "testkit.config.json";
+const VALID_FRAMEWORKS = new Set(["k6", "playwright"]);
+
 /**
  * Parse a .env file into an object. Supports KEY=VALUE, KEY='VALUE', KEY="VALUE".
  * Skips comments (#) and blank lines.
@@ -16,8 +20,10 @@ export function parseDotenv(filePath) {
     if (eq === -1) continue;
     const key = trimmed.slice(0, eq).trim();
     let val = trimmed.slice(eq + 1).trim();
-    if ((val.startsWith("'") && val.endsWith("'")) ||
-        (val.startsWith('"') && val.endsWith('"'))) {
+    if (
+      (val.startsWith("'") && val.endsWith("'")) ||
+      (val.startsWith('"') && val.endsWith('"'))
+    ) {
       val = val.slice(1, -1);
     }
     env[key] = val;
@@ -25,105 +31,62 @@ export function parseDotenv(filePath) {
   return env;
 }
 
-/**
- * Read the manifest and return the service names.
- * Used by the CLI to resolve ambiguous positional args.
- */
 export function getServiceNames(cwd) {
   const dir = cwd || process.cwd();
-  const manifestPath = path.join(dir, "testkit.manifest.json");
-  if (!fs.existsSync(manifestPath)) return [];
-  const m = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
-  if (!isObject(m.services)) return [];
-  return Object.keys(m.services);
+  const runnerPath = path.join(dir, RUNNER_MANIFEST);
+  if (!fs.existsSync(runnerPath)) return [];
+  const runner = JSON.parse(fs.readFileSync(runnerPath, "utf8"));
+  if (!isObject(runner.services)) return [];
+  return Object.keys(runner.services);
 }
 
-/**
- * Load configs for all (or one) service from the manifest.
- * Returns an array of { name, productDir, stateDir, manifest } objects.
- *
- * opts.service — filter to a single service name
- * opts.dir     — explicit product directory
- */
 export function loadConfigs(opts = {}) {
-  const cwd = process.cwd();
-  const productDir = resolveProductDir(cwd, opts.dir);
-  const manifestPath = path.join(productDir, "testkit.manifest.json");
-  const raw = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+  const productDir = resolveProductDir(process.cwd(), opts.dir);
+  const runner = loadRunnerManifest(productDir);
+  const config = loadTestkitConfig(productDir);
+  validateConfigCoverage(runner, config);
 
-  if (!isObject(raw.services)) {
-    throw new Error(`Manifest must have a "services" object (${manifestPath})`);
-  }
-
-  // Load product .env into process.env (product wins on conflict)
   const dotenv = parseDotenv(path.join(productDir, ".env"));
   Object.assign(process.env, dotenv);
 
-  if (!process.env.NEON_API_KEY) {
-    throw new Error(
-      `NEON_API_KEY not found. Set it in your shell environment, .envrc, or .env`
-    );
-  }
-
-  const entries = Object.entries(raw.services);
-
-  // Filter by service name if requested
+  const serviceEntries = Object.entries(runner.services);
   const filtered = opts.service
-    ? entries.filter(([name]) => name === opts.service)
-    : entries;
+    ? serviceEntries.filter(([name]) => name === opts.service)
+    : serviceEntries;
 
   if (opts.service && filtered.length === 0) {
-    const available = entries.map(([n]) => n).join(", ");
+    const available = serviceEntries.map(([name]) => name).join(", ");
     throw new Error(`Service "${opts.service}" not found. Available: ${available}`);
   }
 
-  return filtered.map(([name, svc]) => {
-    validateService(name, svc, manifestPath);
-
-    // Check service secrets are available
-    const tk = svc.testkit;
-    for (const key of [...(tk.fly?.secrets || []), ...(tk.k6?.secrets || []), ...(tk.dal?.secrets || [])]) {
-      if (!process.env[key]) {
-        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`);
-        }
-      }
+  return filtered.map(([name, runnerService]) => {
+    const serviceConfig = config.services[name];
+    if (!serviceConfig) {
+      throw new Error(
+        `Service "${name}" exists in ${RUNNER_MANIFEST} but is missing from ${TESTKIT_CONFIG}`
+      );
     }
 
-    // Each service gets its own state dir: .testkit/<service>/
-    const stateDir = entries.length === 1
-      ? path.join(productDir, ".testkit")
-      : path.join(productDir, ".testkit", name);
+    validateMergedService(name, runnerService, serviceConfig, productDir);
 
     return {
       name,
       productDir,
-      stateDir,
-      manifest: { testkit: tk, suites: svc.suites },
+      stateDir: path.join(productDir, ".testkit", name),
+      suites: runnerService.suites,
+      testkit: serviceConfig,
     };
   });
 }
 
-/**
- * Require FLY_API_TOKEN. Call this only when HTTP tests need Fly infrastructure.
- */
-export function requireFlyToken(serviceName) {
-  if (!process.env.FLY_API_TOKEN) {
+export function requireNeonApiKey() {
+  if (!process.env.NEON_API_KEY) {
     throw new Error(
-      `FLY_API_TOKEN not found. Set it in your shell environment, .envrc, or .env`
+      "NEON_API_KEY not found. Set it in your shell environment, .envrc, or .env"
     );
   }
 }
 
-/**
- * Resolve the bundled k6-sql binary for DAL tests. Returns the absolute path.
- */
 export function resolveDalBinary() {
   const thisFile = fileURLToPath(import.meta.url);
   const abs = path.resolve(path.dirname(thisFile), "..", "vendor", "k6");
@@ -133,150 +96,306 @@ export function resolveDalBinary() {
   return abs;
 }
 
-// ── Directory resolution ────────────────────────────────────────────────
+export function resolveServiceCwd(productDir, maybeRelative) {
+  return path.resolve(productDir, maybeRelative || ".");
+}
+
+function loadRunnerManifest(productDir) {
+  const manifestPath = path.join(productDir, RUNNER_MANIFEST);
+  const raw = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+
+  if (!isObject(raw.services)) {
+    throw new Error(`${RUNNER_MANIFEST} must have a "services" object (${manifestPath})`);
+  }
+
+  for (const [serviceName, service] of Object.entries(raw.services)) {
+    if (!isObject(service)) {
+      throw new Error(`Service "${serviceName}" in ${RUNNER_MANIFEST} must be an object`);
+    }
+    if (!isObject(service.suites)) {
+      throw new Error(`Service "${serviceName}" in ${RUNNER_MANIFEST} must define suites`);
+    }
+
+    for (const [suiteType, suites] of Object.entries(service.suites)) {
+      if (!Array.isArray(suites)) {
+        throw new Error(
+          `Service "${serviceName}" suite type "${suiteType}" must be an array`
+        );
+      }
+
+      const seenNames = new Set();
+      for (const suite of suites) {
+        if (!isObject(suite)) {
+          throw new Error(
+            `Service "${serviceName}" suite type "${suiteType}" contains a non-object suite`
+          );
+        }
+        if (typeof suite.name !== "string" || !suite.name.length) {
+          throw new Error(
+            `Service "${serviceName}" suite type "${suiteType}" has a suite with no name`
+          );
+        }
+        if (seenNames.has(suite.name)) {
+          throw new Error(
+            `Service "${serviceName}" suite type "${suiteType}" has duplicate suite name "${suite.name}"`
+          );
+        }
+        seenNames.add(suite.name);
+
+        if (!Array.isArray(suite.files) || suite.files.length === 0) {
+          throw new Error(
+            `Service "${serviceName}" suite "${suite.name}" must define one or more files`
+          );
+        }
+        for (const file of suite.files) {
+          if (typeof file !== "string" || !file.length) {
+            throw new Error(
+              `Service "${serviceName}" suite "${suite.name}" contains an invalid file entry`
+            );
+          }
+        }
+
+        const framework = suite.framework || "k6";
+        if (!VALID_FRAMEWORKS.has(framework)) {
+          throw new Error(
+            `Service "${serviceName}" suite "${suite.name}" uses unsupported framework "${framework}"`
+          );
+        }
+
+        if (suite.testkit !== undefined) {
+          if (!isObject(suite.testkit)) {
+            throw new Error(
+              `Service "${serviceName}" suite "${suite.name}" testkit config must be an object`
+            );
+          }
+          if (
+            suite.testkit.maxFileConcurrency !== undefined &&
+            (!Number.isInteger(suite.testkit.maxFileConcurrency) ||
+              suite.testkit.maxFileConcurrency <= 0)
+          ) {
+            throw new Error(
+              `Service "${serviceName}" suite "${suite.name}" testkit.maxFileConcurrency must be a positive integer`
+            );
+          }
+          if (
+            suite.testkit.weight !== undefined &&
+            (!Number.isInteger(suite.testkit.weight) || suite.testkit.weight <= 0)
+          ) {
+            throw new Error(
+              `Service "${serviceName}" suite "${suite.name}" testkit.weight must be a positive integer`
+            );
+          }
+        }
+      }
+    }
+  }
+
+  return raw;
+}
+
+function loadTestkitConfig(productDir) {
+  const configPath = path.join(productDir, TESTKIT_CONFIG);
+  const raw = JSON.parse(fs.readFileSync(configPath, "utf8"));
+
+  if (!isObject(raw.services)) {
+    throw new Error(`${TESTKIT_CONFIG} must have a "services" object (${configPath})`);
+  }
+
+  for (const [serviceName, service] of Object.entries(raw.services)) {
+    validateServiceConfig(serviceName, service, configPath);
+  }
+
+  return raw;
+}
+
+function validateConfigCoverage(runner, config) {
+  for (const serviceName of Object.keys(config.services)) {
+    if (!runner.services[serviceName]) {
+      throw new Error(
+        `Service "${serviceName}" exists in ${TESTKIT_CONFIG} but not in ${RUNNER_MANIFEST}`
+      );
+    }
+
+    for (const depName of config.services[serviceName].dependsOn || []) {
+      if (!config.services[depName]) {
+        throw new Error(
+          `Service "${serviceName}" depends on "${depName}", but ${depName} is missing from ${TESTKIT_CONFIG}`
+        );
+      }
+      if (!runner.services[depName]) {
+        throw new Error(
+          `Service "${serviceName}" depends on "${depName}", but ${depName} is missing from ${RUNNER_MANIFEST}`
+        );
+      }
+    }
+  }
+}
 
 function resolveProductDir(cwd, explicitDir) {
   if (explicitDir) {
-    const p = path.resolve(cwd, explicitDir);
-    if (fs.existsSync(path.join(p, "testkit.manifest.json"))) return p;
-    throw new Error(`No testkit.manifest.json in ${p}`);
+    const dir = path.resolve(cwd, explicitDir);
+    ensureProductFiles(dir);
+    return dir;
   }
 
-  // Check cwd
-  if (fs.existsSync(path.join(cwd, "testkit.manifest.json"))) return cwd;
+  ensureProductFiles(cwd);
+  return cwd;
+}
 
-  throw new Error(
-    `No testkit.manifest.json in current directory. ` +
-    `Either cd into a product directory or use --dir.`
+function ensureProductFiles(dir) {
+  const missing = [RUNNER_MANIFEST, TESTKIT_CONFIG].filter(
+    (file) => !fs.existsSync(path.join(dir, file))
   );
+  if (missing.length > 0) {
+    throw new Error(
+      `Expected ${missing.join(" and ")} in ${dir}. Either cd into a product directory or use --dir.`
+    );
+  }
 }
 
-/**
- * Check if the given name (relative to cwd) is a sibling directory with a manifest.
- * Used by the CLI to distinguish dir args from service/type args.
- */
 export function isSiblingProduct(name) {
   const candidate = path.join(process.cwd(), name);
-  return fs.existsSync(path.join(candidate, "testkit.manifest.json"));
+  return (
+    fs.existsSync(path.join(candidate, RUNNER_MANIFEST)) &&
+    fs.existsSync(path.join(candidate, TESTKIT_CONFIG))
+  );
 }
 
-// ── Per-service validation ──────────────────────────────────────────────
-
-function validateService(name, svc, manifestPath) {
-  const errors = [];
-  const ctx = `service "${name}" in ${manifestPath}`;
+function validateMergedService(name, runnerService, serviceConfig, productDir) {
+  const usesLocalExecution = Object.values(runnerService.suites).some((suites) =>
+    suites.some((suite) => suite.framework !== "k6" || !isDalSuiteType(suite, runnerService, suites))
+  );
 
-  if (!isObject(svc.testkit)) {
-    errors.push(`${ctx}: testkit is required and must be an object`);
-  } else {
-    const tk = svc.testkit;
+  if (usesLocalExecution && !isObject(serviceConfig.local)) {
+    throw new Error(
+      `Service "${name}" defines non-DAL suites but has no local runtime in ${TESTKIT_CONFIG}`
+    );
+  }
 
-    if (!isObject(tk.neon)) {
-      errors.push(`${ctx}: testkit.neon is required`);
-    } else {
-      requireString(errors, tk.neon, `${ctx}: testkit.neon.projectId`, "projectId");
-      requireString(errors, tk.neon, `${ctx}: testkit.neon.dbName`, "dbName");
-      if (tk.neon.reset !== undefined && typeof tk.neon.reset !== "boolean") {
-        errors.push(`${ctx}: testkit.neon.reset must be a boolean`);
+  if (serviceConfig.dependsOn) {
+    for (const dep of serviceConfig.dependsOn) {
+      if (dep === name) {
+        throw new Error(`Service "${name}" cannot depend on itself`);
       }
     }
+  }
 
-    if (!isObject(tk.fly)) {
-      errors.push(`${ctx}: testkit.fly is required`);
-    } else {
-      requireString(errors, tk.fly, `${ctx}: testkit.fly.app`, "app");
-      requireString(errors, tk.fly, `${ctx}: testkit.fly.org`, "org");
-      optionalStringArray(errors, tk.fly, `${ctx}: testkit.fly.secrets`, "secrets");
+  if (serviceConfig.local?.cwd) {
+    const cwdPath = resolveServiceCwd(productDir, serviceConfig.local.cwd);
+    if (!fs.existsSync(cwdPath)) {
+      throw new Error(
+        `Service "${name}" local.cwd does not exist: ${serviceConfig.local.cwd}`
+      );
     }
+  }
 
-    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 (serviceConfig.migrate?.cwd) {
+    const cwdPath = resolveServiceCwd(productDir, serviceConfig.migrate.cwd);
+    if (!fs.existsSync(cwdPath)) {
+      throw new Error(
+        `Service "${name}" migrate.cwd does not exist: ${serviceConfig.migrate.cwd}`
+      );
     }
+  }
 
-    if (tk.k6 !== undefined && !isObject(tk.k6)) {
-      errors.push(`${ctx}: testkit.k6 must be an object`);
+  if (serviceConfig.seed?.cwd) {
+    const cwdPath = resolveServiceCwd(productDir, serviceConfig.seed.cwd);
+    if (!fs.existsSync(cwdPath)) {
+      throw new Error(
+        `Service "${name}" seed.cwd does not exist: ${serviceConfig.seed.cwd}`
+      );
     }
+  }
+}
 
-    if (tk.dal !== undefined && !isObject(tk.dal)) {
-      errors.push(`${ctx}: testkit.dal must be an object`);
-    }
+function validateServiceConfig(name, service, configPath) {
+  if (!isObject(service)) {
+    throw new Error(`Service "${name}" in ${configPath} 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 (service.dependsOn !== undefined) {
+    if (!Array.isArray(service.dependsOn) || service.dependsOn.some((v) => typeof v !== "string")) {
+      throw new Error(`Service "${name}" dependsOn must be an array of service names`);
     }
   }
 
-  if (!isObject(svc.suites)) {
-    errors.push(`${ctx}: suites is required and must be an object`);
-  } else {
-    for (const type of Object.keys(svc.suites)) {
-      const arr = svc.suites[type];
-      if (!Array.isArray(arr)) {
-        errors.push(`${ctx}: suites.${type} must be an array`);
-        continue;
-      }
-      for (let i = 0; i < arr.length; i++) {
-        const suite = arr[i];
-        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)`);
-        }
-      }
+  if (service.database !== undefined) {
+    if (!isObject(service.database)) {
+      throw new Error(`Service "${name}" database must be an object`);
+    }
+    const db = service.database;
+    if (db.provider !== "neon") {
+      throw new Error(`Service "${name}" database.provider must be "neon"`);
+    }
+    requireString(db, "projectId", `Service "${name}" database.projectId`);
+    requireString(db, "dbName", `Service "${name}" database.dbName`);
+    if (db.branchName !== undefined && typeof db.branchName !== "string") {
+      throw new Error(`Service "${name}" database.branchName must be a string`);
+    }
+    if (db.reset !== undefined && typeof db.reset !== "boolean") {
+      throw new Error(`Service "${name}" database.reset must be a boolean`);
     }
   }
 
-  if (errors.length) throw new Error(errors.join("\n"));
-}
+  if (service.migrate !== undefined) {
+    if (!isObject(service.migrate)) {
+      throw new Error(`Service "${name}" migrate must be an object`);
+    }
+    requireString(service.migrate, "cmd", `Service "${name}" migrate.cmd`);
+    if (service.migrate.cwd !== undefined && typeof service.migrate.cwd !== "string") {
+      throw new Error(`Service "${name}" migrate.cwd must be a string`);
+    }
+  }
 
-// ── Helpers ─────────────────────────────────────────────────────────────
+  if (service.seed !== undefined) {
+    if (!isObject(service.seed)) {
+      throw new Error(`Service "${name}" seed must be an object`);
+    }
+    requireString(service.seed, "cmd", `Service "${name}" seed.cmd`);
+    if (service.seed.cwd !== undefined && typeof service.seed.cwd !== "string") {
+      throw new Error(`Service "${name}" seed.cwd must be a string`);
+    }
+  }
 
-function isObject(v) {
-  return v !== null && typeof v === "object" && !Array.isArray(v);
+  if (service.local !== undefined) {
+    if (!isObject(service.local)) {
+      throw new Error(`Service "${name}" local must be an object`);
+    }
+    requireString(service.local, "start", `Service "${name}" local.start`);
+    requireString(service.local, "baseUrl", `Service "${name}" local.baseUrl`);
+    requireString(service.local, "readyUrl", `Service "${name}" local.readyUrl`);
+    if (
+      service.local.port !== undefined &&
+      (!Number.isInteger(service.local.port) || service.local.port <= 0)
+    ) {
+      throw new Error(`Service "${name}" local.port must be a positive integer`);
+    }
+    if (service.local.cwd !== undefined && typeof service.local.cwd !== "string") {
+      throw new Error(`Service "${name}" local.cwd must be a string`);
+    }
+    if (
+      service.local.readyTimeoutMs !== undefined &&
+      (!Number.isInteger(service.local.readyTimeoutMs) || service.local.readyTimeoutMs <= 0)
+    ) {
+      throw new Error(`Service "${name}" local.readyTimeoutMs must be a positive integer`);
+    }
+    if (service.local.env !== undefined && !isObject(service.local.env)) {
+      throw new Error(`Service "${name}" local.env must be an object`);
+    }
+  }
 }
 
-function requireString(errors, obj, msg, key) {
+function requireString(obj, key, label) {
   if (typeof obj[key] !== "string" || obj[key].length === 0) {
-    errors.push(`${msg} is required`);
+    throw new Error(`${label} must be a non-empty string`);
   }
 }
 
-function optionalStringArray(errors, obj, msg, key) {
-  const val = obj[key];
-  if (val === undefined) return;
-  if (!Array.isArray(val) || !val.every(v => typeof v === "string")) {
-    errors.push(`${msg} must be a string[]`);
-  }
+function isDalSuiteType(suite, runnerService, suitesForType) {
+  if (suite.framework && suite.framework !== "k6") return false;
+  return suitesForType === runnerService.suites.dal;
 }
 
-function requireNonEmptyStringArray(errors, obj, msg, key) {
-  const val = obj[key];
-  if (!Array.isArray(val) || val.length === 0 || !val.every(v => typeof v === "string")) {
-    errors.push(`${msg} is required and must be a non-empty string[]`);
-  }
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
 }