Merge branch 'main' into test/refresh-policy-mocks

Author: chavanGaneshDatta

app/components/CopyRepoButton.accessibility.test.tsx

@@ -0,0 +1,55 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+
+import CopyRepoButton from './CopyRepoButton';
+
+vi.mock('lucide-react', () => ({
+  Copy: () => <svg aria-hidden="true" data-testid="copy-icon" />,
+}));
+
+Object.assign(navigator, {
+  clipboard: {
+    writeText: vi.fn().mockResolvedValue(undefined),
+  },
+});
+
+describe('CopyRepoButton accessibility behavior', () => {
+  it('renders as an accessible button with visible label', () => {
+    render(<CopyRepoButton />);
+
+    expect(screen.getByRole('button', { name: /copy url/i })).toBeDefined();
+  });
+
+  it('keeps decorative copy icon hidden from assistive technology', () => {
+    render(<CopyRepoButton />);
+
+    expect(screen.getByTestId('copy-icon').getAttribute('aria-hidden')).toBe('true');
+  });
+
+  it('is keyboard focusable through the native button element', () => {
+    render(<CopyRepoButton />);
+
+    const button = screen.getByRole('button', { name: /copy url/i });
+    button.focus();
+
+    expect(document.activeElement).toBe(button);
+  });
+
+  it('updates accessible button name after successful copy action', async () => {
+    render(<CopyRepoButton />);
+
+    const button = screen.getByRole('button', { name: /copy url/i });
+    fireEvent.click(button);
+
+    expect(await screen.findByRole('button', { name: /copied/i })).toBeDefined();
+  });
+
+  it('preserves semantic button role after interaction', async () => {
+    render(<CopyRepoButton />);
+
+    fireEvent.click(screen.getByRole('button', { name: /copy url/i }));
+
+    expect(await screen.findByRole('button', { name: /copied/i })).toBeDefined();
+    expect(screen.getAllByRole('button')).toHaveLength(1);
+  });
+});

app/components/Icons.empty-fallback.test.tsx

@@ -0,0 +1,43 @@
+import { render } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+
+import { BoxIcon, CheckIcon, CloseIcon, CopyIcon, ZapIcon } from './Icons';
+
+type IconProps = React.SVGProps<SVGSVGElement>;
+
+vi.mock('lucide-react', () => ({
+  Copy: (props: IconProps) => <svg data-testid="copy-icon" {...props} />,
+  Zap: (props: IconProps) => <svg data-testid="zap-icon" {...props} />,
+  Box: (props: IconProps) => <svg data-testid="box-icon" {...props} />,
+  Check: (props: IconProps) => <svg data-testid="check-icon" {...props} />,
+  X: (props: IconProps) => <svg data-testid="close-icon" {...props} />,
+}));
+
+describe('Icons empty fallback behavior', () => {
+  it('renders CopyIcon without crashing', () => {
+    const { getByTestId } = render(<CopyIcon />);
+    expect(getByTestId('copy-icon')).toBeDefined();
+  });
+
+  it('renders ZapIcon without crashing', () => {
+    const { getByTestId } = render(<ZapIcon />);
+    expect(getByTestId('zap-icon')).toBeDefined();
+  });
+
+  it('renders BoxIcon without crashing', () => {
+    const { getByTestId } = render(<BoxIcon />);
+    expect(getByTestId('box-icon')).toBeDefined();
+  });
+
+  it('renders CheckIcon with fallback styling', () => {
+    const { getByTestId } = render(<CheckIcon />);
+    const icon = getByTestId('check-icon');
+
+    expect(icon.getAttribute('stroke')).toBe('#10b981');
+  });
+
+  it('renders CloseIcon without runtime errors', () => {
+    const { getByTestId } = render(<CloseIcon />);
+    expect(getByTestId('close-icon')).toBeDefined();
+  });
+});

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

@@ -0,0 +1,91 @@
+import type React from 'react';
+import { render, screen } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+
+import { BoxIcon, CheckIcon, CloseIcon, CopyIcon, ZapIcon } from './Icons';
+
+type IconProps = React.SVGProps<SVGSVGElement>;
+
+vi.mock('lucide-react', () => ({
+  Copy: (props: IconProps) => <svg data-testid="copy-icon" {...props} />,
+  Zap: (props: IconProps) => <svg data-testid="zap-icon" {...props} />,
+  Box: (props: IconProps) => <svg data-testid="box-icon" {...props} />,
+  Check: (props: IconProps) => <svg data-testid="check-icon" {...props} />,
+  X: (props: IconProps) => <svg data-testid="close-icon" {...props} />,
+}));
+
+describe('Icons massive scaling behavior', () => {
+  it('renders 500 CopyIcon instances without crashing', () => {
+    render(
+      <>
+        {Array.from({ length: 500 }, (_, index) => (
+          <CopyIcon key={index} />
+        ))}
+      </>
+    );
+
+    expect(screen.getAllByTestId('copy-icon')).toHaveLength(500);
+  });
+
+  it('renders 500 ZapIcon instances without crashing', () => {
+    render(
+      <>
+        {Array.from({ length: 500 }, (_, index) => (
+          <ZapIcon key={index} />
+        ))}
+      </>
+    );
+
+    expect(screen.getAllByTestId('zap-icon')).toHaveLength(500);
+  });
+
+  it('renders mixed icon sets at high volume', () => {
+    render(
+      <>
+        {Array.from({ length: 100 }, (_, index) => (
+          <div key={index}>
+            <CopyIcon />
+            <ZapIcon />
+            <BoxIcon />
+            <CheckIcon />
+            <CloseIcon />
+          </div>
+        ))}
+      </>
+    );
+
+    expect(screen.getAllByTestId('copy-icon')).toHaveLength(100);
+    expect(screen.getAllByTestId('zap-icon')).toHaveLength(100);
+    expect(screen.getAllByTestId('box-icon')).toHaveLength(100);
+    expect(screen.getAllByTestId('check-icon')).toHaveLength(100);
+    expect(screen.getAllByTestId('close-icon')).toHaveLength(100);
+  });
+
+  it('preserves icon dimension attributes across many rendered icons', () => {
+    render(
+      <>
+        {Array.from({ length: 100 }, (_, index) => (
+          <CopyIcon key={index} />
+        ))}
+      </>
+    );
+
+    expect(
+      screen.getAllByTestId('copy-icon').every((icon) => icon.getAttribute('width') === '20')
+    ).toBe(true);
+  });
+
+  it('preserves CheckIcon stroke styling across high-volume renders', () => {
+    render(
+      <>
+        {Array.from({ length: 100 }, (_, index) => (
+          <CheckIcon key={index} />
+        ))}
+      </>
+    );
+
+    expect(
+      screen.getAllByTestId('check-icon').every((icon) => icon.getAttribute('stroke') === '#10b981')
+    ).toBe(true);
+  });
+});

