test: fix broken changes from latest redis-smq-common

jest.config.cjs

@@ -0,0 +1,9 @@
+/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
+const { resolve } = require('path');
+
+module.exports = {
+  rootDir: resolve('./'),
+  testMatch: ['**/dist/**/*.test.js'],
+  setupFilesAfterEnv: ['<rootDir>/dist/tests/jest.setup.js'],
+  coverageDirectory: '<rootDir>/coverage',
+};

tests/common/events.ts

@@ -2,6 +2,7 @@ import { Consumer } from '../../src/lib/consumer/consumer';
 import { Message } from '../../src/lib/message/message';
 import { events } from '../../src/common/events/events';
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export async function consumerOnEvent<T extends Array<any>>(
   consumer: Consumer,
   event: string,

tests/common/redis.ts

@@ -1,14 +1,14 @@
-import { createClientInstance, RedisClient } from 'redis-smq-common';
+import { redis, RedisClient } from 'redis-smq-common';
 import { promisify, promisifyAll } from 'bluebird';
 import { Configuration } from '../../src/config/configuration';
 
 const RedisClientAsync = promisifyAll(RedisClient.prototype);
-const createClientInstanceAsync = promisify(createClientInstance);
-const redisClients: typeof RedisClientAsync[] = [];
+const createInstanceAsync = promisify(redis.createInstance);
+const redisClients: (typeof RedisClientAsync)[] = [];
 
 export async function getRedisInstance() {
   const c = promisifyAll(
-    await createClientInstanceAsync(Configuration.getSetConfig().redis),
+    await createInstanceAsync(Configuration.getSetConfig().redis),
   );
   redisClients.push(c);
   return c;

tests/common/start-up.ts

@@ -15,6 +15,6 @@ export async function startUp(): Promise<void> {
   });
   const redisClient = await getRedisInstance();
   await redisClient.flushallAsync();
-  logger.reset();
+  logger.destroy();
   logger.setLogger(console);
 }

tests/tests/consuming-messages/test00017.test.ts

