test: add API network function tests with axios mock, socket.io test, /add not-found test

- Unit test all 7 remaining API.js functions (getContributorAvatar, getContributorInfo,
  getRepositories, getOpenPRsNumber, getMergedPRsNumber, getIssuesNumber, checkRateLimit)
  with axios mocked at the correct module path
- Add error handling tests: Bad credentials, ECONNABORTED timeout, rate limit, network errors
- Test getRepositories pagination (100+ repos across pages)
- Test getContributorInfo multi-repo URL construction and chore label exclusion
- Add socket.io e2e: verify 'refresh table' event with contributor data, disconnect cleanup
- Add /add 'Not found' e2e test for non-existent GitHub user

Author: amitb0ra

tests/e2e/server.e2e.test.js

@@ -510,6 +510,14 @@ describe('Server E2E Tests', () => {
             })
             assert.deepStrictEqual(res.body, { message: 'dhairyashiil aready exists' })
         })
+
+        test('returns "Not found" for non-existent GitHub user', async () => {
+            const res = await request(TEST_PORT, '/add', {
+                method: 'POST',
+                body: { token: TEST_ADMIN_PASSWORD, username: 'this-user-definitely-does-not-exist-99999' },
+            })
+            assert.deepStrictEqual(res.body, { message: 'Not found' })
+        })
     })
 
     describe('GET /getRepositories', () => {

tests/e2e/socket.e2e.test.js

@@ -0,0 +1,78 @@
+const { describe, test, before, after } = require('node:test')
+const assert = require('node:assert/strict')
+const {
+    startServer,
+    stopServer,
+    TEST_PORT,
+} = require('./setup')
+
+describe('Socket.io E2E Tests', () => {
+    let io
+
+    before(async () => {
+        await startServer()
+        // Dynamic import of socket.io-client (installed in root package.json)
+        io = require('socket.io-client')
+    })
+
+    after(async () => {
+        await stopServer()
+    })
+
+    test('client receives "refresh table" event with data object', async () => {
+        const socket = io(`http://127.0.0.1:${TEST_PORT}`, {
+            transports: ['websocket'],
+            reconnection: false,
+        })
+
+        try {
+            const data = await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    reject(new Error('Timed out waiting for "refresh table" event (20s)'))
+                }, 20000)
+
+                socket.on('refresh table', (obj) => {
+                    clearTimeout(timeout)
+                    resolve(obj)
+                })
+
+                socket.on('connect_error', (err) => {
+                    clearTimeout(timeout)
+                    reject(new Error('Socket connect error: ' + err.message))
+                })
+            })
+
+            assert.strictEqual(typeof data, 'object')
+            assert.ok(Object.keys(data).length > 0, 'refresh table data should not be empty')
+            // Verify it looks like contributor data
+            const firstKey = Object.keys(data)[0]
+            assert.ok('openPRsNumber' in data[firstKey], 'data should contain contributor objects')
+        } finally {
+            socket.disconnect()
+        }
+    })
+
+    test('server cleans up interval on disconnect', async () => {
+        const socket = io(`http://127.0.0.1:${TEST_PORT}`, {
+            transports: ['websocket'],
+            reconnection: false,
+        })
+
+        await new Promise((resolve, reject) => {
+            socket.on('connect', resolve)
+            socket.on('connect_error', reject)
+        })
+
+        // Disconnect and verify no errors
+        socket.disconnect()
+
+        // Give the server a moment to clean up
+        await new Promise((resolve) => setTimeout(resolve, 200))
+
+        // If disconnection cleanup failed, the server would crash on next interval tick
+        // Verify the server is still responsive
+        const { request } = require('./helpers')
+        const res = await request(TEST_PORT, '/stats')
+        assert.strictEqual(res.status, 200)
+    })
+})

tests/unit/api-network.unit.test.js