app/components/ScrollRestoration.empty-fallback.test.tsx

@@ -0,0 +1,62 @@
+import { render } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import ScrollRestoration from './ScrollRestoration';
+
+const mockUsePathname = vi.fn();
+
+vi.mock('next/navigation', () => ({
+  usePathname: () => mockUsePathname(),
+}));
+
+describe('ScrollRestoration empty fallback behavior', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    sessionStorage.clear();
+    mockUsePathname.mockReturnValue('/');
+    window.scrollTo = vi.fn();
+  });
+
+  it('renders null without crashing when no saved scroll position exists', () => {
+    const { container } = render(<ScrollRestoration />);
+
+    expect(container.firstChild).toBeNull();
+  });
+
+  it('does not scroll when sessionStorage has no saved position', () => {
+    render(<ScrollRestoration />);
+
+    expect(window.scrollTo).not.toHaveBeenCalled();
+  });
+
+  it('restores saved scroll position when value exists', () => {
+    sessionStorage.setItem('scroll-position-/', '250');
+
+    render(<ScrollRestoration />);
+
+    expect(window.scrollTo).toHaveBeenCalledWith(0, 250);
+  });
+
+  it('stores current scroll position on scroll event', () => {
+    Object.defineProperty(window, 'scrollY', {
+      value: 300,
+      configurable: true,
+    });
+
+    render(<ScrollRestoration />);
+
+    window.dispatchEvent(new Event('scroll'));
+
+    expect(sessionStorage.getItem('scroll-position-/')).toBe('300');
+  });
+
+  it('uses pathname-specific storage keys for empty fallback safety', () => {
+    mockUsePathname.mockReturnValue('/dashboard');
+
+    render(<ScrollRestoration />);
+
+    window.dispatchEvent(new Event('scroll'));
+
+    expect(sessionStorage.getItem('scroll-position-/dashboard')).toBeDefined();
+  });
+});

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

@@ -0,0 +1,83 @@
+import { render } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import ScrollRestoration from './ScrollRestoration';
+
+const mockUsePathname = vi.fn();
+
+vi.mock('next/navigation', () => ({
+  usePathname: () => mockUsePathname(),
+}));
+
+describe('ScrollRestoration massive scaling behavior', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    sessionStorage.clear();
+    mockUsePathname.mockReturnValue('/');
+    window.scrollTo = vi.fn();
+  });
+
+  it('renders repeatedly without crashing under high mount volume', () => {
+    expect(() => {
+      for (let index = 0; index < 100; index++) {
+        render(<ScrollRestoration />);
+      }
+    }).not.toThrow();
+  });
+
+  it('handles many stored scroll positions without breaking restoration', () => {
+    for (let index = 0; index < 500; index++) {
+      sessionStorage.setItem(`scroll-position-/page-${index}`, String(index));
+    }
+
+    mockUsePathname.mockReturnValue('/page-499');
+
+    render(<ScrollRestoration />);
+
+    expect(window.scrollTo).toHaveBeenCalledWith(0, 499);
+  });
+
+  it('stores scroll position correctly after many scroll events', () => {
+    render(<ScrollRestoration />);
+
+    for (let index = 0; index < 100; index++) {
+      Object.defineProperty(window, 'scrollY', {
+        value: index,
+        configurable: true,
+      });
+
+      window.dispatchEvent(new Event('scroll'));
+    }
+
+    expect(sessionStorage.getItem('scroll-position-/')).toBe('99');
+  });
+
+  it('keeps pathname-specific keys isolated at scale', () => {
+    for (let index = 0; index < 50; index++) {
+      mockUsePathname.mockReturnValue(`/dashboard-${index}`);
+
+      const { unmount } = render(<ScrollRestoration />);
+
+      Object.defineProperty(window, 'scrollY', {
+        value: index * 10,
+        configurable: true,
+      });
+
+      window.dispatchEvent(new Event('scroll'));
+      unmount();
+    }
+
+    expect(sessionStorage.getItem('scroll-position-/dashboard-0')).toBe('0');
+    expect(sessionStorage.getItem('scroll-position-/dashboard-49')).toBe('490');
+  });
+  it('removes scroll listener safely after many unmount cycles', () => {
+    const removeEventListenerSpy = vi.spyOn(window, 'removeEventListener');
+
+    for (let index = 0; index < 25; index++) {
+      const { unmount } = render(<ScrollRestoration />);
+      unmount();
+    }
+
+    expect(removeEventListenerSpy).toHaveBeenCalledTimes(25);
+  });
+});