feat: add more tests to improve coverage

Author: Mikhus

test/IMQMetadata.ts

@@ -0,0 +1,44 @@
+/*!
+ * IMQMetadata Unit Tests
+ *
+ * I'm Queue Software Project
+ * Copyright (C) 2025  imqueue.com <[email protected]>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * If you want to use this code in a closed source (commercial) project, you can
+ * purchase a proprietary commercial license. Please contact us at
+ * <[email protected]> to get commercial licensing options.
+ */
+import './mocks';
+import { expect } from 'chai';
+import { IMQMetadata } from '..';
+
+describe('IMQMetadata', () => {
+    it('should be a class', () => {
+        expect(typeof IMQMetadata).to.equal('function');
+    });
+
+    it('should copy provided metadata props to instance index', () => {
+        const data = { a: 1, b: 'x', c: { y: true } } as any;
+        const m = new IMQMetadata(data);
+        // direct property access
+        expect((m as any).a).to.equal(1);
+        expect((m as any).b).to.equal('x');
+        expect((m as any).c).to.deep.equal({ y: true });
+        // index signature behavior
+        const keys = Object.keys(m);
+        expect(keys.sort()).to.deep.equal(['a','b','c']);
+    });
+});

test/decorators/logged.ts

@@ -0,0 +1,99 @@
+import 'reflect-metadata';
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { logged } from '../../src/decorators/logged';
+
+describe('decorators/logged()', () => {
+    it('should be a function and return decorator function', () => {
+        expect(typeof logged).to.equal('function');
+        // @ts-ignore
+        const decorator = logged();
+        expect(typeof decorator).to.equal('function');
+    });
+
+    it('should fallback to console logger and rethrow by default', async () => {
+        const error = new Error('boom');
+        const stub = sinon.stub(console, 'error');
+        class A {
+            // @ts-ignore
+            @logged()
+            public fail() {
+                throw error;
+            }
+        }
+
+        try {
+            await new A().fail();
+            expect.fail('should throw');
+        } catch (e) {
+            expect(e).to.equal(error);
+            expect(stub.calledOnce).to.equal(true);
+            expect(stub.firstCall.args[0]).to.equal(error);
+        } finally {
+            stub.restore();
+        }
+    });
+
+    it('should use provided logger, level and suppress throw when doNotThrow', async () => {
+        const error = new Error('warned');
+        const myLogger = {
+            warn: sinon.stub(),
+            error: sinon.stub(),
+            log: sinon.stub(),
+            info: sinon.stub(),
+        } as any;
+
+        class B {
+            // @ts-ignore
+            @logged({ logger: myLogger, level: 'warn', doNotThrow: true })
+            public fail() {
+                throw error;
+            }
+        }
+
+        const res = await new B().fail();
+        expect(res).to.equal(undefined);
+        expect(myLogger.warn.calledOnce).to.equal(true);
+        expect(myLogger.warn.firstCall.args[0]).to.equal(error);
+    });
+
+    it('should accept ILogger directly and rethrow by default', async () => {
+        const error = new Error('as-logger');
+        const myLogger = {
+            warn: sinon.stub(),
+            error: sinon.stub(),
+            log: sinon.stub(),
+            info: sinon.stub(),
+        } as any;
+
+        class C {
+            // @ts-ignore
+            @logged(myLogger)
+            public fail() {
+                throw error;
+            }
+        }
+
+        try {
+            await new C().fail();
+            expect.fail('should throw');
+        } catch (e) {
+            expect(e).to.equal(error);
+            expect(myLogger.error.calledOnce).to.equal(true);
+            expect(myLogger.error.firstCall.args[0]).to.equal(error);
+        }
+    });
+
+    it('should pass through successful return value', async () => {
+        class D {
+            // @ts-ignore
+            @logged()
+            public ok() {
+                return 42;
+            }
+        }
+
+        const v = await new D().ok();
+        expect(v).to.equal(42);
+    });
+});