add: new tests

backend/tests/test_config.py

@@ -0,0 +1,21 @@
+import pytest
+from sqlalchemy.exc import ArgumentError
+
+from app.core.config import (
+    PASSWORD_URL_ENCODING_MESSAGE,
+    normalize_database_url,
+)
+
+
+def test_normalize_database_url_raises_helpful_error_for_malformed_url(monkeypatch):
+    malformed_url = "postgresql://user:pass@localhost:5432/db"
+
+    def fake_make_url(_raw_url):
+        raise ArgumentError("malformed URL")
+
+    monkeypatch.setattr("app.core.config.make_url", fake_make_url)
+
+    with pytest.raises(ValueError, match="DATABASE_URL appears malformed") as exc_info:
+        normalize_database_url(malformed_url)
+
+    assert str(exc_info.value) == PASSWORD_URL_ENCODING_MESSAGE

frontend/src/components/shared/Skeletons.test.jsx

@@ -0,0 +1,50 @@
+import { render, cleanup } from '@testing-library/react'
+import { afterEach, describe, expect, it } from 'vitest'
+import '@testing-library/jest-dom/vitest'
+
+import {
+  LeaderboardSkeleton,
+  ResultCardSkeleton,
+  ResultSkeleton,
+  SkeletonBlock,
+  StatCardSkeleton,
+  TestCardSkeleton,
+} from './Skeletons'
+
+afterEach(() => {
+  cleanup()
+})
+
+describe('Skeletons', () => {
+  it('renders SkeletonBlock with the expected default classes and accessibility marker', () => {
+    const { container } = render(<SkeletonBlock className="h-4 w-full" />)
+    const block = container.firstChild
+
+    expect(block).toBeInTheDocument()
+    expect(block).toHaveAttribute('aria-hidden', 'true')
+    expect(block).toHaveClass('block', 'animate-pulse', 'rounded', 'bg-slate-200/80', 'dark:bg-slate-800', 'h-4', 'w-full')
+  })
+
+  it('renders TestCardSkeleton with its card structure and pulse placeholders', () => {
+    const { container } = render(<TestCardSkeleton />)
+    const card = container.querySelector('.gate-card')
+
+    expect(card).toBeInTheDocument()
+    expect(card).toHaveClass('p-5', 'flex', 'flex-col', 'gap-3')
+    expect(container.querySelectorAll('.animate-pulse')).not.toHaveLength(0)
+  })
+
+  it('renders the other shared skeleton variants without crashing', () => {
+    const statResult = render(<StatCardSkeleton />)
+    expect(statResult.container.querySelector('.gate-card')).toBeInTheDocument()
+
+    const leaderboardResult = render(<LeaderboardSkeleton />)
+    expect(leaderboardResult.container.querySelectorAll('.animate-pulse').length).toBeGreaterThan(0)
+
+    const resultCardResult = render(<ResultCardSkeleton />)
+    expect(resultCardResult.container.querySelector('.gate-card')).toBeInTheDocument()
+
+    const resultPageResult = render(<ResultSkeleton />)
+    expect(resultPageResult.container.querySelectorAll('.animate-pulse').length).toBeGreaterThan(0)
+  })
+})

frontend/src/context/AuthContext.test.jsx

