Merge branch 'main' into fix/wrapped-duplicate-contributions-fetch

Author: ScarsAndSource

app/components/CopyRepoButton.massive-scaling.test.tsx

@@ -1,11 +1,20 @@
-import { render, screen } from '@testing-library/react';
-import { describe, it, expect, vi } from 'vitest';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { beforeEach, describe, it, expect, vi } from 'vitest';
 import CopyRepoButton from './CopyRepoButton';
 
 vi.mock('lucide-react', () => ({
   Copy: () => <svg data-testid="copy-icon" />,
 }));
 
+beforeEach(() => {
+  vi.clearAllMocks();
+  Object.assign(navigator, {
+    clipboard: {
+      writeText: vi.fn().mockResolvedValue(undefined),
+    },
+  });
+});
+
 describe('CopyRepoButton Massive Scaling', () => {
   it('renders 100 buttons without crashing', () => {
     render(
@@ -63,4 +72,35 @@ describe('CopyRepoButton Massive Scaling', () => {
       }
     }).not.toThrow();
   });
+
+  it('shows copied state after a successful clipboard write', async () => {
+    render(<CopyRepoButton />);
+
+    fireEvent.click(screen.getByRole('button', { name: /copy url/i }));
+
+    await waitFor(() => {
+      expect(navigator.clipboard.writeText).toHaveBeenCalledWith(
+        'https://github.com/JhaSourav07/commitpulse'
+      );
+    });
+
+    expect(screen.getByText('Copied!')).toBeDefined();
+  });
+
+  it('shows an error state when clipboard write fails', async () => {
+    vi.mocked(navigator.clipboard.writeText).mockRejectedValueOnce(new Error('Permission denied'));
+
+    render(<CopyRepoButton />);
+
+    fireEvent.click(screen.getByRole('button', { name: /copy url/i }));
+
+    await waitFor(() => {
+      expect(navigator.clipboard.writeText).toHaveBeenCalledWith(
+        'https://github.com/JhaSourav07/commitpulse'
+      );
+    });
+
+    expect(screen.queryByText('Copied!')).toBeNull();
+    expect(screen.getByText('Copy failed')).toBeDefined();
+  });
 });

app/components/CopyRepoButton.tsx

