@elench/testkit 0.1.21 → 0.1.22

package/README.md

@@ -104,7 +104,7 @@ npx @elench/testkit --dir my-product api int -s health
 
 1. **Discovery** — reads `testkit.config.json` for services, then discovers files by suffix:
    `*.int.testkit.ts`, `*.e2e.testkit.ts`, `*.dal.testkit.ts`, `*.load.testkit.ts`, `*.pw.testkit.ts`
-2. **Config** — reads `testkit.config.json` for local runtime, migration, dependency, database, and discovery settings
+2. **Config** — reads `testkit.config.json` for local runtime, migration, dependency, and database settings
    Per-service `.env` files declared in config are loaded when present.
 3. **Database** — provisions Docker-managed local Postgres when a service declares one
 4. **Seed** — runs optional product seed commands against the provisioned database
@@ -124,7 +124,7 @@ Each run ends with a compact summary that shows per-service pass/fail status, su
 `testkit.config.json` can also declare:
 
 - `telemetry` for optional generic HTTP result upload
-- `discovery.include` / `discovery.exclude` for per-service test discovery
+- no test registration in config; `testkit` discovers `*.testkit.ts` files from the filesystem automatically
 - `envFile` / `envFiles` for service-specific environment loading
 - `databaseFrom` for dependency services that must share another service's `DATABASE_URL`
 - `database.provider` for local Postgres settings

package/lib/config/discovery.mjs

@@ -9,148 +9,189 @@ const DISCOVERY_RULES = [
   { suffix: ".pw.testkit.ts", type: "e2e", framework: "playwright" },
 ];
 
