refactor: consolidate test files and update middleware rate-limiting logic

Author: JhaSourav07

hooks/SuggestRepoModal.tsx)

@@ -42,4 +42,63 @@ describe('useDebounce', () => {
       vi.useRealTimers();
     }
   });
+
+  it('updates only after the delay', () => {
+    vi.useFakeTimers();
+    try {
+      const { result, rerender } = renderHook(({ value }) => useDebounce(value, 400), {
+        initialProps: { value: 'a' },
+      });
+
+      expect(result.current).toBe('a');
+
+      rerender({ value: 'ab' });
+      rerender({ value: 'abc' });
+
+      act(() => {
+        vi.advanceTimersByTime(399);
+      });
+
+      expect(result.current).toBe('a');
+
+      act(() => {
+        vi.advanceTimersByTime(1);
+      });
+
+      expect(result.current).toBe('abc');
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('resets the timer when value changes repeatedly', () => {
+    vi.useFakeTimers();
+    try {
+      const { result, rerender } = renderHook(({ value }) => useDebounce(value, 400), {
+        initialProps: { value: 'a' },
+      });
+
+      rerender({ value: 'ab' });
+
+      act(() => {
+        vi.advanceTimersByTime(200);
+      });
+
+      rerender({ value: 'abc' });
+
+      act(() => {
+        vi.advanceTimersByTime(200);
+      });
+
+      expect(result.current).toBe('a');
+
+      act(() => {
+        vi.advanceTimersByTime(200);
+      });
+
+      expect(result.current).toBe('abc');
+    } finally {
+      vi.useRealTimers();
+    }
+  });
 });

hooks/useDebounce.test.ts

@@ -1,6 +1,6 @@
 import { beforeEach, afterEach, describe, expect, it, vi } from 'vitest';
 import { NextRequest, NextResponse } from 'next/server';
-import { middleware } from './middleware';
+import { middleware, config } from './middleware';
 import { rateLimit } from '@/lib/rate-limit';
 
 vi.mock('@/lib/rate-limit', () => ({
@@ -67,7 +67,7 @@ describe('middleware', () => {
     });
   });
 
-  it('sets X-RateLimit-Limit header when rate limit succeeds', async () => {
+  it('calls rateLimit with fixed policy values (60 requests / 60000ms)', async () => {
     vi.mocked(rateLimit).mockResolvedValue({
       success: true,
       limit: 60,
@@ -76,12 +76,12 @@ describe('middleware', () => {
     });
 
     const request = new NextRequest('http://localhost:3000/api/streak?user=octocat');
-    const response = await middleware(request);
+    await middleware(request);
 
-    expect(response.headers.get('X-RateLimit-Limit')).toBe('60');
+    expect(rateLimit).toHaveBeenCalledWith(expect.any(String), 60, 60000);
   });
 
-  it('sets X-RateLimit-Remaining header when rate limit succeeds', async () => {
+  it('sets all X-RateLimit headers on successful requests', async () => {
     vi.mocked(rateLimit).mockResolvedValue({
       success: true,
       limit: 60,
@@ -92,7 +92,26 @@ describe('middleware', () => {
     const request = new NextRequest('http://localhost:3000/api/streak?user=octocat');
     const response = await middleware(request);
 
+    expect(response.headers.get('X-RateLimit-Limit')).toBe('60');
     expect(response.headers.get('X-RateLimit-Remaining')).toBe('59');
+    expect(response.headers.get('X-RateLimit-Reset')).toBe('123456789');
+  });
+
+  it('sets JSON and rate headers on throttled responses', async () => {
+    vi.mocked(rateLimit).mockResolvedValue({
+      success: false,
+      limit: 60,
+      remaining: 0,
+      reset: 123456789,
+    });
+
+    const request = new NextRequest('http://localhost:3000/api/streak?user=octocat');
+    const response = await middleware(request);
+
+    expect(response.headers.get('Content-Type')).toBe('application/json');
+    expect(response.headers.get('X-RateLimit-Limit')).toBe('60');
+    expect(response.headers.get('X-RateLimit-Remaining')).toBe('0');
+    expect(response.headers.get('X-RateLimit-Reset')).toBe('123456789');
   });
 
   it('uses first IP from x-forwarded-for when subsequent hops are trusted', async () => {
@@ -209,4 +228,8 @@ describe('middleware', () => {
 
     expect(rateLimit).toHaveBeenCalledWith('1.2.3.4', 60, 60000);
   });
+
+  it('includes compare API matcher in middleware config', () => {
+    expect(config.matcher).toContain('/api/compare/:path*');
+  });
 });

lib/hooks/useDebounce.test.ts

@@ -96,4 +96,31 @@ describe('getClientIp', () => {
     });
     expect(ip).toBe('198.51.100.5');
   });
+
+  it('sanitizes multi-IP lists and traverses untrusted hops from right to left', () => {
+    const req = new Request('http://localhost:3000/api/streak', {
+      headers: {
+        'x-forwarded-for': '203.0.113.195, 198.51.100.10, 192.168.1.1',
+      },
+    });
+    const options = {
+      proxyConfig: {
+        trustedProxies: ['192.168.1.1'],
+        trustPrivateRanges: false,
+      },
+    };
+    expect(getClientIp(req, options)).toBe('198.51.100.10');
+  });
+
+  it('falls back to 127.0.0.1 when headers are missing or malformed', () => {
+    const req = new Request('http://localhost:3000/api/streak');
+    expect(getClientIp(req)).toBe('127.0.0.1');
+
+    const reqMalformed = new Request('http://localhost:3000/api/streak', {
+      headers: {
+        'x-forwarded-for': '   ,   ',
+      },
+    });
+    expect(getClientIp(reqMalformed)).toBe('127.0.0.1');
+  });
 });

lib/hooks/useDebounce.ts

@@ -31,76 +31,3 @@ describe('isTrustedProxy and Helpers', () => {
     expect(isTrustedProxy('8.8.8.8', config)).toBe(false);
   });
 });
-
-describe('getClientIp extraction and fallback', () => {
-  // Test Case 1: extraction of IP from single X-Forwarded-For header
-  it('extracts IP from a single X-Forwarded-For header when proxy is trusted', () => {
-    const req = new Request('http://localhost', {
-      headers: {
-        'x-forwarded-for': '203.0.113.195',
-      },
-    });
-    const options = {
-      proxyConfig: {
-        trustedProxies: ['*'],
-        trustPrivateRanges: false,
-      },
-    };
-    expect(getClientIp(req, options)).toBe('203.0.113.195');
-  });
-
-  // Test Case 2: sanitization of multi-IP lists
-  it('sanitizes multi-IP lists and traverses untrusted hops from right to left', () => {
-    const req = new Request('http://localhost', {
-      headers: {
-        'x-forwarded-for': '203.0.113.195, 198.51.100.10, 192.168.1.1',
-      },
-    });
-    const options = {
-      proxyConfig: {
-        trustedProxies: ['192.168.1.1'],
-        trustPrivateRanges: false,
-      },
-    };
-    expect(getClientIp(req, options)).toBe('198.51.100.10');
-  });
-
-  // Test Case 3: Cloudflare Cf-Connecting-Ip has precedence
-  it('gives precedence to priority headers like cf-connecting-ip', () => {
-    const req = new Request('http://localhost', {
-      headers: {
-        'cf-connecting-ip': '203.0.113.5',
-        'x-real-ip': '198.51.100.20',
-      },
-    });
-    const options = {
-      headersPriority: ['cf-connecting-ip', 'x-real-ip'],
-      proxyConfig: {
-        trustedProxies: [],
-        trustPrivateRanges: false,
-      },
-    };
-    expect(getClientIp(req, options)).toBe('203.0.113.5');
-  });
-
-  // Test Case 4: fallback to connection remoteAddress (request.ip)
-  it('falls back to request.ip representing connection remoteAddress', () => {
-    const req = new NextRequest('http://localhost');
-    Object.defineProperty(req, 'ip', { value: '198.51.100.5', configurable: true });
-
-    expect(getClientIp(req)).toBe('198.51.100.5');
-  });
-
-  // Test Case 5: behavior when headers are missing or malformed
-  it('falls back to 127.0.0.1 when headers are missing or malformed', () => {
-    const req = new Request('http://localhost');
-    expect(getClientIp(req)).toBe('127.0.0.1');
-
-    const reqMalformed = new Request('http://localhost', {
-      headers: {
-        'x-forwarded-for': '   ,   ',
-      },
-    });
-    expect(getClientIp(reqMalformed)).toBe('127.0.0.1');
-  });
-});