Merge branch 'main' into test-2949

Author: udaycodespace

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);
+  });
+});

app/contributors/loading.type-compiler.test.tsx

@@ -0,0 +1,103 @@
+import { describe, it, expect, expectTypeOf } from 'vitest';
+import { z } from 'zod';
+
+// Test suite: verify TypeScript compiler stability and runtime schema boundaries
+describe('Contributors loading type & schema compiler checks (Variation 10)', () => {
+  // Baseline expected contributor shape (matches ContributorsClient internal shape)
+  type ExpectedContributor = {
+    id: number;
+    login: string;
+    avatar_url: string;
+    contributions: number;
+    html_url: string;
+  };
+
+  it('Case 1: Enforce field property configuration types match expected baseline structures exactly', () => {
+    // A matching shape should be exactly equal to the expected contributor type
+    type Matching = {
+      id: number;
+      login: string;
+      avatar_url: string;
+      contributions: number;
+      html_url: string;
+    };
+
+    expectTypeOf<Matching>().toEqualTypeOf<ExpectedContributor>();
+  });
+
+  it('Case 2: Assert that invalid parameter shapes are structurally incompatible', () => {
+    // Wrong types / missing required fields should not match ExpectedContributor
+    type InvalidContributor = {
+      id: string; // wrong type
+      login?: string; // optional where required
+    };
+
+    expectTypeOf<InvalidContributor>().not.toMatchTypeOf<ExpectedContributor>();
+  });
+
+  it('Case 3: Verify custom configurations accept optional parameters without compiler warnings', () => {
+    // Define an expected loading config with optional parameters
+    type LoadingConfig = {
+      limit?: number;
+      showAvatars?: boolean;
+      filters?: { org?: string } | undefined;
+    };
+
+    // A custom consumer may provide only a subset of optional parameters
+    const customConfig = { limit: 6 } satisfies LoadingConfig;
+
+    // runtime assertion to keep TS happy and ensure the optional property works
+    expect(customConfig.limit).toBe(6);
+
+    // compile-time: ensure the custom minimal shape is assignable to LoadingConfig
+    type CustomMinimal = typeof customConfig;
+    expectTypeOf<CustomMinimal>().toMatchTypeOf<LoadingConfig>();
+  });
+
+  it('Case 4: Runtime validation schemas flag structural boundary anomalies with strict error reports', () => {
+    const contributorSchema = z
+      .object({
+        id: z.number(),
+        login: z.string(),
+        avatar_url: z.string(),
+        contributions: z.number(),
+        html_url: z.string(),
+      })
+      .strict();
+
+    const badPayload = {
+      id: 1,
+      login: 'alice',
+      avatar_url: 'https://example.com/a.png',
+      contributions: 42,
+      html_url: 'https://github.com/alice',
+      unexpected_extra: 'surprise',
+    };
+
+    try {
+      contributorSchema.parse(badPayload);
+      // If parse does not throw, force a failure
+      expect(false).toBe(true);
+    } catch (err) {
+      // ZodError -> inspect issues for unrecognized keys
+      const zErr = err as z.ZodError;
+      const hasUnrecognized = zErr.issues.some((i) => i.code === z.ZodIssueCode.unrecognized_keys);
+      expect(hasUnrecognized).toBe(true);
+    }
+  });
+
+  it('Case 5: Ensure type parameters resolve down to stable readonly or structured object contracts', () => {
+    type ReadonlyContributor = Readonly<ExpectedContributor>;
+
+    // Expected readonly contract
+    type ExplicitReadonly = {
+      readonly id: number;
+      readonly login: string;
+      readonly avatar_url: string;
+      readonly contributions: number;
+      readonly html_url: string;
+    };
+
+    expectTypeOf<ReadonlyContributor>().toEqualTypeOf<ExplicitReadonly>();
+  });
+});