feat: test coverage reached 100%

Author: Mikhus

src/UDPClusterManager.ts

@@ -368,7 +368,10 @@ export class UDPClusterManager extends ClusterManager {
                 if (typeof socket.close === 'function') {
                     socket.removeAllListeners();
                     socket.close(() => {
-                        socket?.unref();
+                        // unref may be missing or not a function on mocked sockets
+                        if (socket && typeof (socket as any).unref === 'function') {
+                            (socket as any).unref();
+                        }
 
                         if (
                             socketKey

test/ClusteredRedisQueue.addServer.defaultInit.spec.ts

@@ -0,0 +1,34 @@
+/*!
+ * ClusteredRedisQueue.addServerWithQueueInitializing default param branch
+ */
+import './mocks';
+import { expect } from 'chai';
+import { ClusteredRedisQueue } from '../src';
+
+describe('ClusteredRedisQueue.addServerWithQueueInitializing() default param', () => {
+    it('should use default initializeQueue=true when second param omitted', async () => {
+        const cq: any = new ClusteredRedisQueue('CQ-Default', {
+            logger: console,
+            cluster: [{ host: '127.0.0.1', port: 6379 }],
+        });
+        // prevent any actual start/subscription side-effects
+        (cq as any).state.started = false;
+        (cq as any).state.subscription = null;
+
+        const server = { host: '192.168.0.1', port: 6380 };
+        const initializedSpy = new Promise<void>((resolve) => {
+            cq['clusterEmitter'].once('initialized', () => resolve());
+        });
+
+        // Call without the second argument to hit default "true" branch
+        (cq as any).addServerWithQueueInitializing(server);
+
+        await initializedSpy; // should emit initialized when default is true
+
+        // Ensure the server added and queue length updated
+        expect((cq as any).servers.some((s: any) => s.host === server.host && s.port === server.port)).to.equal(true);
+        expect((cq as any).queueLength).to.equal((cq as any).imqs.length);
+
+        await cq.destroy();
+    });
+});

test/UDPClusterManager.missing.branches.spec.ts

@@ -0,0 +1,63 @@
+/*!
+ * UDPClusterManager missing branches coverage
+ */
+import './mocks';
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { UDPClusterManager } from '../src';
+
+describe('UDPClusterManager - cover remaining branches', () => {
+    it('serverAliveWait should handle existing.timeout falsy (|| 0) path and remove on timeout', async () => {
+        // Arrange cluster stub
+        const server: any = { host: 'h', port: 1, timer: undefined, timeout: undefined, timestamp: undefined };
+        const cluster: any = {
+            find: sinon.stub().callsFake((_s: any, _strict?: boolean) => server),
+            remove: sinon.stub(),
+        };
+
+        // Use fake timers to control setTimeout and Date
+        const clock = sinon.useFakeTimers();
+        try {
+            // make timestamp truthy
+            clock.tick(1);
+            // Alive correction > 0 ensures timer is scheduled even if timeout is falsy
+            (UDPClusterManager as any).serverAliveWait(cluster, server, 1);
+            // Advance time to trigger setTimeout callback and make delta >= currentTimeout (1ms)
+            clock.tick(2);
+
+            expect(cluster.remove.called).to.equal(true);
+        } finally {
+            clock.restore();
+        }
+    });
+
+    it('destroySocket should call socket.unref() when socket is present', async () => {
+        // Prepare fake socket with unref
+        const unref = sinon.spy();
+        const removeAll = sinon.spy();
+        const sock: any = {
+            removeAllListeners: removeAll,
+            close: (cb: (err?: any) => void) => cb(),
+            unref,
+        };
+        const key = 'test-key';
+        (UDPClusterManager as any).sockets[key] = sock;
+        await (UDPClusterManager as any).destroySocket(key, sock);
+        expect(unref.called).to.equal(true);
+        expect((UDPClusterManager as any).sockets[key]).to.equal(undefined);
+    });
+
+    it('destroySocket should work when socket.unref() is absent (optional chaining negative branch)', async () => {
+        const removeAll = sinon.spy();
+        const sock: any = {
+            removeAllListeners: removeAll,
+            close: (cb: (err?: any) => void) => cb(),
+            // no unref method
+        };
+        const key = 'test-key-2';
+        (UDPClusterManager as any).sockets[key] = sock;
+        await (UDPClusterManager as any).destroySocket(key, sock);
+        // should not throw, sockets map cleaned
+        expect((UDPClusterManager as any).sockets[key]).to.equal(undefined);
+    });
+});

test/UDPClusterManager.serverAliveWait.truthyTimeout.spec.ts

@@ -0,0 +1,25 @@
+/*!
+ * UDPClusterManager serverAliveWait: cover currentTimeout left side (existing.timeout truthy)
+ */
+import './mocks';
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { UDPClusterManager } from '../src';
+
+describe('UDPClusterManager.serverAliveWait truthy timeout', () => {
+    it('should use existing.timeout (truthy) in currentTimeout and remove on expiry', async () => {
+        const server: any = { host: 'h', port: 1, timer: undefined, timeout: 2, timestamp: undefined };
+        const cluster: any = {
+            find: sinon.stub().callsFake((_s: any, _strict?: boolean) => server),
+            remove: sinon.stub(),
+        };
+        const clock = sinon.useFakeTimers();
+        try {
+            (UDPClusterManager as any).serverAliveWait(cluster, server, 0);
+            clock.tick(3);
+            expect(cluster.remove.called).to.equal(true);
+        } finally {
+            clock.restore();
+        }
+    });
+});