test: fill remaining coverage gaps — findContributor, multi-chunk POST, edge cases

- Extract findContributor() from app.js to Util.js for direct unit testing
- Add findContributor unit tests: match, no match, empty array, case sensitivity, duplicates
- Add Util.post multi-chunk body test and UTF-8 multi-byte character test
- Add /remove non-existent user e2e test (documents silent-success behavior)
- Add getContributorInfo edge cases: empty includedRepositories, startDate in URLs
- Add getRepositories boundary tests: exactly 100 repos, empty org (0 repos)

Author: amitb0ra

src/server/app.js

@@ -427,14 +427,4 @@ io.on('connection', (socket) => {
     })
 })
 
-function findContributor(contributorName, admindata) {
-    let result = null
-
-    admindata.forEach((contributor) => {
-        if (contributor.username === contributorName) {
-            result = contributor
-        }
-    })
-
-    return result
-}
+const findContributor = Util.findContributor

src/server/util/Util.js

@@ -17,6 +17,19 @@ function post(req, res, callback) {
     }
 }
 
+function findContributor(contributorName, admindata) {
+    let result = null
+
+    admindata.forEach((contributor) => {
+        if (contributor.username === contributorName) {
+            result = contributor
+        }
+    })
+
+    return result
+}
+
 module.exports = {
-    post
+    post,
+    findContributor
 }

tests/e2e/server.e2e.test.js

@@ -487,6 +487,21 @@ describe('Server E2E Tests', () => {
             const contribRes = await request(TEST_PORT, '/contributor?username=PavanTaddi9')
             assert.deepStrictEqual(contribRes.body, { error: 'Contributor PavanTaddi9 doesn\'t exist' })
         })
+
+        test('removing non-existent user still returns Success', async () => {
+            const beforeData = await request(TEST_PORT, '/data')
+            const countBefore = Object.keys(beforeData.body).length
+
+            const res = await request(TEST_PORT, '/remove', {
+                method: 'POST',
+                body: { token: TEST_ADMIN_PASSWORD, username: 'TOTALLY_FAKE_USER' },
+            })
+            assert.deepStrictEqual(res.body, { message: 'Success' })
+
+            // Data should be unchanged since user didn't exist
+            const afterData = await request(TEST_PORT, '/data')
+            assert.strictEqual(Object.keys(afterData.body).length, countBefore)
+        })
     })
 
     describe('POST /add', () => {

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

@@ -183,6 +183,44 @@ describe('API.getContributorInfo', () => {
         assert.strictEqual(result.mergedPRsNumber, -1)
         assert.strictEqual(result.issuesNumber, -1)
     })
+
+    test('handles empty includedRepositories array', async () => {
+        mockAxiosGetByUrl({
+            '/users/alice': { data: { avatar_url: 'https://example.com/a.png' } },
+            'is:Open': { data: { total_count: 1 } },
+            'is:Merged': { data: { total_count: 2 } },
+            'is:issue': { data: { total_count: 3 } },
+        })
+
+        const result = await API.getContributorInfo('Org', 'alice', [])
+
+        assert.strictEqual(result.openPRsNumber, 1)
+        assert.strictEqual(result.mergedPRsNumber, 2)
+        assert.strictEqual(result.issuesNumber, 3)
+        // With empty repos, URLs should not contain any repo: filter
+        assert.ok(!result.openPRsLink.includes('repo:'))
+        assert.ok(!result.mergedPRsLink.includes('repo:'))
+        assert.ok(!result.issuesLink.includes('repo:'))
+        // But should still have chore exclusion
+        assert.ok(result.openPRsLink.includes('-label:chore'))
+    })
+
+    test('uses startDate from config in URLs', async () => {
+        let capturedUrls = []
+        axios.get = async (url) => {
+            capturedUrls.push(url)
+            if (url.includes('/users/')) return { data: { avatar_url: 'https://example.com/a.png' } }
+            return { data: { total_count: 0 } }
+        }
+
+        await API.getContributorInfo('Org', 'alice', ['repo1'])
+
+        // Config fixture has startDate: '2024-12-01'
+        const searchUrls = capturedUrls.filter(u => u.includes('/search/'))
+        for (const url of searchUrls) {
+            assert.ok(url.includes('2024-12-01'), `URL should contain startDate: ${url}`)
+        }
+    })
 })
 
 describe('API.getRepositories', () => {
@@ -225,6 +263,30 @@ describe('API.getRepositories', () => {
         // fetchRepositories returns '' on failure, length <= 99 stops pagination
         assert.deepStrictEqual(result, [''])
     })
+
+    test('exactly 100 repos triggers another page fetch', async () => {
+        const page1 = Array.from({ length: 100 }, (_, i) => ({ name: `repo-${i}` }))
+        const page2 = [] // empty page means no more repos
+        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) // fetched 2 pages
+        assert.strictEqual(result[0].length, 100)
+        assert.strictEqual(result[1].length, 0) // empty second page
+    })
+
+    test('returns empty result for org with no repos', async () => {
+        mockAxiosGet({ data: [] })
+
+        const result = await API.getRepositories('EmptyOrg')
+        assert.deepStrictEqual(result, [[]])
+    })
 })
 
 describe('API internal error handling', () => {

tests/unit/util.unit.test.js

@@ -126,4 +126,80 @@ describe('Util.post', () => {
             })
         })
     })
