feat: add more tests to improve coverage

Author: Mikhus

test/IMQClient.console.logger.spec.ts

@@ -0,0 +1,77 @@
+/*!
+ * IMQClient console logger fallback branches coverage
+ */
+import './mocks';
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { IMQClient, IMQDelay, IMQMetadata, remote, AFTER_HOOK_ERROR, BEFORE_HOOK_ERROR } from '..';
+
+class ConsoleClient extends IMQClient {
+  @remote()
+  public async ok(name?: string, meta?: IMQMetadata, delay?: IMQDelay) {
+    return this.remoteCall<string>(...arguments);
+  }
+  @remote()
+  public async boom() {
+    return this.remoteCall<any>(...arguments);
+  }
+}
+
+describe('IMQClient console logger fallbacks', () => {
+  let client: ConsoleClient;
+
+  afterEach(async () => {
+    try { await client?.destroy(); } catch { /* ignore */ }
+    sinon.restore();
+  });
+
+  it('should use console logger when BEFORE hook fails', async () => {
+    const warn = sinon.stub(console, 'warn' as any).callsFake(() => {});
+    client = new ConsoleClient({ beforeCall: async () => { throw new Error('before oops'); } });
+    await client.start();
+
+    const imq: any = (client as any).imq;
+    sinon.stub(imq, 'send').callsFake(async (_to: string, request: any) => {
+      const id = 'C1';
+      setImmediate(() => imq.emit('message', { to: id, request, data: 'good' }));
+      return id;
+    });
+
+    const res = await client.ok('x');
+    expect(res).to.equal('good');
+    expect(warn.called).to.equal(true);
+    expect(String(warn.firstCall.args[0])).to.contain(BEFORE_HOOK_ERROR);
+  });
+
+  it('should use console logger when AFTER hook fails (resolve and reject paths)', async () => {
+    const warn = sinon.stub(console, 'warn' as any).callsFake(() => {});
+    client = new ConsoleClient({ afterCall: async () => { throw new Error('after oops'); } });
+    await client.start();
+
+    const imq: any = (client as any).imq;
+    const send = sinon.stub(imq, 'send');
+
+    // success path
+    send.onFirstCall().callsFake(async (_to: string, request: any) => {
+      const id = 'C2';
+      setImmediate(() => imq.emit('message', { to: id, request, data: 'S' }));
+      return id;
+    });
+
+    // reject path
+    send.onSecondCall().callsFake(async (_to: string, request: any) => {
+      const id = 'C3';
+      setImmediate(() => imq.emit('message', { to: id, request, error: new Error('bad') }));
+      return id;
+    });
+
+    const ok = await client.ok('ok');
+    expect(ok).to.equal('S');
+
+    try { await client.boom(); } catch { /* expected */ }
+
+    expect(warn.callCount).to.be.greaterThan(0);
+    const messages = warn.getCalls().map(c => String(c.args[0])).join(' ');
+    expect(messages).to.contain(AFTER_HOOK_ERROR);
+  });
+});

test/IMQService.console.logger.spec.ts

@@ -0,0 +1,74 @@
+/*!
+ * IMQService logger fallback coverage test
+ */
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { uuid } from '@imqueue/core';
+import { IMQService, IMQRPCRequest, expose, BEFORE_HOOK_ERROR, AFTER_HOOK_ERROR } from '..';
+
+class ConsoleLoggerService extends IMQService {
+  @expose()
+  public ping() { return 'pong'; }
+}
+
+describe('IMQService handleRequest logger fallback to console', () => {
+  let warnStub: sinon.SinonSpy;
+
+  beforeEach(() => {
+    warnStub = sinon.stub(console, 'warn' as any).callsFake(() => {});
+  });
+
+  afterEach(async () => {
+    sinon.restore();
+  });
+
+  it('should use console when no custom logger provided and catch BEFORE hook error', async () => {
+    const beforeCall = async () => { throw new Error('before fails'); };
+    const service: any = new ConsoleLoggerService({ beforeCall }); // no logger provided
+
+    const request: IMQRPCRequest = { from: 'Client', method: 'ping', args: [] };
+    const id = uuid();
+
+    await service.start();
+
+    // Spy send to ensure regular flow continues and send is called even without afterCall
+    const sendSpy = sinon.spy(service.imq, 'send');
+
+    service.imq.emit('message', request, id);
+
+    await new Promise((resolve, reject) => setTimeout(() => {
+      try {
+        expect(warnStub.called).to.equal(true);
+        const hasBefore = warnStub.getCalls().some(c => c.args && c.args[0] === BEFORE_HOOK_ERROR);
+        expect(hasBefore).to.equal(true);
+        expect(sendSpy.called).to.equal(true);
+        resolve(undefined);
+      } catch (e) { reject(e); }
+    }, 1));
+
+    await service.destroy();
+  });
+
+  it('should use console when afterCall throws (send() logger fallback)', async () => {
+    const afterCall = async () => { throw new Error('after fails'); };
+    const service: any = new ConsoleLoggerService({ afterCall }); // no logger provided
+
+    const request: IMQRPCRequest = { from: 'Client', method: 'ping', args: [] };
+    const id = uuid();
+
+    await service.start();
+
+    service.imq.emit('message', request, id);
+
+    await new Promise((resolve, reject) => setTimeout(() => {
+      try {
+        expect(warnStub.called).to.equal(true);
+        const hasAfter = warnStub.getCalls().some(c => c.args && c.args[0] === AFTER_HOOK_ERROR);
+        expect(hasAfter).to.equal(true);
+        resolve(undefined);
+      } catch (e) { reject(e); }
+    }, 1));
+
+    await service.destroy();
+  });
+});

