Merge branch 'main' into docs/cache-getorset-comments

Author: khyatiisingh25

README.md

@@ -586,3 +586,5 @@ Thanks to all contributors who have helped make CommitPulse better!
 </a>
 
 <sub>View the [full contributor list →](https://github.com/JhaSourav07/commitpulse/graphs/contributors)</sub>
+
+test commit for PR creation

components/WallOfLove.empty-fallback.test.tsx

@@ -0,0 +1,59 @@
+import { render, screen } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+vi.mock('gsap', () => ({
+  default: {
+    registerPlugin: vi.fn(),
+    context: vi.fn((cb) => {
+      cb();
+      return {
+        revert: vi.fn(),
+      };
+    }),
+    timeline: vi.fn(() => ({
+      fromTo: vi.fn(),
+      to: vi.fn(),
+      kill: vi.fn(),
+    })),
+    set: vi.fn(),
+    to: vi.fn(),
+  },
+}));
+vi.mock('gsap/ScrollTrigger', () => ({
+  ScrollTrigger: {},
+}));
+import { WallOfLove } from './WallOfLove';
+import '@testing-library/jest-dom/vitest';
+
+describe('WallOfLove', () => {
+  it('renders the Wall of Love heading', () => {
+    render(<WallOfLove />);
+
+    expect(screen.getByText(/Wall of/i)).toBeInTheDocument();
+  });
+  it('renders the developer feedback text', () => {
+    render(<WallOfLove />);
+
+    expect(
+      screen.getByText(/See what developers are saying about CommitPulse/i)
+    ).toBeInTheDocument();
+  });
+  it('renders the statistics section', () => {
+    render(<WallOfLove />);
+
+    expect(screen.getByText('Happy Developers')).toBeInTheDocument();
+    expect(screen.getByText('Badges Generated')).toBeInTheDocument();
+    expect(screen.getByText('Average Rating')).toBeInTheDocument();
+  });
+
+  it('renders testimonial content', () => {
+    render(<WallOfLove />);
+
+    expect(screen.getAllByText(/Alex Chen/i).length).toBeGreaterThan(0);
+  });
+
+  it('renders the developer community badge', () => {
+    render(<WallOfLove />);
+
+    expect(screen.getByText(/Loved by developers worldwide/i)).toBeInTheDocument();
+  });
+});

components/dashboard/RadarChart.test.tsx

@@ -78,6 +78,45 @@ describe('RadarChart', () => {
     expect(screen.getAllByText('Python')).toBeDefined();
   });
 
+  it('renders chart elements and layout structure visible across viewport sizes', () => {
+    const mockLangsA = [
+      { name: 'TypeScript', percentage: 80, color: '#3178c6' },
+      { name: 'Python', percentage: 60, color: '#3572A5' },
+      { name: 'JavaScript', percentage: 40, color: '#f1e05a' },
+    ];
+
+    const mockLangsB = [
+      { name: 'TypeScript', percentage: 50, color: '#3178c6' },
+      { name: 'Python', percentage: 70, color: '#3572A5' },
+      { name: 'JavaScript', percentage: 30, color: '#f1e05a' },
+    ];
+
+    const { container } = render(
+      <RadarChart languagesA={mockLangsA} languagesB={mockLangsB} labelA="User A" labelB="User B" />
+    );
+
+    // Check that SVG element is rendered
+    const svg = container.querySelector('svg');
+    expect(svg).toBeDefined();
+
+    // Check that grid polygons are rendered (concentric levels)
+    const polygons = container.querySelectorAll('polygon');
+    expect(polygons.length).toBeGreaterThan(0);
+
+    // Check that axis lines are rendered
+    const lines = container.querySelectorAll('line');
+    expect(lines.length).toBeGreaterThan(0);
+
+    // Check that axis labels are rendered
+    expect(screen.getAllByText('TypeScript')).toBeDefined();
+    expect(screen.getAllByText('Python')).toBeDefined();
+    expect(screen.getAllByText('JavaScript')).toBeDefined();
+
+    // Check that data points (circles) are rendered
+    const circles = container.querySelectorAll('circle');
+    expect(circles.length).toBeGreaterThan(0);
+  });
+
   it('deduplicates shared languages so TypeScript appears as a single axis label', () => {
     const langsA = [{ name: 'TypeScript', percentage: 70, color: '#3178c6' }];
     const langsB = [{ name: 'TypeScript', percentage: 50, color: '#3178c6' }];
@@ -110,7 +149,6 @@ describe('RadarChart', () => {
         labelB="Low Scorer"
       />
     );
-
     expect(screen.getAllByText('TypeScript')).toBeDefined();
     expect(screen.getAllByText('Python')).toBeDefined();
     expect(screen.getAllByText('JavaScript')).toBeDefined();
@@ -121,8 +159,52 @@ describe('RadarChart', () => {
     const svg = container.querySelector('svg');
     expect(svg).not.toBeNull();
 
+    // Check that data points (circles) are rendered
+    const circles = container.querySelectorAll('circle');
+    expect(circles.length).toBeGreaterThan(0);
+  });
+
+  it('dynamically scales axis points based on dataset max score', () => {
+    // Mock dataset with specific maximum score
+    const mockLangsA = [
+      { name: 'TypeScript', percentage: 100, color: '#3178c6' }, // Max score
+      { name: 'Python', percentage: 75, color: '#3572A5' },
+      { name: 'JavaScript', percentage: 50, color: '#f1e05a' },
+    ];
+
+    const mockLangsB = [
+      { name: 'TypeScript', percentage: 90, color: '#3178c6' },
+      { name: 'Python', percentage: 60, color: '#3572A5' },
+      { name: 'JavaScript', percentage: 30, color: '#f1e05a' },
+    ];
+
+    const { container } = render(
+      <RadarChart languagesA={mockLangsA} languagesB={mockLangsB} labelA="User A" labelB="User B" />
+    );
+
+    // Verify that polygons are rendered with points attribute
+    const polygons = container.querySelectorAll('polygon');
+    expect(polygons.length).toBeGreaterThan(0);
+
+    // Check that the data polygons have points attribute (indicating scaling)
+    const dataPolygons = Array.from(polygons).filter((p) =>
+      p.getAttribute('points')?.includes(',')
+    );
+    expect(dataPolygons.length).toBeGreaterThan(0);
+
+    // Verify that circles (data points) are rendered at different positions
     const circles = container.querySelectorAll('circle');
     expect(circles.length).toBeGreaterThan(0);
+
+    // Get all circle positions to verify they're scaled differently
+    const circlePositions = Array.from(circles).map((circle) => ({
+      cx: circle.getAttribute('cx'),
+      cy: circle.getAttribute('cy'),
+    }));
+
+    // Verify that not all circles are at the same position (indicating dynamic scaling)
+    const uniquePositions = new Set(circlePositions.map((pos) => `${pos.cx},${pos.cy}`));
+    expect(uniquePositions.size).toBeGreaterThan(1);
   });
 
   it('check generation of different polygon coordinates for different score magnitudes', () => {

lib/svg/constants.accessibility.test.ts

@@ -0,0 +1,50 @@
+// lib/svg/constants.accessibility.test.ts
+
+import { describe, expect, it } from 'vitest';
+import {
+  SVG_WIDTH,
+  SVG_HEIGHT,
+  FONT_MAP,
+  CONTRIBUTION_MILESTONES,
+  STREAK_MILESTONES,
+} from './constants';
+
+describe('SVG Constants Accessibility', () => {
+  it('provides valid SVG dimensions for accessible rendering', () => {
+    expect(SVG_WIDTH).toBeGreaterThan(0);
+    expect(SVG_HEIGHT).toBeGreaterThan(0);
+  });
+
+  it('exposes readable font mappings for SVG text content', () => {
+    expect(FONT_MAP).toHaveProperty('jetbrains');
+    expect(FONT_MAP).toHaveProperty('fira');
+    expect(FONT_MAP).toHaveProperty('roboto');
+
+    Object.values(FONT_MAP).forEach((font) => {
+      expect(typeof font).toBe('string');
+      expect(font.length).toBeGreaterThan(0);
+    });
+  });
+
+  it('defines contribution milestone values suitable for accessible labels', () => {
+    expect(CONTRIBUTION_MILESTONES.length).toBeGreaterThan(0);
+
+    CONTRIBUTION_MILESTONES.forEach((value) => {
+      expect(value).toBeGreaterThan(0);
+    });
+  });
+
+  it('defines streak milestone values suitable for accessible labels', () => {
+    expect(STREAK_MILESTONES.length).toBeGreaterThan(0);
+
+    STREAK_MILESTONES.forEach((value) => {
+      expect(value).toBeGreaterThan(0);
+    });
+  });
+
+  it('maintains ascending milestone ordering for predictable narration', () => {
+    expect(CONTRIBUTION_MILESTONES).toEqual([...CONTRIBUTION_MILESTONES].sort((a, b) => a - b));
+
+    expect(STREAK_MILESTONES).toEqual([...STREAK_MILESTONES].sort((a, b) => a - b));
+  });
+});

lib/svg/constants.massive-scaling.test.ts

@@ -0,0 +1,48 @@
+// lib/svg/constants.massive-scaling.test.ts
+
+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,
+  CONTRIBUTION_MILESTONES,
+  STREAK_MILESTONES,
+} from './constants';
+
+describe('SVG Constants Massive Scaling', () => {
+  it('supports large simulated contribution datasets', () => {
+    const contributions = Array.from({ length: 10000 }, (_, i) => i + 1);
+
+    expect(contributions.length).toBe(10000);
+    expect(Math.max(...contributions)).toBe(10000);
+  });
+
+  it('maintains positive scaling configuration values', () => {
+    expect(LOG_SCALE_MULTIPLIER).toBeGreaterThan(0);
+    expect(LINEAR_SCALE_MULTIPLIER).toBeGreaterThan(0);
+    expect(MAX_LOG_HEIGHT).toBeGreaterThan(0);
+    expect(MAX_LINEAR_HEIGHT).toBeGreaterThan(0);
+  });
+
+  it('provides valid SVG dimensions under high-volume scenarios', () => {
+    expect(SVG_WIDTH).toBeGreaterThan(0);
+    expect(SVG_HEIGHT).toBeGreaterThan(0);
+    expect(GHOST_HEIGHT_PX).toBeGreaterThan(0);
+  });
+
+  it('maintains milestone integrity with large data references', () => {
+    expect(CONTRIBUTION_MILESTONES.every((v) => v > 0)).toBe(true);
+    expect(STREAK_MILESTONES.every((v) => v > 0)).toBe(true);
+  });
+
+  it('handles repeated access without configuration drift', () => {
+    for (let i = 0; i < 10000; i++) {
+      expect(SVG_WIDTH).toBe(600);
+      expect(SVG_HEIGHT).toBe(420);
+    }
+  });
+});

services/github/refresh-policy.theme-contrast.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect, beforeEach, vi, Mock } from 'vitest';
+import { RefreshPolicy } from './refresh-policy';
+import { quotaMonitor } from './quota-monitor';
+
+// Mock the quota monitor to control high-contrast "override" states
+vi.mock('./quota-monitor', () => ({
+  quotaMonitor: {
+    isQuotaLow: vi.fn(() => false),
+    incrementRefreshCount: vi.fn(),
+  },
+}));
+
+describe('RefreshPolicy - Theme Contrast Equivalent (Mode Cohesion)', () => {
+  let policy: RefreshPolicy;
+
+  beforeEach(() => {
+    policy = RefreshPolicy.getInstance();
+    policy.reset();
+    vi.clearAllMocks();
+  });
+
+  it('Dual Environment Setup: seamlessly swaps between standard (light) and aggressive (dark) modes', () => {
+    // Light Mode (Standard Cooldown)
+    policy.setCooldown(300000);
+    expect(policy.getRemainingCooldown('new_user')).toBe(0);
+
+    // Dark Mode (Aggressive Cooldown)
+    policy.setCooldown(600000);
+    expect(policy.getRemainingCooldown('new_user')).toBe(0);
+
+    // Swap back
+    policy.setCooldown(300000);
+    expect(policy.getRemainingCooldown('new_user')).toBe(0);
+  });
+
+  it('Behavior Adaptation Cohesion: dynamically adapts allow/deny status based on active mode', () => {
+    // Record user in Standard Mode (300000ms)
+    policy.setCooldown(300000);
+    policy.recordRefresh('mode_user');
+
+    // Simulate exactly 400000ms passing by manipulating Date.now
+    const originalDateNow = Date.now;
+    const futureTime = originalDateNow() + 400000;
+    vi.spyOn(Date, 'now').mockReturnValue(futureTime);
+
+    // In Standard Mode, 400000 > 300000, so refresh is allowed
+    expect(policy.isRefreshAllowed('mode_user')).toBe(true);
+
+    // Swap to Aggressive Mode (600000ms)
+    policy.setCooldown(600000);
+
+    // In Aggressive Mode, 400000 < 600000, so refresh is now denied!
+    expect(policy.isRefreshAllowed('mode_user')).toBe(false);
+
+    // Restore
+    vi.restoreAllMocks();
+  });
+
+  it('Contrast Verification (Overrides): quota lockouts uniformly block across all configuration modes', () => {
+    // Activate high-contrast global override
+    (quotaMonitor.isQuotaLow as Mock).mockReturnValue(true);
+
+    policy.setCooldown(100);
+    expect(policy.isRefreshAllowed('user_1')).toBe(false);
+
+    policy.setCooldown(9999999);
+    expect(policy.isRefreshAllowed('user_1')).toBe(false);
+
+    policy.setCooldown(0);
+    expect(policy.isRefreshAllowed('user_1')).toBe(false);
+
+    // Deactivate override
+    (quotaMonitor.isQuotaLow as Mock).mockReturnValue(false);
+  });
+
+  it('Configuration Preservation: swapping modes preserves internal caching data integrity', () => {
+    // Record in mode A
+    policy.setCooldown(300000);
+    policy.recordRefresh('state_user');
+
+    // Check remaining cooldown (should be roughly 300000)
+    const remainingA = policy.getRemainingCooldown('state_user');
+
+    // Swap to mode B
+    policy.setCooldown(600000);
+
+    // The timestamp state is still intact, just the boundary shifted
+    const remainingB = policy.getRemainingCooldown('state_user');
+
+    expect(remainingB).toBeGreaterThan(remainingA);
+    // Delta should be exactly 300000
+    expect(Math.abs(remainingB - remainingA - 300000)).toBeLessThan(50);
+  });
+
+  it('Foreground/Background Cohesion: getRemainingCooldown calculates foreground values flawlessly against active background mode', () => {
+    policy.recordRefresh('fg_bg_user');
+
+    // Background Mode 1
+    policy.setCooldown(1000);
+    const bg1 = policy.getRemainingCooldown('fg_bg_user');
+    expect(bg1).toBeGreaterThan(0);
+    expect(bg1).toBeLessThanOrEqual(1000);
+
+    // Background Mode 2
+    policy.setCooldown(5000);
+    const bg2 = policy.getRemainingCooldown('fg_bg_user');
+    expect(bg2).toBeGreaterThan(1000);
+    expect(bg2).toBeLessThanOrEqual(5000);
+
+    // Background Mode 3 (Disabled)
+    policy.setCooldown(0);
+    const bg3 = policy.getRemainingCooldown('fg_bg_user');
+    expect(bg3).toBe(0);
+  });
+});