@@ -0,0 +1,215 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { render, screen, cleanup, act, waitFor } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import { MemoryRouter } from 'react-router-dom'
+import { AuthProvider, useAuth } from './AuthContext'
+
+// ── Mocks ────────────────────────────────────────────────────────
+const mockNavigate = vi.fn()
+vi.mock('react-router-dom', async () => {
+  const actual = await vi.importActual('react-router-dom')
+  return { ...actual, useNavigate: () => mockNavigate }
+})
+
+vi.mock('swr', () => ({ mutate: vi.fn() }))
+
+const mockGet = vi.fn()
+const mockPost = vi.fn()
+vi.mock('../api/client', () => ({
+  default: { get: (...args) => mockGet(...args), post: (...args) => mockPost(...args) },
+  AUTH_UNAUTHORIZED_EVENT: 'gateprep:auth-unauthorized',
+  startTokenRefresh: vi.fn(),
+  stopTokenRefresh: vi.fn(),
+}))
+
+// Helper to consume and display context values
+function AuthConsumer() {
+  const { user, loading, sessionExpired, logout, saveUser } = useAuth()
+  return (
+    <div>
+      <span data-testid="loading">{String(loading)}</span>
+      <span data-testid="user">{user ? JSON.stringify(user) : 'null'}</span>
+      <span data-testid="session-expired">{String(sessionExpired)}</span>
+      <button data-testid="logout-btn" onClick={logout}>Logout</button>
+      <button data-testid="save-btn" onClick={() => saveUser({ id: 99, email: 'new@test.com', role: 'student', full_name: 'New' })}>Save</button>
+    </div>
+  )
+}
+
+function renderWithRouter(ui) {
+  return render(<MemoryRouter>{ui}</MemoryRouter>)
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+})
+
+afterEach(() => {
+  cleanup()
+})
+
+// ── Tests ────────────────────────────────────────────────────────
+describe('AuthProvider', () => {
+  it('initialises: fetches /auth/me and sets user on success', async () => {
+    const userData = { id: 1, email: 'a@b.com', role: 'admin', full_name: 'Admin' }
+    mockGet.mockResolvedValueOnce({ data: userData })
+
+    renderWithRouter(
+      <AuthProvider><AuthConsumer /></AuthProvider>
+    )
+
+    // Initially loading
+    expect(screen.getByTestId('loading').textContent).toBe('true')
+
+    await waitFor(() => {
+      expect(screen.getByTestId('loading').textContent).toBe('false')
+    })
+
+    expect(screen.getByTestId('user').textContent).toContain('"email":"a@b.com"')
+
+    const { startTokenRefresh } = await import('../api/client')
+    expect(startTokenRefresh).toHaveBeenCalledWith({ refreshNow: true })
+  })
+
+  it('initialises: sets user to null when /auth/me fails', async () => {
+    mockGet.mockRejectedValueOnce(new Error('Unauthorized'))
+
+    renderWithRouter(
+      <AuthProvider><AuthConsumer /></AuthProvider>
+    )
+
+    await waitFor(() => {
+      expect(screen.getByTestId('loading').textContent).toBe('false')
+    })
+
+    expect(screen.getByTestId('user').textContent).toBe('null')
+  })
+
+  it('logout: clears user, stops refresh, and navigates to /login', async () => {
+    const userData = { id: 1, email: 'a@b.com', role: 'admin', full_name: 'Admin' }
+    mockGet.mockResolvedValueOnce({ data: userData })
+    mockPost.mockResolvedValueOnce({}) // logout API call
+
+    renderWithRouter(
+      <AuthProvider><AuthConsumer /></AuthProvider>
+    )
+
+    await waitFor(() => {
+      expect(screen.getByTestId('loading').textContent).toBe('false')
+    })
+
+    await act(async () => {
+      await userEvent.click(screen.getByTestId('logout-btn'))
+    })
+
+    const { stopTokenRefresh } = await import('../api/client')
+    expect(stopTokenRefresh).toHaveBeenCalled()
+    expect(screen.getByTestId('user').textContent).toBe('null')
+    expect(mockNavigate).toHaveBeenCalledWith('/login', { replace: true })
+  })
+
+  it('logout: still clears state even if API call fails', async () => {
+    mockGet.mockResolvedValueOnce({ data: { id: 1, email: 'a@b.com', role: 'student', full_name: 'S' } })
+    mockPost.mockRejectedValueOnce(new Error('network error'))
+
+    renderWithRouter(
+      <AuthProvider><AuthConsumer /></AuthProvider>
+    )
+
+    await waitFor(() => {
+      expect(screen.getByTestId('loading').textContent).toBe('false')
+    })
+
+    await act(async () => {
+      await userEvent.click(screen.getByTestId('logout-btn'))
+    })
+
+    // User should still be cleared despite API failure
+    expect(screen.getByTestId('user').textContent).toBe('null')
+    expect(mockNavigate).toHaveBeenCalledWith('/login', { replace: true })
+  })
+
+  it('saveUser: sets user from provided data and starts token refresh', async () => {
+    mockGet.mockRejectedValueOnce(new Error('no session')) // initial load fails
+
+    renderWithRouter(
+      <AuthProvider><AuthConsumer /></AuthProvider>
+    )
+
+    await waitFor(() => {
+      expect(screen.getByTestId('loading').textContent).toBe('false')
+    })
+
+    await act(async () => {
+      await userEvent.click(screen.getByTestId('save-btn'))
+    })
+
+    expect(screen.getByTestId('user').textContent).toContain('"email":"new@test.com"')
+    expect(screen.getByTestId('session-expired').textContent).toBe('false')
+
+    const { startTokenRefresh } = await import('../api/client')
+    expect(startTokenRefresh).toHaveBeenCalled()
+  })
+
+  it('session expired: shows dialog on AUTH_UNAUTHORIZED_EVENT', async () => {
+    mockGet.mockResolvedValueOnce({ data: { id: 1, email: 'a@b.com', role: 'admin', full_name: 'A' } })
+
+    renderWithRouter(
+      <AuthProvider><AuthConsumer /></AuthProvider>
+    )
+
+    await waitFor(() => {
+      expect(screen.getByTestId('loading').textContent).toBe('false')
+    })
+
+    // Fire the unauthorized event
+    act(() => {
+      window.dispatchEvent(new CustomEvent('gateprep:auth-unauthorized'))
+    })
+
+    expect(screen.getByTestId('session-expired').textContent).toBe('true')
+    expect(screen.getByText('Session expired')).toBeTruthy()
+    expect(screen.getByText('Sign in')).toBeTruthy()
+  })
+
+  it('confirmSessionExpired: clicking "Sign in" clears state and navigates to /login', async () => {
+    mockGet.mockResolvedValueOnce({ data: { id: 1, email: 'a@b.com', role: 'admin', full_name: 'A' } })
+
+    renderWithRouter(
+      <AuthProvider><AuthConsumer /></AuthProvider>
+    )
+
+    await waitFor(() => {
+      expect(screen.getByTestId('loading').textContent).toBe('false')
+    })
+
+    act(() => {
+      window.dispatchEvent(new CustomEvent('gateprep:auth-unauthorized'))
+    })
+
+    await act(async () => {
+      await userEvent.click(screen.getByText('Sign in'))
+    })
+
+    const { stopTokenRefresh } = await import('../api/client')
+    expect(stopTokenRefresh).toHaveBeenCalled()
+    expect(screen.getByTestId('user').textContent).toBe('null')
+    expect(screen.getByTestId('session-expired').textContent).toBe('false')
+    expect(mockNavigate).toHaveBeenCalledWith('/login', expect.objectContaining({ replace: true }))
+  })
+})
+
+describe('useAuth', () => {
+  it('throws if used outside AuthProvider', () => {
+    // Suppress React error boundary console noise
+    const spy = vi.spyOn(console, 'error').mockImplementation(() => {})
+
+    function Naked() {
+      useAuth()
+      return null
+    }
+
+    expect(() => render(<Naked />)).toThrow('useAuth must be used within AuthProvider')
+    spy.mockRestore()
+  })
+})