test/IMQService.signal.publish.spec.ts

@@ -0,0 +1,56 @@
+/*!
+ * IMQService signal handler and publish() coverage tests
+ */
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { uuid } from '@imqueue/core';
+import { IMQService, IMQRPCRequest, expose } from '..';
+
+class SignalTestService extends IMQService {
+  @expose()
+  public ping() {
+    return 'pong';
+  }
+}
+
+describe('IMQService signal handler and publish()', () => {
+  afterEach(async () => {
+    sinon.restore();
+  });
+
+  it('should call destroy() and log error on process signal (without exiting)', async () => {
+    const onStub = sinon.stub(process as any, 'on');
+    const handlers: { sig: string; fn: (...args: any[]) => any }[] = [];
+    onStub.callsFake((sig: string, fn: any) => { handlers.push({ sig, fn }); return process as any; });
+
+    // use fake timers to avoid triggering real process.exit from setTimeout
+    const clock = sinon.useFakeTimers();
+
+    const logger: any = { info: () => {}, warn: () => {}, error: sinon.spy() };
+    const service: any = new SignalTestService({ logger });
+
+    // make destroy reject to hit catch(logger.error)
+    sinon.stub(service, 'destroy').callsFake(async () => { throw new Error('boom'); });
+
+    // simulate first registered signal handler
+    expect(handlers.length).to.be.greaterThan(0);
+    await handlers[0].fn();
+
+    // let microtasks settle
+    await Promise.resolve();
+
+    expect(logger.error.called).to.equal(true);
+
+    clock.restore();
+  });
+
+  it('publish() should delegate to imq.publish', async () => {
+    const logger: any = { info: () => {}, warn: () => {}, error: () => {} };
+    const service: any = new SignalTestService({ logger });
+    const stub = sinon.stub(service.imq, 'publish').resolves(undefined as any);
+
+    await service.publish({ id: uuid() } as any);
+
+    expect(stub.calledOnce).to.equal(true);
+  });
+});

test/cache/RedisCache.errors.spec.ts

@@ -0,0 +1,61 @@
+/*!
+ * RedisCache error branches: methods before init should throw
+ */
+import { expect } from 'chai';
+import { RedisCache, REDIS_CLIENT_INIT_ERROR } from '../..';
+
+describe('cache/RedisCache errors when not initialized', () => {
+  beforeEach(() => { delete (RedisCache as any).redis; });
+
+  it('get() should throw if redis not initialized', async () => {
+    const cache = new RedisCache();
+    let threw = false;
+    try {
+      await cache.get('x');
+    } catch (e: any) {
+      threw = true;
+      expect(e).to.be.instanceOf(TypeError);
+      expect(e.message).to.equal(REDIS_CLIENT_INIT_ERROR);
+    }
+    expect(threw).to.equal(true);
+  });
+
+  it('set() should throw if redis not initialized', async () => {
+    const cache = new RedisCache();
+    let threw = false;
+    try {
+      await cache.set('x', 1);
+    } catch (e: any) {
+      threw = true;
+      expect(e).to.be.instanceOf(TypeError);
+      expect(e.message).to.equal(REDIS_CLIENT_INIT_ERROR);
+    }
+    expect(threw).to.equal(true);
+  });
+
+  it('del() should throw if redis not initialized', async () => {
+    const cache = new RedisCache();
+    let threw = false;
+    try {
+      await cache.del('x');
+    } catch (e: any) {
+      threw = true;
+      expect(e).to.be.instanceOf(TypeError);
+      expect(e.message).to.equal(REDIS_CLIENT_INIT_ERROR);
+    }
+    expect(threw).to.equal(true);
+  });
+
+  it('purge() should throw if redis not initialized', async () => {
+    const cache = new RedisCache();
+    let threw = false;
+    try {
+      await cache.purge('mask');
+    } catch (e: any) {
+      threw = true;
+      expect(e).to.be.instanceOf(TypeError);
+      expect(e.message).to.equal(REDIS_CLIENT_INIT_ERROR);
+    }
+    expect(threw).to.equal(true);
+  });
+});