Merge pull request #168 from CSSLab/dev

Update feature branch

Author: kevinjosethomas

__tests__/api/active-users.test.ts

@@ -0,0 +1,25 @@
+import { createMocks } from 'node-mocks-http'
+import handler from 'src/pages/api/active-users'
+
+global.fetch = jest.fn()
+
+describe('/api/active-users', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    delete process.env.POSTHOG_PROJECT_ID
+    delete process.env.POSTHOG_API_KEY
+  })
+
+  it('should return 405 for non-GET requests', async () => {
+    const { req, res } = createMocks({
+      method: 'POST',
+    })
+
+    await handler(req, res)
+
+    expect(res._getStatusCode()).toBe(405)
+    const data = JSON.parse(res._getData())
+    expect(data.success).toBe(false)
+    expect(data.error).toBe('Method not allowed')
+  })
+})

__tests__/api/home/activeUsers.test.ts

@@ -0,0 +1,41 @@
+import { getActiveUserCount } from 'src/api/home/activeUsers'
+
+// Mock fetch for API calls
+global.fetch = jest.fn()
+
+describe('getActiveUserCount', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('should return a positive number', async () => {
+    // Mock successful API response
+    ;(fetch as jest.Mock).mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        activeUsers: 15,
+        success: true,
+      }),
+    })
+
+    const count = await getActiveUserCount()
+    expect(count).toBeGreaterThanOrEqual(0)
+    expect(Number.isInteger(count)).toBe(true)
+  })
+
+  it('should call the internal API endpoint', async () => {
+    // Mock successful API response
+    ;(fetch as jest.Mock).mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        activeUsers: 10,
+        success: true,
+      }),
+    })
+
+    const count = await getActiveUserCount()
+
+    expect(fetch).toHaveBeenCalledWith('/api/active-users')
+    expect(count).toBe(10)
+  })
+})

__tests__/hooks/useLeaderboardStatus.test.ts

@@ -0,0 +1,103 @@
+import { renderHook, waitFor } from '@testing-library/react'
+import { useLeaderboardStatus } from 'src/hooks/useLeaderboardStatus'
+import * as api from 'src/api'
+
+// Mock the API
+jest.mock('src/api', () => ({
+  getLeaderboard: jest.fn(),
+}))
+
+const mockLeaderboardData = {
+  play_leaders: [
+    { display_name: 'TestPlayer1', elo: 1800 },
+    { display_name: 'TestPlayer2', elo: 1750 },
+  ],
+  puzzles_leaders: [
+    { display_name: 'TestPlayer1', elo: 1600 },
+    { display_name: 'TestPlayer3', elo: 1550 },
+  ],
+  turing_leaders: [{ display_name: 'TestPlayer4', elo: 1400 }],
+  hand_leaders: [{ display_name: 'TestPlayer1', elo: 1500 }],
+  brain_leaders: [{ display_name: 'TestPlayer5', elo: 1300 }],
+  last_updated: '2024-01-01T00:00:00',
+}
+
+describe('useLeaderboardStatus', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    ;(api.getLeaderboard as jest.Mock).mockResolvedValue(mockLeaderboardData)
+  })
+
+  it('should return correct status for player on multiple leaderboards', async () => {
+    const { result } = renderHook(() => useLeaderboardStatus('TestPlayer1'))
+
+    expect(result.current.loading).toBe(true)
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false)
+    })
+
+    expect(result.current.status.isOnLeaderboard).toBe(true)
+    expect(result.current.status.totalLeaderboards).toBe(3)
+    expect(result.current.status.positions).toHaveLength(3)
+
+    // Check specific positions
+    const regularPosition = result.current.status.positions.find(
+      (p) => p.gameType === 'regular',
+    )
+    expect(regularPosition?.position).toBe(1)
+    expect(regularPosition?.elo).toBe(1800)
+
+    const trainPosition = result.current.status.positions.find(
+      (p) => p.gameType === 'train',
+    )
+    expect(trainPosition?.position).toBe(1)
+    expect(trainPosition?.elo).toBe(1600)
+
+    const handPosition = result.current.status.positions.find(
+      (p) => p.gameType === 'hand',
+    )
+    expect(handPosition?.position).toBe(1)
+    expect(handPosition?.elo).toBe(1500)
+  })
+
+  it('should return correct status for player not on leaderboard', async () => {
+    const { result } = renderHook(() =>
+      useLeaderboardStatus('NonExistentPlayer'),
+    )
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false)
+    })
+
+    expect(result.current.status.isOnLeaderboard).toBe(false)
+    expect(result.current.status.totalLeaderboards).toBe(0)
+    expect(result.current.status.positions).toHaveLength(0)
+  })
+
+  it('should return empty status when no displayName provided', async () => {
+    const { result } = renderHook(() => useLeaderboardStatus(undefined))
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false)
+    })
+
+    expect(result.current.status.isOnLeaderboard).toBe(false)
+    expect(result.current.status.totalLeaderboards).toBe(0)
+    expect(result.current.status.positions).toHaveLength(0)
+    expect(api.getLeaderboard).not.toHaveBeenCalled()
+  })
+
+  it('should handle API errors gracefully', async () => {
+    ;(api.getLeaderboard as jest.Mock).mockRejectedValue(new Error('API Error'))
+
+    const { result } = renderHook(() => useLeaderboardStatus('TestPlayer1'))
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false)
+    })
+
+    expect(result.current.status.isOnLeaderboard).toBe(false)
+    expect(result.current.error).toBe('Failed to fetch leaderboard data')
+  })
+})