+
+    test('handles multi-chunk POST body', async () => {
+        const req = new EventEmitter()
+        req.method = 'POST'
+        const res = mockRes()
+        const fullBody = { key: 'value', nested: { a: 1 } }
+        const json = JSON.stringify(fullBody)
+        const mid = Math.floor(json.length / 2)
+
+        process.nextTick(() => {
+            req.emit('data', Buffer.from(json.slice(0, mid)))
+            req.emit('data', Buffer.from(json.slice(mid)))
+            req.emit('end')
+        })
+
+        await new Promise((resolve) => {
+            Util.post(req, res, (params) => {
+                assert.deepStrictEqual(params, fullBody)
+                resolve()
+            })
+        })
+    })
+
+    test('handles UTF-8 multi-byte characters in JSON', async () => {
+        const body = { name: '日本語テスト', emoji: '🚀' }
+        const req = mockReq('POST', JSON.stringify(body))
+        const res = mockRes()
+
+        await new Promise((resolve) => {
+            Util.post(req, res, (params) => {
+                assert.deepStrictEqual(params, body)
+                resolve()
+            })
+        })
+    })
+})
+
+describe('Util.findContributor', () => {
+    test('returns matching contributor object', () => {
+        const admindata = [
+            { username: 'alice', avatarUrl: 'https://example.com/alice.png' },
+            { username: 'bob', avatarUrl: 'https://example.com/bob.png' },
+        ]
+        const result = Util.findContributor('bob', admindata)
+        assert.deepStrictEqual(result, { username: 'bob', avatarUrl: 'https://example.com/bob.png' })
+    })
+
+    test('returns null for non-existent contributor', () => {
+        const admindata = [
+            { username: 'alice', avatarUrl: 'https://example.com/alice.png' },
+        ]
+        const result = Util.findContributor('nonexistent', admindata)
+        assert.strictEqual(result, null)
+    })
+
+    test('returns null for empty admindata array', () => {
+        const result = Util.findContributor('alice', [])
+        assert.strictEqual(result, null)
+    })
+
+    test('is case-sensitive', () => {
+        const admindata = [
+            { username: 'Alice', avatarUrl: 'https://example.com/alice.png' },
+        ]
+        assert.strictEqual(Util.findContributor('alice', admindata), null)
+        assert.notStrictEqual(Util.findContributor('Alice', admindata), null)
+    })
+
+    test('returns last match if duplicates exist', () => {
+        const admindata = [
+            { username: 'alice', avatarUrl: 'first' },
+            { username: 'alice', avatarUrl: 'second' },
+        ]
+        const result = Util.findContributor('alice', admindata)
+        assert.strictEqual(result.avatarUrl, 'second')
+    })
 })