frontend/src/context/ThemeContext.test.jsx

@@ -0,0 +1,93 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { render, screen, cleanup, act } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import { ThemeProvider, useTheme } from './ThemeContext'
+
+function ThemeConsumer() {
+  const { theme, toggle } = useTheme()
+  return (
+    <div>
+      <span data-testid="theme">{theme}</span>
+      <button data-testid="toggle-btn" onClick={toggle}>Toggle</button>
+    </div>
+  )
+}
+
+beforeEach(() => {
+  localStorage.clear()
+  document.documentElement.removeAttribute('data-theme')
+  document.documentElement.style.colorScheme = ''
+  document.documentElement.classList.remove('dark')
+})
+
+afterEach(() => {
+  cleanup()
+})
+
+describe('ThemeProvider', () => {
+  it('defaults to "dark" when localStorage has no saved theme', () => {
+    render(<ThemeProvider><ThemeConsumer /></ThemeProvider>)
+
+    expect(screen.getByTestId('theme').textContent).toBe('dark')
+    expect(localStorage.getItem('theme')).toBe('dark')
+    expect(document.documentElement.getAttribute('data-theme')).toBe('dark')
+    expect(document.documentElement.classList.contains('dark')).toBe(true)
+  })
+
+  it('restores saved theme from localStorage', () => {
+    localStorage.setItem('theme', 'light')
+
+    render(<ThemeProvider><ThemeConsumer /></ThemeProvider>)
+
+    expect(screen.getByTestId('theme').textContent).toBe('light')
+    expect(document.documentElement.getAttribute('data-theme')).toBe('light')
+    expect(document.documentElement.classList.contains('dark')).toBe(false)
+  })
+
+  it('toggles from dark to light', async () => {
+    render(<ThemeProvider><ThemeConsumer /></ThemeProvider>)
+
+    expect(screen.getByTestId('theme').textContent).toBe('dark')
+
+    await act(async () => {
+      await userEvent.click(screen.getByTestId('toggle-btn'))
+    })
+
+    expect(screen.getByTestId('theme').textContent).toBe('light')
+    expect(localStorage.getItem('theme')).toBe('light')
+    expect(document.documentElement.classList.contains('dark')).toBe(false)
+  })
+
+  it('toggles from light back to dark', async () => {
+    localStorage.setItem('theme', 'light')
+
+    render(<ThemeProvider><ThemeConsumer /></ThemeProvider>)
+
+    await act(async () => {
+      await userEvent.click(screen.getByTestId('toggle-btn'))
+    })
+
+    expect(screen.getByTestId('theme').textContent).toBe('dark')
+    expect(localStorage.getItem('theme')).toBe('dark')
+    expect(document.documentElement.classList.contains('dark')).toBe(true)
+  })
+
+  it('sets colorScheme on the document element', () => {
+    render(<ThemeProvider><ThemeConsumer /></ThemeProvider>)
+
+    expect(document.documentElement.style.colorScheme).toBe('dark')
+  })
+})
+
+describe('useTheme', () => {
+  it('returns null when used outside ThemeProvider', () => {
+    // useTheme uses raw useContext without a guard, so it returns null outside provider
+    function Naked() {
+      const ctx = useTheme()
+      return <span data-testid="ctx">{String(ctx)}</span>
+    }
+
+    render(<Naked />)
+    expect(screen.getByTestId('ctx').textContent).toBe('null')
+  })
+})