feat: add more tests to improve coverage

Author: Mikhus

test/RedisQueue.send.worker.mode.spec.ts

@@ -0,0 +1,36 @@
+/*!
+ * Additional RedisQueue tests: send() worker-only mode error
+ */
+import './mocks';
+import { expect } from 'chai';
+import { RedisQueue, IMQMode } from '../src';
+
+function makeLogger() {
+    return {
+        log: (..._args: any[]) => undefined,
+        info: (..._args: any[]) => undefined,
+        warn: (..._args: any[]) => undefined,
+        error: (..._args: any[]) => undefined,
+    } as any;
+}
+
+describe('RedisQueue.send() worker-only mode', function() {
+    this.timeout(10000);
+
+    it('should throw when called in WORKER only mode', async () => {
+        const logger = makeLogger();
+        const rq: any = new RedisQueue('WorkerOnly', { logger }, IMQMode.WORKER);
+
+        let thrown: any;
+        try {
+            await rq.send('AnyQueue', { test: true });
+        } catch (err) {
+            thrown = err;
+        }
+
+        expect(thrown).to.be.instanceof(TypeError);
+        expect(`${thrown}`).to.include('WORKER only mode');
+
+        await rq.destroy().catch(() => undefined);
+    });
+});

test/RedisQueue.unsubscribe.spec.ts

@@ -0,0 +1,53 @@
+/*!
+ * Additional RedisQueue tests: unsubscribe() cleanup path
+ */
+import './mocks';
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { RedisQueue } from '../src';
+
+function makeLogger() {
+    return {
+        log: (..._args: any[]) => undefined,
+        info: (..._args: any[]) => undefined,
+        warn: (..._args: any[]) => undefined,
+        error: (..._args: any[]) => undefined,
+    } as any;
+}
+
+describe('RedisQueue.unsubscribe()', function() {
+    this.timeout(10000);
+
+    it('should cleanup subscription channel when present', async () => {
+        const logger = makeLogger();
+        const rq: any = new RedisQueue('SubUnsub', { logger });
+        await rq.start();
+
+        const handler = sinon.spy();
+        await rq.subscribe('SubUnsub', handler);
+
+        expect(rq.subscription).to.be.ok;
+        expect(rq.subscriptionName).to.equal('SubUnsub');
+
+        const unsubSpy = sinon.spy(rq.subscription, 'unsubscribe');
+        const ralSpy = sinon.spy(rq.subscription, 'removeAllListeners');
+        const disconnectSpy = sinon.spy(rq.subscription, 'disconnect');
+        const quitSpy = sinon.spy(rq.subscription, 'quit');
+
+        await rq.unsubscribe();
+
+        expect(unsubSpy.calledOnce).to.equal(true);
+        expect(ralSpy.calledOnce).to.equal(true);
+        expect(disconnectSpy.calledOnce).to.equal(true);
+        expect(quitSpy.calledOnce).to.equal(true);
+        expect(rq.subscription).to.equal(undefined);
+        expect(rq.subscriptionName).to.equal(undefined);
+
+        unsubSpy.restore();
+        ralSpy.restore();
+        disconnectSpy.restore();
+        quitSpy.restore();
+
+        await rq.destroy().catch(() => undefined);
+    });
+});

test/UDPClusterManager.free.spec.ts

@@ -0,0 +1,27 @@
+/*!
+ * UDPClusterManager.free() coverage test
+ */
+import './mocks';
+import { expect } from 'chai';
+
+describe('UDPClusterManager.free()', () => {
+    it('should destroy all sockets via destroySocket and clear sockets map', async () => {
+        const { UDPClusterManager } = await import('../src');
+        const sockets = (UDPClusterManager as any).sockets as Record<string, any>;
+        // prepare two mock sockets
+        sockets['0.0.0.0:5555'] = {
+            removeAllListeners: () => {},
+            close: (cb: Function) => cb(),
+            unref: () => {},
+        };
+        sockets['0.0.0.0:6666'] = {
+            removeAllListeners: () => {},
+            close: (cb: Function) => cb(),
+            unref: () => {},
+        };
+
+        await (UDPClusterManager as any).free();
+
+        expect(Object.keys((UDPClusterManager as any).sockets)).to.have.length(0);
+    });
+});