@@ -0,0 +1,254 @@
+const { describe, test, afterEach } = require('node:test')
+const assert = require('node:assert/strict')
+const path = require('path')
+
+// Load API module with a dummy config
+process.env.LEADERBOARD_CONFIG_PATH = path.resolve(
+    __dirname,
+    '../e2e/fixtures/config.json'
+)
+const API = require(path.resolve(__dirname, '../../src/server/util/API'))
+
+// Resolve axios from the same location API.js uses (src/server/node_modules/axios)
+const axiosPath = require.resolve('axios', {
+    paths: [path.resolve(__dirname, '../../src/server/util')]
+})
+const axios = require(axiosPath)
+
+// Store original axios.get so we can restore it after each test
+const originalGet = axios.get
+
+afterEach(() => {
+    axios.get = originalGet
+})
+
+// Helper: mock axios.get to return a given response for any URL
+function mockAxiosGet(response) {
+    axios.get = async () => response
+}
+
+// Helper: mock axios.get to reject with a given error
+function mockAxiosGetError(error) {
+    axios.get = async () => { throw error }
+}
+
+// Helper: mock axios.get to return different responses per URL pattern
+function mockAxiosGetByUrl(mapping) {
+    axios.get = async (url) => {
+        for (const [pattern, response] of Object.entries(mapping)) {
+            if (url.includes(pattern)) return response
+        }
+        throw new Error(`Unmocked URL: ${url}`)
+    }
+}
+
+describe('API.checkRateLimit', () => {
+    test('returns avatar_url on success', async () => {
+        mockAxiosGet({ data: { avatar_url: 'https://example.com/avatar.png' } })
+        const result = await API.checkRateLimit()
+        assert.strictEqual(result, 'https://example.com/avatar.png')
+    })
+
+    test('returns empty object when API fails', async () => {
+        mockAxiosGetError({ code: 'ECONNABORTED' })
+        const result = await API.checkRateLimit()
+        assert.deepStrictEqual(result, {})
+    })
+})
+
+describe('API.getContributorAvatar', () => {
+    test('returns avatar URL on success', async () => {
+        mockAxiosGet({ data: { avatar_url: 'https://avatars.githubusercontent.com/u/123?v=4' } })
+        const result = await API.getContributorAvatar('testuser')
+        assert.strictEqual(result, 'https://avatars.githubusercontent.com/u/123?v=4')
+    })
+
+    test('returns empty string when API fails', async () => {
+        mockAxiosGetError({ response: { data: { message: 'Not Found' } } })
+        const result = await API.getContributorAvatar('nonexistent')
+        assert.strictEqual(result, '')
+    })
+
+    test('returns empty string on timeout', async () => {
+        mockAxiosGetError({ code: 'ECONNABORTED' })
+        const result = await API.getContributorAvatar('testuser')
+        assert.strictEqual(result, '')
+    })
+})
+
+describe('API.getOpenPRsNumber', () => {
+    test('returns total_count on success', async () => {
+        mockAxiosGet({ data: { total_count: 42 } })
+        const result = await API.getOpenPRsNumber('/search/issues?q=test')
+        assert.strictEqual(result, 42)
+    })
+
+    test('returns 0 for zero open PRs', async () => {
+        mockAxiosGet({ data: { total_count: 0 } })
+        const result = await API.getOpenPRsNumber('/search/issues?q=test')
+        assert.strictEqual(result, 0)
+    })
+
+    test('returns -1 when API fails', async () => {
+        mockAxiosGetError({ response: { data: { message: 'Bad credentials' } } })
+        const result = await API.getOpenPRsNumber('/search/issues?q=test')
+        assert.strictEqual(result, -1)
+    })
+})
+
+describe('API.getMergedPRsNumber', () => {
+    test('returns total_count on success', async () => {
+        mockAxiosGet({ data: { total_count: 15 } })
+        const result = await API.getMergedPRsNumber('/search/issues?q=test')
+        assert.strictEqual(result, 15)
+    })
+
+    test('returns -1 when API fails', async () => {
+        mockAxiosGetError({ code: 'ECONNABORTED' })
+        const result = await API.getMergedPRsNumber('/search/issues?q=test')
+        assert.strictEqual(result, -1)
+    })
+})
+
+describe('API.getIssuesNumber', () => {
+    test('returns total_count on success', async () => {
+        mockAxiosGet({ data: { total_count: 7 } })
+        const result = await API.getIssuesNumber('/search/issues?q=test')
+        assert.strictEqual(result, 7)
+    })
+
+    test('returns -1 when API fails', async () => {
+        mockAxiosGetError({ response: { data: { message: 'rate limit exceeded' } } })
+        const result = await API.getIssuesNumber('/search/issues?q=test')
+        assert.strictEqual(result, -1)
+    })
+})
+
+describe('API.getContributorInfo', () => {
+    test('returns full contributor info on success', async () => {
+        mockAxiosGetByUrl({
+            '/users/alice': { data: { avatar_url: 'https://avatars.githubusercontent.com/u/1?v=4' } },
+            'is:Open': { data: { total_count: 3 } },
+            'is:Merged': { data: { total_count: 5 } },
+            'is:issue': { data: { total_count: 2 } },
+        })
+
+        const result = await API.getContributorInfo('TestOrg', 'alice', ['repo1'])
+
+        assert.strictEqual(result.home, 'https://github.com/alice')
+        assert.strictEqual(result.avatarUrl, 'https://avatars.githubusercontent.com/u/1?v=4')
+        assert.strictEqual(result.openPRsNumber, 3)
+        assert.strictEqual(result.mergedPRsNumber, 5)
+        assert.strictEqual(result.issuesNumber, 2)
+        assert.ok(result.openPRsLink.includes('alice'))
+        assert.ok(result.openPRsLink.includes('repo1'))
+        assert.ok(result.mergedPRsLink.includes('alice'))
+        assert.ok(result.issuesLink.includes('alice'))
+        // Verify chore exclusion label is in links
+        assert.ok(result.openPRsLink.includes('-label:chore'))
+        assert.ok(result.mergedPRsLink.includes('-label:chore'))
+        assert.ok(result.issuesLink.includes('-label:chore'))
+    })
+
+    test('includes multiple repos in search URLs', async () => {
+        mockAxiosGetByUrl({
+            '/users/bob': { data: { avatar_url: 'https://example.com/bob.png' } },
+            'is:Open': { data: { total_count: 1 } },
+            'is:Merged': { data: { total_count: 2 } },
+            'is:issue': { data: { total_count: 0 } },
+        })
+
+        const result = await API.getContributorInfo('Org', 'bob', ['repo1', 'repo2'])
+
+        assert.ok(result.openPRsLink.includes('repo:Org/repo1'))
+        assert.ok(result.openPRsLink.includes('repo:Org/repo2'))
+        assert.ok(result.mergedPRsLink.includes('repo:Org/repo1'))
+        assert.ok(result.mergedPRsLink.includes('repo:Org/repo2'))
+        assert.ok(result.issuesLink.includes('repo:Org/repo1'))
+        assert.ok(result.issuesLink.includes('repo:Org/repo2'))
+    })
+
+    test('returns -1 counts when API calls fail', async () => {
+        axios.get = async (url) => {
+            if (url.includes('/users/')) {
+                return { data: { avatar_url: '' } }
+            }
+            throw { response: { data: { message: 'API rate limit exceeded' } } }
+        }
+
+        const result = await API.getContributorInfo('Org', 'failuser', ['repo1'])
+
+        assert.strictEqual(result.avatarUrl, '')
+        assert.strictEqual(result.openPRsNumber, -1)
+        assert.strictEqual(result.mergedPRsNumber, -1)
+        assert.strictEqual(result.issuesNumber, -1)
+    })
+})
+
+describe('API.getRepositories', () => {
+    test('returns repos from a single page (< 100 repos)', async () => {
+        mockAxiosGet({
+            data: [
+                { name: 'Rocket.Chat' },
+                { name: 'fuselage' },
+                { name: 'docs' },
+            ],
+        })
+
+        const result = await API.getRepositories('RocketChat')
+        // getRepositories returns results.push(repositories) so it's nested
+        assert.deepStrictEqual(result, [['Rocket.Chat', 'fuselage', 'docs']])
+    })
+
+    test('paginates when first page has 100+ repos', async () => {
+        const page1 = Array.from({ length: 100 }, (_, i) => ({ name: `repo-${i}` }))
+        const page2 = [{ name: 'repo-100' }, { name: 'repo-101' }]
+        let callNum = 0
+
+        axios.get = async (_url) => {
+            callNum++
+            if (callNum === 1) return { data: page1 }
+            return { data: page2 }
+        }
+
+        const result = await API.getRepositories('TestOrg')
+        assert.strictEqual(result.length, 2) // two pages
+        assert.strictEqual(result[0].length, 100)
+        assert.strictEqual(result[1].length, 2)
+        assert.strictEqual(result[1][1], 'repo-101')
+    })
+
+    test('returns empty string pages when API fails', async () => {
+        mockAxiosGetError({ code: 'ECONNABORTED' })
+
+        const result = await API.getRepositories('FailOrg')
+        // fetchRepositories returns '' on failure, length <= 99 stops pagination
+        assert.deepStrictEqual(result, [''])
+    })
+})
+
+describe('API internal error handling', () => {
+    test('handles Bad credentials error without crashing', async () => {
+        mockAxiosGetError({ response: { data: { message: 'Bad credentials' } } })
+        const result = await API.getContributorAvatar('testuser')
+        assert.strictEqual(result, '')
+    })
+
+    test('handles ECONNABORTED timeout', async () => {
+        mockAxiosGetError({ code: 'ECONNABORTED' })
+        const result = await API.getContributorAvatar('testuser')
+        assert.strictEqual(result, '')
+    })
+
+    test('handles generic error with response message', async () => {
+        mockAxiosGetError({ response: { data: { message: 'API rate limit exceeded' } } })
+        const result = await API.getOpenPRsNumber('/search/issues?q=test')
+        assert.strictEqual(result, -1)
+    })
+
+    test('handles error without response object', async () => {
+        mockAxiosGetError(new Error('Network error'))
+        const result = await API.getMergedPRsNumber('/search/issues?q=test')
+        assert.strictEqual(result, -1)
+    })
+})