Merge branch 'main' into feat/grace-range-validation

Author: pari7maheshwari

components/dashboard/VisualizationTooltip.test.tsx

@@ -0,0 +1,76 @@
+// components/dashboard/VisualizationTooltip.test.tsx
+import { render, screen } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+import type { HTMLAttributes, ReactNode } from 'react';
+import VisualizationTooltip from './VisualizationTooltip';
+import '@testing-library/jest-dom/vitest';
+
+// framer-motion mock
+vi.mock('framer-motion', () => ({
+  motion: {
+    div: ({ children, ...props }: HTMLAttributes<HTMLDivElement> & { children?: ReactNode }) => (
+      <div {...props}>{children}</div>
+    ),
+  },
+}));
+
+describe('VisualizationTooltip', () => {
+  it('renders tooltip role', () => {
+    render(
+      <VisualizationTooltip title="Tooltip Title" x={100} y={200}>
+        Content
+      </VisualizationTooltip>
+    );
+
+    expect(screen.getByRole('tooltip')).toBeInTheDocument();
+  });
+
+  it('renders title correctly', () => {
+    render(
+      <VisualizationTooltip title="Commits" x={100} y={200}>
+        Content
+      </VisualizationTooltip>
+    );
+
+    expect(screen.getByText('Commits')).toBeInTheDocument();
+  });
+
+  it('renders children content', () => {
+    render(
+      <VisualizationTooltip title="Title" x={100} y={200}>
+        <span>5 contributions</span>
+      </VisualizationTooltip>
+    );
+
+    expect(screen.getByText('5 contributions')).toBeInTheDocument();
+  });
+
+  it('applies x and y coordinates to style', () => {
+    render(
+      <VisualizationTooltip title="Title" x={150} y={250}>
+        Content
+      </VisualizationTooltip>
+    );
+
+    const tooltip = screen.getByRole('tooltip');
+
+    expect(tooltip).toHaveStyle({
+      left: '150px',
+      top: '250px',
+    });
+  });
+
+  it('renders nested React elements passed as children', () => {
+    render(
+      <VisualizationTooltip title="Stats" x={10} y={20}>
+        <>
+          <div>Total: 10</div>
+          <div>Today: 2</div>
+        </>
+      </VisualizationTooltip>
+    );
+
+    expect(screen.getByText('Total: 10')).toBeInTheDocument();
+    expect(screen.getByText('Today: 2')).toBeInTheDocument();
+  });
+});

services/github/refresh-policy.mouse-interactivity.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect, vi } from 'vitest';
+import { RefreshPolicy } from './refresh-policy';
+
+describe('RefreshPolicy - Mouse Interactivity & Click Handling', () => {
+  it('prevents double-clicks from triggering redundant refresh calls using cooldown cooldownMs validation', () => {
+    const policy = RefreshPolicy.getInstance();
+    policy.reset();
+    policy.setCooldown(1000);
+
+    const firstCheck = policy.isRefreshAllowed('double-clicker');
+    expect(firstCheck).toBe(true);
+
+    policy.recordRefresh('double-clicker');
+
+    // Simulate instant second click (mouse double click)
+    const secondCheck = policy.isRefreshAllowed('double-clicker');
+    expect(secondCheck).toBe(false);
+  });
+
+  it('computes layout offset dimensions for hover tooltip displays correctly', () => {
+    const hoverEvent = { clientX: 100, clientY: 200 };
+    const getTooltipPosition = (e: { clientX: number; clientY: number }) => ({
+      top: e.clientY + 10,
+      left: e.clientX + 10,
+    });
+
+    const pos = getTooltipPosition(hoverEvent);
+    expect(pos.top).toBe(210);
+    expect(pos.left).toBe(110);
+  });
+
+  it('verifies click handlers call refresh record actions exactly once', () => {
+    const policy = RefreshPolicy.getInstance();
+    policy.reset();
+    const mockRecord = vi.spyOn(policy, 'recordRefresh');
+
+    const handleRefreshClick = (username: string) => {
+      if (policy.isRefreshAllowed(username)) {
+        policy.recordRefresh(username);
+      }
+    };
+
+    handleRefreshClick('click-tester');
+    expect(mockRecord).toHaveBeenCalledTimes(1);
+    expect(mockRecord).toHaveBeenCalledWith('click-tester');
+
+    // Subsequent click is blocked, so record is not called again
+    handleRefreshClick('click-tester');
+    expect(mockRecord).toHaveBeenCalledTimes(1);
+
+    vi.restoreAllMocks();
+  });
+});

services/github/refresh-rate-limiter.error-resilience.test.ts

