feat: add more tests to improve coverage

Author: Mikhus

test/RedisQueue.connect.fallbacks.spec.ts

@@ -0,0 +1,40 @@
+/*!
+ * Additional RedisQueue tests: connect() option fallbacks branches
+ */
+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.connect() option fallbacks', function() {
+    this.timeout(10000);
+
+    it('should use fallback values when falsy options are provided', async () => {
+        const logger = makeLogger();
+        // Intentionally provide falsy values to trigger `||` fallbacks in connect()
+        const rq: any = new RedisQueue('ConnFallbacks', {
+            logger,
+            port: 0 as unknown as number,   // falsy to trigger 6379 fallback
+            host: '' as unknown as string,  // falsy to trigger 'localhost' fallback
+            prefix: '' as unknown as string, // falsy to trigger '' fallback in connectionName
+            cleanup: false,
+        }, IMQMode.BOTH);
+
+        await rq.start();
+
+        // Basic sanity: writer/reader/watcher are created
+        expect(Boolean(rq.writer)).to.equal(true);
+        expect(Boolean(rq.reader)).to.equal(true);
+        expect(Boolean(rq.watcher)).to.equal(true);
+
+        await rq.destroy();
+    });
+});

test/RedisQueue.processCleanup.clientsFilter.spec.ts

@@ -0,0 +1,53 @@
+/*!
+ * Additional RedisQueue tests: processCleanup connectedKeys filter branches
+ */
+import './mocks';
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { RedisQueue, uuid } from '../src';
+
+describe('RedisQueue.processCleanup connectedKeys RX/filter combinations', function() {
+    this.timeout(5000);
+
+    it('should handle RX_CLIENT_TEST true but filter false case (exclude unmatched prefix)', async () => {
+        const name = `PCleanRX_${uuid()}`;
+        const rq: any = new RedisQueue(name, {
+            logger: console,
+            cleanup: true,
+            prefix: 'imqA',
+            cleanupFilter: '*',
+        });
+
+        await rq.start();
+
+        const writer: any = rq.writer;
+
+        // Stub client('LIST') to include a writer channel with a different prefix,
+        // so RX_CLIENT_TEST.test(name) is true but filter.test(name) is false.
+        const clientStub = sinon.stub(writer, 'client');
+        clientStub.callsFake(async (cmd: string) => {
+            if (cmd === 'LIST') {
+                return [
+                    'id=1 name=imqZ:Other:writer:pid:1:host:x', // RX true, filter false
+                    'id=2 name=imqA:Other:subscription:pid:1:host:x', // RX false, filter true
+                ].join('\n');
+            }
+            return true as any;
+        });
+
+        // Return no keys on SCAN to avoid deletions and just walk the branch
+        const scanStub = sinon.stub(writer, 'scan');
+        scanStub.resolves(['0', []] as any);
+
+        const delSpy = sinon.spy(writer, 'del');
+
+        await rq.processCleanup();
+
+        expect(delSpy.called).to.equal(false);
+
+        clientStub.restore();
+        scanStub.restore();
+        delSpy.restore();
+        await rq.destroy();
+    });
+});

test/RedisQueue.processCleanup.multiscan.spec.ts

@@ -0,0 +1,42 @@
+/*!
+ * Additional RedisQueue tests for processCleanup branches: multi-scan and no-deletion path
+ */
+import './mocks';
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { RedisQueue, uuid } from '../src';
+
+describe('RedisQueue.processCleanup multi-scan/no-delete branches', function() {
+    this.timeout(5000);
+
+    it('should handle multi-page SCAN (cursor != "0" first) and avoid deletion when keys belong to connected clients', async () => {
+        const name = `PClean_${uuid()}`;
+        const rq: any = new RedisQueue(name, {
+            logger: console,
+            cleanup: true,
+            prefix: 'imq',
+            cleanupFilter: '*',
+        });
+
+        await rq.start();
+
+        const writer: any = rq.writer;
+
+        // Stub scan to first return non-zero cursor with undefined keys (to exercise `|| []`),
+        // then return zero cursor with keys that include connectedKey (so no removal happens).
+        const scanStub = sinon.stub(writer, 'scan');
+        scanStub.onCall(0).resolves(['1', undefined] as any);
+        scanStub.onCall(1).resolves(['0', [`imq:${name}:reader:pid:123`]] as any);
+
+        const delSpy = sinon.spy(writer, 'del');
+
+        await rq.processCleanup();
+
+        // del should not be called because keysToRemove.length === 0
+        expect(delSpy.called).to.equal(false);
+
+        scanStub.restore();
+        delSpy.restore();
+        await rq.destroy();
+    });
+});

test/RedisQueue.processCleanup.nullmatch.spec.ts

@@ -0,0 +1,49 @@
+/*!
+ * Additional RedisQueue tests for processCleanup branches: clients.match null and cleanupFilter falsy
+ */
+import './mocks';
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { RedisQueue, uuid } from '../src';
+
+describe('RedisQueue.processCleanup null-match and falsy cleanupFilter', function() {
+    this.timeout(5000);
+
+    it('should handle clients.match returning null and cleanupFilter as falsy (\'\')', async () => {
+        const name = `PCleanNull_${uuid()}`;
+        const rq: any = new RedisQueue(name, {
+            logger: console,
+            cleanup: true,
+            prefix: 'imq',
+            cleanupFilter: '', // falsy to exercise "|| '*'" in both RegExp and SCAN MATCH
+        });
+
+        await rq.start();
+
+        const writer: any = rq.writer;
+
+        // Force clients.match(...) to return null by stubbing client('LIST') to return a string without 'name='
+        const clientStub = sinon.stub(writer, 'client');
+        clientStub.callsFake(async (cmd: string) => {
+            if (cmd === 'LIST') {
+                return 'id=1 flags=x'; // no 'name='
+            }
+            return true as any;
+        });
+
+        // Ensure SCAN returns no keys, to avoid deletions and just cover the branch paths
+        const scanStub = sinon.stub(writer, 'scan');
+        scanStub.resolves(['0', []] as any);
+
+        const delSpy = sinon.spy(writer, 'del');
+
+        await rq.processCleanup();
+
+        expect(delSpy.called).to.equal(false);
+
+        clientStub.restore();
+        scanStub.restore();
+        delSpy.restore();
+        await rq.destroy();
+    });
+});