test(refresh-rate-limiter): add error resilience coverage (JhaSourav07#3046)

## Description

Fixes JhaSourav07#2948 

Added isolated unit tests for `services/github/refresh-rate-limiter.ts`
focusing on error resilience, recovery behavior, and stability under
unexpected configurations.

### Changes
- Added `services/github/refresh-rate-limiter.error-resilience.test.ts`
- Verified fallback behavior when `MAX_REFRESHES_PER_HOUR` contains
invalid values
- Tested recovery to default limits when environment configuration is
malformed or zero
- Ensured malformed or whitespace-only client identifiers are handled
safely without crashes
- Verified limiter state can be reset and reused successfully after
exhaustion
- Confirmed stable behavior when requests continue after rate limits
have been exceeded
- Improved coverage around exception safety and fallback execution paths

## Pillar

- [ ] 🎨 Pillar 1 — New Theme Design
- [ ] 📐 Pillar 2 — Geometric SVG Improvement
- [ ] 🕐 Pillar 3 — Timezone Logic Optimization
- [x] 🛠️ Other (Bug fix, refactoring, docs)

## Visual Preview

N/A (test-only changes)

## Checklist before requesting a review:

- [x] I have read the `CONTRIBUTING.md` file.
- [x] I have tested these changes locally
(`localhost:3000/api/streak?user=YOUR_USERNAME`).
- [x] I have run `npm run format` and `npm run lint` locally and
resolved all errors (CI will fail otherwise).
- [x] My commits follow the Conventional Commits format (e.g.,
`feat(themes): ...`, `fix(calculate): ...`).
- [ ] I have updated `README.md` if I added a new theme or URL
parameter.
- [x] I have starred the repo.
- [x] I have made sure that I have only one commit to merge in this PR.
- [x] The SVG output matches the CommitPulse "premium quality" aesthetic
standard (no SVG changes made).
- [ ] (Recommended) I joined the CommitPulse Discord community for
contributor discussions, mentorship, and faster PR support.

Author: JhaSourav07

services/github/refresh-rate-limiter.error-resilience.test.ts

@@ -0,0 +1,81 @@
+// services/github/refresh-rate-limiter.error-resilience.test.ts
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { refreshRateLimiter } from './refresh-rate-limiter';
+
+describe('RefreshRateLimiter Error Resilience', () => {
+  const originalEnv = process.env.MAX_REFRESHES_PER_HOUR;
+
+  beforeEach(() => {
+    refreshRateLimiter.reset();
+    delete process.env.MAX_REFRESHES_PER_HOUR;
+  });
+
+  afterEach(() => {
+    refreshRateLimiter.reset();
+
+    if (originalEnv) {
+      process.env.MAX_REFRESHES_PER_HOUR = originalEnv;
+    } else {
+      delete process.env.MAX_REFRESHES_PER_HOUR;
+    }
+  });
+
+  it('falls back to default limit when environment value is invalid', () => {
+    process.env.MAX_REFRESHES_PER_HOUR = 'invalid';
+
+    const result = refreshRateLimiter.checkLimit('127.0.0.1');
+
+    expect(result.success).toBe(true);
+    expect(result.limit).toBe(3);
+    expect(result.remaining).toBe(2);
+  });
+
+  it('falls back to default limit when environment value is zero', () => {
+    process.env.MAX_REFRESHES_PER_HOUR = '0';
+
+    const result = refreshRateLimiter.checkLimit('127.0.0.1');
+
+    expect(result.success).toBe(true);
+    expect(result.limit).toBe(3);
+  });
+
+  it('handles malformed or whitespace-only client identifiers safely', () => {
+    const result = refreshRateLimiter.checkLimit('   ');
+
+    expect(result.success).toBe(true);
+    expect(result.limit).toBe(3);
+    expect(result.remaining).toBe(2);
+  });
+
+  it('recovers correctly after reset is called', () => {
+    refreshRateLimiter.setLimit(1);
+
+    expect(refreshRateLimiter.checkLimit('192.168.1.1').success).toBe(true);
+
+    expect(refreshRateLimiter.checkLimit('192.168.1.1').success).toBe(false);
+
+    refreshRateLimiter.reset();
+
+    const result = refreshRateLimiter.checkLimit('192.168.1.1');
+
+    expect(result.success).toBe(true);
+    expect(result.limit).toBe(3);
+    expect(result.remaining).toBe(2);
+  });
+
+  it('maintains stable behavior across repeated checks after limit exhaustion', () => {
+    refreshRateLimiter.setLimit(1);
+
+    expect(refreshRateLimiter.checkLimit('10.0.0.1').success).toBe(true);
+
+    const blocked1 = refreshRateLimiter.checkLimit('10.0.0.1');
+    const blocked2 = refreshRateLimiter.checkLimit('10.0.0.1');
+
+    expect(blocked1.success).toBe(false);
+    expect(blocked2.success).toBe(false);
+
+    expect(blocked1.remaining).toBe(0);
+    expect(blocked2.remaining).toBe(0);
+  });
+});