@elench/testkit 0.1.62 → 0.1.63

package/lib/coverage/evidence.mjs

@@ -5,6 +5,8 @@ import {
   apiRouteLookupKey,
   HTTP_METHODS,
   dedupeTargets,
+  findMatchingApiRouteEntry,
+  findMatchingRouteValue,
   toApiRequestPath,
   toSelectionType,
 } from "./shared.mjs";
@@ -22,6 +24,12 @@ function readTestFileContent(entry, context) {
   return fs.readFileSync(absolutePath, "utf8");
 }
 
+function resolveApiRouteEntry(context, method, requestPath) {
+  const exact = context.apiRouteByKey.get(apiRouteLookupKey(method, requestPath));
+  if (exact) return exact;
+  return findMatchingApiRouteEntry(method, requestPath, context.apiRouteEntries || []);
+}
+
 export function inferCoveredNodeIdsForTest(entry, context) {
   const coveredNodeIds = new Set();
   const content = readTestFileContent(entry, context);
@@ -33,7 +41,10 @@ export function inferCoveredNodeIdsForTest(entry, context) {
       ? gotoRoutes
       : (() => { const r = inferPageRouteFromTestFile(entry.filePath, context.nextAppRoot, context.serviceRoot); return r ? [r] : []; })();
     for (const route of routes) {
-      const pageEntry = context.pageByRoute.get(route);
+      const matchedRoute = context.pageByRoute.get(route)
+        ? route
+        : findMatchingRouteValue(route, [...context.pageByRoute.keys()]);
+      const pageEntry = matchedRoute ? context.pageByRoute.get(matchedRoute) : null;
       if (!pageEntry) continue;
       coveredNodeIds.add(pageEntry.node.id);
       for (const target of extractPlaywrightTargets(entry, context)) {
@@ -48,7 +59,7 @@ export function inferCoveredNodeIdsForTest(entry, context) {
     const requests = extractHttpSuiteRequests(content, entry.filePath);
     for (const request of requests) {
       if (!request.path.startsWith("/api/")) continue;
-      const routeEntry = context.apiRouteByKey.get(apiRouteLookupKey(request.method, request.path));
+      const routeEntry = resolveApiRouteEntry(context, request.method, request.path);
       if (routeEntry) coveredNodeIds.add(routeEntry.node.id);
     }
   }
@@ -58,7 +69,7 @@ export function inferCoveredNodeIdsForTest(entry, context) {
     const apiRoutes = inferApiRoutesFromTestFile(entry.filePath, context.nextAppRoot, context.serviceRoot);
     for (const route of apiRoutes) {
       for (const method of HTTP_METHODS) {
-        const routeEntry = context.apiRouteByKey.get(apiRouteLookupKey(method, toApiRequestPath(route)));
+        const routeEntry = resolveApiRouteEntry(context, method, toApiRequestPath(route));
         if (routeEntry) coveredNodeIds.add(routeEntry.node.id);
       }
     }

package/lib/coverage/evidence.test.mjs

@@ -5,6 +5,7 @@ import {
   inferDataCapabilitiesFromOwner,
 } from "./evidence.mjs";
 import { extractPlaywrightVisitedRoutes } from "./next-static-analysis.mjs";
+import { DYNAMIC_SEGMENT_TOKEN } from "./shared.mjs";
 
 describe("coverage evidence helpers", () => {
   it("extracts and dedupes Playwright targets from source content", () => {
@@ -68,10 +69,10 @@ describe("extractPlaywrightVisitedRoutes", () => {
     `, "test.pw.testkit.ts")).toEqual(["/projects"]);
   });
 
-  it("ignores dynamic goto expressions", () => {
+  it("normalizes dynamic goto expressions into route patterns", () => {
     expect(extractPlaywrightVisitedRoutes(`
       await page.goto(\`/projects/\${id}\`);
       await page.goto(someVar);
-    `, "test.pw.testkit.ts")).toEqual([]);
+    `, "test.pw.testkit.ts")).toEqual([`/projects/${DYNAMIC_SEGMENT_TOKEN}`]);
   });
 });

package/lib/coverage/graph-builder.mjs

@@ -3,10 +3,10 @@ import { buildEvidenceDetails, inferCoveredNodeIdsForTest } from "./evidence.mjs
 import { findNextAppRoot, resolveImportToSourceFile, resolveServiceRoot } from "./fs-walk.mjs";
 import { discoverApiRoutes, discoverPageViews, discoverServerActions } from "./next-discovery.mjs";
 import {
-  apiRouteLookupKey,
   appendGraph,
   createEmptyGraph,
   createTestFileNode,
+  findMatchingApiRouteEntry,
   normalizePath,
   toSelectionType,
 } from "./shared.mjs";
@@ -122,7 +122,7 @@ export function buildServiceCoverageContext(productDir, serviceName, config, rep
 
   const pageByRoute = new Map(pages.pageEntries.map((entry) => [entry.route, entry]));
   const apiRouteByKey = new Map(
-    apiRoutes.routeEntries.map((entry) => [apiRouteLookupKey(entry.method, entry.requestPath), entry])
+    apiRoutes.routeEntries.map((entry) => [`${entry.method}:${entry.requestPath}`, entry])
   );
   const serverActionByExportKey = new Map(
     serverActions.actionEntries.map((entry) => [`${entry.sourceFile}#${entry.exportName}`, entry])
@@ -130,7 +130,7 @@ export function buildServiceCoverageContext(productDir, serviceName, config, rep
 
   for (const pageEntry of pages.pageEntries) {
     for (const request of pageEntry.requests) {
-      const apiRoute = apiRouteByKey.get(apiRouteLookupKey(request.method, request.path));
+      const apiRoute = findMatchingApiRouteEntry(request.method, request.path, apiRoutes.routeEntries);
       if (!apiRoute) continue;
       graph.edges.push({
         id: `handles:${request.node.id}:${apiRoute.node.id}`,
@@ -161,6 +161,7 @@ export function buildServiceCoverageContext(productDir, serviceName, config, rep
     graph,
     pageByRoute,
     apiRouteByKey,
+    apiRouteEntries: apiRoutes.routeEntries,
     serverActionByExportKey,
     dataCapabilities: dataAugmentation.nodes,
   };

package/lib/coverage/index.test.mjs

@@ -501,6 +501,141 @@ describe("coverage graph builder", () => {
     expect(evidence.coveredNodeIds).toEqual(["api_route:web:POST:/api/campaigns"]);
   });
 
+  it("builds route-tree coverage from ancestor layouts, provider effects, local handlers, and dynamic request templates", () => {
+    const productDir = createProduct();
+    writeFile(
+      productDir,
+      "src/app/(dashboard)/layout.tsx",
+      `
+        import { ProjectProvider } from "@/components/project-context";
+
+        export default function DashboardLayout({ children }) {
+          return <ProjectProvider>{children}</ProjectProvider>;
+        }
+      `
+    );
+    writeFile(
+      productDir,
+      "src/components/project-context.tsx",
+      `
+        "use client";
+        import { useEffect } from "react";
+
+        export function ProjectProvider({ children }) {
+          const fetchProjects = async () => {
+            await fetch("/api/projects");
+          };
+
+          useEffect(() => {
+            fetchProjects();
+          }, []);
+
+          return <section>{children}</section>;
+        }
+      `
+    );
+    writeFile(
+      productDir,
+      "src/app/(dashboard)/projects/page.tsx",
+      `
+        "use client";
+        import { useState } from "react";
+
+        export default function ProjectsPage() {
+          const [name, setName] = useState("");
+
+          const handleCreate = async (event) => {
+            event.preventDefault();
+            await fetch("/api/projects", { method: "POST" });
+            setName("");
+          };
+
+          return (
+            <form onSubmit={handleCreate}>
+              <input value={name} onChange={(event) => setName(event.target.value)} />
+              <button data-testid="project-create-button" type="submit">Create Project</button>
+            </form>
+          );
+        }
+      `
+    );
+    writeFile(
+      productDir,
+      "src/app/(dashboard)/events/page.tsx",
+      `
+        "use client";
+        import { useEffect } from "react";
+
+        export default function EventsPage() {
+          const activeProject = { id: "project-1" };
+
+          useEffect(() => {
+            fetch(\`/api/projects/\${activeProject.id}/events?limit=100\`);
+          }, [activeProject.id]);
+
+          return <div>Events</div>;
+        }
+      `
+    );
+    writeFile(
+      productDir,
+      "src/app/api/projects/route.ts",
+      `
+        export async function GET() { return Response.json([]); }
+        export async function POST() { return Response.json({}, { status: 201 }); }
+      `
+    );
+    writeFile(
+      productDir,
+      "src/app/api/projects/[projectId]/events/route.ts",
+      `
+        export async function GET() { return Response.json([]); }
+      `
+    );
+
+    const context = buildServiceCoverageContext(productDir, "web", {
+      local: { cwd: ".", start: "node server.js", baseUrl: "http://127.0.0.1:3000", readyUrl: "http://127.0.0.1:3000" },
+    });
+
+    expect(context.graph.edges).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          kind: "requests",
+          from: "page_view:web:/projects",
+          to: expect.stringContaining("client_request:web:src/components/project-context.tsx:page:/projects"),
+        }),
+        expect.objectContaining({
+          kind: "handles",
+          from: expect.stringContaining("client_request:web:src/components/project-context.tsx:page:/projects"),
+          to: "api_route:web:GET:/api/projects",
+        }),
+        expect.objectContaining({
+          kind: "triggers",
+          from: expect.stringContaining("ui_surface:web:/projects"),
+          to: "ui_action:web:/projects:handleCreate",
+        }),
+        expect.objectContaining({
+          kind: "requests",
+          from: "ui_action:web:/projects:handleCreate",
+          to: expect.stringContaining("client_request:web:src/app/(dashboard)/projects/page.tsx"),
+        }),
+        expect.objectContaining({
+          kind: "handles",
+          to: "api_route:web:POST:/api/projects",
+        }),
+        expect.objectContaining({
+          kind: "requests",
+          from: "page_view:web:/events",
+          to: expect.stringContaining("client_request:web:src/components/project-context.tsx:page:/events"),
+        }),
+        expect.objectContaining({
+          kind: "handles",
+          to: "api_route:web:GET:/api/projects/[projectId]/events",
+        }),
+      ])
+    );
+  });
+
   it("emits zero-coverage-inferred diagnostic when no patterns match", () => {
     const productDir = createProduct();
     writeFile(productDir, "src/app/page.tsx", `export default function HomePage() { return null; }`);

package/lib/coverage/next-discovery.mjs

@@ -1,6 +1,6 @@
 import fs from "fs";
 import path from "path";
-import { analyzeNextPageFile } from "./next-static-analysis.mjs";
+import { analyzeNextRouteTree } from "./next-static-analysis.mjs";
 import { extractBackendImports, extractExportedFunctions, extractExportedMethodBodies } from "./backend-discovery.mjs";
 import { resolveImportToSourceFile, walkFiles } from "./fs-walk.mjs";
 import { routeFromApiFile, routeFromAppFile } from "./routing.mjs";
@@ -36,18 +36,22 @@ export function discoverPageViews({ serviceName, serviceRoot, nextAppRoot, exclu
       filePath: relativePath,
     };
     nodes.push(node);
+    const routeRootFiles = collectRouteRootFiles(nextAppRoot, absolutePath)
+      .map((absoluteRootPath) => ({
+        filePath: normalizePath(path.relative(serviceRoot, absoluteRootPath)),
+        content: fs.readFileSync(absoluteRootPath, "utf8"),
+      }));
 
-    const pageAnalysis = analyzeNextPageFile({
+    const pageAnalysis = analyzeNextRouteTree({
       serviceName,
       serviceRoot,
-      filePath: relativePath,
       route,
-      content,
+      rootFiles: routeRootFiles,
       readSourceFile: (resolvedPath) => {
         const absoluteResolved = path.join(serviceRoot, resolvedPath);
         return fs.existsSync(absoluteResolved) ? fs.readFileSync(absoluteResolved, "utf8") : null;
       },
-      resolveImportPath: (specifier) => resolveImportToSourceFile(serviceRoot, relativePath, specifier),
+      resolveImportPath: (fromFilePath, specifier) => resolveImportToSourceFile(serviceRoot, fromFilePath, specifier),
       isServerActionFile,
       normalizeRoute,
     });
@@ -68,6 +72,33 @@ export function discoverPageViews({ serviceName, serviceRoot, nextAppRoot, exclu
   return { nodes, edges, pageEntries };
 }
 
+function collectRouteRootFiles(nextAppRoot, pageAbsolutePath) {
+  const rootFiles = [];
+  let currentDir = path.dirname(pageAbsolutePath);
+  const appRoot = path.resolve(nextAppRoot);
+
+  while (currentDir.startsWith(appRoot)) {
+    const layoutFile = resolveRouteCompanion(currentDir, "layout");
+    if (layoutFile) rootFiles.push(layoutFile);
+    if (currentDir === appRoot) break;
+    currentDir = path.dirname(currentDir);
+  }
+
+  rootFiles.reverse();
+  rootFiles.push(pageAbsolutePath);
+  return [...new Set(rootFiles)];
+}
+
+function resolveRouteCompanion(directoryPath, baseName) {
+  const candidates = [
+    path.join(directoryPath, `${baseName}.tsx`),
+    path.join(directoryPath, `${baseName}.ts`),
+    path.join(directoryPath, `${baseName}.jsx`),
+    path.join(directoryPath, `${baseName}.js`),
+  ];
+  return candidates.find((candidate) => fs.existsSync(candidate)) || null;
+}
+
 export function discoverApiRoutes({ serviceName, serviceRoot, nextAppRoot, exclude = [], resolveImportToSourceFile }) {
   const routeFiles = walkFiles(path.join(nextAppRoot, "api"), { baseDir: serviceRoot, exclude }).filter(
     (filePath) => filePath.endsWith("/route.ts") || filePath.endsWith("/route.tsx") || filePath.endsWith("/route.js")