@mojaloop/central-services-shared 18.26.1-snapshot.1 → 18.26.2

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [18.26.2](https://github.com/mojaloop/central-services-shared/compare/v18.26.1...v18.26.2) (2025-05-20)
+
+
+### Chore
+
+* update peer dependencies versions ([#453](https://github.com/mojaloop/central-services-shared/issues/453)) ([87932e5](https://github.com/mojaloop/central-services-shared/commit/87932e5382bc89a0a39638859334cba064b5b433))
+
+### [18.26.1](https://github.com/mojaloop/central-services-shared/compare/v18.26.0...v18.26.1) (2025-05-20)
+
+
+### Chore
+
+* update dependencies ([#452](https://github.com/mojaloop/central-services-shared/issues/452)) ([b5c2e4f](https://github.com/mojaloop/central-services-shared/commit/b5c2e4f5c9cefac35ece322c50c9e20375f12317))
+
 ## [18.26.0](https://github.com/mojaloop/central-services-shared/compare/v18.25.0...v18.26.0) (2025-05-13)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojaloop/central-services-shared",
-  "version": "18.26.1-snapshot.1",
+  "version": "18.26.2",
   "description": "Shared code for mojaloop central services",
   "license": "Apache-2.0",
   "author": "ModusBox",
@@ -80,27 +80,26 @@
     "openapi-backend": "5.12.0",
     "raw-body": "3.0.0",
     "rc": "1.2.8",
-    "redis": "^5.0.1",
     "shins": "2.6.0",
     "ulidx": "2.4.1",
     "uuid4": "2.0.3",
     "widdershins": "4.0.1",
-    "yaml": "2.7.1"
+    "yaml": "2.8.0"
   },
   "devDependencies": {
-    "@mojaloop/central-services-error-handling": "13.0.7",
-    "@mojaloop/central-services-logger": "11.8.1",
-    "@mojaloop/central-services-metrics": "12.5.0",
-    "@mojaloop/event-sdk": "14.4.0",
-    "@mojaloop/sdk-standard-components": "19.14.0",
-    "@opentelemetry/auto-instrumentations-node": "^0.58.1",
+    "@mojaloop/central-services-error-handling": "13.1.0",
+    "@mojaloop/central-services-logger": "11.9.0",
+    "@mojaloop/central-services-metrics": "12.6.0",
+    "@mojaloop/event-sdk": "14.5.1",
+    "@mojaloop/sdk-standard-components": "19.15.0",
+    "@opentelemetry/auto-instrumentations-node": "^0.59.0",
     "@types/hapi__joi": "17.1.15",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "ajv-keywords": "^5.1.0",
     "audit-ci": "7.1.0",
     "base64url": "3.0.1",
-    "chance": "1.1.12",
+    "chance": "1.1.13",
     "npm-check-updates": "18.0.1",
     "nyc": "17.1.0",
     "portfinder": "1.0.37",
@@ -138,10 +137,10 @@
     "yargs-parser": "21.1.1"
   },
   "peerDependencies": {
-    "@mojaloop/central-services-error-handling": "13.0.7",
-    "@mojaloop/central-services-logger": "11.8.1",
-    "@mojaloop/central-services-metrics": "12.5.0",
-    "@mojaloop/event-sdk": "14.4.0",
+    "@mojaloop/central-services-error-handling": "13.1.0",
+    "@mojaloop/central-services-logger": "11.9.0",
+    "@mojaloop/central-services-metrics": "12.6.0",
+    "@mojaloop/event-sdk": "14.5.1",
     "ajv": "8.x.x",
     "ajv-formats": "3.x.x",
     "ajv-keywords": "5.x.x"

package/src/util/redis/pubSub.js

@@ -28,13 +28,20 @@
  ******/
 
 'use strict'
-const { createClient, createCluster } = require('redis')
+const Redis = require('ioredis')
 const { createLogger } = require('../createLogger')
 const isClusterConfig = (config) => { return 'cluster' in config }
 const { rethrowRedisError } = require('../rethrow')
+const { REDIS_SUCCESS, REDIS_IS_CONNECTED_STATUSES } = require('../../constants')
 
 class PubSub {
   constructor (config, publisherClient, subscriberClient) {
+    // prepare redis connection instances
+    // once the client enters the subscribed state it is not supposed to issue
+    // any other commands, except for additional SUBSCRIBE, PSUBSCRIBE,
+    // UNSUBSCRIBE, PUNSUBSCRIBE, PING and QUIT commands.
+    // So we create two clients, one for subscribing another for
+    // and publishing
     this.config = config
     this.isCluster = isClusterConfig(config)
     this.log = createLogger(this.constructor.name)
@@ -45,17 +52,10 @@ class PubSub {
   }
 
   createRedisClient () {
-    if (this.isCluster) {
-      // node-redis cluster config expects rootNodes: [{url: 'redis://host:port'}]
-      const rootNodes = this.config.cluster.map(
-        node => ({ url: `redis://${node.host}:${node.port}` })
-      )
-      return createCluster({ rootNodes })
-    } else {
-      // node-redis expects url: 'redis://host:port'
-      const url = `redis://${this.config.host}:${this.config.port}`
-      return createClient({ url, ...this.config })
-    }
+    this.config.lazyConnect ??= true
+    return this.isCluster
+      ? new Redis.Cluster(this.config.cluster, { ...this.config, shardedSubscribers: true })
+      : new Redis(this.config)
   }
 
   async connect () {
@@ -71,12 +71,12 @@ class PubSub {
 
   async disconnect () {
     try {
-      await this.publisherClient.quit()
-      await this.subscriberClient.quit()
-      this.subscriberClient.removeAllListeners && this.subscriberClient.removeAllListeners()
+      const publisherResponse = await this.publisherClient.quit()
+      const subscriberResponse = await this.subscriberClient.quit()
+      const isDisconnected = publisherResponse === REDIS_SUCCESS && subscriberResponse === REDIS_SUCCESS
+      this.subscriberClient.removeAllListeners()
       this.log.info('Redis clients disconnected successfully')
-      // node-redis returns 'OK' on quit
-      return true
+      return isDisconnected
     } catch (err) {
       this.log.error('Error disconnecting Redis clients:', err)
       rethrowRedisError(err)
@@ -97,9 +97,8 @@ class PubSub {
   }
 
   get isConnected () {
-    // node-redis: status is 'ready' when connected
-    const publisherConnected = this.publisherClient.isOpen
-    const subscriberConnected = this.subscriberClient.isOpen
+    const publisherConnected = REDIS_IS_CONNECTED_STATUSES.includes(this.publisherClient.status)
+    const subscriberConnected = REDIS_IS_CONNECTED_STATUSES.includes(this.subscriberClient.status)
     this.log.debug('Redis connection status', {
       publisherConnected,
       subscriberConnected
@@ -108,9 +107,7 @@ class PubSub {
   }
 
   addEventListeners (client) {
-    client.on('connect', () => this.log.info('Redis client connecting'))
-    client.on('ready', () => this.log.info('Redis client ready'))
-    client.on('end', () => this.log.info('Redis client connection closed'))
+    client.on('connect', () => this.log.info('Redis client connected'))
     client.on('error', (err) => this.log.error('Redis client error:', err))
   }
 
@@ -118,11 +115,10 @@ class PubSub {
     try {
       if (this.isCluster) {
         await this.publisherClient.spublish(channel, JSON.stringify(message))
-        this.log.info(`Message SPUBLISHED to channel: ${channel}`)
       } else {
         await this.publisherClient.publish(channel, JSON.stringify(message))
-        this.log.info(`Message published to channel: ${channel}`)
       }
+      this.log.info(`Message published to channel: ${channel}`)
     } catch (err) {
       this.log.error('Error publishing message:', err)
       rethrowRedisError(err)
@@ -132,20 +128,21 @@ class PubSub {
   async subscribe (channel, callback) {
     try {
       if (this.isCluster) {
-        await this.subscriberClient.ssubscribe(channel, (message, subscribedChannel) => {
+        await this.subscriberClient.ssubscribe(channel)
+        this.subscriberClient.on('smessage', (subscribedChannel, message) => {
           if (subscribedChannel === channel) {
             callback(JSON.parse(message))
           }
         })
-        this.log.info(`SSUBSCRIBED to channel: ${channel}`)
       } else {
-        await this.subscriberClient.subscribe(channel, (message, subscribedChannel) => {
+        await this.subscriberClient.subscribe(channel)
+        this.subscriberClient.on('message', (subscribedChannel, message) => {
           if (subscribedChannel === channel) {
             callback(JSON.parse(message))
           }
         })
-        this.log.info(`Subscribed to channel: ${channel}`)
       }
+      this.log.info(`Subscribed to channel: ${channel}`)
       return channel
     } catch (err) {
       this.log.error('Error subscribing to channel:', err)
@@ -157,11 +154,10 @@ class PubSub {
     try {
       if (this.isCluster) {
         await this.subscriberClient.sunsubscribe(channel)
-        this.log.info(`SUNSUBSCRIBED from channel: ${channel}`)
       } else {
         await this.subscriberClient.unsubscribe(channel)
-        this.log.info(`Unsubscribed from channel: ${channel}`)
       }
+      this.log.info(`Unsubscribed from channel: ${channel}`)
     } catch (err) {
       this.log.error('Error unsubscribing from channel:', err)
       rethrowRedisError(err)

package/test/unit/util/redis/pubSub.test.js

@@ -22,486 +22,502 @@
  * Mojaloop Foundation
  - Name Surname <name.surname@mojaloop.io>
 
- * Kevin Leyow <kevin.leyow@infitx.com>
+ * Kevin Leyow <kevin.leyow@modusbox.com>
 
  --------------
  ******/
 const Test = require('tapes')(require('tape'))
 const sinon = require('sinon')
-let PubSub = require('../../../../src/util/redis/pubSub')
-const proxyquire = require('proxyquire')
+const Redis = require('ioredis')
+const PubSub = require('../../../../src/util/redis/pubSub')
+const { constructSystemExtensionError } = require('../../../../src/util/rethrow')
 
-Test('PubSub', pubSubTest => {
-  let sandbox, publisherStub, subscriberStub, pubSub, logStub
+Test('PubSub', (t) => {
+  let sandbox
 
-  pubSubTest.beforeEach(t => {
+  t.beforeEach((t) => {
     sandbox = sinon.createSandbox()
-    logStub = {
-      info: sandbox.stub(),
-      error: sandbox.stub(),
-      debug: sandbox.stub()
-    }
-    publisherStub = {
-      connect: sandbox.stub().resolves(),
-      quit: sandbox.stub().resolves(),
-      ping: sandbox.stub().resolves('PONG'),
-      publish: sandbox.stub().resolves(),
-      spublish: undefined,
-      isOpen: true,
-      on: sandbox.stub().returnsThis(),
-      removeAllListeners: sandbox.stub()
-    }
-    subscriberStub = {
-      connect: sandbox.stub().resolves(),
-      quit: sandbox.stub().resolves(),
-      ping: sandbox.stub().resolves('PONG'),
-      subscribe: sandbox.stub().resolves(),
-      unsubscribe: sandbox.stub().resolves(),
-      ssubscribe: undefined,
-      sunsubscribe: undefined,
-      isOpen: true,
-      on: sandbox.stub().returnsThis(),
-      removeAllListeners: sandbox.stub()
-    }
-    sandbox.stub(require('../../../../src/util/createLogger'), 'createLogger').returns(logStub)
+    sandbox.stub(Redis.prototype, 'publish')
+    sandbox.stub(Redis.prototype, 'subscribe')
+    sandbox.stub(Redis.prototype, 'unsubscribe')
+    sandbox.stub(Redis.prototype, 'on')
+    sandbox.stub(Redis.Cluster.prototype, 'on')
     t.end()
   })
 
-  pubSubTest.afterEach(t => {
+  t.afterEach((t) => {
     sandbox.restore()
     t.end()
   })
 
-  pubSubTest.test('should connect publisher and subscriber clients', async t => {
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
+  t.test('should create a Redis client and subscriber', (t) => {
+    const config = { lazyConnect: true }
+    const pubSub = new PubSub(config)
+    t.ok(pubSub.publisherClient instanceof Redis, 'publisherClient is an instance of Redis')
+    t.ok(pubSub.subscriberClient instanceof Redis, 'subscriberClient is an instance of Redis')
+    t.end()
+  })
 
-    await pubSub.connect()
-    t.ok(publisherStub.connect.called, 'publisher connect called')
-    t.ok(subscriberStub.connect.called, 'subscriber connect called')
+  t.test('should publish a message to a channel', async (t) => {
+    const config = {}
+    const pubSub = new PubSub(config)
+    const channel = 'test-channel'
+    const message = { key: 'value' }
+    await pubSub.publish(channel, message)
+
+    t.ok(pubSub.publisherClient.publish.calledWith(channel, JSON.stringify(message)), 'publish called with correct arguments')
     t.end()
   })
 
-  pubSubTest.test('should disconnect publisher and subscriber clients', async t => {
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
+  t.test('should handle error when publishing a message', async (t) => {
+    const config = {}
+    const pubSub = new PubSub(config)
+    const channel = 'test-channel'
+    const message = { key: 'value' }
+    const error = new Error('Publish error')
 
-    await pubSub.disconnect()
-    t.ok(publisherStub.quit.called, 'publisher quit called')
-    t.ok(subscriberStub.quit.called, 'subscriber quit called')
-    t.ok(subscriberStub.removeAllListeners.called, 'subscriber removeAllListeners called')
+    pubSub.publisherClient.publish.rejects(error)
+
+    try {
+      await pubSub.publish(channel, message)
+      t.fail('Should have thrown an error')
+    } catch (err) {
+      t.deepEqual(err, constructSystemExtensionError(error, '["redis"]'), 'Error thrown and rethrown correctly')
+    }
     t.end()
   })
 
-  pubSubTest.test('should return true on healthy healthCheck', async t => {
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
+  t.test('should subscribe to a channel and handle messages', async (t) => {
+    const config = {}
+    const pubSub = new PubSub(config)
+    const channel = 'test-channel'
+    const callback = sinon.stub()
+    const message = JSON.stringify({ key: 'value' })
+
+    await pubSub.subscribe(channel, callback)
+    pubSub.subscriberClient.on.callArgWith(1, channel, message)
 
-    const result = await pubSub.healthCheck()
-    t.equal(result, true, 'healthCheck returns true')
-    t.ok(publisherStub.ping.called, 'publisher ping called')
-    t.ok(subscriberStub.ping.called, 'subscriber ping called')
+    t.ok(pubSub.subscriberClient.subscribe.calledWith(channel), 'subscribe called with correct channel')
+    t.ok(callback.calledWith(JSON.parse(message)), 'callback called with parsed message')
     t.end()
   })
 
-  pubSubTest.test('should return false on unhealthy healthCheck', async t => {
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
+  t.test('should handle error when subscribing to a channel', async (t) => {
+    const config = {}
+    const pubSub = new PubSub(config)
+    const channel = 'test-channel'
+    const callback = sinon.stub()
+    const error = new Error('Subscribe error')
 
-    publisherStub.ping.rejects(new Error('fail'))
-    const result = await pubSub.healthCheck()
-    t.equal(result, false, 'healthCheck returns false')
+    pubSub.subscriberClient.subscribe.rejects(error)
+
+    try {
+      await pubSub.subscribe(channel, callback)
+      t.fail('Should have thrown an error')
+    } catch (err) {
+      t.deepEqual(err, constructSystemExtensionError(error, '["redis"]'), 'Error thrown and rethrown correctly')
+    }
     t.end()
   })
 
-  pubSubTest.test('should return isConnected status', t => {
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
+  t.test('should unsubscribe from a channel', async (t) => {
+    const config = {}
+    const pubSub = new PubSub(config)
+    const channel = 'test-channel'
 
-    const status = pubSub.isConnected
-    t.deepEqual(status, { publisherConnected: true, subscriberConnected: true }, 'isConnected returns correct status')
+    await pubSub.unsubscribe(channel)
+
+    t.ok(pubSub.subscriberClient.unsubscribe.calledWith(channel), 'unsubscribe called with correct channel')
     t.end()
   })
 
-  pubSubTest.test('should publish message to channel', async t => {
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
+  t.test('should handle error when unsubscribing from a channel', async (t) => {
+    const config = {}
+    const pubSub = new PubSub(config)
+    const channel = 'test-channel'
+    const error = new Error('Unsubscribe error')
+
+    pubSub.subscriberClient.unsubscribe.rejects(error)
 
-    await pubSub.publish('test-channel', { foo: 'bar' })
-    t.ok(publisherStub.publish.calledWith('test-channel', JSON.stringify({ foo: 'bar' })), 'publish called with correct args')
+    try {
+      await pubSub.unsubscribe(channel)
+      t.fail('Should have thrown an error')
+    } catch (err) {
+      t.deepEqual(err, constructSystemExtensionError(error, '["redis"]'), 'Error thrown and rethrown correctly')
+    }
     t.end()
   })
 
-  pubSubTest.test('should publish message using spublish in cluster mode', async t => {
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
+  t.test('should broadcast a message to multiple channels', async (t) => {
+    const config = {}
+    const pubSub = new PubSub(config)
+    const channels = ['channel1', 'channel2']
+    const message = { key: 'value' }
+
+    await pubSub.broadcast(channels, message)
 
-    pubSub.isCluster = true
-    publisherStub.spublish = sandbox.stub().resolves()
-    await pubSub.publish('test-channel', { foo: 'bar' })
-    t.ok(publisherStub.spublish.calledWith('test-channel', JSON.stringify({ foo: 'bar' })), 'spublish called with correct args')
+    t.ok(pubSub.publisherClient.publish.calledTwice, 'publish called twice')
+    t.ok(pubSub.publisherClient.publish.firstCall.calledWith(channels[0], JSON.stringify(message)), 'publish called with first channel and message')
+    t.ok(pubSub.publisherClient.publish.secondCall.calledWith(channels[1], JSON.stringify(message)), 'publish called with second channel and message')
     t.end()
   })
 
-  pubSubTest.test('should subscribe to channel', async t => {
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
+  t.test('should handle error when broadcasting a message', async (t) => {
+    const config = {}
+    const pubSub = new PubSub(config)
+    const channels = ['channel1', 'channel2']
+    const message = { key: 'value' }
+    const error = new Error('Broadcast error')
+
+    pubSub.publisherClient.publish.onFirstCall().rejects(error)
 
-    const callback = sandbox.stub()
-    await pubSub.subscribe('test-channel', callback)
-    t.ok(subscriberStub.subscribe.called, 'subscribe called')
+    try {
+      await pubSub.broadcast(channels, message)
+      t.fail('Should have thrown an error')
+    } catch (err) {
+      t.deepEqual(err, constructSystemExtensionError(error, '["redis"]'), 'Error thrown and rethrown correctly')
+    }
     t.end()
   })
 
-  pubSubTest.test('should subscribe using ssubscribe in cluster mode', async t => {
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
+  t.test('should connect Redis clients successfully', async (t) => {
+    const config = {}
+    const pubSub = new PubSub(config)
+
+    sandbox.stub(pubSub.publisherClient, 'connect').resolves()
+    sandbox.stub(pubSub.subscriberClient, 'connect').resolves()
+
+    await pubSub.connect()
 
-    pubSub.isCluster = true
-    subscriberStub.ssubscribe = sandbox.stub().resolves()
-    const callback = sandbox.stub()
-    await pubSub.subscribe('test-channel', callback)
-    t.ok(subscriberStub.ssubscribe.called, 'ssubscribe called')
+    t.ok(pubSub.publisherClient.connect.calledOnce, 'publisherClient connect called once')
+    t.ok(pubSub.subscriberClient.connect.calledOnce, 'subscriberClient connect called once')
     t.end()
   })
 
-  pubSubTest.test('should unsubscribe from channel', async t => {
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
+  t.test('should handle error when connecting Redis clients', async (t) => {
+    const config = {}
+    const pubSub = new PubSub(config)
+    const error = new Error('Connect error')
+
+    sandbox.stub(pubSub.publisherClient, 'connect').rejects(error)
+    sandbox.stub(pubSub.subscriberClient, 'connect').resolves()
 
-    await pubSub.unsubscribe('test-channel')
-    t.ok(subscriberStub.unsubscribe.calledWith('test-channel'), 'unsubscribe called')
+    try {
+      await pubSub.connect()
+      t.fail('Should have thrown an error')
+    } catch (err) {
+      t.deepEqual(err, constructSystemExtensionError(error, '["redis"]'), 'Error thrown and rethrown correctly')
+    }
     t.end()
   })
 
-  pubSubTest.test('should unsubscribe using sunsubscribe in cluster mode', async t => {
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
+  t.test('should create a Redis Cluster client when cluster config is provided', (t) => {
+    const config = { cluster: [{ host: '127.0.0.1', port: 6379 }] }
+    const pubSub = new PubSub(config)
 
-    pubSub.isCluster = true
-    subscriberStub.sunsubscribe = sandbox.stub().resolves()
-    await pubSub.unsubscribe('test-channel')
-    t.ok(subscriberStub.sunsubscribe.calledWith('test-channel'), 'sunsubscribe called')
+    t.ok(pubSub.publisherClient instanceof Redis.Cluster, 'publisherClient is an instance of Redis.Cluster')
+    t.ok(pubSub.subscriberClient instanceof Redis.Cluster, 'subscriberClient is an instance of Redis.Cluster')
     t.end()
   })
 
-  pubSubTest.test('should broadcast message to multiple channels', async t => {
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
+  t.test('should connect Redis Cluster clients successfully', async (t) => {
+    const config = { cluster: [{ host: '127.0.0.1', port: 6379 }] }
+    const pubSub = new PubSub(config)
+
+    sandbox.stub(pubSub.publisherClient, 'connect').resolves()
+    sandbox.stub(pubSub.subscriberClient, 'connect').resolves()
+
+    await pubSub.connect()
 
-    sandbox.stub(pubSub, 'publish').resolves()
-    await pubSub.broadcast(['a', 'b'], { foo: 'bar' })
-    t.ok(pubSub.publish.calledTwice, 'publish called for each channel')
+    t.ok(pubSub.publisherClient.connect.calledOnce, 'publisherClient connect called once')
+    t.ok(pubSub.subscriberClient.connect.calledOnce, 'subscriberClient connect called once')
     t.end()
   })
 
-  pubSubTest.test('should handle error on connect', async t => {
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
+  t.test('should handle error when connecting Redis Cluster clients', async (t) => {
+    const config = { cluster: [{ host: '127.0.0.1', port: 6379 }] }
+    const pubSub = new PubSub(config)
+    const error = new Error('Cluster connect error')
+
+    sandbox.stub(pubSub.publisherClient, 'connect').rejects(error)
+    sandbox.stub(pubSub.subscriberClient, 'connect').resolves()
 
-    publisherStub.connect.rejects(new Error('connect error'))
     try {
       await pubSub.connect()
-      t.fail('Expected error not thrown')
+      t.fail('Should have thrown an error')
     } catch (err) {
-      t.match(err.message, /connect error/, 'throws error on connect failure')
+      t.deepEqual(err, constructSystemExtensionError(error, '["redis"]'), 'Error thrown and rethrown correctly')
     }
     t.end()
   })
 
-  pubSubTest.test('should handle error on disconnect', async t => {
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
+  t.test('should not call callback if subscribedChannel does not match channel', async (t) => {
+    const config = {}
+    const pubSub = new PubSub(config)
+    const channel = 'test-channel'
+    const callback = sinon.stub()
+    const message = JSON.stringify({ key: 'value' })
+    const otherChannel = 'other-channel'
 
-    publisherStub.quit.rejects(new Error('disconnect error'))
-    try {
-      await pubSub.disconnect()
-      t.fail('Expected error not thrown')
-    } catch (err) {
-      t.match(err.message, /disconnect error/, 'throws error on disconnect failure')
-    }
+    await pubSub.subscribe(channel, callback)
+    pubSub.subscriberClient.on.callArgWith(1, otherChannel, message)
+
+    t.ok(pubSub.subscriberClient.subscribe.calledWith(channel), 'subscribe called with correct channel')
+    t.notOk(callback.called, 'callback not called when subscribedChannel does not match channel')
     t.end()
   })
 
-  pubSubTest.test('should handle error on publish', async t => {
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
+  t.test('should disconnect Redis clients successfully', async (t) => {
+    const config = {}
+    const pubSub = new PubSub(config)
 
-    publisherStub.publish.rejects(new Error('publish error'))
-    try {
-      await pubSub.publish('chan', { a: 1 })
-      t.fail('Expected error not thrown')
-    } catch (err) {
-      t.match(err.message, /publish error/, 'throws error on publish failure')
-    }
+    sandbox.stub(pubSub.publisherClient, 'quit').resolves()
+    sandbox.stub(pubSub.subscriberClient, 'quit').resolves()
+    sandbox.stub(pubSub.subscriberClient, 'removeAllListeners').resolves()
+
+    await pubSub.disconnect()
+
+    t.ok(pubSub.publisherClient.quit.calledOnce, 'publisherClient quit called once')
+    t.ok(pubSub.subscriberClient.quit.calledOnce, 'subscriberClient quit called once')
+    t.ok(pubSub.subscriberClient.removeAllListeners.calledOnce, 'subscriberClient removeAllListeners called once')
     t.end()
   })
 
-  pubSubTest.test('should handle error on subscribe', async t => {
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
+  t.test('should handle error when disconnecting Redis clients', async (t) => {
+    const config = {}
+    const pubSub = new PubSub(config)
+    const error = new Error('Disconnect error')
+
+    sandbox.stub(pubSub.publisherClient, 'quit').rejects(error)
+    sandbox.stub(pubSub.subscriberClient, 'quit').resolves()
 
-    subscriberStub.subscribe.rejects(new Error('subscribe error'))
     try {
-      await pubSub.subscribe('chan', () => {})
-      t.fail('Expected error not thrown')
+      await pubSub.disconnect()
+      t.fail('Should have thrown an error')
     } catch (err) {
-      t.match(err.message, /subscribe error/, 'throws error on subscribe failure')
+      t.deepEqual(err, constructSystemExtensionError(error, '["redis"]'), 'Error thrown and rethrown correctly')
     }
     t.end()
   })
 
-  pubSubTest.test('should handle error on unsubscribe', async t => {
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
+  t.test('should perform health check and return true if both clients are healthy', async (t) => {
+    const config = {}
+    const pubSub = new PubSub(config)
 
-    subscriberStub.unsubscribe.rejects(new Error('unsubscribe error'))
-    try {
-      await pubSub.unsubscribe('chan')
-      t.fail('Expected error not thrown')
-    } catch (err) {
-      t.match(err.message, /unsubscribe error/, 'throws error on unsubscribe failure')
-    }
+    sandbox.stub(pubSub.publisherClient, 'ping').resolves('PONG')
+    sandbox.stub(pubSub.subscriberClient, 'ping').resolves('PONG')
+
+    const isHealthy = await pubSub.healthCheck()
+
+    t.equal(isHealthy, true, 'healthCheck returns true when both clients are healthy')
+    t.ok(pubSub.publisherClient.ping.calledOnce, 'publisherClient ping called once')
+    t.ok(pubSub.subscriberClient.ping.calledOnce, 'subscriberClient ping called once')
     t.end()
   })
 
-  pubSubTest.test('should handle error on broadcast', async t => {
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
+  t.test('should perform health check and return false if any client is unhealthy', async (t) => {
+    const config = {}
+    const pubSub = new PubSub(config)
 
-    sandbox.stub(pubSub, 'publish').rejects(new Error('broadcast error'))
-    try {
-      await pubSub.broadcast(['a', 'b'], { foo: 'bar' })
-      t.fail('Expected error not thrown')
-    } catch (err) {
-      t.match(err.message, /broadcast error/, 'throws error on broadcast failure')
-    }
+    sandbox.stub(pubSub.publisherClient, 'ping').resolves('PONG')
+    sandbox.stub(pubSub.subscriberClient, 'ping').resolves('ERROR')
+
+    const isHealthy = await pubSub.healthCheck()
+
+    t.equal(isHealthy, false, 'healthCheck returns false when any client is unhealthy')
+    t.ok(pubSub.publisherClient.ping.calledOnce, 'publisherClient ping called once')
+    t.ok(pubSub.subscriberClient.ping.calledOnce, 'subscriberClient ping called once')
     t.end()
   })
 
-  pubSubTest.test('should call callback with parsed message on subscribe', async t => {
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
+  t.test('should handle error during health check and return false', async (t) => {
+    const config = {}
+    const pubSub = new PubSub(config)
+    const error = new Error('Health check error')
+
+    sandbox.stub(pubSub.publisherClient, 'ping').rejects(error)
+    sandbox.stub(pubSub.subscriberClient, 'ping').resolves('PONG')
 
-    let received
-    subscriberStub.subscribe.callsFake(async (channel, cb) => {
-      cb(JSON.stringify({ test: 1 }), channel)
-    })
-    await pubSub.subscribe('chan', msg => { received = msg })
-    t.same(received, { test: 1 }, 'callback called with parsed message')
+    const isHealthy = await pubSub.healthCheck()
+
+    t.equal(isHealthy, false, 'healthCheck returns false when an error occurs')
+    t.ok(pubSub.publisherClient.ping.calledOnce, 'publisherClient ping called once')
+    t.notOk(pubSub.subscriberClient.ping.calledOnce, 'subscriberClient ping not called once')
     t.end()
   })
 
-  pubSubTest.test('should call callback with parsed message on ssubscribe in cluster mode', async t => {
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
+  t.test('should return correct connection statuses for isConnected', (t) => {
+    const config = {}
+    const pubSub = new PubSub(config)
+
+    sandbox.stub(pubSub.publisherClient, 'status').value('ready')
+    sandbox.stub(pubSub.subscriberClient, 'status').value('ready')
+
+    const connectionStatus = pubSub.isConnected
 
-    pubSub.isCluster = true
-    let received
-    subscriberStub.ssubscribe = sandbox.stub().callsFake(async (channel, cb) => {
-      cb(JSON.stringify({ test: 2 }), channel)
-    })
-    await pubSub.subscribe('chan', msg => { received = msg })
-    t.same(received, { test: 2 }, 'callback called with parsed message')
+    t.deepEqual(connectionStatus, { publisherConnected: true, subscriberConnected: true }, 'isConnected returns correct statuses')
     t.end()
   })
 
-  pubSubTest.test('should not call callback if subscribedChannel does not match', async t => {
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
+  t.test('should return false connection statuses for isConnected when clients are not connected', (t) => {
+    const config = {}
+    const pubSub = new PubSub(config)
+
+    sandbox.stub(pubSub.publisherClient, 'status').value('disconnected')
+    sandbox.stub(pubSub.subscriberClient, 'status').value('disconnected')
+
+    const connectionStatus = pubSub.isConnected
 
-    let called = false
-    subscriberStub.subscribe.callsFake(async (channel, cb) => {
-      cb(JSON.stringify({ test: 3 }), 'other-channel')
-    })
-    await pubSub.subscribe('chan', () => { called = true })
-    t.notOk(called, 'callback not called for other channel')
+    t.deepEqual(connectionStatus, { publisherConnected: false, subscriberConnected: false }, 'isConnected returns false statuses when clients are not connected')
     t.end()
   })
+  t.test('should publish a message to a channel using spublish when isCluster is true', async (t) => {
+    const config = { cluster: [{ host: '127.0.0.1', port: 6379 }] }
+    const pubSub = new PubSub(config)
+    const channel = 'cluster-channel'
+    const message = { key: 'cluster-value' }
 
-  pubSubTest.test('should add event listeners to publisher and subscriber clients', t => {
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
+    sandbox.stub(pubSub.publisherClient, 'spublish').resolves()
 
-    // The event listeners are added in the constructor
-    // We check that .on was called with the correct events for both clients
-    const expectedEvents = ['connect', 'ready', 'end', 'error']
-    for (const event of expectedEvents) {
-      t.ok(
-        publisherStub.on.calledWith(event, sinon.match.func),
-        `publisherStub.on called with event '${event}'`
-      )
-      t.ok(
-        subscriberStub.on.calledWith(event, sinon.match.func),
-        `subscriberStub.on called with event '${event}'`
-      )
-    }
+    await pubSub.publish(channel, message)
+
+    t.ok(pubSub.publisherClient.spublish.calledWith(channel, JSON.stringify(message)), 'spublish called with correct arguments')
     t.end()
   })
 
-  pubSubTest.test('should create publisher and subscriber clients if not provided', t => {
-    // Arrange
-    const config = { host: 'localhost', port: 6379 }
-    // Stub createClient and createLogger
-    const createClientStub = sandbox.stub(require('redis'), 'createClient').returns({
-      connect: sandbox.stub().resolves(),
-      quit: sandbox.stub().resolves(),
-      ping: sandbox.stub().resolves('PONG'),
-      publish: sandbox.stub().resolves(),
-      isOpen: true,
-      on: sandbox.stub().returnsThis(),
-      removeAllListeners: sandbox.stub()
-    })
-    PubSub = proxyquire('../../../../src/util/redis/pubSub', {
-      redis: {
-        createClient: createClientStub
-      }
-    })
-    // Act
+  t.test('should handle error when publishing a message with spublish in cluster mode', async (t) => {
+    const config = { cluster: [{ host: '127.0.0.1', port: 6379 }] }
     const pubSub = new PubSub(config)
-    // Assert
-    t.ok(createClientStub.calledTwice, 'createClient called for both publisher and subscriber')
-    t.ok(pubSub.publisherClient, 'publisherClient is created')
-    t.ok(pubSub.subscriberClient, 'subscriberClient is created')
-    t.end()
-  })
-
-  pubSubTest.test('should create cluster clients if cluster config is provided and clients not provided', async t => {
-    // Arrange
-    const clusterConfig = { cluster: [{ host: 'c1', port: 7000 }, { host: 'c2', port: 7001 }] }
-    const createClusterStub = sandbox.stub().callsFake(() => ({
-      connect: sandbox.stub().resolves(),
-      quit: sandbox.stub().resolves(),
-      ping: sandbox.stub().resolves('PONG'),
-      spublish: sandbox.stub().resolves(),
-      ssubscribe: sandbox.stub().resolves(),
-      sunsubscribe: sandbox.stub().resolves(),
-      isOpen: true,
-      on: sandbox.stub().returnsThis(),
-      removeAllListeners: sandbox.stub()
-    }))
-
-    PubSub = proxyquire('../../../../src/util/redis/pubSub', {
-      redis: {
-        createCluster: createClusterStub
-      }
-    })
-
-    // Act
-    const pubSubCluster = new PubSub(clusterConfig)
-    // Assert
-    t.ok(createClusterStub.calledTwice, 'createCluster called for both publisher and subscriber')
-    t.ok(pubSubCluster.isCluster, 'isCluster is true')
-    t.end()
-  })
-
-  pubSubTest.test('should log info on publisher client connect event', t => {
-    logStub = {
-      info: sandbox.stub(),
-      error: sandbox.stub(),
-      debug: sandbox.stub()
-    }
-    PubSub = proxyquire('../../../../src/util/redis/pubSub', {
-      '../createLogger': { createLogger: sandbox.stub().returns(logStub) }
-    })
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
-    // Find the connect event handler
-    const connectHandler = publisherStub.on.getCalls().find(call => call.args[0] === 'connect').args[1]
-    connectHandler()
-    t.ok(logStub.info.calledWith('Redis client connecting'), 'logs info on connect')
-    t.end()
-  })
-
-  pubSubTest.test('should log info on publisher client ready event', t => {
-    logStub = {
-      info: sandbox.stub(),
-      error: sandbox.stub(),
-      debug: sandbox.stub()
+    const channel = 'cluster-channel'
+    const message = { key: 'cluster-value' }
+    const error = new Error('Cluster spublish error')
+
+    sandbox.stub(pubSub.publisherClient, 'spublish').rejects(error)
+
+    try {
+      await pubSub.publish(channel, message)
+      t.fail('Should have thrown an error')
+    } catch (err) {
+      t.deepEqual(err, constructSystemExtensionError(error, '["redis"]'), 'Error thrown and rethrown correctly')
     }
-    PubSub = proxyquire('../../../../src/util/redis/pubSub', {
-      '../createLogger': { createLogger: sandbox.stub().returns(logStub) }
-    })
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
-    const readyHandler = publisherStub.on.getCalls().find(call => call.args[0] === 'ready').args[1]
-    readyHandler()
-    t.ok(logStub.info.calledWith('Redis client ready'), 'logs info on ready')
     t.end()
   })
 
-  pubSubTest.test('should log info on publisher client end event', t => {
-    logStub = {
-      info: sandbox.stub(),
-      error: sandbox.stub(),
-      debug: sandbox.stub()
-    }
-    PubSub = proxyquire('../../../../src/util/redis/pubSub', {
-      '../createLogger': { createLogger: sandbox.stub().returns(logStub) }
-    })
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
-    const endHandler = publisherStub.on.getCalls().find(call => call.args[0] === 'end').args[1]
-    endHandler()
-    t.ok(logStub.info.calledWith('Redis client connection closed'), 'logs info on end')
+  t.test('should subscribe to a channel and handle smessage in cluster mode', async (t) => {
+    const config = { cluster: [{ host: '127.0.0.1', port: 6379 }] }
+    const pubSub = new PubSub(config)
+    const channel = 'cluster-channel'
+    const callback = sinon.stub()
+    const message = JSON.stringify({ key: 'cluster-value' })
+
+    sandbox.stub(pubSub.subscriberClient, 'ssubscribe').resolves()
+    pubSub.subscriberClient.on.withArgs('smessage').yields(channel, message)
+
+    await pubSub.subscribe(channel, callback)
+
+    t.ok(pubSub.subscriberClient.ssubscribe.calledWith(channel), 'ssubscribe called with correct channel')
+    t.ok(callback.calledWith(JSON.parse(message)), 'callback called with parsed message')
     t.end()
   })
 
-  pubSubTest.test('should log error on publisher client error event', t => {
-    logStub = {
-      info: sandbox.stub(),
-      error: sandbox.stub(),
-      debug: sandbox.stub()
-    }
-    PubSub = proxyquire('../../../../src/util/redis/pubSub', {
-      '../createLogger': { createLogger: sandbox.stub().returns(logStub) }
-    })
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
-    const errorHandler = publisherStub.on.getCalls().find(call => call.args[0] === 'error').args[1]
-    const err = new Error('test error')
-    errorHandler(err)
-    t.ok(logStub.error.calledWith('Redis client error:', err), 'logs error on error event')
-    t.end()
-  })
-
-  pubSubTest.test('should log info on subscriber client connect event', t => {
-    logStub = {
-      info: sandbox.stub(),
-      error: sandbox.stub(),
-      debug: sandbox.stub()
-    }
-    PubSub = proxyquire('../../../../src/util/redis/pubSub', {
-      '../createLogger': { createLogger: sandbox.stub().returns(logStub) }
-    })
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
-    const connectHandler = subscriberStub.on.getCalls().find(call => call.args[0] === 'connect').args[1]
-    connectHandler()
-    t.ok(logStub.info.calledWith('Redis client connecting'), 'logs info on subscriber connect')
+  t.test('should not call callback if smessage subscribedChannel does not match channel in cluster mode', async (t) => {
+    const config = { cluster: [{ host: '127.0.0.1', port: 6379 }] }
+    const pubSub = new PubSub(config)
+    const channel = 'cluster-channel'
+    const callback = sinon.stub()
+    const message = JSON.stringify({ key: 'cluster-value' })
+    const otherChannel = 'other-cluster-channel'
+
+    sandbox.stub(pubSub.subscriberClient, 'ssubscribe').resolves()
+    pubSub.subscriberClient.on.withArgs('smessage').yields(otherChannel, message)
+
+    await pubSub.subscribe(channel, callback)
+
+    t.ok(pubSub.subscriberClient.ssubscribe.calledWith(channel), 'ssubscribe called with correct channel')
+    t.notOk(callback.called, 'callback not called when smessage channel does not match')
     t.end()
   })
 
-  pubSubTest.test('should log info on subscriber client ready event', t => {
-    logStub = {
-      info: sandbox.stub(),
-      error: sandbox.stub(),
-      debug: sandbox.stub()
+  t.test('should handle error when subscribing to a channel in cluster mode', async (t) => {
+    const config = { cluster: [{ host: '127.0.0.1', port: 6379 }] }
+    const pubSub = new PubSub(config)
+    const channel = 'cluster-channel'
+    const callback = sinon.stub()
+    const error = new Error('Cluster subscribe error')
+
+    sandbox.stub(pubSub.subscriberClient, 'ssubscribe').rejects(error)
+
+    try {
+      await pubSub.subscribe(channel, callback)
+      t.fail('Should have thrown an error')
+    } catch (err) {
+      t.deepEqual(err, constructSystemExtensionError(error, '["redis"]'), 'Error thrown and rethrown correctly')
     }
-    PubSub = proxyquire('../../../../src/util/redis/pubSub', {
-      '../createLogger': { createLogger: sandbox.stub().returns(logStub) }
-    })
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
-    const readyHandler = subscriberStub.on.getCalls().find(call => call.args[0] === 'ready').args[1]
-    readyHandler()
-    t.ok(logStub.info.calledWith('Redis client ready'), 'logs info on subscriber ready')
     t.end()
   })
 
-  pubSubTest.test('should log info on subscriber client end event', t => {
-    logStub = {
-      info: sandbox.stub(),
-      error: sandbox.stub(),
-      debug: sandbox.stub()
+  t.test('should unsubscribe from a channel using sunsubscribe in cluster mode', async (t) => {
+    const config = { cluster: [{ host: '127.0.0.1', port: 6379 }] }
+    const pubSub = new PubSub(config)
+    const channel = 'cluster-channel'
+
+    sandbox.stub(pubSub.subscriberClient, 'sunsubscribe').resolves()
+
+    await pubSub.unsubscribe(channel)
+
+    t.ok(pubSub.subscriberClient.sunsubscribe.calledWith(channel), 'sunsubscribe called with correct channel')
+    t.end()
+  })
+
+  t.test('should handle error when unsubscribing from a channel in cluster mode', async (t) => {
+    const config = { cluster: [{ host: '127.0.0.1', port: 6379 }] }
+    const pubSub = new PubSub(config)
+    const channel = 'cluster-channel'
+    const error = new Error('Cluster unsubscribe error')
+
+    sandbox.stub(pubSub.subscriberClient, 'sunsubscribe').rejects(error)
+
+    try {
+      await pubSub.unsubscribe(channel)
+      t.fail('Should have thrown an error')
+    } catch (err) {
+      t.deepEqual(err, constructSystemExtensionError(error, '["redis"]'), 'Error thrown and rethrown correctly')
     }
-    PubSub = proxyquire('../../../../src/util/redis/pubSub', {
-      '../createLogger': { createLogger: sandbox.stub().returns(logStub) }
-    })
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
-    const endHandler = subscriberStub.on.getCalls().find(call => call.args[0] === 'end').args[1]
-    endHandler()
-    t.ok(logStub.info.calledWith('Redis client connection closed'), 'logs info on subscriber end')
     t.end()
   })
 
-  pubSubTest.test('should log error on subscriber client error event', t => {
-    logStub = {
-      info: sandbox.stub(),
-      error: sandbox.stub(),
-      debug: sandbox.stub()
+  t.test('should broadcast a message to multiple channels using spublish in cluster mode', async (t) => {
+    const config = { cluster: [{ host: '127.0.0.1', port: 6379 }] }
+    const pubSub = new PubSub(config)
+    const channels = ['cluster1', 'cluster2']
+    const message = { key: 'cluster-broadcast' }
+
+    sandbox.stub(pubSub.publisherClient, 'spublish').resolves()
+
+    await pubSub.broadcast(channels, message)
+
+    t.ok(pubSub.publisherClient.spublish.calledTwice, 'spublish called twice')
+    t.ok(pubSub.publisherClient.spublish.firstCall.calledWith(channels[0], JSON.stringify(message)), 'spublish called with first channel and message')
+    t.ok(pubSub.publisherClient.spublish.secondCall.calledWith(channels[1], JSON.stringify(message)), 'spublish called with second channel and message')
+    t.end()
+  })
+
+  t.test('should handle error when broadcasting a message in cluster mode', async (t) => {
+    const config = { cluster: [{ host: '127.0.0.1', port: 6379 }] }
+    const pubSub = new PubSub(config)
+    const channels = ['cluster1', 'cluster2']
+    const message = { key: 'cluster-broadcast' }
+    const error = new Error('Cluster broadcast error')
+
+    sandbox.stub(pubSub.publisherClient, 'spublish').onFirstCall().rejects(error)
+
+    try {
+      await pubSub.broadcast(channels, message)
+      t.fail('Should have thrown an error')
+    } catch (err) {
+      t.deepEqual(err, constructSystemExtensionError(error, '["redis"]'), 'Error thrown and rethrown correctly')
     }
-    PubSub = proxyquire('../../../../src/util/redis/pubSub', {
-      '../createLogger': { createLogger: sandbox.stub().returns(logStub) }
-    })
-    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
-    const errorHandler = subscriberStub.on.getCalls().find(call => call.args[0] === 'error').args[1]
-    const err = new Error('subscriber error')
-    errorHandler(err)
-    t.ok(logStub.error.calledWith('Redis client error:', err), 'logs error on subscriber error event')
     t.end()
   })
-  pubSubTest.end()
+  t.end()
 })