@@ -0,0 +1,81 @@
+// services/github/refresh-rate-limiter.error-resilience.test.ts
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { refreshRateLimiter } from './refresh-rate-limiter';
+
+describe('RefreshRateLimiter Error Resilience', () => {
+  const originalEnv = process.env.MAX_REFRESHES_PER_HOUR;
+
+  beforeEach(() => {
+    refreshRateLimiter.reset();
+    delete process.env.MAX_REFRESHES_PER_HOUR;
+  });
+
+  afterEach(() => {
+    refreshRateLimiter.reset();
+
+    if (originalEnv) {
+      process.env.MAX_REFRESHES_PER_HOUR = originalEnv;
+    } else {
+      delete process.env.MAX_REFRESHES_PER_HOUR;
+    }
+  });
+
+  it('falls back to default limit when environment value is invalid', () => {
+    process.env.MAX_REFRESHES_PER_HOUR = 'invalid';
+
+    const result = refreshRateLimiter.checkLimit('127.0.0.1');
+
+    expect(result.success).toBe(true);
+    expect(result.limit).toBe(3);
+    expect(result.remaining).toBe(2);
+  });
+
+  it('falls back to default limit when environment value is zero', () => {
+    process.env.MAX_REFRESHES_PER_HOUR = '0';
+
+    const result = refreshRateLimiter.checkLimit('127.0.0.1');
+
+    expect(result.success).toBe(true);
+    expect(result.limit).toBe(3);
+  });
+
+  it('handles malformed or whitespace-only client identifiers safely', () => {
+    const result = refreshRateLimiter.checkLimit('   ');
+
+    expect(result.success).toBe(true);
+    expect(result.limit).toBe(3);
+    expect(result.remaining).toBe(2);
+  });
+
+  it('recovers correctly after reset is called', () => {
+    refreshRateLimiter.setLimit(1);
+
+    expect(refreshRateLimiter.checkLimit('192.168.1.1').success).toBe(true);
+
+    expect(refreshRateLimiter.checkLimit('192.168.1.1').success).toBe(false);
+
+    refreshRateLimiter.reset();
+
+    const result = refreshRateLimiter.checkLimit('192.168.1.1');
+
+    expect(result.success).toBe(true);
+    expect(result.limit).toBe(3);
+    expect(result.remaining).toBe(2);
+  });
+
+  it('maintains stable behavior across repeated checks after limit exhaustion', () => {
+    refreshRateLimiter.setLimit(1);
+
+    expect(refreshRateLimiter.checkLimit('10.0.0.1').success).toBe(true);
+
+    const blocked1 = refreshRateLimiter.checkLimit('10.0.0.1');
+    const blocked2 = refreshRateLimiter.checkLimit('10.0.0.1');
+
+    expect(blocked1.success).toBe(false);
+    expect(blocked2.success).toBe(false);
+
+    expect(blocked1.remaining).toBe(0);
+    expect(blocked2.remaining).toBe(0);
+  });
+});

services/github/validate-user.empty-fallback.test.ts

@@ -0,0 +1,63 @@
+// services/github/validate-user.empty-fallback.test.ts
+
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('../../lib/github', () => ({
+  fetchUserProfile: vi.fn(),
+}));
+
+import { fetchUserProfile } from '../../lib/github';
+import { gitHubUserValidator } from './validate-user';
+
+describe('GitHubUserValidator Empty & Missing Input Fallbacks', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    gitHubUserValidator.reset();
+  });
+
+  it('throws for empty usernames', async () => {
+    vi.mocked(fetchUserProfile).mockRejectedValue(new Error('User not found'));
+
+    await expect(gitHubUserValidator.validateUser('')).rejects.toThrow('Cache key cannot be empty');
+  });
+
+  it('throws for whitespace-only usernames', async () => {
+    vi.mocked(fetchUserProfile).mockRejectedValue(new Error('User not found'));
+
+    await expect(gitHubUserValidator.validateUser('     ')).rejects.toThrow(
+      'Cache key cannot be empty'
+    );
+  });
+
+  it('caches negative results for missing users', async () => {
+    vi.mocked(fetchUserProfile).mockRejectedValue(new Error('User not found'));
+
+    const first = await gitHubUserValidator.validateUser('missing-user');
+    const second = await gitHubUserValidator.validateUser('missing-user');
+
+    expect(first).toBe(false);
+    expect(second).toBe(false);
+
+    expect(fetchUserProfile).toHaveBeenCalledTimes(1);
+  });
+
+  it('returns cached result for usernames with different casing and spacing', async () => {
+    vi.mocked(fetchUserProfile).mockResolvedValue({} as never);
+
+    const first = await gitHubUserValidator.validateUser('Ganesh');
+    const second = await gitHubUserValidator.validateUser('  ganesh  ');
+
+    expect(first).toBe(true);
+    expect(second).toBe(true);
+
+    expect(fetchUserProfile).toHaveBeenCalledTimes(1);
+  });
+
+  it('rethrows unexpected service errors instead of masking them', async () => {
+    vi.mocked(fetchUserProfile).mockRejectedValue(new Error('GitHub API unavailable'));
+
+    await expect(gitHubUserValidator.validateUser('ganesh')).rejects.toThrow(
+      'GitHub API unavailable'
+    );
+  });
+});