-export function discoverServiceSuites(productDir, serviceName, serviceConfig) {
-  const include = serviceConfig.discovery?.include || [];
-  const exclude = serviceConfig.discovery?.exclude || [];
-  const grouped = {};
-  const seen = new Set();
-
-  for (const pattern of include) {
-    const normalizedPattern = normalizePath(pattern);
-    const patternInfo = compilePattern(normalizedPattern);
-    const rootDir = path.resolve(productDir, patternInfo.baseDir);
-    if (!fs.existsSync(rootDir)) continue;
-
-    for (const relativeFile of walkFiles(productDir, rootDir)) {
-      const normalizedFile = normalizePath(relativeFile);
-      if (!patternInfo.regex.test(normalizedFile)) continue;
-      if (exclude.some((candidate) => compilePattern(normalizePath(candidate)).regex.test(normalizedFile))) {
-        continue;
-      }
-      if (seen.has(normalizedFile)) continue;
+const IGNORED_DIRS = new Set([
+  ".cache",
+  ".git",
+  ".hg",
+  ".next",
+  ".nuxt",
+  ".playwright-browsers",
+  ".svn",
+  ".testkit",
+  ".turbo",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules",
+  "playwright-report",
+  "test-results",
+]);
+
+export function discoverSuites(productDir, services) {
+  const serviceEntries = Object.entries(services || {});
+  const rules = serviceEntries.map(([serviceName, serviceConfig]) =>
+    buildServiceRule(serviceName, serviceConfig)
+  );
+  const groupedByService = Object.fromEntries(
+    serviceEntries.map(([serviceName]) => [serviceName, {}])
+  );
+  const discoveredFiles = discoverFiles(productDir);
+  const unowned = [];
+  const ambiguous = [];
+
+  for (const filePath of discoveredFiles) {
+    const rule = inferRule(filePath);
+    if (!rule) continue;
+
+    const matches = rules
+      .filter((serviceRule) => ownsFile(serviceRule, filePath))
+      .map((serviceRule) => serviceRule.name);
+
+    if (matches.length === 0) {
+      unowned.push(filePath);
+      continue;
+    }
 
-      const rule = inferRule(normalizedFile);
-      if (!rule) continue;
+    if (matches.length > 1) {
+      ambiguous.push({
+        filePath,
+        serviceNames: matches.sort((left, right) => left.localeCompare(right)),
+      });
+      continue;
+    }
 
-      const typeSuites = grouped[rule.type] || [];
-      typeSuites.push({
-        name: buildSuiteName(normalizedFile, rule.suffix, patternInfo.baseDir),
-        files: [normalizedFile],
+    const serviceName = matches[0];
+    const serviceRule = rules.find((candidate) => candidate.name === serviceName);
+    const relativeToService = relativeToServiceRoot(serviceRule, filePath);
+    const suiteName = deriveSuiteName(relativeToService, rule.suffix);
+    const grouped = groupedByService[serviceName];
+    const suitesForType = grouped[rule.type] || [];
+    let suite = suitesForType.find(
+      (candidate) => candidate.name === suiteName && candidate.framework === rule.framework
+    );
+
+    if (!suite) {
+      suite = {
+        name: suiteName,
+        files: [],
         framework: rule.framework,
-      });
-      grouped[rule.type] = typeSuites;
-      seen.add(normalizedFile);
+      };
+      suitesForType.push(suite);
+      grouped[rule.type] = suitesForType;
     }
-  }
 
-  for (const suites of Object.values(grouped)) {
-    suites.sort((left, right) => left.files[0].localeCompare(right.files[0]));
+    suite.files.push(filePath);
   }
 
-  return grouped;
-}
+  if (unowned.length > 0 || ambiguous.length > 0) {
+    throw buildDiscoveryError(unowned, ambiguous);
+  }
 
-function inferRule(filePath) {
-  return DISCOVERY_RULES.find((rule) => filePath.endsWith(rule.suffix)) || null;
-}
+  for (const grouped of Object.values(groupedByService)) {
+    for (const suites of Object.values(grouped)) {
+      for (const suite of suites) {
+        suite.files.sort((left, right) => left.localeCompare(right));
+      }
+      suites.sort((left, right) => left.name.localeCompare(right.name));
+    }
+  }
 
-function buildSuiteName(filePath, suffix, baseDir) {
-  const normalizedBase = normalizePath(baseDir);
-  const relativeToBase =
-    normalizedBase === "." || normalizedBase.length === 0
-      ? filePath
-      : path.posix.relative(normalizedBase, filePath);
-  const candidate = relativeToBase.length > 0 ? relativeToBase : path.posix.basename(filePath);
-  return candidate.slice(0, -suffix.length);
+  return groupedByService;
 }
 
-function walkFiles(productDir, rootDir) {
-  const rootStats = fs.statSync(rootDir);
-  if (rootStats.isFile()) {
-    return [normalizePath(path.relative(productDir, rootDir))];
-  }
-
+function discoverFiles(productDir) {
   const files = [];
-  const queue = [rootDir];
+  const queue = [productDir];
 
   while (queue.length > 0) {
     const current = queue.pop();
     for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
-      const absolute = path.join(current, entry.name);
+      const absolutePath = path.join(current, entry.name);
+
+      if (entry.isSymbolicLink()) continue;
+
       if (entry.isDirectory()) {
-        queue.push(absolute);
+        if (IGNORED_DIRS.has(entry.name)) continue;
+        queue.push(absolutePath);
         continue;
       }
+
       if (!entry.isFile()) continue;
-      files.push(normalizePath(path.relative(productDir, absolute)));
+
+      const relativePath = normalizePath(path.relative(productDir, absolutePath));
+      if (inferRule(relativePath)) files.push(relativePath);
     }
   }
 
   return files.sort((left, right) => left.localeCompare(right));
 }
 
-function compilePattern(pattern) {
-  const baseDir = patternBase(pattern);
+function buildServiceRule(serviceName, serviceConfig) {
+  const testPrefix = normalizePath(path.posix.join("tests", serviceName));
+  const cwd = normalizePath(serviceConfig?.local?.cwd || ".");
   return {
-    baseDir,
-    regex: globToRegExp(pattern),
+    name: serviceName,
+    testPrefix,
+    cwdPrefix: cwd === "." ? null : cwd,
   };
 }
 
-function patternBase(pattern) {
-  const parts = pattern.split("/");
-  const baseParts = [];
+function ownsFile(serviceRule, filePath) {
+  if (hasPrefix(filePath, serviceRule.testPrefix)) return true;
+  if (serviceRule.cwdPrefix && hasPrefix(filePath, serviceRule.cwdPrefix)) return true;
+  return false;
+}
 
-  for (const part of parts) {
-    if (/[?*\[]/.test(part)) break;
-    baseParts.push(part);
+function relativeToServiceRoot(serviceRule, filePath) {
+  if (hasPrefix(filePath, serviceRule.testPrefix)) {
+    return path.posix.relative(serviceRule.testPrefix, filePath);
   }
-
-  return baseParts.length > 0 ? baseParts.join("/") : ".";
+  if (serviceRule.cwdPrefix && hasPrefix(filePath, serviceRule.cwdPrefix)) {
+    return path.posix.relative(serviceRule.cwdPrefix, filePath);
+  }
+  return filePath;
 }
 
-function globToRegExp(pattern) {
-  let source = "^";
-
-  for (let index = 0; index < pattern.length; index += 1) {
-    const current = pattern[index];
-    const next = pattern[index + 1];
-    const afterNext = pattern[index + 2];
-
-    if (current === "*" && next === "*" && afterNext === "/") {
-      source += "(?:.*/)?";
-      index += 2;
-      continue;
-    }
+function deriveSuiteName(relativePath, suffix) {
+  const parts = relativePath.split("/").filter(Boolean);
+  if (parts.length >= 3) return parts[1];
+  return path.posix.basename(relativePath, suffix);
+}
 
-    if (current === "*" && next === "*") {
-      source += ".*";
-      index += 1;
-      continue;
-    }
+function buildDiscoveryError(unowned, ambiguous) {
+  const lines = ["Filesystem discovery failed for one or more .testkit.ts files."];
 
-    if (current === "*") {
-      source += "[^/]*";
-      continue;
+  if (unowned.length > 0) {
+    lines.push("");
+    lines.push("Unowned test files:");
+    for (const filePath of unowned) {
+      lines.push(`- ${filePath}`);
     }
+  }
 
-    if (current === "?") {
-      source += "[^/]";
-      continue;
+  if (ambiguous.length > 0) {
+    lines.push("");
+    lines.push("Ambiguous test files:");
+    for (const entry of ambiguous) {
+      lines.push(`- ${entry.filePath} -> ${entry.serviceNames.join(", ")}`);
     }
+  }
 
-    if ("\\.[]{}()+-^$|".includes(current)) {
-      source += `\\${current}`;
-      continue;
-    }
+  lines.push("");
+  lines.push('Expected test files to live under "tests/<service>/..." or a non-root service local.cwd directory.');
+  return new Error(lines.join("\n"));
+}
 
-    source += current;
-  }
+function inferRule(filePath) {
+  return DISCOVERY_RULES.find((rule) => filePath.endsWith(rule.suffix)) || null;
+}
 
-  source += "$";
-  return new RegExp(source);
+function hasPrefix(filePath, prefix) {
+  return filePath === prefix || filePath.startsWith(`${prefix}/`);
 }
 
 function normalizePath(value) {
-  return value.split(path.sep).join("/");
+  const normalized = String(value).split(path.sep).join("/");
+  if (normalized === "." || normalized === "./") return ".";
+  return normalized.replace(/^\.\/+/, "").replace(/\/+$/, "") || ".";
 }

package/lib/config/discovery.test.mjs

@@ -2,7 +2,7 @@ import fs from "fs";
 import os from "os";
 import path from "path";
 import { afterEach, describe, expect, it } from "vitest";
-import { discoverServiceSuites } from "./discovery.mjs";
+import { discoverSuites } from "./discovery.mjs";
 
 const cleanups = [];
 
@@ -12,33 +12,91 @@ afterEach(() => {
   }
 });
 
-describe("config-discovery", () => {
-  it("discovers exact-file includes with stable suite names", () => {
+describe("filesystem-discovery", () => {
+  it("discovers tests by convention without config registration", () => {
     const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-discovery-"));
     cleanups.push(() => fs.rmSync(productDir, { recursive: true, force: true }));
 
-    const filePath = path.join(
-      productDir,
-      "tests",
-      "api",
-      "integration",
-      "health.int.testkit.ts"
-    );
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, "export {};\n");
-
-    const suites = discoverServiceSuites(productDir, "api", {
-      discovery: {
-        include: ["tests/api/integration/health.int.testkit.ts"],
+    writeFile(productDir, "tests/api/integration/health.int.testkit.ts");
+    writeFile(productDir, "tests/api/integration/auth/me.int.testkit.ts");
+    writeFile(productDir, "frontend/e2e/homepage.pw.testkit.ts");
+
+    const suites = discoverSuites(productDir, {
+      api: {
+        local: {
+          cwd: ".",
+        },
+      },
+      frontend: {
+        local: {
+          cwd: "frontend",
+        },
       },
     });
 
-    expect(suites.integration).toEqual([
+    expect(suites.api.integration).toEqual([
+      {
+        name: "auth",
+        files: ["tests/api/integration/auth/me.int.testkit.ts"],
+        framework: "k6",
+      },
       {
         name: "health",
         files: ["tests/api/integration/health.int.testkit.ts"],
         framework: "k6",
       },
     ]);
+    expect(suites.frontend.e2e).toEqual([
+      {
+        name: "homepage",
+        files: ["frontend/e2e/homepage.pw.testkit.ts"],
+        framework: "playwright",
+      },
+    ]);
+  });
+
+  it("fails when a discovered file does not map to any configured service", () => {
+    const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-discovery-"));
+    cleanups.push(() => fs.rmSync(productDir, { recursive: true, force: true }));
+
+    writeFile(productDir, "tests/unknown/integration/health.int.testkit.ts");
+
+    expect(() =>
+      discoverSuites(productDir, {
+        api: {
+          local: {
+            cwd: ".",
+          },
+        },
+      })
+    ).toThrow("Unowned test files");
+  });
+
+  it("fails when a discovered file maps to multiple services", () => {
+    const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-discovery-"));
+    cleanups.push(() => fs.rmSync(productDir, { recursive: true, force: true }));
+
+    writeFile(productDir, "frontend/e2e/homepage.pw.testkit.ts");
+
+    expect(() =>
+      discoverSuites(productDir, {
+        frontend: {
+          local: {
+            cwd: "frontend",
+          },
+        },
+        web: {
+          local: {
+            cwd: "frontend",
+          },
+        },
+      })
+    ).toThrow("Ambiguous test files");
   });
 });
+
+function writeFile(productDir, relativePath) {
+  const absolutePath = path.join(productDir, relativePath);
+  fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+  fs.writeFileSync(absolutePath, "export {};\n");
+}

package/lib/config/index.mjs

@@ -1,7 +1,7 @@
 import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
-import { discoverServiceSuites } from "./discovery.mjs";
+import { discoverSuites } from "./discovery.mjs";
 import {
   getServiceEnvFiles as getServiceEnvFilesModel,
   isObject as isObjectModel,
@@ -34,6 +34,7 @@ export function loadConfigs(opts = {}) {
   const productDir = resolveProductDir(process.cwd(), opts.dir);
   const config = loadTestkitConfig(productDir);
   validateConfigCoverage(config);
+  const discoveredSuites = discoverSuites(productDir, config.services);
 
   const serviceEntries = Object.entries(config.services);
   const filtered = opts.service
@@ -46,7 +47,7 @@ export function loadConfigs(opts = {}) {
   }
 
   return filtered.map(([name, serviceConfig]) => {
-    const suites = discoverServiceSuites(productDir, name, serviceConfig);
+    const suites = discoveredSuites[name] || {};
     const resolvedDatabase = resolveSelectedDatabase(name, serviceConfig);
     const serviceEnv = loadServiceEnv(productDir, serviceConfig);
     const selectedBackend = resolvedDatabase?.selectedBackend;

package/lib/config/model.mjs

@@ -213,23 +213,9 @@ export function validateServiceConfig(name, service, configPath) {
   }
 
   if (service.discovery !== undefined) {
-    if (!isObject(service.discovery)) {
-      throw new Error(`Service "${name}" discovery must be an object`);
-    }
-    if (
-      service.discovery.include !== undefined &&
-      (!Array.isArray(service.discovery.include) ||
-        service.discovery.include.some((value) => typeof value !== "string" || value.length === 0))
-    ) {
-      throw new Error(`Service "${name}" discovery.include must be an array of glob strings`);
-    }
-    if (
-      service.discovery.exclude !== undefined &&
-      (!Array.isArray(service.discovery.exclude) ||
-        service.discovery.exclude.some((value) => typeof value !== "string" || value.length === 0))
-    ) {
-      throw new Error(`Service "${name}" discovery.exclude must be an array of glob strings`);
-    }
+    throw new Error(
+      `Service "${name}" cannot define discovery. Testkit discovers *.testkit.ts files from the filesystem automatically.`
+    );
   }
 }
 

package/lib/config/model.test.mjs

@@ -95,11 +95,9 @@ QUX='zap'
 
     expect(() =>
       validateServiceConfig("api", {
-        discovery: {
-          include: "tests/**/*.int.testkit.ts",
-        },
+        discovery: {},
       }, "testkit.config.json")
-    ).toThrow("discovery.include must be an array of glob strings");
+    ).toThrow("cannot define discovery");
 
     expect(() =>
       validateTelemetryConfig(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit",
-  "version": "0.1.21",
+  "version": "0.1.22",
   "description": "CLI for discovering and running local test suites across k6 and Playwright",
   "type": "module",
   "exports": {