test(background-refresh-mock-integrations): add mock integration test suite (JhaSourav07#2921) (JhaSourav07#3069)

## Description

Adds the comprehensive background-refresh.mock-integrations.test.ts test
suite to verify asynchronous service layer mocking, local cache stubs,
and fallback paths under the background refresh service.

Fixes JhaSourav07#2921

## 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.mock-integrations.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 Mock Integrations', () => {
+  let service: BackgroundRefresh;
+
+  beforeEach(() => {
+    service = BackgroundRefresh.getInstance();
+    service.reset();
+    vi.clearAllMocks();
+  });
+
+  it('mocks standard asynchronous imports using stubs for background refresh', async () => {
+    vi.mocked(getFullDashboardData).mockResolvedValue(
+      {} as unknown as Awaited<ReturnType<typeof getFullDashboardData>>
+    );
+
+    service.triggerRefresh('john_doe');
+
+    expect(service.isJobActive('john_doe')).toBe(true);
+    expect(getFullDashboardData).toHaveBeenCalledWith('john_doe', { bypassCache: true });
+  });
+
+  it('tests service loading paths to ensure pending state overlays render', async () => {
+    let resolvePromise!: (val: unknown) => void;
+    const promise = new Promise((resolve) => {
+      resolvePromise = resolve;
+    });
+    vi.mocked(getFullDashboardData).mockReturnValue(
+      promise as unknown as ReturnType<typeof getFullDashboardData>
+    );
+
+    service.triggerRefresh('pending_user');
+    expect(service.isJobActive('pending_user')).toBe(true);
+
+    resolvePromise({});
+    await promise;
+
+    // Small microtask tick to let the finally block run
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(service.isJobActive('pending_user')).toBe(false);
+  });
+
+  it('asserts local cache layers are queried before triggering database retrievals', () => {
+    // Check if cache is stale or not. If not stale, we should not trigger database retrievals.
+    const lastSyncedTenSecsAgo = new Date(Date.now() - 10000).toISOString();
+    const isStale = service.isStale(lastSyncedTenSecsAgo);
+
+    expect(isStale).toBe(false);
+
+    if (isStale) {
+      service.triggerRefresh('cached_user');
+    }
+
+    expect(getFullDashboardData).not.toHaveBeenCalled();
+  });
+
+  it('verifies correct fallback procedures during fake endpoint timeout blocks', async () => {
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    vi.mocked(getFullDashboardData).mockRejectedValue(new Error('timeout'));
+
+    service.triggerRefresh('timeout_user');
+    expect(service.isJobActive('timeout_user')).toBe(true);
+
+    // Wait for promise rejection to propagate
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(service.isJobActive('timeout_user')).toBe(false);
+    expect(consoleErrorSpy).toHaveBeenCalled();
+    consoleErrorSpy.mockRestore();
+  });
+
+  it('asserts complete cache sync is written on success callbacks', async () => {
+    const consoleInfoSpy = vi.spyOn(console, 'info').mockImplementation(() => {});
+    vi.mocked(getFullDashboardData).mockResolvedValue({ success: true } as unknown as Awaited<
+      ReturnType<typeof getFullDashboardData>
+    >);
+
+    service.triggerRefresh('sync_user');
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(consoleInfoSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Successfully completed background refresh for: sync_user')
+    );
+    consoleInfoSpy.mockRestore();
+  });
+});