skillrepo 4.5.0 → 4.5.2

package/src/test/e2e/mock-server.mjs

@@ -80,6 +80,18 @@ export function createMockServer(initialPayload, options = {}) {
   /** @type {{ status: number, body: any } | null} */
   let forcedError = null;
 
+  // Library-request inspection. Tests use these to distinguish a true
+  // 304 wire exchange (`If-None-Match` sent, server replied 304) from
+  // a request that produced "up to date" output via some other path.
+  // PR #1575's placement-presence fix made this distinction
+  // load-bearing — see the assertion at the call sites in
+  // update-list-contract.integration.test.mjs.
+  /** @type {string | null} */
+  let lastLibraryIfNoneMatch = null;
+  /** @type {string | null} */
+  let lastLibrarySince = null;
+  let libraryRequestCount = 0;
+
   // PR3a mutable slots for POST/DELETE library routes
   //
   // Each entry is `{ status: number, body: any }` describing the
@@ -486,18 +498,57 @@ export function createMockServer(initialPayload, options = {}) {
         return;
       }
 
-      // ETag short-circuit
+      // ETag short-circuit. Capture the inbound If-None-Match and
+      // `since` into inspectable slots BEFORE deciding 304-vs-200 so
+      // tests can assert on what the client actually sent — not just
+      // whether the response was 304. PR #1575's placement-presence
+      // fix makes the wire-level distinction load-bearing.
       const ifNoneMatch = req.headers["if-none-match"];
+      const sinceParam = url.searchParams.get("since");
+      lastLibraryIfNoneMatch = ifNoneMatch ?? null;
+      lastLibrarySince = sinceParam ?? null;
+      libraryRequestCount++;
       if (libraryEtag && ifNoneMatch === libraryEtag) {
         res.writeHead(304, { ETag: libraryEtag });
         res.end();
         return;
       }
 
+      // Mirror the production server's `since` filter — only return
+      // skills updated AFTER the `since` timestamp. Pre-PR #1575 the
+      // mock returned every skill regardless of `since`, which hid a
+      // real production bug: dropping the ETag without ALSO dropping
+      // `since` made the server respond with an empty delta, leaving
+      // newly-detected vendor placements empty forever. Mirroring the
+      // filter here means any future regression of that class fails
+      // at test time. See src/lib/queries/library.ts in the server
+      // for the production behavior (`gt(skills.updatedAt, since)`).
+      let respondedSkills = libraryResponse.skills ?? [];
+      if (sinceParam && Array.isArray(respondedSkills)) {
+        const sinceDate = new Date(sinceParam);
+        if (!Number.isNaN(sinceDate.getTime())) {
+          respondedSkills = respondedSkills.filter((s) => {
+            // updatedAt is a string ISO timestamp in the fixture skills.
+            // Missing/invalid → treat as "older than since" → exclude
+            // (matches the production semantic of "not modified in
+            // the window").
+            if (typeof s.updatedAt !== "string") return false;
+            const updated = new Date(s.updatedAt);
+            if (Number.isNaN(updated.getTime())) return false;
+            return updated.getTime() > sinceDate.getTime();
+          });
+        }
+      }
+
+      const filteredResponse = {
+        ...libraryResponse,
+        skills: respondedSkills,
+      };
+
       const headers = { "Content-Type": "application/json" };
       if (libraryEtag) headers.ETag = libraryEtag;
       res.writeHead(200, headers);
-      res.end(JSON.stringify(libraryResponse));
+      res.end(JSON.stringify(filteredResponse));
       return;
     }
 
@@ -586,6 +637,45 @@ export function createMockServer(initialPayload, options = {}) {
       libraryEtag = etag;
     },
 
+    /**
+     * Inspect the inbound `If-None-Match` header from the LAST request
+     * to GET /api/v1/library. Returns the literal header string, or
+     * `null` if the request didn't send one (full-fetch path). Used
+     * by tests asserting that the placement-presence check correctly
+     * dropped or sent the ETag header. See PR #1575's coverage gap
+     * 2 — without this accessor, the "304 fires" tests could pass on
+     * an implementation that broke the wire-level optimization while
+     * preserving the user-facing "up to date" output.
+     */
+    getLastLibraryIfNoneMatch() {
+      return lastLibraryIfNoneMatch;
+    },
+
+    /** Count of GET /api/v1/library requests since server start or reset. */
+    getLibraryRequestCount() {
+      return libraryRequestCount;
+    },
+
+    /**
+     * Inspect the inbound `?since=` query param from the LAST request
+     * to GET /api/v1/library. Returns the literal string or `null` if
+     * not present. The placement-presence fix must drop BOTH the
+     * If-None-Match header AND the `since` query param when placements
+     * are incomplete — otherwise the server returns an empty delta
+     * and missing placements stay empty. Tests use this to assert the
+     * fix at the wire level.
+     */
+    getLastLibrarySince() {
+      return lastLibrarySince;
+    },
+
+    /** Reset the inspection slots — useful between phases of a multi-step test. */
+    resetLibraryInspection() {
+      lastLibraryIfNoneMatch = null;
+      lastLibrarySince = null;
+      libraryRequestCount = 0;
+    },
+
     /** Register a single-skill response keyed by `owner/name`. */
     setSkillResponse(owner, name, skill) {
       skillResponses.set(`${owner}/${name}`, skill);