@elench/testkit 0.1.16 → 0.1.18

package/lib/config.mjs

@@ -1,666 +0,0 @@
-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"]);
-const VALID_DB_PROVIDERS = new Set(["neon", "local"]);
-
-/**
- * Parse a .env file into an object. Supports KEY=VALUE, KEY='VALUE', KEY="VALUE".
- * Skips comments (#) and blank lines.
- */
-export function parseDotenv(filePath) {
-  if (!fs.existsSync(filePath)) return {};
-  const env = {};
-  for (const line of fs.readFileSync(filePath, "utf8").split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-    const eq = trimmed.indexOf("=");
-    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('"'))
-    ) {
-      val = val.slice(1, -1);
-    }
-    env[key] = val;
-  }
-  return env;
-}
-
-export function getServiceNames(cwd) {
-  const dir = cwd || process.cwd();
-  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);
-}
-
-export function loadConfigs(opts = {}) {
-  const productDir = resolveProductDir(process.cwd(), opts.dir);
-  const runner = loadRunnerManifest(productDir);
-  const config = loadTestkitConfig(productDir);
-  validateConfigCoverage(runner, config);
-
-  const dotenv = parseDotenv(path.join(productDir, ".env"));
-  Object.assign(process.env, dotenv);
-
-  const serviceEntries = Object.entries(runner.services);
-  const filtered = opts.service
-    ? serviceEntries.filter(([name]) => name === opts.service)
-    : serviceEntries;
-
-  if (opts.service && filtered.length === 0) {
-    const available = serviceEntries.map(([name]) => name).join(", ");
-    throw new Error(`Service "${opts.service}" not found. Available: ${available}`);
-  }
-
-  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}`
-      );
-    }
-
-    const resolvedDatabase = resolveSelectedDatabase(name, serviceConfig, opts.dbBackend);
-    const serviceEnv = loadServiceEnv(productDir, serviceConfig);
-    const selectedBackend = resolvedDatabase?.selectedBackend;
-    const resolvedMigrate = resolveLifecycleConfig(serviceConfig.migrate, selectedBackend);
-    const resolvedSeed = resolveLifecycleConfig(serviceConfig.seed, selectedBackend);
-    validateMergedService(
-      name,
-      runnerService,
-      serviceConfig,
-      resolvedDatabase,
-      resolvedMigrate,
-      resolvedSeed,
-      productDir
-    );
-
-    return {
-      name,
-      productDir,
-      stateDir: path.join(productDir, ".testkit", name),
-      suites: runnerService.suites,
-      testkit: {
-        ...serviceConfig,
-        database: resolvedDatabase,
-        migrate: resolvedMigrate,
-        seed: resolvedSeed,
-        envFiles: getServiceEnvFiles(serviceConfig),
-        serviceEnv,
-      },
-    };
-  });
-}
-
-export function requireNeonApiKey() {
-  if (!process.env.NEON_API_KEY) {
-    throw new Error(
-      "NEON_API_KEY not found. Set it in your shell environment, .envrc, or .env"
-    );
-  }
-}
-
-export function resolveDalBinary() {
-  const thisFile = fileURLToPath(import.meta.url);
-  const abs = path.resolve(path.dirname(thisFile), "..", "vendor", "k6");
-  if (!fs.existsSync(abs)) {
-    throw new Error(`Bundled DAL k6 binary not found: ${abs}`);
-  }
-  return abs;
-}
-
-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}`
-        );
-      }
-    }
-
-    const databaseFrom = config.services[serviceName].databaseFrom;
-    if (databaseFrom) {
-      if (!config.services[databaseFrom]) {
-        throw new Error(
-          `Service "${serviceName}" databaseFrom "${databaseFrom}" is missing from ${TESTKIT_CONFIG}`
-        );
-      }
-      if (!runner.services[databaseFrom]) {
-        throw new Error(
-          `Service "${serviceName}" databaseFrom "${databaseFrom}" is missing from ${RUNNER_MANIFEST}`
-        );
-      }
-    }
-  }
-}
-
-function resolveProductDir(cwd, explicitDir) {
-  if (explicitDir) {
-    const dir = path.resolve(cwd, explicitDir);
-    ensureProductFiles(dir);
-    return dir;
-  }
-
-  ensureProductFiles(cwd);
-  return cwd;
-}
-
-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.`
-    );
-  }
-}
-
-export function isSiblingProduct(name) {
-  const candidate = path.join(process.cwd(), name);
-  return (
-    fs.existsSync(path.join(candidate, RUNNER_MANIFEST)) &&
-    fs.existsSync(path.join(candidate, TESTKIT_CONFIG))
-  );
-}
-
-function validateMergedService(
-  name,
-  runnerService,
-  serviceConfig,
-  resolvedDatabase,
-  resolvedMigrate,
-  resolvedSeed,
-  productDir
-) {
-  const usesLocalExecution = Object.values(runnerService.suites).some((suites) =>
-    suites.some(
-      (suite) =>
-        (suite.framework && suite.framework !== "k6") ||
-        !isDalSuiteType(suite, runnerService, suites)
-    )
-  );
-
-  if (usesLocalExecution && !isObject(serviceConfig.local)) {
-    throw new Error(
-      `Service "${name}" defines non-DAL suites but has no local runtime in ${TESTKIT_CONFIG}`
-    );
-  }
-
-  if (serviceConfig.dependsOn) {
-    for (const dep of serviceConfig.dependsOn) {
-      if (dep === name) {
-        throw new Error(`Service "${name}" cannot depend on itself`);
-      }
-    }
-  }
-
-  if (
-    resolvedDatabase?.provider === "local" &&
-    (serviceConfig.migrate || serviceConfig.seed) &&
-    resolvedDatabase.template.inputs.length === 0
-  ) {
-    throw new Error(
-      `Service "${name}" uses local database provisioning with migrations or seeds, so database.template.inputs must list the files/directories that define the template cache`
-    );
-  }
-
-  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 (resolvedMigrate?.cwd) {
-    const cwdPath = resolveServiceCwd(productDir, resolvedMigrate.cwd);
-    if (!fs.existsSync(cwdPath)) {
-      throw new Error(
-        `Service "${name}" migrate.cwd does not exist: ${resolvedMigrate.cwd}`
-      );
-    }
-  }
-
-  if (resolvedSeed?.cwd) {
-    const cwdPath = resolveServiceCwd(productDir, resolvedSeed.cwd);
-    if (!fs.existsSync(cwdPath)) {
-      throw new Error(
-        `Service "${name}" seed.cwd does not exist: ${resolvedSeed.cwd}`
-      );
-    }
-  }
-
-}
-
-function validateServiceConfig(name, service, configPath) {
-  if (!isObject(service)) {
-    throw new Error(`Service "${name}" in ${configPath} must be an object`);
-  }
-
-  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 (service.databaseFrom !== undefined && typeof service.databaseFrom !== "string") {
-    throw new Error(`Service "${name}" databaseFrom must be a string`);
-  }
-
-  if (service.database !== undefined && service.databaseFrom !== undefined) {
-    throw new Error(
-      `Service "${name}" cannot define both database and databaseFrom`
-    );
-  }
-
-  if (service.envFile !== undefined && typeof service.envFile !== "string") {
-    throw new Error(`Service "${name}" envFile must be a string`);
-  }
-
-  if (
-    service.envFiles !== undefined &&
-    (!Array.isArray(service.envFiles) || service.envFiles.some((v) => typeof v !== "string"))
-  ) {
-    throw new Error(`Service "${name}" envFiles must be an array of strings`);
-  }
-
-  if (service.database !== undefined) {
-    if (!isObject(service.database)) {
-      throw new Error(`Service "${name}" database must be an object`);
-    }
-
-    if (service.database.provider !== undefined) {
-      validateDatabaseProviderConfig(name, service.database, `Service "${name}" database`);
-    } else if (service.database.backends !== undefined) {
-      validateMultiBackendDatabaseConfig(name, service.database);
-    } else {
-      throw new Error(
-        `Service "${name}" database must define either provider or backends`
-      );
-    }
-  }
-
-  if (service.migrate !== undefined) {
-    validateLifecycleConfig(name, service.migrate, "migrate");
-  }
-
-  if (service.seed !== undefined) {
-    validateLifecycleConfig(name, service.seed, "seed");
-  }
-
-  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 loadServiceEnv(productDir, serviceConfig) {
-  const env = {};
-  for (const envFile of getServiceEnvFiles(serviceConfig)) {
-    Object.assign(env, parseDotenv(resolveServiceCwd(productDir, envFile)));
-  }
-  return env;
-}
-
-function getServiceEnvFiles(serviceConfig) {
-  const files = [];
-  if (serviceConfig.envFile) files.push(serviceConfig.envFile);
-  if (Array.isArray(serviceConfig.envFiles)) {
-    files.push(...serviceConfig.envFiles);
-  }
-  return files;
-}
-
-function resolveSelectedDatabase(name, serviceConfig, requestedBackend) {
-  if (!serviceConfig.database) return undefined;
-
-  const database = serviceConfig.database;
-  if (database.provider !== undefined) {
-    if (requestedBackend && requestedBackend !== database.provider) {
-      throw new Error(
-        `Service "${name}" does not define database backend "${requestedBackend}". Available: ${database.provider}`
-      );
-    }
-
-    return {
-      ...database,
-      provider: database.provider,
-      selectedBackend: database.provider,
-      reset: database.reset !== false,
-      template: normalizeTemplateConfig(database.template),
-    };
-  }
-
-  const backends = database.backends || {};
-  const selectedBackend =
-    requestedBackend ||
-    process.env.TESTKIT_DB_BACKEND ||
-    database.defaultBackend ||
-    Object.keys(backends)[0];
-
-  if (!selectedBackend || !backends[selectedBackend]) {
-    throw new Error(
-      `Service "${name}" does not define database backend "${selectedBackend || "undefined"}"`
-    );
-  }
-
-  const backend = backends[selectedBackend];
-  return {
-    ...backend,
-    provider: backend.provider,
-    selectedBackend,
-    reset: database.reset !== false,
-    template: normalizeTemplateConfig(database.template),
-  };
-}
-
-function validateMultiBackendDatabaseConfig(name, database) {
-  if (
-    database.defaultBackend !== undefined &&
-    (typeof database.defaultBackend !== "string" || !database.defaultBackend.length)
-  ) {
-    throw new Error(`Service "${name}" database.defaultBackend must be a non-empty string`);
-  }
-  if (database.reset !== undefined && typeof database.reset !== "boolean") {
-    throw new Error(`Service "${name}" database.reset must be a boolean`);
-  }
-  if (database.template !== undefined) {
-    validateTemplateConfig(name, database.template, `Service "${name}" database.template`);
-  }
-  if (!isObject(database.backends) || Object.keys(database.backends).length === 0) {
-    throw new Error(`Service "${name}" database.backends must be a non-empty object`);
-  }
-
-  for (const [backendName, backendConfig] of Object.entries(database.backends)) {
-    if (!isObject(backendConfig)) {
-      throw new Error(
-        `Service "${name}" database.backends.${backendName} must be an object`
-      );
-    }
-    validateDatabaseProviderConfig(
-      name,
-      backendConfig,
-      `Service "${name}" database.backends.${backendName}`
-    );
-  }
-
-  if (database.defaultBackend && !database.backends[database.defaultBackend]) {
-    throw new Error(
-      `Service "${name}" database.defaultBackend "${database.defaultBackend}" is missing from database.backends`
-    );
-  }
-}
-
-function validateDatabaseProviderConfig(name, db, label) {
-  if (!VALID_DB_PROVIDERS.has(db.provider)) {
-    throw new Error(
-      `${label}.provider must be one of: ${[...VALID_DB_PROVIDERS].join(", ")}`
-    );
-  }
-
-  if (db.reset !== undefined && typeof db.reset !== "boolean") {
-    throw new Error(`${label}.reset must be a boolean`);
-  }
-  if (db.template !== undefined) {
-    validateTemplateConfig(name, db.template, `${label}.template`);
-  }
-
-  if (db.provider === "neon") {
-    requireString(db, "projectId", `${label}.projectId`);
-    requireString(db, "dbName", `${label}.dbName`);
-    if (db.branchName !== undefined && typeof db.branchName !== "string") {
-      throw new Error(`${label}.branchName must be a string`);
-    }
-    return;
-  }
-
-  if (db.image !== undefined && typeof db.image !== "string") {
-    throw new Error(`${label}.image must be a string`);
-  }
-  if (db.user !== undefined && typeof db.user !== "string") {
-    throw new Error(`${label}.user must be a string`);
-  }
-  if (db.password !== undefined && typeof db.password !== "string") {
-    throw new Error(`${label}.password must be a string`);
-  }
-}
-
-function validateTemplateConfig(name, template, label) {
-  if (!isObject(template)) {
-    throw new Error(`${label} must be an object`);
-  }
-  if (
-    template.inputs !== undefined &&
-    (!Array.isArray(template.inputs) || template.inputs.some((value) => typeof value !== "string"))
-  ) {
-    throw new Error(`${label}.inputs must be an array of strings`);
-  }
-}
-
-function normalizeTemplateConfig(template) {
-  return {
-    inputs: Array.isArray(template?.inputs) ? [...template.inputs] : [],
-  };
-}
-
-function validateLifecycleConfig(name, value, label) {
-  if (!isObject(value)) {
-    throw new Error(`Service "${name}" ${label} must be an object`);
-  }
-
-  if (value.cmd !== undefined) {
-    requireString(value, "cmd", `Service "${name}" ${label}.cmd`);
-  }
-  if (value.cwd !== undefined && typeof value.cwd !== "string") {
-    throw new Error(`Service "${name}" ${label}.cwd must be a string`);
-  }
-
-  if (value.backends !== undefined) {
-    if (!isObject(value.backends)) {
-      throw new Error(`Service "${name}" ${label}.backends must be an object`);
-    }
-    for (const [backendName, override] of Object.entries(value.backends)) {
-      if (!isObject(override)) {
-        throw new Error(
-          `Service "${name}" ${label}.backends.${backendName} must be an object`
-        );
-      }
-      if (override.cmd !== undefined) {
-        requireString(override, "cmd", `Service "${name}" ${label}.backends.${backendName}.cmd`);
-      }
-      if (override.cwd !== undefined && typeof override.cwd !== "string") {
-        throw new Error(
-          `Service "${name}" ${label}.backends.${backendName}.cwd must be a string`
-        );
-      }
-    }
-  }
-
-  if (value.cmd === undefined && value.backends === undefined) {
-    throw new Error(`Service "${name}" ${label} must define cmd or backends`);
-  }
-}
-
-function resolveLifecycleConfig(value, selectedBackend) {
-  if (!value) return value;
-
-  const override =
-    selectedBackend && isObject(value.backends) ? value.backends[selectedBackend] || {} : {};
-  const resolved = {
-    ...value,
-    ...override,
-  };
-  delete resolved.backends;
-  return resolved;
-}
-
-function requireString(obj, key, label) {
-  if (typeof obj[key] !== "string" || obj[key].length === 0) {
-    throw new Error(`${label} must be a non-empty string`);
-  }
-}
-
-function isDalSuiteType(suite, runnerService, suitesForType) {
-  if (suite.framework && suite.framework !== "k6") return false;
-  return suitesForType === runnerService.suites.dal;
-}
-
-function isObject(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}

package/lib/exec.mjs

@@ -1,20 +0,0 @@
-import { execaCommand } from "execa";
-import { fileURLToPath } from "url";
-import path from "path";
-
-const INFRA_DIR = path.resolve(
-  path.dirname(fileURLToPath(import.meta.url)), "../infra"
-);
-
-/**
- * Run a bundled infra script with the given env vars.
- * Inherits process.env, overlays scriptEnv, streams stdout/stderr.
- */
-export async function runScript(name, scriptEnv, opts = {}) {
-  const script = path.join(INFRA_DIR, name);
-  return execaCommand(`bash ${script}`, {
-    env: { ...process.env, ...scriptEnv },
-    stdio: "inherit",
-    cwd: opts.cwd,
-  });
-}