feat: http request tracker clear (#100)

apps/zimic-test-client/tests/v0/interceptor/thirdParty/shared/default.ts

@@ -725,6 +725,18 @@ function declareDefaultClientTests(options: ClientTestDeclarationOptions) {
         expect(returnedNotifications).toEqual([]);
 
         expect(listRequests).toHaveLength(1);
+        expect(listTracker.requests()).toHaveLength(1);
+
+        listTracker.clear();
+
+        response = await listNotifications(notification.userId);
+        expect(response.status).toBe(200);
+
+        returnedNotifications = (await response.json()) as Notification[];
+        expect(returnedNotifications).toEqual([]);
+
+        expect(listRequests).toHaveLength(1);
+        expect(listTracker.requests()).toHaveLength(0);
       });
     });
   });

packages/zimic/src/interceptor/http/requestTracker/HttpRequestTracker.ts

@@ -93,9 +93,13 @@ class HttpRequestTracker<
 
   bypass(): HttpRequestTracker<Schema, Method, Path, StatusCode> {
     this.createResponseDeclaration = undefined;
+    return this;
+  }
+
+  clear(): HttpRequestTracker<Schema, Method, Path, StatusCode> {
     this.restrictions = [];
     this.interceptedRequests = [];
-    return this;
+    return this.bypass();
   }
 
   matchesRequest(request: HttpInterceptorRequest<Default<Schema[Path][Method]>>): boolean {

packages/zimic/src/interceptor/http/requestTracker/__tests__/shared/requestTrackerTests.ts

@@ -117,25 +117,23 @@ export function declareSharedHttpRequestTrackerTests(options: { platform: HttpIn
       expect(tracker.matchesRequest(parsedRequest)).toBe(true);
     });
 
-    it('should clear restrictions after bypassed', async () => {
+    it('should not match any request if cleared', async () => {
       const tracker = new HttpRequestTracker<Schema, 'GET', '/users'>(interceptor, 'GET', '/users');
 
       const request = new Request(baseURL);
       const parsedRequest = await HttpInterceptorWorker.parseRawRequest<MethodSchema>(request);
       expect(tracker.matchesRequest(parsedRequest)).toBe(false);
 
-      tracker.bypass();
+      tracker.clear();
       expect(tracker.matchesRequest(parsedRequest)).toBe(false);
 
-      tracker
-        .with((_request) => false)
-        .respond({
-          status: 200,
-          body: { success: true },
-        });
-      expect(tracker.matchesRequest(parsedRequest)).toBe(false);
+      tracker.respond({
+        status: 200,
+        body: { success: true },
+      });
+      expect(tracker.matchesRequest(parsedRequest)).toBe(true);
 
-      tracker.bypass();
+      tracker.clear();
       expect(tracker.matchesRequest(parsedRequest)).toBe(false);
 
       tracker.respond({
@@ -242,6 +240,35 @@ export function declareSharedHttpRequestTrackerTests(options: { platform: HttpIn
       expect(interceptedRequests[1].response).toEqual(secondResponse);
     });
 
+    it('should clear the intercepted requests and responses after cleared', async () => {
+      const tracker = new HttpRequestTracker<Schema, 'GET', '/users'>(interceptor, 'GET', '/users').respond({
+        status: 200,
+        body: { success: true },
+      });
+
+      const firstRequest = new Request(baseURL);
+      const parsedFirstRequest = await HttpInterceptorWorker.parseRawRequest<MethodSchema>(firstRequest);
+
+      const firstResponseDeclaration = await tracker.applyResponseDeclaration(parsedFirstRequest);
+      const firstResponse = Response.json(firstResponseDeclaration.body, {
+        status: firstResponseDeclaration.status,
+      });
+      const parsedFirstResponse = await HttpInterceptorWorker.parseRawResponse<MethodSchema, 200>(firstResponse);
+
+      tracker.registerInterceptedRequest(parsedFirstRequest, parsedFirstResponse);
+
+      const interceptedRequests = tracker.requests();
+      expect(interceptedRequests).toHaveLength(1);
+
+      expect(interceptedRequests[0]).toEqual(firstRequest);
+      expect(interceptedRequests[0].response).toEqual(firstResponse);
+
+      tracker.clear();
+
+      expect(interceptedRequests).toHaveLength(1);
+      expect(tracker.requests()).toHaveLength(0);
+    });
+
     it('should provide access to the raw intercepted requests and responses', async () => {
       const tracker = new HttpRequestTracker<Schema, 'GET', '/users'>(interceptor, 'GET', '/users').respond({
         status: 200,
@@ -465,5 +492,61 @@ export function declareSharedHttpRequestTrackerTests(options: { platform: HttpIn
         }
       });
     });
+
+    it('should clear restrictions after cleared', async () => {
+      const tracker = new HttpRequestTracker<Schema, 'GET', '/users'>(interceptor, 'GET', '/users');
+
+      const request = new Request(baseURL);
+      const parsedRequest = await HttpInterceptorWorker.parseRawRequest<MethodSchema>(request);
+      expect(tracker.matchesRequest(parsedRequest)).toBe(false);
+
+      tracker.clear();
+      expect(tracker.matchesRequest(parsedRequest)).toBe(false);
+
+      tracker
+        .with((_request) => false)
+        .respond({
+          status: 200,
+          body: { success: true },
+        });
+      expect(tracker.matchesRequest(parsedRequest)).toBe(false);
+
+      tracker.clear();
+      expect(tracker.matchesRequest(parsedRequest)).toBe(false);
+
+      tracker.respond({
+        status: 200,
+        body: { success: true },
+      });
+      expect(tracker.matchesRequest(parsedRequest)).toBe(true);
+    });
+
+    it('should not clear restrictions after bypassed', async () => {
+      const tracker = new HttpRequestTracker<Schema, 'GET', '/users'>(interceptor, 'GET', '/users');
+
+      const request = new Request(baseURL);
+      const parsedRequest = await HttpInterceptorWorker.parseRawRequest<MethodSchema>(request);
+      expect(tracker.matchesRequest(parsedRequest)).toBe(false);
+
+      tracker.bypass();
+      expect(tracker.matchesRequest(parsedRequest)).toBe(false);
+
+      tracker
+        .with((_request) => false)
+        .respond({
+          status: 200,
+          body: { success: true },
+        });
+      expect(tracker.matchesRequest(parsedRequest)).toBe(false);
+
+      tracker.bypass();
+      expect(tracker.matchesRequest(parsedRequest)).toBe(false);
+
+      tracker.respond({
+        status: 200,
+        body: { success: true },
+      });
+      expect(tracker.matchesRequest(parsedRequest)).toBe(false);
+    });
   });
 }

packages/zimic/src/interceptor/http/requestTracker/types/public.ts

@@ -101,14 +101,27 @@ export interface HttpRequestTracker<
   ) => HttpRequestTracker<Schema, Method, Path, StatusCode>;
 
   /**
-   * Clears any restrictions and declared responses and makes the tracker stop matching intercepted requests. The next
-   * tracker, created before this one, that matches the same method and path will be used if present. If not, the
-   * requests of the method and path will not be intercepted.
+   * Clears any declared responses, making the tracker stop matching intercepted requests. The next tracker, created
+   * before this one, that matches the same method and path will be used if present. If not, the requests of the method
+   * and path will not be intercepted.
+   *
+   * To make the tracker match requests again, register a new response with `tracker.respond()`.
    *
    * @see {@link https://github.com/diego-aquino/zimic#trackerbypass}
    */
   bypass: () => HttpRequestTracker<Schema, Method, Path, StatusCode>;
 
+  /**
+   * Clears any declared responses, restrictions, and intercepted requests, making the tracker stop matching intercepted
+   * requests. The next tracker, created before this one, that matches the same method and path will be used if present.
+   * If not, the requests of the method and path will not be intercepted.
+   *
+   * To make the tracker match requests again, register a new response with `tracker.respond()`.
+   *
+   * @see {@link https://github.com/diego-aquino/zimic#trackerclear}
+   */
+  clear: () => HttpRequestTracker<Schema, Method, Path, StatusCode>;
+
   /**
    * @returns The intercepted requests that matched this tracker, along with the responses returned to each of them.
    *   This is useful for testing that the correct requests were made by your application.