@elench/testkit 0.1.26 → 0.1.27

package/lib/config/model.mjs

@@ -1,320 +0,0 @@
-export const VALID_FRAMEWORKS = new Set(["k6", "playwright"]);
-export const VALID_DB_PROVIDERS = new Set(["local"]);
-
-export function parseDotenvString(source) {
-  const env = {};
-  for (const line of String(source).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 validateConfigCoverage(
-  config,
-  configName = "testkit.config.json"
-) {
-  for (const serviceName of Object.keys(config.services || {})) {
-    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 ${configName}`
-        );
-      }
-    }
-
-    const databaseFrom = config.services[serviceName].databaseFrom;
-    if (databaseFrom && !config.services[databaseFrom]) {
-      throw new Error(
-        `Service "${serviceName}" databaseFrom "${databaseFrom}" is missing from ${configName}`
-      );
-    }
-  }
-}
-
-export 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) {
-      throw new Error(
-        `Service "${name}" database.backends is no longer supported. Define a single local database provider instead.`
-      );
-    } else {
-      throw new Error(`Service "${name}" database must define provider`);
-    }
-  }
-
-  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`);
-    }
-  }
-
-  if (service.discovery !== undefined) {
-    throw new Error(
-      `Service "${name}" cannot define discovery. Testkit discovers *.testkit.ts files from the filesystem automatically.`
-    );
-  }
-}
-
-export function validateTelemetryConfig(
-  telemetry,
-  configPath,
-  configName = "testkit.config.json"
-) {
-  if (!isObject(telemetry)) {
-    throw new Error(`${configName} telemetry must be an object (${configPath})`);
-  }
-  if (telemetry.enabled !== undefined && typeof telemetry.enabled !== "boolean") {
-    throw new Error(`${configName} telemetry.enabled must be a boolean (${configPath})`);
-  }
-  if (telemetry.endpoint !== undefined) {
-    requireString(telemetry, "endpoint", `${configName} telemetry.endpoint`);
-    validateHttpUrl(telemetry.endpoint, `${configName} telemetry.endpoint`);
-  }
-  if (telemetry.tokenEnv !== undefined) {
-    requireString(telemetry, "tokenEnv", `${configName} telemetry.tokenEnv`);
-  }
-  if (
-    telemetry.timeoutMs !== undefined &&
-    (!Number.isInteger(telemetry.timeoutMs) || telemetry.timeoutMs <= 0)
-  ) {
-    throw new Error(`${configName} telemetry.timeoutMs must be a positive integer (${configPath})`);
-  }
-  if (telemetry.enabled === true) {
-    requireString(telemetry, "endpoint", `${configName} telemetry.endpoint`);
-    requireString(telemetry, "tokenEnv", `${configName} telemetry.tokenEnv`);
-  }
-}
-
-export function getServiceEnvFiles(serviceConfig) {
-  const files = [];
-  if (serviceConfig.envFile) files.push(serviceConfig.envFile);
-  if (Array.isArray(serviceConfig.envFiles)) {
-    files.push(...serviceConfig.envFiles);
-  }
-  return files;
-}
-
-export function resolveSelectedDatabase(name, serviceConfig) {
-  if (!serviceConfig.database) return undefined;
-
-  const database = serviceConfig.database;
-  if (database.provider !== "local") {
-    throw new Error(
-      `Service "${name}" database.provider must be "local". Received "${database.provider}"`
-    );
-  }
-
-  return {
-    ...database,
-    provider: "local",
-    selectedBackend: "local",
-    reset: database.reset !== false,
-    template: normalizeTemplateConfig(database.template),
-  };
-}
-
-export 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.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`);
-  }
-}
-
-export 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`);
-  }
-}
-
-export function normalizeTemplateConfig(template) {
-  return {
-    inputs: Array.isArray(template?.inputs) ? [...template.inputs] : [],
-  };
-}
-
-export 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`);
-  }
-}
-
-export 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;
-}
-
-export function requireString(obj, key, label) {
-  if (typeof obj[key] !== "string" || obj[key].length === 0) {
-    throw new Error(`${label} must be a non-empty string`);
-  }
-}
-
-export function isDalSuiteType(suite, runnerService, suitesForType) {
-  if (suite.framework && suite.framework !== "k6") return false;
-  return suitesForType === runnerService.suites.dal;
-}
-
-export function isObject(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-export function normalizeTelemetryConfig(telemetry) {
-  if (!isObject(telemetry)) return null;
-  return {
-    enabled: telemetry.enabled === true,
-    endpoint: telemetry.endpoint || null,
-    tokenEnv: telemetry.tokenEnv || null,
-    timeoutMs: telemetry.timeoutMs || 3_000,
-  };
-}
-
-export function validateHttpUrl(value, label) {
-  let parsed;
-  try {
-    parsed = new URL(value);
-  } catch {
-    throw new Error(`${label} must be a valid URL`);
-  }
-  if (!["http:", "https:"].includes(parsed.protocol)) {
-    throw new Error(`${label} must use http or https`);
-  }
-}

package/lib/config/model.test.mjs

@@ -1,163 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  getServiceEnvFiles,
-  isDalSuiteType,
-  normalizeTelemetryConfig,
-  parseDotenvString,
-  resolveLifecycleConfig,
-  resolveSelectedDatabase,
-  validateConfigCoverage,
-  validateLifecycleConfig,
-  validateServiceConfig,
-  validateTelemetryConfig,
-} from "./model.mjs";
-
-describe("config-model", () => {
-  it("parses dotenv text", () => {
-    expect(
-      parseDotenvString(`
-# comment
-FOO=bar
-BAR="baz"
-QUX='zap'
-      `)
-    ).toEqual({
-      FOO: "bar",
-      BAR: "baz",
-      QUX: "zap",
-    });
-  });
-
-  it("validates config coverage", () => {
-    const config = {
-      services: {
-        frontend: {
-          dependsOn: ["api"],
-        },
-      },
-    };
-
-    expect(() => validateConfigCoverage(config)).toThrow(
-      'Service "frontend" depends on "api", but api is missing from testkit.config.json'
-    );
-  });
-
-  it("validates service and telemetry config", () => {
-    expect(() =>
-      validateServiceConfig("api", {
-        local: {
-          start: "npm run dev",
-          baseUrl: "http://127.0.0.1:3000",
-          readyUrl: "http://127.0.0.1:3000/health",
-          port: 3000,
-        },
-      }, "testkit.config.json")
-    ).not.toThrow();
-
-    expect(() =>
-      validateServiceConfig("api", {
-        database: {
-          backends: {},
-        },
-      }, "testkit.config.json")
-    ).toThrow("database.backends is no longer supported");
-
-    expect(() =>
-      validateServiceConfig("api", {
-        discovery: {},
-      }, "testkit.config.json")
-    ).toThrow("cannot define discovery");
-
-    expect(() =>
-      validateTelemetryConfig(
-        {
-          enabled: true,
-          endpoint: "ftp://bad.example.com/upload",
-          tokenEnv: "TOKEN",
-        },
-        "testkit.config.json"
-      )
-    ).toThrow("must use http or https");
-  });
-
-  it("collects env files and resolves lifecycle overrides", () => {
-    expect(
-      getServiceEnvFiles({
-        envFile: ".env.shared",
-        envFiles: [".env.local"],
-      })
-    ).toEqual([".env.shared", ".env.local"]);
-
-    expect(() =>
-      validateLifecycleConfig("api", { backends: {} }, "migrate")
-    ).not.toThrow();
-
-    expect(
-      resolveLifecycleConfig(
-        {
-          cmd: "npm run migrate",
-          backends: {
-            local: {
-              cmd: "npm run migrate:local",
-            },
-          },
-        },
-        "local"
-      )
-    ).toEqual({
-      cmd: "npm run migrate:local",
-    });
-  });
-
-  it("normalizes telemetry and database config", () => {
-    expect(
-      resolveSelectedDatabase("api", {
-        database: {
-          provider: "local",
-          image: "pgvector/pgvector:pg16",
-          template: {
-            inputs: ["schema"],
-          },
-        },
-      })
-    ).toEqual({
-      provider: "local",
-      image: "pgvector/pgvector:pg16",
-      selectedBackend: "local",
-      reset: true,
-      template: {
-        inputs: ["schema"],
-      },
-    });
-
-    expect(
-      normalizeTelemetryConfig({
-        enabled: true,
-        endpoint: "https://example.com",
-        tokenEnv: "TOKEN",
-      })
-    ).toEqual({
-      enabled: true,
-      endpoint: "https://example.com",
-      tokenEnv: "TOKEN",
-      timeoutMs: 3000,
-    });
-  });
-
-  it("detects dal suite types", () => {
-    const suite = { name: "db", files: ["a.js"] };
-    const runnerService = {
-      suites: {
-        dal: [suite],
-      },
-    };
-    expect(isDalSuiteType(suite, runnerService, runnerService.suites.dal)).toBe(true);
-    expect(
-      isDalSuiteType(
-        { ...suite, framework: "playwright" },
-        runnerService,
-        runnerService.suites.dal
-      )
-    ).toBe(false);
-  });
-});

package/lib/runtime-manager/index.mjs

@@ -1,190 +0,0 @@
-import crypto from "crypto";
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-
-const TESTKIT_CONFIG = "testkit.config.json";
-const DEFAULT_RUNTIME_DIR = path.join("tests", "_testkit");
-const METADATA_FILE = ".runtime-manifest.json";
-const RUNTIME_FORMAT = 1;
-
-export function installRuntime(options = {}) {
-  const productDir = resolveProductDir(process.cwd(), options.dir);
-  const runtimeDir = resolveRuntimeDir(productDir, options.path);
-  const sourceFiles = readBundledRuntimeFiles();
-
-  fs.mkdirSync(runtimeDir, { recursive: true });
-
-  for (const file of sourceFiles) {
-    const targetPath = path.join(runtimeDir, file.path);
-    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-    fs.writeFileSync(targetPath, file.content);
-  }
-
-  const metadata = {
-    format: RUNTIME_FORMAT,
-    package: "@elench/testkit",
-    version: readPackageVersion(),
-    files: sourceFiles.map((file) => ({
-      path: file.path,
-      sha256: hashContent(file.content),
-    })),
-  };
-  fs.writeFileSync(
-    path.join(runtimeDir, METADATA_FILE),
-    `${JSON.stringify(metadata, null, 2)}\n`
-  );
-
-  return {
-    productDir,
-    runtimeDir,
-    relativeRuntimeDir: relativeToProduct(productDir, runtimeDir),
-    files: metadata.files,
-  };
-}
-
-export function getRuntimeStatus(options = {}) {
-  const productDir = resolveProductDir(process.cwd(), options.dir);
-  const runtimeDir = resolveRuntimeDir(productDir, options.path);
-  const sourceFiles = readBundledRuntimeFiles();
-  const metadataPath = path.join(runtimeDir, METADATA_FILE);
-
-  if (!fs.existsSync(runtimeDir) || !fs.existsSync(metadataPath)) {
-    return {
-      status: "missing",
-      productDir,
-      runtimeDir,
-      relativeRuntimeDir: relativeToProduct(productDir, runtimeDir),
-      missingFiles: sourceFiles.map((file) => file.path),
-      driftedFiles: [],
-    };
-  }
-
-  const missingFiles = [];
-  const driftedFiles = [];
-
-  for (const file of sourceFiles) {
-    const targetPath = path.join(runtimeDir, file.path);
-    if (!fs.existsSync(targetPath)) {
-      missingFiles.push(file.path);
-      continue;
-    }
-
-    const installed = fs.readFileSync(targetPath, "utf8");
-    if (installed !== file.content) {
-      driftedFiles.push(file.path);
-    }
-  }
-
-  const metadata = JSON.parse(fs.readFileSync(metadataPath, "utf8"));
-  const versionMatches = metadata.version === readPackageVersion();
-
-  return {
-    status:
-      missingFiles.length === 0 && driftedFiles.length === 0 && versionMatches
-        ? "installed"
-        : "drifted",
-    productDir,
-    runtimeDir,
-    relativeRuntimeDir: relativeToProduct(productDir, runtimeDir),
-    versionMatches,
-    missingFiles,
-    driftedFiles,
-  };
-}
-
-export function formatRuntimeStatus(result) {
-  if (result.status === "missing") {
-    return `Runtime not installed at ${result.relativeRuntimeDir}`;
-  }
-
-  if (result.status === "installed") {
-    return `Runtime at ${result.relativeRuntimeDir} is up to date`;
-  }
-
-  const problems = [];
-  if (result.missingFiles.length > 0) {
-    problems.push(`missing: ${result.missingFiles.join(", ")}`);
-  }
-  if (result.driftedFiles.length > 0) {
-    problems.push(`drifted: ${result.driftedFiles.join(", ")}`);
-  }
-  if (result.versionMatches === false) {
-    problems.push("version drift");
-  }
-
-  return `Runtime at ${result.relativeRuntimeDir} is drifted (${problems.join("; ")})`;
-}
-
-function resolveProductDir(cwd, explicitDir) {
-  const dir = explicitDir ? path.resolve(cwd, explicitDir) : cwd;
-  ensureProductFiles(dir);
-  return dir;
-}
-
-function ensureProductFiles(dir) {
-  const missing = [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.`
-    );
-  }
-}
-
-function resolveRuntimeDir(productDir, explicitPath) {
-  return path.resolve(productDir, explicitPath || DEFAULT_RUNTIME_DIR);
-}
-
-function relativeToProduct(productDir, targetPath) {
-  return path.relative(productDir, targetPath) || ".";
-}
-
-function readBundledRuntimeFiles() {
-  const sourceDir = path.resolve(
-    path.dirname(fileURLToPath(import.meta.url)),
-    "..",
-    "runtime-src"
-  );
-
-  return walkRuntimeFiles(sourceDir);
-}
-
-function walkRuntimeFiles(rootDir, relativeDir = "") {
-  const entries = fs.readdirSync(path.join(rootDir, relativeDir), {
-    withFileTypes: true,
-  });
-  const files = [];
-
-  for (const entry of entries) {
-    const nextRelative = path.join(relativeDir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...walkRuntimeFiles(rootDir, nextRelative));
-      continue;
-    }
-
-    const absolute = path.join(rootDir, nextRelative);
-    files.push({
-      path: nextRelative.split(path.sep).join("/"),
-      content: fs.readFileSync(absolute, "utf8"),
-    });
-  }
-
-  return files.sort((left, right) => left.path.localeCompare(right.path));
-}
-
-function readPackageVersion() {
-  const packagePath = path.resolve(
-    path.dirname(fileURLToPath(import.meta.url)),
-    "..",
-    "..",
-    "package.json"
-  );
-  return JSON.parse(fs.readFileSync(packagePath, "utf8")).version;
-}
-
-function hashContent(content) {
-  return crypto.createHash("sha256").update(content).digest("hex");
-}