feat: add more tests to improve coverage

Author: Mikhus

test/RedisQueue.processCleanup.extra.spec.ts

@@ -0,0 +1,38 @@
+/*!
+ * Additional RedisQueue tests for processCleanup branches
+ */
+import './mocks';
+import { expect } from 'chai';
+import { RedisQueue, uuid } from '../src';
+import { RedisClientMock } from './mocks';
+
+describe('RedisQueue.processCleanup extra branches', function() {
+    this.timeout(5000);
+
+    it('should remove scanned keys that do not match any connectedKey (different prefix)', async () => {
+        const name = uuid();
+        const rq: any = new RedisQueue(name, {
+            logger: console,
+            cleanup: true,
+            prefix: 'imqX',
+            cleanupFilter: '*',
+        });
+
+        // start to create reader/writer/watcher with connection names
+        await rq.start();
+
+        // Create an orphan worker key with a different prefix so it won't include any connectedKey
+        const orphanKey = 'imqY:orphan:worker:someuuid:123456';
+        (RedisClientMock as any).__queues__[orphanKey] = ['payload'];
+
+        // Sanity: ensure the key is present before cleanup
+        expect((RedisClientMock as any).__queues__[orphanKey]).to.be.ok;
+
+        await rq.processCleanup();
+
+        // The orphan key should be deleted by cleanup (true branch of keysToRemove filter)
+        expect((RedisClientMock as any).__queues__[orphanKey]).to.be.undefined;
+
+        await rq.destroy();
+    });
+});

test/UDPClusterManager.selectNetworkInterface.spec.ts

@@ -0,0 +1,46 @@
+/*!
+ * UDPClusterManager.selectNetworkInterface() branch coverage tests
+ */
+import './mocks';
+import { expect } from 'chai';
+import * as mock from 'mock-require';
+
+describe('UDPClusterManager.selectNetworkInterface()', () => {
+    it('should return default when broadcastAddress is undefined', async () => {
+        const { UDPClusterManager } = await import('../src');
+        const select = (UDPClusterManager as any).selectNetworkInterface as Function;
+        const res = select({});
+        expect(res).to.equal('0.0.0.0');
+    });
+
+    it('should return default when broadcastAddress equals limitedBroadcastAddress', async () => {
+        const { UDPClusterManager } = await import('../src');
+        const select = (UDPClusterManager as any).selectNetworkInterface as Function;
+        const res = select({ broadcastAddress: '127.0.0.255', limitedBroadcastAddress: '127.0.0.255' });
+        expect(res).to.equal('0.0.0.0');
+    });
+
+    it('should continue on undefined interface entry and still select matching address', () => {
+        // Re-mock os.networkInterfaces to include an undefined entry
+        const os = require('node:os');
+        const networkInterfaces = () => ({ bad: undefined, lo: [{ address: '127.0.0.1', family: 'IPv4' }] });
+        mock.stop('os');
+        mock('os', Object.assign({}, os, { networkInterfaces }));
+        // Re-require the module to capture new binding
+        const { UDPClusterManager } = mock.reRequire('../src/UDPClusterManager');
+        const res = (UDPClusterManager as any).selectNetworkInterface({ broadcastAddress: '127.0.0.255', limitedBroadcastAddress: '255.255.255.255' });
+        expect(res).to.equal('127.0.0.1');
+
+        // restore to base mocks for other tests
+        mock.stop('os');
+        mock.reRequire('./mocks/os');
+        mock.reRequire('../src/UDPClusterManager');
+    });
+
+    it('should select matching interface address when not equal to limited broadcast', async () => {
+        const { UDPClusterManager } = await import('../src');
+        const select = (UDPClusterManager as any).selectNetworkInterface as Function;
+        const res = select({ broadcastAddress: '127.0.0.255', limitedBroadcastAddress: '255.255.255.255' });
+        expect(res).to.equal('127.0.0.1');
+    });
+});