__tests__/lib/ratingUtils.test.ts

@@ -0,0 +1,114 @@
+import { isValidRating, safeUpdateRating } from '../../src/lib/ratingUtils'
+
+describe('ratingUtils', () => {
+  describe('isValidRating', () => {
+    it('should accept valid positive ratings', () => {
+      expect(isValidRating(1500)).toBe(true)
+      expect(isValidRating(1100)).toBe(true)
+      expect(isValidRating(1900)).toBe(true)
+      expect(isValidRating(800)).toBe(true)
+      expect(isValidRating(2500)).toBe(true)
+      expect(isValidRating(3000)).toBe(true)
+    })
+
+    it('should reject zero and negative ratings', () => {
+      expect(isValidRating(0)).toBe(false)
+      expect(isValidRating(-100)).toBe(false)
+      expect(isValidRating(-1500)).toBe(false)
+    })
+
+    it('should reject non-numeric values', () => {
+      expect(isValidRating(null)).toBe(false)
+      expect(isValidRating(undefined)).toBe(false)
+      expect(isValidRating('1500')).toBe(false)
+      expect(isValidRating({})).toBe(false)
+      expect(isValidRating([])).toBe(false)
+      expect(isValidRating(true)).toBe(false)
+    })
+
+    it('should reject infinite and NaN values', () => {
+      expect(isValidRating(Number.POSITIVE_INFINITY)).toBe(false)
+      expect(isValidRating(Number.NEGATIVE_INFINITY)).toBe(false)
+      expect(isValidRating(Number.NaN)).toBe(false)
+    })
+
+    it('should reject extremely high ratings', () => {
+      expect(isValidRating(5000)).toBe(false)
+      expect(isValidRating(10000)).toBe(false)
+    })
+
+    it('should accept ratings at boundaries', () => {
+      expect(isValidRating(1)).toBe(true)
+      expect(isValidRating(4000)).toBe(true)
+    })
+  })
+
+  describe('safeUpdateRating', () => {
+    let mockUpdateFunction: jest.Mock
+
+    beforeEach(() => {
+      mockUpdateFunction = jest.fn()
+      // Mock console.warn to avoid noise in test output
+      jest.spyOn(console, 'warn').mockImplementation(() => {
+        // Do nothing
+      })
+    })
+
+    afterEach(() => {
+      jest.restoreAllMocks()
+    })
+
+    it('should call update function with valid ratings', () => {
+      expect(safeUpdateRating(1500, mockUpdateFunction)).toBe(true)
+      expect(mockUpdateFunction).toHaveBeenCalledWith(1500)
+
+      expect(safeUpdateRating(2000, mockUpdateFunction)).toBe(true)
+      expect(mockUpdateFunction).toHaveBeenCalledWith(2000)
+
+      expect(mockUpdateFunction).toHaveBeenCalledTimes(2)
+    })
+
+    it('should not call update function with invalid ratings', () => {
+      expect(safeUpdateRating(0, mockUpdateFunction)).toBe(false)
+      expect(safeUpdateRating(null, mockUpdateFunction)).toBe(false)
+      expect(safeUpdateRating(undefined, mockUpdateFunction)).toBe(false)
+      expect(safeUpdateRating('1500', mockUpdateFunction)).toBe(false)
+      expect(safeUpdateRating(-100, mockUpdateFunction)).toBe(false)
+
+      expect(mockUpdateFunction).not.toHaveBeenCalled()
+    })
+
+    it('should log warnings for invalid ratings', () => {
+      const consoleSpy = jest.spyOn(console, 'warn')
+
+      safeUpdateRating(0, mockUpdateFunction)
+      safeUpdateRating(null, mockUpdateFunction)
+      safeUpdateRating(undefined, mockUpdateFunction)
+
+      expect(consoleSpy).toHaveBeenCalledTimes(3)
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'Attempted to update rating with invalid value:',
+        0,
+      )
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'Attempted to update rating with invalid value:',
+        null,
+      )
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'Attempted to update rating with invalid value:',
+        undefined,
+      )
+    })
+
+    it('should handle edge cases that might come from API responses', () => {
+      // Test common problematic API response values
+      expect(safeUpdateRating('', mockUpdateFunction)).toBe(false)
+      expect(safeUpdateRating(' ', mockUpdateFunction)).toBe(false)
+      expect(safeUpdateRating(Number.NaN, mockUpdateFunction)).toBe(false)
+      expect(safeUpdateRating({}, mockUpdateFunction)).toBe(false)
+      expect(safeUpdateRating([], mockUpdateFunction)).toBe(false)
+
+      expect(mockUpdateFunction).not.toHaveBeenCalled()
+    })
+  })
+})