@@ -21,9 +21,8 @@ test('Message storage: storeMessages = false', async () => {
   Configuration.getSetConfig(cfg);
 
   await createQueue(defaultQueue, false);
-  const { producer, consumer } = await produceAndDeadLetterMessage(
-    defaultQueue,
-  );
+  const { producer, consumer } =
+    await produceAndDeadLetterMessage(defaultQueue);
   await shutDownBaseInstance(producer);
   await shutDownBaseInstance(consumer);
   const deadLetteredMessages = await getQueueDeadLetteredMessages();
@@ -35,9 +34,8 @@ test('Message storage: storeMessages = false', async () => {
   expect(res1.totalItems).toBe(0);
   expect(res1.items.length).toBe(0);
 
-  const { producer: p, consumer: c } = await produceAndAcknowledgeMessage(
-    defaultQueue,
-  );
+  const { producer: p, consumer: c } =
+    await produceAndAcknowledgeMessage(defaultQueue);
 
   await shutDownBaseInstance(p);
   await shutDownBaseInstance(c);

tests/tests/consuming-messages/test00018.test.ts

@@ -3,12 +3,12 @@ import {
   defaultQueue,
   produceMessage,
 } from '../../common/message-producing-consuming';
-import { MessageAlreadyPublishedError } from '../../../src/lib/producer/errors/message-already-published.error';
+import { ProducerMessageAlreadyPublishedError } from '../../../src/lib/producer/errors';
 
 test('Producing duplicate message', async () => {
   await createQueue(defaultQueue, false);
   const { producer, message } = await produceMessage();
   await expect(async () => {
     await producer.produceAsync(message);
-  }).rejects.toThrow(MessageAlreadyPublishedError);
+  }).rejects.toThrow(ProducerMessageAlreadyPublishedError);
 });

tests/tests/consuming-messages/test00020.test.ts

@@ -1,6 +1,6 @@
 import { Message } from '../../../index';
 import { getProducer } from '../../common/producer';
-import { MessageExchangeRequiredError } from '../../../src/lib/message/errors/message-exchange-required.error';
+import { MessageExchangeRequiredError } from '../../../src/lib/message/errors';
 
 test('Producing a message without a message queue', async () => {
   const producer = getProducer();

tests/tests/consuming-messages/test00021.test.ts

@@ -4,7 +4,7 @@ import {
   createQueue,
   defaultQueue,
 } from '../../common/message-producing-consuming';
-import { ProducerNotRunningError } from '../../../src/lib/producer/errors/producer-not-running.error';
+import { ProducerInstanceNotRunningError } from '../../../src/lib/producer/errors';
 
 test('Shutdown a producer and try to produce a message', async () => {
   const producer = getProducer();
@@ -14,5 +14,5 @@ test('Shutdown a producer and try to produce a message', async () => {
   msg.setBody({ hello: 'world' }).setQueue(defaultQueue);
   await expect(async () => {
     await producer.produceAsync(msg);
-  }).rejects.toThrowError(ProducerNotRunningError);
+  }).rejects.toThrowError(ProducerInstanceNotRunningError);
 });

tests/tests/consuming-messages/test00024.test.ts

@@ -24,9 +24,8 @@ test('Message storage: acknowledged = true, deadLettered = false', async () => {
   Configuration.getSetConfig(cfg);
 
   await createQueue(defaultQueue, false);
-  const { producer, consumer } = await produceAndDeadLetterMessage(
-    defaultQueue,
-  );
+  const { producer, consumer } =
+    await produceAndDeadLetterMessage(defaultQueue);
   await shutDownBaseInstance(producer);
   await shutDownBaseInstance(consumer);
   const deadLetteredMessages = await getQueueDeadLetteredMessages();
@@ -38,9 +37,8 @@ test('Message storage: acknowledged = true, deadLettered = false', async () => {
   expect(res1.totalItems).toBe(0);
   expect(res1.items.length).toBe(0);
 
-  const { producer: p, consumer: c } = await produceAndAcknowledgeMessage(
-    defaultQueue,
-  );
+  const { producer: p, consumer: c } =
+    await produceAndAcknowledgeMessage(defaultQueue);
 
   await shutDownBaseInstance(p);
   await shutDownBaseInstance(c);

tests/tests/consuming-messages/test00025.test.ts

@@ -24,9 +24,8 @@ test('Message storage: acknowledged = false, deadLettered = true', async () => {
   Configuration.getSetConfig(cfg);
 
   await createQueue(defaultQueue, false);
-  const { producer, consumer } = await produceAndDeadLetterMessage(
-    defaultQueue,
-  );
+  const { producer, consumer } =
+    await produceAndDeadLetterMessage(defaultQueue);
   await shutDownBaseInstance(producer);
   await shutDownBaseInstance(consumer);
   const deadLetteredMessages = await getQueueDeadLetteredMessages();
@@ -38,9 +37,8 @@ test('Message storage: acknowledged = false, deadLettered = true', async () => {
   expect(res1.totalItems).toBe(1);
   expect(res1.items.length).toBe(1);
 
-  const { producer: p, consumer: c } = await produceAndAcknowledgeMessage(
-    defaultQueue,
-  );
+  const { producer: p, consumer: c } =
+    await produceAndAcknowledgeMessage(defaultQueue);
 
   await shutDownBaseInstance(p);
   await shutDownBaseInstance(c);

tests/tests/consuming-messages/test00026.test.ts

@@ -24,9 +24,8 @@ test('Message storage: acknowledged.expire = 10000', async () => {
   Configuration.getSetConfig(cfg);
 
   await createQueue(defaultQueue, false);
-  const { producer: p, consumer: c } = await produceAndAcknowledgeMessage(
-    defaultQueue,
-  );
+  const { producer: p, consumer: c } =
+    await produceAndAcknowledgeMessage(defaultQueue);
 
   await shutDownBaseInstance(p);
   await shutDownBaseInstance(c);

tests/tests/consuming-messages/test00027.test.ts

@@ -23,9 +23,8 @@ test('Message storage: acknowledged.queueSize = 3', async () => {
   Configuration.getSetConfig(cfg);
 
   await createQueue(defaultQueue, false);
-  const { consumer: c1, producer: p1 } = await produceAndAcknowledgeMessage(
-    defaultQueue,
-  );
+  const { consumer: c1, producer: p1 } =
+    await produceAndAcknowledgeMessage(defaultQueue);
   await shutDownBaseInstance(c1);
   await shutDownBaseInstance(p1);
 
@@ -38,9 +37,8 @@ test('Message storage: acknowledged.queueSize = 3', async () => {
   expect(res1.totalItems).toBe(1);
   expect(res1.items.length).toBe(1);
 
-  const { consumer: c2, producer: p2 } = await produceAndAcknowledgeMessage(
-    defaultQueue,
-  );
+  const { consumer: c2, producer: p2 } =
+    await produceAndAcknowledgeMessage(defaultQueue);
   await shutDownBaseInstance(c2);
   await shutDownBaseInstance(p2);
 
@@ -52,9 +50,8 @@ test('Message storage: acknowledged.queueSize = 3', async () => {
   expect(res2.totalItems).toBe(2);
   expect(res2.items.length).toBe(2);
 
-  const { consumer: c3, producer: p3 } = await produceAndAcknowledgeMessage(
-    defaultQueue,
-  );
+  const { consumer: c3, producer: p3 } =
+    await produceAndAcknowledgeMessage(defaultQueue);
   await shutDownBaseInstance(c3);
   await shutDownBaseInstance(p3);
 
@@ -66,9 +63,8 @@ test('Message storage: acknowledged.queueSize = 3', async () => {
   expect(res3.totalItems).toBe(3);
   expect(res3.items.length).toBe(3);
 
-  const { consumer: c4, producer: p4 } = await produceAndAcknowledgeMessage(
-    defaultQueue,
-  );
+  const { consumer: c4, producer: p4 } =
+    await produceAndAcknowledgeMessage(defaultQueue);
   await shutDownBaseInstance(c4);
   await shutDownBaseInstance(p4);
 

tests/tests/consuming-messages/test00036.test.ts

@@ -1,5 +1,5 @@
 import { Message } from '../../../src/lib/message/message';
-import { MessageNotPublishedError } from '../../../src/lib/producer/errors/message-not-published.error';
+import { ProducerMessageNotPublishedError } from '../../../src/lib/producer/errors';
 import { getProducer } from '../../common/producer';
 import { EQueueType } from '../../../types';
 import { getQueue } from '../../common/queue';
@@ -19,23 +19,23 @@ test('Producing a message and expecting different kind of failures', async () =>
       .setPriority(Message.MessagePriority.LOW);
     await producer.produceAsync(msg);
   } catch (e: unknown) {
-    const m = e instanceof MessageNotPublishedError ? e.message : '';
+    const m = e instanceof ProducerMessageNotPublishedError ? e.message : '';
     expect(m).toBe('PRIORITY_QUEUING_NOT_ENABLED');
   }
 
   try {
     const msg1 = new Message().setQueue('test1').setBody('body');
     await producer.produceAsync(msg1);
   } catch (e: unknown) {
-    const m = e instanceof MessageNotPublishedError ? e.message : '';
+    const m = e instanceof ProducerMessageNotPublishedError ? e.message : '';
     expect(m).toBe('MESSAGE_PRIORITY_REQUIRED');
   }
 
   try {
     const msg2 = new Message().setQueue('test2').setBody('body');
     await producer.produceAsync(msg2);
   } catch (e: unknown) {
-    const m = e instanceof MessageNotPublishedError ? e.message : '';
+    const m = e instanceof ProducerMessageNotPublishedError ? e.message : '';
     expect(m).toBe('QUEUE_NOT_FOUND');
   }
 });

tests/tests/event-listeners/test00001.test.ts

@@ -65,13 +65,11 @@ test('Consumer event listeners', async () => {
   Message.setDefaultConsumeOptions({ retryDelay: 0 });
 
   await createQueue(defaultQueue, false);
-  const { message: m0, consumer: c0 } = await produceAndAcknowledgeMessage(
-    defaultQueue,
-  );
+  const { message: m0, consumer: c0 } =
+    await produceAndAcknowledgeMessage(defaultQueue);
   await shutDownBaseInstance(c0);
-  const { message: m1, consumer: c1 } = await produceAndAcknowledgeMessage(
-    defaultQueue,
-  );
+  const { message: m1, consumer: c1 } =
+    await produceAndAcknowledgeMessage(defaultQueue);
   await shutDownBaseInstance(c1);
   const anotherQueue = { name: 'another_queue', ns: 'testing' };
   await createQueue(anotherQueue, false);

tests/tests/exchanges/direct-exchange/test00002.test.ts

@@ -1,5 +1,5 @@
 import { EExchangeType, TExchangeSerialized } from '../../../../types';
-import { InvalidExchangeDataError } from '../../../../src/lib/exchange/errors/invalid-exchange-data.error';
+import { ExchangeInvalidDataError } from '../../../../src/lib/exchange/errors';
 import { _fromJSON } from '../../../../src/lib/exchange/_from-json';
 
 test('ExchangeDirect: fromJSON()', async () => {
@@ -8,7 +8,7 @@ test('ExchangeDirect: fromJSON()', async () => {
     type: EExchangeType.DIRECT,
     exchangeTag: '123',
   };
-  expect(() => _fromJSON({})).toThrow(InvalidExchangeDataError);
+  expect(() => _fromJSON({})).toThrow(ExchangeInvalidDataError);
   const e = _fromJSON(json);
   expect(e.toJSON()).toEqual({
     bindingParams: {

tests/tests/exchanges/fanout-exchange/test00005.test.ts

@@ -1,5 +1,5 @@
 import { EExchangeType, TExchangeSerialized } from '../../../../types';
-import { InvalidExchangeDataError } from '../../../../src/lib/exchange/errors/invalid-exchange-data.error';
+import { ExchangeInvalidDataError } from '../../../../src/lib/exchange/errors';
 import { _fromJSON } from '../../../../src/lib/exchange/_from-json';
 
 test('ExchangeFanOut: fromJSON()', async () => {
@@ -8,7 +8,7 @@ test('ExchangeFanOut: fromJSON()', async () => {
     type: EExchangeType.FANOUT,
     exchangeTag: '123',
   };
-  expect(() => _fromJSON({})).toThrow(InvalidExchangeDataError);
+  expect(() => _fromJSON({})).toThrow(ExchangeInvalidDataError);
   const e = _fromJSON(json);
   expect(e.toJSON()).toEqual(json);
 });

tests/tests/exchanges/fanout-exchange/test00006.test.ts

@@ -1,7 +1,7 @@
 import { Message } from '../../../../src/lib/message/message';
 import { getProducer } from '../../../common/producer';
 import { ExchangeFanOut } from '../../../../src/lib/exchange/exchange-fan-out';
-import { MessageNotPublishedError } from '../../../../src/lib/producer/errors/message-not-published.error';
+import { ProducerMessageNotPublishedError } from '../../../../src/lib/producer/errors';
 
 test('ExchangeFanOut: producing message having an exchange without matched queues ', async () => {
   const producer = getProducer();
@@ -11,6 +11,6 @@ test('ExchangeFanOut: producing message having an exchange without matched queue
   const msg = new Message().setExchange(e).setBody('hello');
 
   await expect(async () => await producer.produceAsync(msg)).rejects.toThrow(
-    MessageNotPublishedError,
+    ProducerMessageNotPublishedError,
   );
 });

tests/tests/exchanges/fanout-exchange/test00008.test.ts

@@ -1,4 +1,4 @@
-import { FanOutExchangeQueueError } from '../../../../src/lib/exchange/errors/fan-out-exchange-queue.error';
+import { ExchangeFanOutError } from '../../../../src/lib/exchange/errors';
 import { EQueueType } from '../../../../types';
 import { getQueue } from '../../../common/queue';
 import { getFanOutExchange } from '../../../common/exchange';
@@ -15,5 +15,5 @@ test('ExchangeFanOut: binding different types of queues', async () => {
   const q2 = { ns: 'testing', name: 'w456' };
   await queueInstance.saveAsync(q2, EQueueType.PRIORITY_QUEUE);
 
-  await expect(e1.bindQueueAsync(q2)).rejects.toThrow(FanOutExchangeQueueError);
+  await expect(e1.bindQueueAsync(q2)).rejects.toThrow(ExchangeFanOutError);
 });

tests/tests/exchanges/topic-exchange/test00006.test.ts

@@ -1,5 +1,5 @@
 import { EExchangeType, TExchangeSerialized } from '../../../../types';
-import { InvalidExchangeDataError } from '../../../../src/lib/exchange/errors/invalid-exchange-data.error';
+import { ExchangeInvalidDataError } from '../../../../src/lib/exchange/errors';
 import { _fromJSON } from '../../../../src/lib/exchange/_from-json';
 
 test('ExchangeTopic: fromJSON()', async () => {
@@ -8,7 +8,7 @@ test('ExchangeTopic: fromJSON()', async () => {
     type: EExchangeType.TOPIC,
     exchangeTag: '123',
   };
-  expect(() => _fromJSON({})).toThrow(InvalidExchangeDataError);
+  expect(() => _fromJSON({})).toThrow(ExchangeInvalidDataError);
   const e = _fromJSON(json);
   expect(e.toJSON()).toEqual({
     bindingParams: {

tests/tests/exchanges/topic-exchange/test00007.test.ts

@@ -1,6 +1,6 @@
 import { Message } from '../../../../src/lib/message/message';
 import { getProducer } from '../../../common/producer';
-import { MessageNotPublishedError } from '../../../../src/lib/producer/errors/message-not-published.error';
+import { ProducerMessageNotPublishedError } from '../../../../src/lib/producer/errors';
 import { ExchangeTopic } from '../../../../src/lib/exchange/exchange-topic';
 
 test('ExchangeTopic: producing message having an exchange without matched queues ', async () => {
@@ -11,6 +11,6 @@ test('ExchangeTopic: producing message having an exchange without matched queues
   const msg = new Message().setExchange(e).setBody('hello');
 
   await expect(async () => await producer.produceAsync(msg)).rejects.toThrow(
-    MessageNotPublishedError,
+    ProducerMessageNotPublishedError,
   );
 });

tests/tests/misc/test00020.test.ts

@@ -1,5 +1,5 @@
 import { Message } from '../../../src/lib/message/message';
-import { DestinationQueueRequiredError } from '../../../src/lib/message/errors/destination-queue-required.error';
+import { MessageDestinationQueueRequiredError } from '../../../src/lib/message/errors';
 
 test('Message: validations', async () => {
   const msg = new Message();
@@ -32,11 +32,11 @@ test('Message: validations', async () => {
   }).toThrow('Invalid message priority.');
   expect(() => {
     msg.getDestinationQueue();
-  }).toThrow(DestinationQueueRequiredError);
+  }).toThrow(MessageDestinationQueueRequiredError);
   msg.setQueue('test1');
   expect(() => {
     msg.getDestinationQueue();
-  }).toThrow(DestinationQueueRequiredError);
+  }).toThrow(MessageDestinationQueueRequiredError);
   expect(msg.hasNextDelay()).toBe(false);
   expect(msg.hasRetryThresholdExceeded()).toBe(false);
 });