test: add unit tests for background-refresh service (JhaSourav07#3548)

## Description

This PR introduces unit tests for the BackgroundRefresh service class.
It covers singleton structure, cache staleness checks, username
sanitization, concurrent job lock prevention, and failure state
resolution. It also fixes a bug in isStale where invalid date strings
caused the cache to never refresh.

Fixes JhaSourav07#3345

## 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 (Utility/Unit Tests only)

## Checklist before requesting a review:

- [x] I have read the `CONTRIBUTING.md` file.
- [x] I have tested these changes locally.
- [x] I have run `npm run format` and `npm run lint` locally and
resolved all errors.
- [x] My commits follow the Conventional Commits format.
- [x] I have updated `README.md` if I added a new theme or URL
parameter.
- [x] I have started the repo.
- [x] I have made sure that i have only one commit to merge in this PR.
- [ ] The SVG output matches the CommitPulse "premium quality" aesthetic
standard.
- [ ] (Recommended) I joined the CommitPulse Discord community.

Author: JhaSourav07

services/github/background-refresh.test.ts

@@ -0,0 +1,93 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { BackgroundRefresh } from './background-refresh';
+import { getFullDashboardData } from '../../lib/github';
+
+vi.mock('../../lib/github', () => ({
+  getFullDashboardData: vi.fn(),
+}));
+
+describe('BackgroundRefresh Unit Tests', () => {
+  let service: BackgroundRefresh;
+
+  beforeEach(() => {
+    service = BackgroundRefresh.getInstance();
+    service.reset();
+    vi.clearAllMocks();
+  });
+
+  it('behaves as a singleton and returns the same instance', () => {
+    const anotherInstance = BackgroundRefresh.getInstance();
+    expect(service).toBe(anotherInstance);
+  });
+
+  describe('isStale', () => {
+    it('returns true when lastSyncedAt is undefined', () => {
+      expect(service.isStale(undefined)).toBe(true);
+    });
+
+    it('returns true when lastSyncedAt is an invalid date string', () => {
+      expect(service.isStale('invalid-date')).toBe(true);
+    });
+
+    it('returns true when lastSyncedAt is older than 10 minutes', () => {
+      const elevenMinutesAgo = new Date(Date.now() - 11 * 60 * 1000).toISOString();
+      expect(service.isStale(elevenMinutesAgo)).toBe(true);
+    });
+
+    it('returns false when lastSyncedAt is within 10 minutes', () => {
+      const nineMinutesAgo = new Date(Date.now() - 9 * 60 * 1000).toISOString();
+      expect(service.isStale(nineMinutesAgo)).toBe(false);
+    });
+  });
+
+  describe('triggerRefresh', () => {
+    it('sanitizes username (trims and converts to lowercase) and sets job active', async () => {
+      vi.mocked(getFullDashboardData).mockResolvedValue({} as never);
+
+      service.triggerRefresh('  TestUser  ');
+
+      expect(service.isJobActive('testuser')).toBe(true);
+      expect(getFullDashboardData).toHaveBeenCalledWith('  TestUser  ', { bypassCache: true });
+
+      // Allow promise microtask to resolve
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      expect(service.isJobActive('testuser')).toBe(false);
+    });
+
+    it('prevents concurrent duplicate jobs for the same user', () => {
+      vi.mocked(getFullDashboardData).mockReturnValue(new Promise(() => {})); // Never resolves
+
+      service.triggerRefresh('user1');
+      service.triggerRefresh('user1');
+
+      expect(service.isJobActive('user1')).toBe(true);
+      expect(getFullDashboardData).toHaveBeenCalledTimes(1);
+    });
+
+    it('removes the user from active jobs on failure', async () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      vi.mocked(getFullDashboardData).mockRejectedValue(new Error('Network error'));
+
+      service.triggerRefresh('user-fail');
+      expect(service.isJobActive('user-fail')).toBe(true);
+
+      // Allow promise microtask to reject and run finally block
+      await new Promise((resolve) => setTimeout(resolve, 0));
+
+      expect(service.isJobActive('user-fail')).toBe(false);
+      expect(consoleErrorSpy).toHaveBeenCalled();
+      consoleErrorSpy.mockRestore();
+    });
+  });
+
+  describe('reset', () => {
+    it('clears all currently active jobs', () => {
+      vi.mocked(getFullDashboardData).mockReturnValue(new Promise(() => {})); // Never resolves
+      service.triggerRefresh('active-user');
+      expect(service.isJobActive('active-user')).toBe(true);
+
+      service.reset();
+      expect(service.isJobActive('active-user')).toBe(false);
+    });
+  });
+});

services/github/background-refresh.ts

@@ -25,6 +25,7 @@ export class BackgroundRefresh {
 
     try {
       const lastSyncTime = new Date(lastSyncedAt).getTime();
+      if (isNaN(lastSyncTime)) return true;
       return Date.now() - lastSyncTime > STALE_THRESHOLD_MS;
     } catch {
       return true;

services/github/background-refresh.type-compiler.test.ts

@@ -41,6 +41,6 @@ describe('BackgroundRefresh type compiler validation', () => {
 
     expect(backgroundRefresh.isStale(staleDate)).toBe(true);
     expect(backgroundRefresh.isStale(freshDate)).toBe(false);
-    expect(backgroundRefresh.isStale('invalid-date')).toBe(false);
+    expect(backgroundRefresh.isStale('invalid-date')).toBe(true);
   });
 });