package.json

@@ -6,7 +6,7 @@
     "build": "next build",
     "start": "next start",
     "export": "next export",
-    "lint": "eslint . --ext ts,tsx",
+    "lint": "eslint . --ext ts,tsx --fix",
     "test": "jest"
   },
   "dependencies": {
@@ -61,6 +61,7 @@
     "eslint-plugin-react": "^7.28.0",
     "jest": "^30.0.4",
     "jest-environment-jsdom": "^30.0.4",
+    "node-mocks-http": "^1.17.2",
     "postcss": "^8.4.45",
     "prettier": "^3.4.2",
     "prettier-plugin-tailwindcss": "^0.6.6",

src/api/home/activeUsers.ts

@@ -0,0 +1,19 @@
+/**
+ * Get the count of active users in the last 30 minutes
+ * Calls our secure server-side API endpoint that handles PostHog integration
+ */
+export const getActiveUserCount = async (): Promise<number> => {
+  try {
+    const response = await fetch('/api/active-users')
+
+    const data = await response.json()
+
+    if (data.success && typeof data.activeUsers === 'number') {
+      return data.activeUsers
+    }
+  } catch (error) {
+    console.error('Failed to fetch active user count:', error)
+  }
+
+  return 0
+}

src/api/home/index.ts

@@ -1 +1,2 @@
 export * from './home'
+export * from './activeUsers'

src/api/index.ts

@@ -6,3 +6,4 @@ export * from './turing'
 export * from './play'
 export * from './profile'
 export * from './opening'
+export { getActiveUserCount } from './home'