Test/notification error resilience (JhaSourav07#3118)

## Description

Fixes JhaSourav07#2898 

Added isolated unit/integration tests for `models/Notification.ts`
focused on hydration stability, exception safety, and error recovery
behavior.

### Changes made:
* Added `models/Notification.error-resilience.test.ts`
* Tested hydration stability by reusing existing Notification model
instances
* Tested exception safety when `mongoose.model()` throws unexpected
runtime/database errors
* Verified safe default values for recovery stability
* Ensured invalid `frequency` values fail validation safely without
crashing
* Verified required validation failures remain localized and recover
gracefully

## 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 change)

## Checklist before requesting a review:
* [x] I have read the `CONTRIBUTING.md` file.
* [x] I have tested these changes locally (`vitest run` passes).
* [ ] 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 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 (not applicable for test-only changes).
* [ ] (Recommended) I joined the CommitPulse Discord community for
contributor discussions, mentorship, and faster PR support.

Author: JhaSourav07

lib/svg/constants.mock-integrations.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest';
+import {
+  SVG_WIDTH,
+  SVG_HEIGHT,
+  GHOST_HEIGHT_PX,
+  LOG_SCALE_MULTIPLIER,
+  LINEAR_SCALE_MULTIPLIER,
+  MAX_LOG_HEIGHT,
+  MAX_LINEAR_HEIGHT,
+  FONT_MAP,
+  CONTRIBUTION_MILESTONES,
+  STREAK_MILESTONES,
+} from './constants';
+
+describe('lib/svg/constants', () => {
+  it('should expose expected SVG dimensions', () => {
+    expect(SVG_WIDTH).toBe(600);
+    expect(SVG_HEIGHT).toBe(420);
+  });
+
+  it('should expose expected rendering scale constants', () => {
+    expect(GHOST_HEIGHT_PX).toBe(4);
+    expect(LOG_SCALE_MULTIPLIER).toBe(12);
+    expect(LINEAR_SCALE_MULTIPLIER).toBe(5);
+    expect(MAX_LOG_HEIGHT).toBe(80);
+    expect(MAX_LINEAR_HEIGHT).toBe(50);
+  });
+
+  it('should expose correct font mappings', () => {
+    expect(FONT_MAP).toEqual({
+      jetbrains: '"JetBrains Mono", monospace',
+      fira: '"Fira Code", monospace',
+      roboto: '"Roboto", sans-serif',
+    });
+  });
+
+  it('should expose expected contribution milestones', () => {
+    expect(CONTRIBUTION_MILESTONES).toEqual([1, 10, 100, 250, 500, 1000]);
+  });
+
+  it('should expose expected streak milestones', () => {
+    expect(STREAK_MILESTONES).toEqual([3, 7, 30, 100]);
+  });
+});

models/Notification.error-resilience.test.ts

@@ -0,0 +1,101 @@
+import mongoose from 'mongoose';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+describe('Notification error resilience', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.restoreAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should safely reuse existing Notification model during hydration', async () => {
+    vi.resetModules();
+
+    const existingModel = { mocked: true };
+
+    mongoose.models.Notification = existingModel as never;
+
+    const { Notification } = await import('./Notification');
+
+    expect(Notification).toBe(existingModel);
+  });
+
+  it('should recover cleanly when mongoose.model throws unexpectedly', async () => {
+    vi.resetModules();
+
+    // Force recreation instead of reusing cached model
+    delete mongoose.models.Notification;
+
+    vi.spyOn(mongoose, 'model').mockImplementation(() => {
+      throw new Error('Database connectivity error');
+    });
+
+    let caughtError: Error | null = null;
+
+    try {
+      await import('./Notification');
+    } catch (error) {
+      caughtError = error as Error;
+    }
+
+    expect(caughtError).toBeTruthy();
+    expect(caughtError?.message).toContain('Database connectivity error');
+  });
+
+  it('should expose safe default values for recovery stability', async () => {
+    vi.resetModules();
+
+    delete mongoose.models.Notification;
+
+    const { Notification } = await import('./Notification');
+
+    const doc = new Notification({
+      username: 'pari',
+      email: 'pari@example.com',
+    });
+
+    expect(doc.frequency).toBe('daily');
+    expect(doc.notifyOnCommit).toBe(true);
+    expect(doc.notifyOnStreak).toBe(true);
+    expect(doc.notifyOnMilestone).toBe(true);
+    expect(doc.isActive).toBe(true);
+  });
+
+  it('should prevent invalid frequency values from crashing validation', async () => {
+    vi.resetModules();
+
+    delete mongoose.models.Notification;
+
+    const { Notification } = await import('./Notification');
+
+    const doc = new Notification({
+      username: 'pari',
+      email: 'pari@example.com',
+      frequency: 'invalid-value',
+    });
+
+    const validationError = doc.validateSync();
+
+    expect(validationError).toBeTruthy();
+    expect(validationError?.errors.frequency).toBeDefined();
+  });
+
+  it('should keep required validation failures localized', async () => {
+    vi.resetModules();
+
+    delete mongoose.models.Notification;
+
+    const { Notification } = await import('./Notification');
+
+    const doc = new Notification({});
+
+    const validationError = doc.validateSync();
+
+    expect(validationError).toBeTruthy();
+    expect(validationError?.errors.username).toBeDefined();
+    expect(validationError?.errors.email).toBeDefined();
+  });
+});