@elench/testkit 0.1.26 → 0.1.28

package/lib/config/discovery.mjs

@@ -1,6 +1,7 @@
 import fs from "fs";
 import path from "path";
 
+const TESTKIT_DIRNAME = "__testkit__";
 const DISCOVERY_RULES = [
   { suffix: ".int.testkit.ts", type: "integration", framework: "k6" },
   { suffix: ".e2e.testkit.ts", type: "e2e", framework: "k6" },
@@ -27,80 +28,98 @@ const IGNORED_DIRS = new Set([
   "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);
+export function discoverProject(productDir, explicitServices = {}) {
+  const { suiteFiles, legacyFiles } = discoverFiles(productDir);
+  const groupedByService = {};
+  const services = {};
   const unowned = [];
   const ambiguous = [];
+  const discoveredSuites = [];
 
-  for (const filePath of discoveredFiles) {
+  for (const filePath of suiteFiles) {
     const rule = inferRule(filePath);
     if (!rule) continue;
 
-    const matches = rules
-      .filter((serviceRule) => ownsFile(serviceRule, filePath))
-      .map((serviceRule) => serviceRule.name);
-
-    if (matches.length === 0) {
+    const owners = inferOwners(filePath, explicitServices);
+    if (owners.length === 0) {
       unowned.push(filePath);
       continue;
     }
-
-    if (matches.length > 1) {
+    if (owners.length > 1) {
       ambiguous.push({
         filePath,
-        serviceNames: matches.sort((left, right) => left.localeCompare(right)),
+        serviceNames: owners.map((owner) => owner.name).sort((left, right) => left.localeCompare(right)),
       });
       continue;
     }
 
-    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] || [];
+    const owner = owners[0];
+    services[owner.name] = mergeServiceDiscovery(services[owner.name], owner);
+    const relativeToService = relativeToServiceRoot(owner, filePath);
+    const suiteRef = deriveSuiteRef(relativeToService, rule.suffix);
+    discoveredSuites.push({
+      serviceName: owner.name,
+      type: rule.type,
+      framework: rule.framework,
+      filePath,
+      suitePath: suiteRef.suitePath,
+    });
+  }
+
+  if (legacyFiles.length > 0 || unowned.length > 0 || ambiguous.length > 0) {
+    throw buildDiscoveryError(legacyFiles, unowned, ambiguous);
+  }
+
+  for (const entry of discoveredSuites) {
+    const grouped = groupedByService[entry.serviceName] || {};
+    const suitesForType = grouped[entry.type] || [];
+    const suiteKey = entry.suitePath.join("/");
     let suite = suitesForType.find(
-      (candidate) => candidate.name === suiteName && candidate.framework === rule.framework
+      (candidate) => candidate._suiteKey === suiteKey && candidate.framework === entry.framework
     );
 
     if (!suite) {
       suite = {
-        name: suiteName,
+        name: null,
         files: [],
-        framework: rule.framework,
+        framework: entry.framework,
+        _suiteKey: suiteKey,
+        _suitePath: entry.suitePath,
       };
       suitesForType.push(suite);
-      grouped[rule.type] = suitesForType;
+      grouped[entry.type] = suitesForType;
+      groupedByService[entry.serviceName] = grouped;
     }
 
-    suite.files.push(filePath);
-  }
-
-  if (unowned.length > 0 || ambiguous.length > 0) {
-    throw buildDiscoveryError(unowned, ambiguous);
+    suite.files.push(entry.filePath);
   }
 
   for (const grouped of Object.values(groupedByService)) {
     for (const suites of Object.values(grouped)) {
+      const suiteNames = disambiguateSuiteNames(suites);
       for (const suite of suites) {
+        suite.name = suiteNames.get(suite._suiteKey);
         suite.files.sort((left, right) => left.localeCompare(right));
+        delete suite._suiteKey;
+        delete suite._suitePath;
       }
       suites.sort((left, right) => left.name.localeCompare(right.name));
     }
   }
 
-  return groupedByService;
+  return {
+    services,
+    suitesByService: groupedByService,
+  };
+}
+
+export function discoverSuites(productDir, explicitServices = {}) {
+  return discoverProject(productDir, explicitServices).suitesByService;
 }
 
 function discoverFiles(productDir) {
-  const files = [];
+  const suiteFiles = [];
+  const legacyFiles = [];
   const queue = [productDir];
 
   while (queue.length > 0) {
@@ -119,48 +138,184 @@ function discoverFiles(productDir) {
       if (!entry.isFile()) continue;
 
       const relativePath = normalizePath(path.relative(productDir, absolutePath));
-      if (inferRule(relativePath)) files.push(relativePath);
+      if (!inferRule(relativePath)) continue;
+      if (relativePath.split("/").includes(TESTKIT_DIRNAME)) {
+        suiteFiles.push(relativePath);
+      } else {
+        legacyFiles.push(relativePath);
+      }
     }
   }
 
-  return files.sort((left, right) => left.localeCompare(right));
+  return {
+    suiteFiles: suiteFiles.sort((left, right) => left.localeCompare(right)),
+    legacyFiles: legacyFiles.sort((left, right) => left.localeCompare(right)),
+  };
+}
+
+function inferOwners(filePath, explicitServices) {
+  const serviceRules = Object.entries(explicitServices).flatMap(([name, config]) =>
+    buildServiceRules(name, config)
+  );
+  if (serviceRules.length === 0) {
+    return [
+      {
+        name: "app",
+        source: "implicit-root",
+        cwdPrefix: ".",
+      },
+    ];
+  }
+
+  const owningRules = serviceRules.filter((rule) => ownsFile(rule, filePath));
+  if (owningRules.length === 0) {
+    return [];
+  }
+
+  const maxDepth = Math.max(...owningRules.map((rule) => rule.depth));
+  return owningRules.filter((rule) => rule.depth === maxDepth);
 }
 
-function buildServiceRule(serviceName, serviceConfig) {
-  const testPrefix = normalizePath(path.posix.join("tests", serviceName));
+function disambiguateSuiteNames(suites) {
+  const used = new Map();
+  const resolved = new Map();
+
+  for (const suite of suites) {
+    const pathSegments = suite._suitePath;
+    let candidate = "";
+
+    for (let depth = 1; depth <= pathSegments.length; depth += 1) {
+      candidate = pathSegments.slice(-depth).join("-");
+      const existing = used.get(candidate);
+      if (!existing) {
+        used.set(candidate, suite._suiteKey);
+        break;
+      }
+      if (existing === suite._suiteKey) break;
+      candidate = "";
+    }
+
+    if (!candidate) {
+      candidate = pathSegments.join("-");
+    }
+
+    resolved.set(suite._suiteKey, candidate);
+  }
+
+  if (resolved.size !== suites.length) {
+    for (const suite of suites) {
+      if (!resolved.has(suite._suiteKey)) {
+        resolved.set(suite._suiteKey, suite._suitePath.join("-"));
+      }
+    }
+  }
+
+  if (new Set(resolved.values()).size !== suites.length) {
+    const counts = new Map();
+    for (const suite of suites) {
+      const base = suite._suitePath.join("-");
+      const count = counts.get(base) || 0;
+      counts.set(base, count + 1);
+      resolved.set(suite._suiteKey, count === 0 ? base : `${base}-${count + 1}`);
+    }
+  }
+
+  return resolved;
+}
+
+function buildServiceRules(serviceName, serviceConfig) {
   const cwd = normalizePath(serviceConfig?.local?.cwd || ".");
-  return {
-    name: serviceName,
-    testPrefix,
-    cwdPrefix: cwd === "." ? null : cwd,
-  };
+  const discoveryRoots = Array.isArray(serviceConfig?.discovery?.roots)
+    ? serviceConfig.discovery.roots
+    : [cwd];
+
+  return discoveryRoots.map((root) => {
+    const normalizedRoot = normalizePath(root || ".");
+    return {
+      name: serviceName,
+      source: "cwd",
+      cwdPrefix: cwd === "." ? null : cwd,
+      matchPrefix: normalizedRoot === "." ? null : normalizedRoot,
+      depth: normalizedRoot === "." ? 0 : normalizedRoot.split("/").filter(Boolean).length,
+    };
+  });
 }
 
 function ownsFile(serviceRule, filePath) {
-  if (hasPrefix(filePath, serviceRule.testPrefix)) return true;
-  if (serviceRule.cwdPrefix && hasPrefix(filePath, serviceRule.cwdPrefix)) return true;
+  if (serviceRule.depth === 0) return true;
+  if (serviceRule.matchPrefix && hasPrefix(filePath, serviceRule.matchPrefix)) return true;
   return false;
 }
 
 function relativeToServiceRoot(serviceRule, filePath) {
-  if (hasPrefix(filePath, serviceRule.testPrefix)) {
-    return path.posix.relative(serviceRule.testPrefix, filePath);
-  }
   if (serviceRule.cwdPrefix && hasPrefix(filePath, serviceRule.cwdPrefix)) {
     return path.posix.relative(serviceRule.cwdPrefix, filePath);
   }
   return filePath;
 }
 
-function deriveSuiteName(relativePath, suffix) {
+function deriveSuiteRef(relativePath, suffix) {
   const parts = relativePath.split("/").filter(Boolean);
-  if (parts.length >= 3) return parts[1];
-  return path.posix.basename(relativePath, suffix);
+  const testkitIndex = parts.indexOf(TESTKIT_DIRNAME);
+  if (testkitIndex === -1) {
+    const fallback = path.posix.basename(relativePath, suffix);
+    return {
+      suitePath: [fallback],
+    };
+  }
+
+  const before = parts.slice(0, testkitIndex);
+  const after = parts.slice(testkitIndex + 1);
+  if (after.length === 0) {
+    const fallback = path.posix.basename(relativePath, suffix);
+    return {
+      suitePath: [fallback],
+    };
+  }
+
+  if (after.length === 1) {
+    if (before.length === 0) {
+      return {
+        suitePath: [path.posix.basename(after[0], suffix)],
+      };
+    }
+    return {
+      suitePath: before,
+    };
+  }
+
+  return {
+    suitePath: [...before, after[0]],
+  };
+}
+
+function mergeServiceDiscovery(existing, owner) {
+  if (!existing) {
+    return {
+      name: owner.name,
+      inferredLocalCwd: owner.cwdPrefix || ".",
+      source: owner.source,
+    };
+  }
+
+  return {
+    ...existing,
+    inferredLocalCwd:
+      existing.inferredLocalCwd === "." ? owner.cwdPrefix || "." : existing.inferredLocalCwd,
+  };
 }
 
-function buildDiscoveryError(unowned, ambiguous) {
+function buildDiscoveryError(legacyFiles, unowned, ambiguous) {
   const lines = ["Filesystem discovery failed for one or more .testkit.ts files."];
 
+  if (legacyFiles.length > 0) {
+    lines.push("");
+    lines.push("Legacy test files outside __testkit__:");
+    for (const filePath of legacyFiles) {
+      lines.push(`- ${filePath}`);
+    }
+  }
+
   if (unowned.length > 0) {
     lines.push("");
     lines.push("Unowned test files:");
@@ -178,7 +333,7 @@ function buildDiscoveryError(unowned, ambiguous) {
   }
 
   lines.push("");
-  lines.push('Expected test files to live under "tests/<service>/..." or a non-root service local.cwd directory.');
+  lines.push('Expected test files to live under a "__testkit__" directory within a service root.');
   return new Error(lines.join("\n"));
 }
 

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 { discoverSuites } from "./discovery.mjs";
+import { discoverProject, discoverSuites } from "./discovery.mjs";
 
 const cleanups = [];
 
@@ -13,13 +13,13 @@ afterEach(() => {
 });
 
 describe("filesystem-discovery", () => {
-  it("discovers tests by convention without config registration", () => {
+  it("discovers colocated __testkit__ suites by service root", () => {
     const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-discovery-"));
     cleanups.push(() => fs.rmSync(productDir, { recursive: true, force: true }));
 
-    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");
+    writeFile(productDir, "src/api/routes/__testkit__/auth/me.int.testkit.ts");
+    writeFile(productDir, "src/api/routes/__testkit__/health/ready.int.testkit.ts");
+    writeFile(productDir, "frontend/app/__testkit__/homepage/homepage.pw.testkit.ts");
 
     const suites = discoverSuites(productDir, {
       api: {
@@ -37,61 +37,90 @@ describe("filesystem-discovery", () => {
     expect(suites.api.integration).toEqual([
       {
         name: "auth",
-        files: ["tests/api/integration/auth/me.int.testkit.ts"],
+        files: ["src/api/routes/__testkit__/auth/me.int.testkit.ts"],
         framework: "k6",
       },
       {
         name: "health",
-        files: ["tests/api/integration/health.int.testkit.ts"],
+        files: ["src/api/routes/__testkit__/health/ready.int.testkit.ts"],
         framework: "k6",
       },
     ]);
     expect(suites.frontend.e2e).toEqual([
       {
         name: "homepage",
-        files: ["frontend/e2e/homepage.pw.testkit.ts"],
+        files: ["frontend/app/__testkit__/homepage/homepage.pw.testkit.ts"],
         framework: "playwright",
       },
     ]);
   });
 
-  it("fails when a discovered file does not map to any configured service", () => {
+  it("infers the suite from the directory that owns __testkit__", () => {
     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");
+    writeFile(productDir, "src/services/search/__testkit__/query/validation.int.testkit.ts");
 
-    expect(() =>
-      discoverSuites(productDir, {
-        api: {
-          local: {
-            cwd: ".",
-          },
+    const project = discoverProject(productDir, {
+      api: {
+        local: {
+          cwd: ".",
         },
-      })
-    ).toThrow("Unowned test files");
+      },
+    });
+    expect(project.services.api).toMatchObject({
+      name: "api",
+      inferredLocalCwd: ".",
+    });
+    expect(project.suitesByService.api.integration[0]).toMatchObject({
+      name: "query",
+      files: ["src/services/search/__testkit__/query/validation.int.testkit.ts"],
+      framework: "k6",
+    });
   });
 
-  it("fails when a discovered file maps to multiple services", () => {
+  it("prefers the deepest matching service root", () => {
     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");
+    writeFile(productDir, "frontend/app/__testkit__/billing/lifecycle.pw.testkit.ts");
+
+    const project = discoverProject(productDir, {
+      app: {
+        local: {
+          cwd: ".",
+        },
+      },
+      frontend: {
+        local: {
+          cwd: "frontend",
+        },
+      },
+    });
+
+    expect(project.suitesByService.app).toBeUndefined();
+    expect(project.suitesByService.frontend.e2e[0]).toMatchObject({
+      name: "billing",
+      files: ["frontend/app/__testkit__/billing/lifecycle.pw.testkit.ts"],
+      framework: "playwright",
+    });
+  });
+
+  it("fails on legacy files outside __testkit__", () => {
+    const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-discovery-"));
+    cleanups.push(() => fs.rmSync(productDir, { recursive: true, force: true }));
+
+    writeFile(productDir, "tests/api/integration/health.int.testkit.ts");
 
     expect(() =>
       discoverSuites(productDir, {
-        frontend: {
-          local: {
-            cwd: "frontend",
-          },
-        },
-        web: {
+        api: {
           local: {
-            cwd: "frontend",
+            cwd: ".",
           },
         },
       })
-    ).toThrow("Ambiguous test files");
+    ).toThrow("Legacy test files outside __testkit__");
   });
 });