fix: resolve rebase conflict in responsive breakpoint tests

Author: udaycodespace

services/github/refresh-rate-limiter.responsive-breakpoints.test.ts

@@ -1,102 +1,75 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { beforeEach, describe, expect, it } from 'vitest';
 import refreshRateLimiter from './refresh-rate-limiter';
 
-function setViewportWidth(width: number) {
-  Object.defineProperty(window, 'innerWidth', {
-    configurable: true,
-    writable: true,
-    value: width,
-  });
-  window.dispatchEvent(new Event('resize'));
-}
-
-function mockMatchMedia(matches: boolean) {
-  Object.defineProperty(window, 'matchMedia', {
-    configurable: true,
-    writable: true,
-    value: vi.fn().mockImplementation((query: string) => ({
-      matches,
-      media: query,
-      onchange: null,
-      addListener: vi.fn(),
-      removeListener: vi.fn(),
-      addEventListener: vi.fn(),
-      removeEventListener: vi.fn(),
-      dispatchEvent: vi.fn(),
-    })),
-  });
-}
-
 describe('RefreshRateLimiter responsive breakpoints', () => {
   beforeEach(() => {
     refreshRateLimiter.reset();
-    setViewportWidth(1280);
-    mockMatchMedia(false);
+    delete process.env.MAX_REFRESHES_PER_HOUR;
+    window.innerWidth = 375;
+    window.dispatchEvent(new Event('resize'));
   });
 
-  it('allows refreshes normally on a mobile-width viewport (375px)', () => {
-    setViewportWidth(375);
-    mockMatchMedia(true);
+  it('maintains default limit behavior under a narrow mobile viewport', () => {
+    expect(window.innerWidth).toBe(375);
 
-    const response = refreshRateLimiter.checkLimit('203.0.113.5');
+    const response1 = refreshRateLimiter.checkLimit('203.0.113.5');
+    expect(response1.success).toBe(true);
+    expect(response1.limit).toBe(3);
+    expect(response1.remaining).toBe(2);
 
-    expect(window.innerWidth).toBe(375);
-    expect(response.success).toBe(true);
-    expect(response.limit).toBe(3);
-    expect(response.remaining).toBe(2);
+    const response2 = refreshRateLimiter.checkLimit('203.0.113.5');
+    expect(response2.success).toBe(true);
+    expect(response2.remaining).toBe(1);
   });
 
-  it('maintains the same rate-limit behavior when switching from desktop to mobile widths', () => {
-    setViewportWidth(1280);
-    const desktopResponse = refreshRateLimiter.checkLimit('198.51.100.10');
+  it('reflows client tracking correctly when the same IP is reused on mobile breakpoints', () => {
+    window.innerWidth = 375;
+    window.dispatchEvent(new Event('resize'));
 
-    setViewportWidth(375);
-    mockMatchMedia(true);
-    const mobileResponse = refreshRateLimiter.checkLimit('198.51.100.10');
+    const first = refreshRateLimiter.checkLimit(' 203.0.113.5 ');
+    expect(first.success).toBe(true);
+    expect(first.remaining).toBe(2);
 
-    expect(window.innerWidth).toBe(375);
-    expect(desktopResponse.success).toBe(true);
-    expect(mobileResponse.success).toBe(true);
-    expect(mobileResponse.remaining).toBe(desktopResponse.remaining - 1);
+    const second = refreshRateLimiter.checkLimit('203.0.113.5');
+    expect(second.success).toBe(true);
+    expect(second.remaining).toBe(1);
+    expect(second.limit).toBe(first.limit);
   });
 
-  it('reports cleanly when a mobile breakpoint is active and the same IP checks again', () => {
-    setViewportWidth(375);
-    mockMatchMedia(true);
+  it('adapts to environment-driven limits while preserving mobile-friendly fallback state', () => {
+    process.env.MAX_REFRESHES_PER_HOUR = '2';
+    refreshRateLimiter.reset();
 
-    const first = refreshRateLimiter.checkLimit('127.0.0.1');
-    const second = refreshRateLimiter.checkLimit('127.0.0.1');
+    expect(window.innerWidth).toBe(375);
 
+    const first = refreshRateLimiter.checkLimit('198.51.100.1');
     expect(first.success).toBe(true);
+    expect(first.limit).toBe(2);
+    expect(first.remaining).toBe(1);
+
+    const second = refreshRateLimiter.checkLimit('198.51.100.1');
     expect(second.success).toBe(true);
-    expect(second.remaining).toBe(1);
-    expect(first.limit).toBe(3);
+    expect(second.remaining).toBe(0);
   });
 
-  it('enforces a custom mobile friendly limit without breaking on narrow viewports', () => {
-    setViewportWidth(375);
-    mockMatchMedia(true);
-    refreshRateLimiter.setLimit(1, 60 * 60 * 1000);
+  it('returns a reset timestamp without relying on absolute screen dimensions', () => {
+    const response = refreshRateLimiter.checkLimit('198.51.100.2');
+    expect(response.reset).toBeGreaterThan(Date.now());
+    expect(typeof response.reset).toBe('number');
+    expect(response.limit).toBe(3);
+  });
 
-    const allowed = refreshRateLimiter.checkLimit('203.0.113.15');
-    const blocked = refreshRateLimiter.checkLimit('203.0.113.15');
+  it('enforces the limit and reports blocked refreshes cleanly on simulated mobile width', () => {
+    refreshRateLimiter.setLimit(1, 1000 * 60 * 60);
+    expect(window.innerWidth).toBe(375);
 
+    const allowed = refreshRateLimiter.checkLimit('203.0.113.10');
     expect(allowed.success).toBe(true);
     expect(allowed.remaining).toBe(0);
+
+    const blocked = refreshRateLimiter.checkLimit('203.0.113.10');
     expect(blocked.success).toBe(false);
     expect(blocked.remaining).toBe(0);
     expect(blocked.limit).toBe(1);
   });
-
-  it('keeps responsive viewport simulation clean and does not depend on absolute width assumptions', () => {
-    setViewportWidth(375);
-    mockMatchMedia(true);
-
-    const response = refreshRateLimiter.checkLimit('192.0.2.1');
-
-    expect(window.innerWidth).toBeLessThanOrEqual(375);
-    expect(response.success).toBe(true);
-    expect(response.reset).toBeGreaterThan(Date.now() - 1000);
-    expect(response.limit).toBe(3);
-  });
 });