@zimic/interceptor 1.1.4-canary.1 → 1.1.5-canary.0

package/dist/http.mjs

@@ -614,23 +614,30 @@ var HttpRequestHandlerClient = class {
     return this;
   }
   async matchesRequest(request) {
-    const hasDeclaredResponse = this.createResponseDeclaration !== void 0;
-    const restrictionsMatch = await this.matchesRequestRestrictions(request);
-    if (restrictionsMatch.success) {
-      this.numberOfMatchedRequests++;
-    } else {
-      const shouldSaveUnmatchedGroup = this.interceptor.requestSaving.enabled && this.restrictions.length > 0 && this.timesDeclarationPointer !== void 0;
-      if (shouldSaveUnmatchedGroup) {
-        this.unmatchedRequestGroups.push({ request, diff: restrictionsMatch.diff });
-      }
+    const restrictionsMatch = await this.matchesRestrictions(request);
+    if (!restrictionsMatch.success) {
+      return { success: false, cause: "unmatchedRestrictions", diff: restrictionsMatch.diff };
     }
-    if (!hasDeclaredResponse) {
-      return false;
+    const hasResponseDeclaration = this.createResponseDeclaration !== void 0;
+    if (!hasResponseDeclaration) {
+      return { success: false, cause: "missingResponseDeclaration" };
     }
-    const isWithinLimits = this.numberOfMatchedRequests <= this.limits.numberOfRequests.max;
-    return restrictionsMatch.success && isWithinLimits;
+    const canAcceptMoreRequests = this.numberOfMatchedRequests < this.limits.numberOfRequests.max;
+    if (!canAcceptMoreRequests) {
+      return { success: false, cause: "exceededNumberOfRequests" };
+    }
+    return { success: true };
   }
-  async matchesRequestRestrictions(request) {
+  markRequestAsMatched(_request) {
+    this.numberOfMatchedRequests++;
+  }
+  markRequestAsUnmatched(request, options) {
+    const shouldSaveUnmatchedRequests = this.interceptor.requestSaving.enabled && this.restrictions.length > 0 && this.timesDeclarationPointer !== void 0;
+    if (shouldSaveUnmatchedRequests) {
+      this.unmatchedRequestGroups.push({ request, diff: options.diff });
+    }
+  }
+  async matchesRestrictions(request) {
     for (const restriction of this.restrictions) {
       if (this.isComputedRequestRestriction(restriction)) {
         const matchesComputedRestriction = await restriction(request);
@@ -828,8 +835,16 @@ var LocalHttpRequestHandler = class {
   get requests() {
     return this.client.requests;
   }
-  matchesRequest(request) {
-    return this.client.matchesRequest(request);
+  async matchesRequest(request) {
+    const requestMatch = await this.client.matchesRequest(request);
+    if (requestMatch.success) {
+      this.client.markRequestAsMatched(request);
+    } else if (requestMatch.cause === "unmatchedRestrictions") {
+      this.client.markRequestAsUnmatched(request, { diff: requestMatch.diff });
+    } else {
+      this.client.markRequestAsMatched(request);
+    }
+    return requestMatch;
   }
   async applyResponseDeclaration(request) {
     return this.client.applyResponseDeclaration(request);
@@ -1312,8 +1327,16 @@ var RemoteHttpRequestHandler = class {
   get requests() {
     return this.client.requests;
   }
-  matchesRequest(request) {
-    return this.client.matchesRequest(request);
+  async matchesRequest(request) {
+    const requestMatch = await this.client.matchesRequest(request);
+    if (requestMatch.success) {
+      this.client.markRequestAsMatched(request);
+    } else if (requestMatch.cause === "unmatchedRestrictions") {
+      this.client.markRequestAsUnmatched(request, { diff: requestMatch.diff });
+    } else {
+      this.client.markRequestAsMatched(request);
+    }
+    return requestMatch;
   }
   async applyResponseDeclaration(request) {
     return this.client.applyResponseDeclaration(request);
@@ -1357,7 +1380,7 @@ var HttpInterceptorClient = class {
   onUnhandledRequest;
   isRunning = false;
   Handler;
-  handlerClientsByMethod = {
+  handlers = {
     GET: /* @__PURE__ */ new Map(),
     POST: /* @__PURE__ */ new Map(),
     PATCH: /* @__PURE__ */ new Map(),
@@ -1478,17 +1501,17 @@ var HttpInterceptorClient = class {
     return handler;
   }
   registerRequestHandler(handler) {
-    const handlerClients = this.handlerClientsByMethod[handler.method].get(handler.path) ?? [];
-    const isAlreadyRegistered = handlerClients.includes(handler.client);
+    const pathHandlers = this.handlers[handler.method].get(handler.path) ?? [];
+    const isAlreadyRegistered = pathHandlers.includes(handler.client);
     if (isAlreadyRegistered) {
       return;
     }
-    handlerClients.push(handler.client);
-    const isFirstHandlerForMethodPath = handlerClients.length === 1;
+    pathHandlers.push(handler.client);
+    const isFirstHandlerForMethodPath = pathHandlers.length === 1;
     if (!isFirstHandlerForMethodPath) {
       return;
     }
-    this.handlerClientsByMethod[handler.method].set(handler.path, handlerClients);
+    this.handlers[handler.method].set(handler.path, pathHandlers);
     const pathRegex = createRegexFromPath_default(handler.path);
     const registrationResult = this.workerOrThrow.use(this, handler.method, handler.path, async (context) => {
       const response = await this.handleInterceptedRequest(
@@ -1529,21 +1552,36 @@ var HttpInterceptorClient = class {
       console.warn(error);
     }
   }
-  async findMatchedHandler(method, path, parsedRequest) {
-    const handlersByPath = this.handlerClientsByMethod[method].get(path) ?? [];
-    for (let handlerIndex = handlersByPath.length - 1; handlerIndex >= 0; handlerIndex--) {
-      const handler = handlersByPath[handlerIndex];
-      if (await handler.matchesRequest(parsedRequest)) {
+  async findMatchedHandler(method, path, request) {
+    const pathHandlers = this.handlers[method].get(path) ?? [];
+    const failedRequestMatches = /* @__PURE__ */ new Map();
+    for (let handlerIndex = pathHandlers.length - 1; handlerIndex >= 0; handlerIndex--) {
+      const handler = pathHandlers[handlerIndex];
+      const requestMatch = await handler.matchesRequest(request);
+      if (requestMatch.success) {
+        handler.markRequestAsMatched(request);
         return handler;
       }
+      failedRequestMatches.set(handler, requestMatch);
+    }
+    for (let handlerIndex = pathHandlers.length - 1; handlerIndex >= 0; handlerIndex--) {
+      const handler = pathHandlers[handlerIndex];
+      const requestMatch = failedRequestMatches.get(handler);
+      if (requestMatch?.cause === "unmatchedRestrictions") {
+        handler.markRequestAsUnmatched(request, { diff: requestMatch.diff });
+      } else {
+        handler.markRequestAsMatched(request);
+        break;
+      }
     }
     return void 0;
   }
   checkTimes() {
     for (const method of HTTP_METHODS) {
-      const handlersByPath = this.handlerClientsByMethod[method];
-      for (const handlers of handlersByPath.values()) {
-        for (const handler of handlers) {
+      const pathHandlers = this.handlers[method];
+      for (const handlers of pathHandlers.values()) {
+        for (let handlerIndex = handlers.length - 1; handlerIndex >= 0; handlerIndex--) {
+          const handler = handlers[handlerIndex];
           handler.checkTimes();
         }
       }
@@ -1558,17 +1596,17 @@ var HttpInterceptorClient = class {
       for (const result of newClearResults) {
         clearResults.push(Promise.resolve(result));
       }
-      const handlersByPath = this.handlerClientsByMethod[method];
-      handlersByPath.clear();
+      const pathHandlers = this.handlers[method];
+      pathHandlers.clear();
     }
     if (options.onCommitSuccess) {
       void Promise.all(clearResults).then(options.onCommitSuccess, options.onCommitError);
     }
   }
   clearMethodHandlers(method) {
-    const handlersByPath = this.handlerClientsByMethod[method];
+    const pathHandlers = this.handlers[method];
     const clearResults = [];
-    for (const handlers of handlersByPath.values()) {
+    for (const handlers of pathHandlers.values()) {
       for (const handler of handlers) {
         clearResults.push(handler.clear());
       }