@@ -4,18 +4,19 @@ import { useState } from 'react';
 import { Copy } from 'lucide-react';
 
 export default function CopyRepoButton() {
-  const [copied, setCopied] = useState(false);
+  const [copyState, setCopyState] = useState<'idle' | 'copied' | 'error'>('idle');
 
   const repoUrl = 'https://github.com/JhaSourav07/commitpulse';
 
   const handleCopy = async () => {
-    await navigator.clipboard.writeText(repoUrl);
+    try {
+      await navigator.clipboard.writeText(repoUrl);
+      setCopyState('copied');
+    } catch {
+      setCopyState('error');
+    }
 
-    setCopied(true);
-
-    setTimeout(() => {
-      setCopied(false);
-    }, 2000);
+    setTimeout(() => setCopyState('idle'), 2000);
   };
 
   return (
@@ -24,7 +25,7 @@ export default function CopyRepoButton() {
       className="inline-flex items-center gap-2 rounded-2xl border border-black/10 bg-white/60 px-8 py-4 font-semibold transition-all duration-300 hover:scale-105 dark:border-white/10 dark:bg-white/5"
     >
       <Copy className="h-5 w-5" />
-      {copied ? 'Copied!' : 'Copy URL'}
+      {copyState === 'copied' ? 'Copied!' : copyState === 'error' ? 'Copy failed' : 'Copy URL'}
     </button>
   );
 }

services/security/track-user-protection.accessibility.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+import { TrackUserProtection } from './track-user-protection';
+
+describe('TrackUserProtection Accessibility Compliance', () => {
+  it('validates correct use of aria roles and labels on indicator markup', () => {
+    const tracker = TrackUserProtection.getInstance();
+    const element = { role: 'status', 'aria-live': 'polite' };
+    expect(tracker).toBeDefined();
+    expect(element.role).toBe('status');
+    expect(element['aria-live']).toBe('polite');
+  });
+
+  it('asserts elements accepting focus maintain visible outline styles', () => {
+    const focusableElement = { focusable: true, style: { outline: '2px solid purple' } };
+    expect(focusableElement.focusable).toBe(true);
+    expect(focusableElement.style.outline).toContain('solid');
+  });
+
+  it('verifies tooltip elements announce correct accessibility descriptions', () => {
+    const tooltip = { 'aria-describedby': 'tooltip-desc', textContent: 'User tracking status' };
+    expect(tooltip['aria-describedby']).toBe('tooltip-desc');
+    expect(tooltip.textContent).toBe('User tracking status');
+  });
+
+  it('tests keyboard control paths to ensure correct tab index order', () => {
+    const items = [
+      { id: 'btn-1', tabIndex: 0 },
+      { id: 'btn-2', tabIndex: 0 },
+      { id: 'btn-3', tabIndex: -1 },
+    ];
+    const activeTabs = items.filter((item) => item.tabIndex >= 0);
+    expect(activeTabs.length).toBe(2);
+  });
+
+  it('confirms logical hierarchy ordering of headings', () => {
+    const headings = ['H1', 'H2', 'H3'];
+    const isOrdered = headings.every((h, idx) => idx === 0 || headings[idx - 1] < h);
+    expect(isOrdered).toBe(true);
+  });
+});

services/security/track-user-protection.mouse-interactivity.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect, vi } from 'vitest';
+import { TrackUserProtection } from './track-user-protection';
+
+describe('TrackUserProtection Mouse Interactivity', () => {
+  // Test 1: Trigger simulated mouseenter/hover gestures on active segments
+  it('handles simulated hover state flags without throwing', () => {
+    const tracker = TrackUserProtection.getInstance();
+    const hoverState = { active: false, coordinates: { x: 0, y: 0 } };
+
+    // Simulate hover
+    hoverState.active = true;
+    hoverState.coordinates = { x: 120, y: 340 };
+
+    expect(tracker).toBeDefined();
+    expect(hoverState.active).toBe(true);
+    expect(hoverState.coordinates.x).toBe(120);
+  });
+
+  // Test 2: Verify that responsive tooltip layouts display at computed coordinates
+  it('computes responsive tooltip offset coordinates correctly', () => {
+    const computeOffset = (x: number, y: number) => ({ top: y - 10, left: x + 15 });
+    const offset = computeOffset(100, 200);
+    expect(offset.top).toBe(190);
+    expect(offset.left).toBe(115);
+  });
+
+  // Test 3: Test custom click/touch gestures and ensure click events propagate correctly
+  it('verifies click/touch propagation events do not trigger double calls', () => {
+    const onClick = vi.fn();
+    const simulateTouch = (e: { stopPropagation: () => void }) => {
+      e.stopPropagation();
+      onClick();
+    };
+    const mockEvent = { stopPropagation: vi.fn() };
+    simulateTouch(mockEvent);
+    expect(onClick).toHaveBeenCalledTimes(1);
+    expect(mockEvent.stopPropagation).toHaveBeenCalledTimes(1);
+  });
+
+  // Test 4: Assert appropriate cursor style classes (like pointer) are applied on hover
+  it('checks if correct cursor pointer class is returned for interactive elements', () => {
+    const getCursorStyle = (isHovered: boolean) =>
+      isHovered ? 'cursor-pointer' : 'cursor-default';
+    expect(getCursorStyle(true)).toBe('cursor-pointer');
+    expect(getCursorStyle(false)).toBe('cursor-default');
+  });
+
+  // Test 5: Check that mouseleave events successfully hide temporary overlay visuals
+  it('hides active tooltip overlay when mouseleave is triggered', () => {
+    const overlay = { visible: true };
+    const onMouseLeave = () => {
+      overlay.visible = false;
+    };
+    onMouseLeave();
+    expect(overlay.visible).toBe(false);
+  });
+});

services/security/track-user-protection.theme-contrast.test.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect } from 'vitest';
+import { TrackUserProtection } from './track-user-protection';
+
+describe('TrackUserProtection Theme Contrast and Visual Cohesion', () => {
+  it('emulates dual theme configuration presets correctly', () => {
+    const tracker = TrackUserProtection.getInstance();
+    const themes = {
+      dark: { bg: '#0b0f19', text: '#ffffff' },
+      light: { bg: '#ffffff', text: '#0b0f19' },
+    };
+    expect(tracker).toBeDefined();
+    expect(themes.dark.bg).toBe('#0b0f19');
+    expect(themes.light.bg).toBe('#ffffff');
+  });
+
+  it('asserts styling adapts properly according to current theme preset', () => {
+    const getBgColor = (theme: 'dark' | 'light') => (theme === 'dark' ? '#0f172a' : '#f8fafc');
+    expect(getBgColor('dark')).toBe('#0f172a');
+    expect(getBgColor('light')).toBe('#f8fafc');
+  });
+
+  it('verifies contrast ratio compliance thresholds are met', () => {
+    // WCAG AAA requires 7:1 for normal text, AA requires 4.5:1
+    const contrastRatio = 7.2;
+    expect(contrastRatio).toBeGreaterThanOrEqual(4.5);
+  });
+
+  it('checks presence of active tailwind or class properties', () => {
+    const cardClasses = ['dark:bg-slate-900', 'bg-white', 'text-slate-100'];
+    expect(cardClasses).toContain('dark:bg-slate-900');
+  });
+
+  it('ensures background colors do not obstruct foreground content elements', () => {
+    const container = { bgOpacity: 0.8, textVisible: true };
+    expect(container.bgOpacity).toBeLessThan(1);
+    expect(container.textVisible).toBe(true);
+  });
+});