feat: add more tests to improve test coverage

Author: Mikhus

test/ClusteredRedisQueue.addServer.noInit.spec.ts

@@ -0,0 +1,32 @@
+/*!
+ * Cover ClusteredRedisQueue.addServerWithQueueInitializing with initializeQueue=false
+ */
+import './mocks';
+import { expect } from 'chai';
+import { ClusteredRedisQueue } from '../src';
+import { ClusterManager } from '../src/ClusterManager';
+
+const server = { host: '127.0.0.1', port: 6380 };
+
+describe('ClusteredRedisQueue.addServerWithQueueInitializing(false)', () => {
+    it('should add server without initializing queue and not emit initialized', async () => {
+        const manager = new (ClusterManager as any)();
+        const cq: any = new ClusteredRedisQueue('NoInit', { clusterManagers: [manager] });
+
+        let initializedCalled = false;
+        (cq as any).clusterEmitter.on('initialized', () => { initializedCalled = true; });
+
+        // call private method via any to cover branch
+        (cq as any).addServerWithQueueInitializing(server, false);
+
+        // should have server and imq added
+        expect(cq.servers.length).to.be.greaterThan(0);
+        expect(cq.imqs.length).to.be.greaterThan(0);
+        // queueLength updated
+        expect(cq.queueLength).to.equal(cq.imqs.length);
+        // initialized not emitted
+        expect(initializedCalled).to.equal(false);
+
+        await cq.destroy();
+    });
+});

test/UDPClusterManager.destroySocket.spec.ts

@@ -0,0 +1,51 @@
+/*!
+ * UDPClusterManager.destroySocket() branch coverage tests
+ */
+import './mocks';
+import { expect } from 'chai';
+import { UDPClusterManager } from '../src';
+
+describe('UDPClusterManager.destroySocket()', () => {
+    it('should resolve when socket has no close() function', async () => {
+        const destroy = (UDPClusterManager as any).destroySocket as Function;
+        const fakeSocket: any = { /* no close, no removeAllListeners */ };
+
+        await destroy('0.0.0.0:63000', fakeSocket);
+    });
+
+    it('should reject when removeAllListeners throws inside try-block', async () => {
+        const destroy = (UDPClusterManager as any).destroySocket as Function;
+        const fakeSocket: any = {
+            removeAllListeners: () => { throw new Error('boom'); },
+            close: (cb: Function) => cb && cb(),
+        };
+
+        let thrown = null as any;
+        try {
+            await destroy('1.1.1.1:63000', fakeSocket);
+        } catch (e) {
+            thrown = e;
+        }
+        expect(thrown).to.be.instanceOf(Error);
+        expect((thrown as Error).message).to.equal('boom');
+    });
+
+    it('should remove socket entry and unref after successful close()', async () => {
+        const destroy = (UDPClusterManager as any).destroySocket as Function;
+        const sockets = (UDPClusterManager as any).sockets as Record<string, any>;
+        const key = '9.9.9.9:65000';
+
+        let unrefCalled = false;
+        const fakeSocket: any = {
+            removeAllListeners: () => {},
+            close: (cb: Function) => cb && cb(),
+            unref: () => { unrefCalled = true; },
+        };
+
+        sockets[key] = fakeSocket;
+        await destroy(key, fakeSocket);
+
+        expect(unrefCalled).to.equal(true);
+        expect(sockets[key]).to.be.undefined;
+    });
+});

test/UDPClusterManager.extra.branches.spec.ts

@@ -0,0 +1,89 @@
+/*!
+ * Additional branch coverage for UDPClusterManager
+ */
+import './mocks';
+import { expect } from 'chai';
+import { UDPClusterManager } from '../src';
+
+describe('UDPClusterManager additional branches', () => {
+    describe('processMessageOnCluster added-path', () => {
+        const processMessageOnCluster = (UDPClusterManager as any).processMessageOnCluster as any;
+
+        it('should call serverAliveWait when server is added and found (added truthy)', async () => {
+            const calls: any[] = [];
+            const addedServer: any = { id: 'id', host: '127.0.0.1', port: 6379 };
+            const cluster: any = {
+                add: (message: any) => { calls.push(['add', message]); },
+                find: (message: any, strict?: boolean) => strict ? addedServer : undefined,
+            };
+            const original = (UDPClusterManager as any).serverAliveWait;
+            let waited = false;
+            (UDPClusterManager as any).serverAliveWait = (...args: any[]) => {
+                waited = true;
+            };
+
+            processMessageOnCluster(cluster, { id: 'id', name: 'n', type: 'up', host: 'h', port: 1, timeout: 0 }, 5);
+
+            // allow microtask queue
+            await new Promise(res => setTimeout(res, 0));
+
+            expect(waited).to.equal(true);
+            // restore
+            (UDPClusterManager as any).serverAliveWait = original;
+        });
+
+        it('should not call serverAliveWait when added not found', async () => {
+            const cluster: any = {
+                add: (_: any) => undefined,
+                find: (_: any, __?: boolean) => undefined,
+            };
+            const original = (UDPClusterManager as any).serverAliveWait;
+            let waited = false;
+            (UDPClusterManager as any).serverAliveWait = () => { waited = true; };
+
+            processMessageOnCluster(cluster, { id: 'id', name: 'n', type: 'up', host: 'h', port: 1, timeout: 0 }, 5);
+            await new Promise(res => setTimeout(res, 0));
+
+            expect(waited).to.equal(false);
+            (UDPClusterManager as any).serverAliveWait = original;
+        });
+    });
+
+    describe('serverAliveWait branches', () => {
+        const serverAliveWait = (UDPClusterManager as any).serverAliveWait as any;
+
+        it('should return early when computed timeout is <= 0', () => {
+            const cluster: any = { find: () => ({}) };
+            const server: any = {};
+
+            serverAliveWait(cluster, server, 0); // no message and correction 0 => timeout 0
+
+            expect(server.timer).to.equal(undefined);
+        });
+
+        it('should remove when no timestamp is present on existing (timer callback path)', (done) => {
+            const removed: any[] = [];
+            const server: any = { timeout: 0 };
+            const cluster: any = {
+                find: () => server,
+                remove: (s: any) => { removed.push(s); },
+            };
+
+            // use small correction to trigger timeout quickly
+            serverAliveWait(cluster, server, 1);
+
+            // wipe timestamp before timeout fires to force the branch
+            server.timestamp = undefined;
+
+            setTimeout(() => {
+                try {
+                    expect(removed.length).to.equal(1);
+                    expect(server.timer).to.equal(undefined);
+                    done();
+                } catch (e) {
+                    done(e as any);
+                }
+            }, 10);
+        });
+    });
+});