add tests for multiple rate limit headers

Author: Lms24

packages/replay/test/unit/index.test.ts

@@ -876,93 +876,119 @@ describe('Replay', () => {
   });
 
   describe('rate-limiting behaviour', () => {
-    it('pauses recording and flushing a rate limit is hit and resumes both after the rate limit duration is over', async () => {
-      expect(replay.session?.segmentId).toBe(0);
-      jest.spyOn(replay, 'sendReplay');
-      jest.spyOn(replay, 'pause');
-      jest.spyOn(replay, 'resume');
-      // @ts-ignore private API
-      jest.spyOn(replay, '_handleRateLimit');
-
-      const TEST_EVENT = { data: {}, timestamp: BASE_TIMESTAMP, type: 2 };
-
-      mockTransportSend.mockImplementationOnce(() => {
-        return Promise.resolve({
-          statusCode: 429,
-          headers: {
-            'x-sentry-rate-limits': null,
-            'retry-after': `30`,
-          },
-        } as TransportMakeRequestResponse);
-      });
-
-      mockRecord._emitter(TEST_EVENT);
-
-      // T = base + 5
-      await advanceTimers(DEFAULT_FLUSH_MIN_DELAY);
+    it.each([
+      {
+        statusCode: 429,
+        headers: {
+          'x-sentry-rate-limits': '30',
+          'retry-after': null,
+        },
+      },
+      {
+        statusCode: 429,
+        headers: {
+          'x-sentry-rate-limits': '30:replay_event',
+          'retry-after': null,
+        },
+      },
+      {
+        statusCode: 429,
+        headers: {
+          'x-sentry-rate-limits': '30:replay_recording',
+          'retry-after': null,
+        },
+      },
+      {
+        statusCode: 429,
+        headers: {
+          'x-sentry-rate-limits': null,
+          'retry-after': '30',
+        },
+      },
+    ] as TransportMakeRequestResponse[])(
+      'pauses recording and flushing a rate limit is hit and resumes both after the rate limit duration is over',
+      async ratelimitResponse => {
+        expect(replay.session?.segmentId).toBe(0);
+        jest.spyOn(replay, 'sendReplay');
+        jest.spyOn(replay, 'pause');
+        jest.spyOn(replay, 'resume');
+        // @ts-ignore private API
+        jest.spyOn(replay, '_handleRateLimit');
 
-      expect(mockRecord.takeFullSnapshot).not.toHaveBeenCalled();
-      expect(mockTransportSend).toHaveBeenCalledTimes(1);
-      expect(replay).toHaveLastSentReplay({ events: JSON.stringify([TEST_EVENT]) });
+        const TEST_EVENT = { data: {}, timestamp: BASE_TIMESTAMP, type: 2 };
 
-      expect(replay['_handleRateLimit']).toHaveBeenCalledTimes(1);
-      // resume() was called once before we even started
-      expect(replay.resume).not.toHaveBeenCalled();
-      expect(replay.pause).toHaveBeenCalledTimes(1);
+        mockTransportSend.mockImplementationOnce(() => {
+          return Promise.resolve(ratelimitResponse);
+        });
 
-      // No user activity to trigger an update
-      expect(replay.session?.lastActivity).toBe(BASE_TIMESTAMP);
-      expect(replay.session?.segmentId).toBe(1);
+        mockRecord._emitter(TEST_EVENT);
 
-      // let's simulate the rate-limit time of inactivity (30secs) and check that we don't do anything in the meantime
-      const TEST_EVENT2 = { data: {}, timestamp: BASE_TIMESTAMP + DEFAULT_FLUSH_MIN_DELAY, type: 3 };
-      for (let i = 0; i < 5; i++) {
-        const ev = {
-          ...TEST_EVENT2,
-          timestamp: BASE_TIMESTAMP + DEFAULT_FLUSH_MIN_DELAY * (i + 1),
-        };
-        mockRecord._emitter(ev);
+        // T = base + 5
         await advanceTimers(DEFAULT_FLUSH_MIN_DELAY);
-        expect(replay.isPaused()).toBe(true);
-        expect(replay.sendReplay).toHaveBeenCalledTimes(1);
+
+        expect(mockRecord.takeFullSnapshot).not.toHaveBeenCalled();
         expect(mockTransportSend).toHaveBeenCalledTimes(1);
-      }
+        expect(replay).toHaveLastSentReplay({ events: JSON.stringify([TEST_EVENT]) });
+
+        expect(replay['_handleRateLimit']).toHaveBeenCalledTimes(1);
+        // resume() was called once before we even started
+        expect(replay.resume).not.toHaveBeenCalled();
+        expect(replay.pause).toHaveBeenCalledTimes(1);
+
+        // No user activity to trigger an update
+        expect(replay.session?.lastActivity).toBe(BASE_TIMESTAMP);
+        expect(replay.session?.segmentId).toBe(1);
+
+        // let's simulate the rate-limit time of inactivity (30secs) and check that we don't do anything in the meantime
+        const TEST_EVENT2 = { data: {}, timestamp: BASE_TIMESTAMP + DEFAULT_FLUSH_MIN_DELAY, type: 3 };
+        for (let i = 0; i < 5; i++) {
+          const ev = {
+            ...TEST_EVENT2,
+            timestamp: BASE_TIMESTAMP + DEFAULT_FLUSH_MIN_DELAY * (i + 1),
+          };
+          mockRecord._emitter(ev);
+          await advanceTimers(DEFAULT_FLUSH_MIN_DELAY);
+          expect(replay.isPaused()).toBe(true);
+          expect(replay.sendReplay).toHaveBeenCalledTimes(1);
+          expect(mockTransportSend).toHaveBeenCalledTimes(1);
+        }
+
+        // T = base + 35
+        await advanceTimers(DEFAULT_FLUSH_MIN_DELAY);
 
-      // T = base + 35
-      await advanceTimers(DEFAULT_FLUSH_MIN_DELAY);
+        // now, recording should resume and first, we expect a checkout event to be sent, as resume()
+        // should trigger a full snapshot
+        expect(replay.resume).toHaveBeenCalledTimes(1);
+        expect(replay.isPaused()).toBe(false);
+
+        expect(replay.sendReplay).toHaveBeenCalledTimes(2);
+        expect(replay).toHaveLastSentReplay({
+          events: '[{"data":{"isCheckout":true},"timestamp":1580598035000,"type":2}]',
+        });
+
+        // and let's also emit a new event and check that it is recorded
+        const TEST_EVENT3 = {
+          data: {},
+          timestamp: BASE_TIMESTAMP + 7 * DEFAULT_FLUSH_MIN_DELAY,
+          type: 3,
+        };
+        mockRecord._emitter(TEST_EVENT3);
 
-      // now, recording should resume and first, we expect a checkout event to be sent, as resume()
-      // should trigger a full snapshot
-      expect(replay.resume).toHaveBeenCalledTimes(1);
-      expect(replay.isPaused()).toBe(false);
+        // T = base + 40
+        await advanceTimers(DEFAULT_FLUSH_MIN_DELAY);
+        expect(replay.sendReplay).toHaveBeenCalledTimes(3);
+        expect(replay).toHaveLastSentReplay({ events: JSON.stringify([TEST_EVENT3]) });
 
-      expect(replay.sendReplay).toHaveBeenCalledTimes(2);
-      expect(replay).toHaveLastSentReplay({
-        events: '[{"data":{"isCheckout":true},"timestamp":1580598035000,"type":2}]',
-      });
+        // nothing should happen afterwards
+        // T = base + 60
+        await advanceTimers(20_000);
+        expect(replay.sendReplay).toHaveBeenCalledTimes(3);
+        expect(replay).toHaveLastSentReplay({ events: JSON.stringify([TEST_EVENT3]) });
 
-      // and let's also emit a new event and check that it is recorded
-      const TEST_EVENT3 = {
-        data: {},
-        timestamp: BASE_TIMESTAMP + 7 * DEFAULT_FLUSH_MIN_DELAY,
-        type: 3,
-      };
-      mockRecord._emitter(TEST_EVENT3);
-
-      // T = base + 40
-      await advanceTimers(DEFAULT_FLUSH_MIN_DELAY);
-      expect(replay.sendReplay).toHaveBeenCalledTimes(3);
-      expect(replay).toHaveLastSentReplay({ events: JSON.stringify([TEST_EVENT3]) });
-
-      // nothing should happen afterwards
-      // T = base + 60
-      await advanceTimers(20_000);
-      expect(replay.sendReplay).toHaveBeenCalledTimes(3);
-      expect(replay).toHaveLastSentReplay({ events: JSON.stringify([TEST_EVENT3]) });
-
-      // events array should be empty
-      expect(replay.eventBuffer?.length).toBe(0);
-    });
+        // events array should be empty
+        expect(replay.eventBuffer?.length).toBe(0);
+      },
+    );
   });
 });