@codeyam-editor/codeyam-editor 0.1.4 → 0.1.6

package/npm/scenario-mocks.js

@@ -1,45 +1,124 @@
-function normalizeMockCandidates(url) {
+// Route matcher shared, semantically, with the injected live-preview shim
+// (crates/proxy-http/src/fetch_patch.js::matchUrl / matchPath / matchQuerySpec).
+// This is a VERBATIM port of that shim's matcher — the two interception paths
+// MUST agree on which requests a mock route covers. When they drifted (the
+// shim gained `:param` + query-spec parity but this capture-harness matcher was
+// left doing exact string matching), a parameterized or query-spec'd mock
+// rendered in the Live Preview but escaped Playwright's `page.route` during
+// capture and rendered an empty list. `scenario-mocks.test.js` pins the two to
+// identical verdicts on a shared fixture table so a future divergence is a
+// test failure, not another lost build session.
+//
+// `:param` path segments match any single non-empty segment; a `?k=v` / `?k=*`
+// query-spec suffix constrains the query as a subset match (`k=*` matches any
+// value; an empty spec matches any query). Full-URL patterns (`http://…`) match
+// by prefix on the raw URL. Mirrors crates/mock-engine's server matcher.
+function matchUrl(pattern, url) {
+  // Full-URL patterns (external APIs) match by prefix on the raw URL.
+  if (pattern.startsWith("http://") || pattern.startsWith("https://")) {
+    return url.indexOf(pattern) === 0;
+  }
+
+  let reqPath = url;
+  let reqQuery = "";
   try {
-    const parsed = new URL(url);
-    return [url, `${parsed.pathname}${parsed.search}`, parsed.pathname];
+    const u = new URL(url);
+    reqPath = u.pathname;
+    reqQuery = u.search.replace(/^\?/, "");
   } catch {
-    return [url];
+    const qi = url.indexOf("?");
+    if (qi >= 0) {
+      reqPath = url.slice(0, qi);
+      reqQuery = url.slice(qi + 1);
+    }
   }
+
+  const patParts = pattern.split("?");
+  if (!matchPath(patParts[0], reqPath)) return false;
+  return matchQuerySpec(patParts.length > 1 ? patParts[1] : "", reqQuery);
+}
+
+// Segment-wise path match with `:param` wildcards. A `:name` segment matches
+// any single non-empty segment; every other segment must be equal, and the
+// segment counts must match — no implicit prefix match, same as the server.
+function matchPath(pattern, path) {
+  const pp = pattern.split("/");
+  const rp = path.split("/");
+  if (pp.length !== rp.length) return false;
+  for (let i = 0; i < pp.length; i++) {
+    if (pp[i].charAt(0) === ":") {
+      if (rp[i] === "") return false;
+      continue;
+    }
+    if (pp[i] !== rp[i]) return false;
+  }
+  return true;
+}
+
+// Query-spec match. An empty spec matches any query (a path-only route still
+// matches a request that carries query params). Otherwise every `k=v` pair in
+// the spec must be present in the request query; `k=*` matches any value.
+function matchQuerySpec(spec, query) {
+  if (!spec) return true;
+  const want = new URLSearchParams(spec);
+  const have = new URLSearchParams(query);
+  let ok = true;
+  want.forEach((v, k) => {
+    const got = have.get(k);
+    if (got === null) {
+      ok = false;
+      return;
+    }
+    if (v !== "*" && got !== v) ok = false;
+  });
+  return ok;
+}
+
+// Split a mock key (`"<METHOD> <route>"`, e.g. `"GET /api/plans"`) into its
+// method and route pattern. Returns null for a malformed key with no separator.
+function splitMockKey(key) {
+  const spaceIdx = key.indexOf(" ");
+  if (spaceIdx === -1) return null;
+  return { method: key.slice(0, spaceIdx), route: key.slice(spaceIdx + 1) };
 }
 
 function findHttpMock(httpMocks, request) {
   const method = request.method().toUpperCase();
-  const candidates = normalizeMockCandidates(request.url());
-  for (const candidate of candidates) {
-    const key = `${method} ${candidate}`;
-    if (httpMocks[key]) {
-      return httpMocks[key];
-    }
+  const url = request.url();
+  for (const [key, mock] of Object.entries(httpMocks)) {
+    const parsed = splitMockKey(key);
+    if (!parsed) continue;
+    // Method stays an exact check; only the route is matched by pattern.
+    if (parsed.method.toUpperCase() !== method) continue;
+    if (matchUrl(parsed.route, url)) return mock;
   }
   return null;
 }
 
-// The set of path/URL targets declared by the mock keys. A key is
-// `"<METHOD> <target>"` (e.g. `"GET /api/plans"`); we strip the method so the
+// The set of path/URL route patterns declared by the mock keys. A key is
+// `"<METHOD> <route>"` (e.g. `"GET /api/plans"`); we strip the method so the
 // route matcher can decide whether a request *could* match any mock without
 // knowing the method (the handler re-checks method via findHttpMock).
 function mockedTargets(httpMocks) {
   const targets = new Set();
   for (const key of Object.keys(httpMocks)) {
-    const spaceIdx = key.indexOf(" ");
-    if (spaceIdx === -1) continue;
-    targets.add(key.slice(spaceIdx + 1));
+    const parsed = splitMockKey(key);
+    if (!parsed) continue;
+    targets.add(parsed.route);
   }
   return targets;
 }
 
-// True when a request URL matches one of the declared mock targets. Accepts
-// either a string or a WHATWG URL (Playwright's URL-matcher passes a URL).
+// True when a request URL matches one of the declared mock route patterns under
+// the shared route matcher (`:param` + query-spec parity), not exact string
+// equality. Accepts either a string or a WHATWG URL (Playwright's URL-matcher
+// passes a URL).
 function requestTargetsMock(targets, url) {
   const href = typeof url === "string" ? url : url.href;
-  return normalizeMockCandidates(href).some((candidate) =>
-    targets.has(candidate),
-  );
+  for (const target of targets) {
+    if (matchUrl(target, href)) return true;
+  }
+  return false;
 }
 
 async function attachHttpMocks(page, httpMocks) {
@@ -98,10 +177,54 @@ async function attachHttpMocks(page, httpMocks) {
   });
 }
 
+
+// True when a console "Failed to load resource" error at `url` corresponds to
+// a mock this scenario DECLARED with an error status (>= 400). An intentional
+// error-state scenario (e.g. a History tab mocking `GET /api/history` -> 500)
+// must not fail its own capture on the console noise its mock deliberately
+// produces. Console errors carry no HTTP method, so any method's mock on a
+// matching target counts.
+function isDeclaredErrorMock(httpMocks, url) {
+  for (const [key, mock] of Object.entries(httpMocks || {})) {
+    const parsed = splitMockKey(key);
+    if (!parsed) continue;
+    // Method-agnostic on purpose: console errors carry no HTTP method, so any
+    // method's error mock on a matching route counts. Route matching uses the
+    // shared matcher so a `:param`/query-spec error mock is recognised too.
+    if (!matchUrl(parsed.route, url)) continue;
+    if ((mock.status || 200) >= 400) return true;
+  }
+  return false;
+}
+
+// Given a same-origin response's method/url/status and the scenario's declared
+// mocks, return the `{method, path, status}` to record as an unmocked route, or
+// `null` if it should be ignored: a sub-4xx response, or one already covered by
+// a declared error mock (status >= 400, whose 4xx is the mock's intended
+// behavior). The caller applies the same-origin and `expectedConsoleErrors`
+// gates before calling. `path` is the URL pathname — the route half of the
+// `"<METHOD> <path>"` stub-mock key; a malformed URL falls back to the raw
+// string so the key is still well-formed.
+function unmockedRouteFrom(method, url, status, httpMocks) {
+  if (status < 400) return null;
+  if (isDeclaredErrorMock(httpMocks, url)) return null;
+  let path = url;
+  try {
+    path = new URL(url).pathname;
+  } catch {
+    /* malformed URL — fall back to the raw string for the stub key */
+  }
+  return { method: String(method).toUpperCase(), path, status };
+}
+
 module.exports = {
-  normalizeMockCandidates,
+  matchUrl,
+  matchPath,
+  matchQuerySpec,
   findHttpMock,
   mockedTargets,
   requestTargetsMock,
   attachHttpMocks,
+  isDeclaredErrorMock,
+  unmockedRouteFrom,
 };