@mojaloop/central-services-shared 18.26.0 → 18.26.1-snapshot.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojaloop/central-services-shared",
-  "version": "18.26.0",
+  "version": "18.26.1-snapshot.0",
   "description": "Shared code for mojaloop central services",
   "license": "Apache-2.0",
   "author": "ModusBox",
@@ -80,6 +80,7 @@
     "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",

package/src/util/redis/pubSub.js

@@ -28,20 +28,13 @@
  ******/
 
 'use strict'
-const Redis = require('ioredis')
+const { createClient, createCluster } = require('redis')
 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)
@@ -52,10 +45,19 @@ class PubSub {
   }
 
   createRedisClient () {
-    this.config.lazyConnect ??= true
-    return this.isCluster
-      ? new Redis.Cluster(this.config.cluster, { ...this.config, shardedSubscribers: true })
-      : new Redis(this.config)
+    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 = this.config.host && this.config.port
+        ? `redis://${this.config.host}:${this.config.port}`
+        : undefined
+      return createClient({ url, ...this.config })
+    }
   }
 
   async connect () {
@@ -71,12 +73,12 @@ class PubSub {
 
   async disconnect () {
     try {
-      const publisherResponse = await this.publisherClient.quit()
-      const subscriberResponse = await this.subscriberClient.quit()
-      const isDisconnected = publisherResponse === REDIS_SUCCESS && subscriberResponse === REDIS_SUCCESS
-      this.subscriberClient.removeAllListeners()
+      await this.publisherClient.quit()
+      await this.subscriberClient.quit()
+      this.subscriberClient.removeAllListeners && this.subscriberClient.removeAllListeners()
       this.log.info('Redis clients disconnected successfully')
-      return isDisconnected
+      // node-redis returns 'OK' on quit
+      return true
     } catch (err) {
       this.log.error('Error disconnecting Redis clients:', err)
       rethrowRedisError(err)
@@ -97,8 +99,9 @@ class PubSub {
   }
 
   get isConnected () {
-    const publisherConnected = REDIS_IS_CONNECTED_STATUSES.includes(this.publisherClient.status)
-    const subscriberConnected = REDIS_IS_CONNECTED_STATUSES.includes(this.subscriberClient.status)
+    // node-redis: status is 'ready' when connected
+    const publisherConnected = this.publisherClient.isOpen
+    const subscriberConnected = this.subscriberClient.isOpen
     this.log.debug('Redis connection status', {
       publisherConnected,
       subscriberConnected
@@ -107,18 +110,21 @@ class PubSub {
   }
 
   addEventListeners (client) {
-    client.on('connect', () => this.log.info('Redis client connected'))
+    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('error', (err) => this.log.error('Redis client error:', err))
   }
 
   async publish (channel, message) {
     try {
-      if (this.isCluster) {
+      if (this.isCluster && typeof this.publisherClient.spublish === 'function') {
         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)
@@ -127,22 +133,21 @@ class PubSub {
 
   async subscribe (channel, callback) {
     try {
-      if (this.isCluster) {
-        await this.subscriberClient.ssubscribe(channel)
-        this.subscriberClient.on('smessage', (subscribedChannel, message) => {
+      if (this.isCluster && typeof this.subscriberClient.ssubscribe === 'function') {
+        await this.subscriberClient.ssubscribe(channel, (message, subscribedChannel) => {
           if (subscribedChannel === channel) {
             callback(JSON.parse(message))
           }
         })
+        this.log.info(`SSUBSCRIBED to channel: ${channel}`)
       } else {
-        await this.subscriberClient.subscribe(channel)
-        this.subscriberClient.on('message', (subscribedChannel, message) => {
+        await this.subscriberClient.subscribe(channel, (message, subscribedChannel) => {
           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)
@@ -152,12 +157,13 @@ class PubSub {
 
   async unsubscribe (channel) {
     try {
-      if (this.isCluster) {
+      if (this.isCluster && typeof this.subscriberClient.sunsubscribe === 'function') {
         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,502 +22,486 @@
  * Mojaloop Foundation
  - Name Surname <name.surname@mojaloop.io>
 
- * Kevin Leyow <kevin.leyow@modusbox.com>
+ * Kevin Leyow <kevin.leyow@infitx.com>
 
  --------------
  ******/
 const Test = require('tapes')(require('tape'))
 const sinon = require('sinon')
-const Redis = require('ioredis')
-const PubSub = require('../../../../src/util/redis/pubSub')
-const { constructSystemExtensionError } = require('../../../../src/util/rethrow')
+let PubSub = require('../../../../src/util/redis/pubSub')
+const proxyquire = require('proxyquire')
 
-Test('PubSub', (t) => {
-  let sandbox
+Test('PubSub', pubSubTest => {
+  let sandbox, publisherStub, subscriberStub, pubSub, logStub
 
-  t.beforeEach((t) => {
+  pubSubTest.beforeEach(t => {
     sandbox = sinon.createSandbox()
-    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')
+    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)
     t.end()
   })
 
-  t.afterEach((t) => {
+  pubSubTest.afterEach(t => {
     sandbox.restore()
     t.end()
   })
 
-  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()
-  })
-
-  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)
+  pubSubTest.test('should connect publisher and subscriber clients', async t => {
+    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
 
-    t.ok(pubSub.publisherClient.publish.calledWith(channel, JSON.stringify(message)), 'publish called with correct arguments')
+    await pubSub.connect()
+    t.ok(publisherStub.connect.called, 'publisher connect called')
+    t.ok(subscriberStub.connect.called, 'subscriber connect called')
     t.end()
   })
 
-  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')
-
-    pubSub.publisherClient.publish.rejects(error)
+  pubSubTest.test('should disconnect publisher and subscriber clients', async t => {
+    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
 
-    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')
-    }
+    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')
     t.end()
   })
 
-  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)
+  pubSubTest.test('should return true on healthy healthCheck', async t => {
+    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
 
-    t.ok(pubSub.subscriberClient.subscribe.calledWith(channel), 'subscribe called with correct channel')
-    t.ok(callback.calledWith(JSON.parse(message)), 'callback called with parsed 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.end()
   })
 
-  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')
+  pubSubTest.test('should return false on unhealthy healthCheck', async t => {
+    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
 
-    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')
-    }
+    publisherStub.ping.rejects(new Error('fail'))
+    const result = await pubSub.healthCheck()
+    t.equal(result, false, 'healthCheck returns false')
     t.end()
   })
 
-  t.test('should unsubscribe from a channel', async (t) => {
-    const config = {}
-    const pubSub = new PubSub(config)
-    const channel = 'test-channel'
+  pubSubTest.test('should return isConnected status', t => {
+    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
 
-    await pubSub.unsubscribe(channel)
-
-    t.ok(pubSub.subscriberClient.unsubscribe.calledWith(channel), 'unsubscribe called with correct channel')
+    const status = pubSub.isConnected
+    t.deepEqual(status, { publisherConnected: true, subscriberConnected: true }, 'isConnected returns correct status')
     t.end()
   })
 
-  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)
+  pubSubTest.test('should publish message to channel', async t => {
+    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
 
-    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')
-    }
+    await pubSub.publish('test-channel', { foo: 'bar' })
+    t.ok(publisherStub.publish.calledWith('test-channel', JSON.stringify({ foo: 'bar' })), 'publish called with correct args')
     t.end()
   })
 
-  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)
+  pubSubTest.test('should publish message using spublish in cluster mode', async t => {
+    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
 
-    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')
+    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.end()
   })
 
-  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)
+  pubSubTest.test('should subscribe to channel', async t => {
+    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
 
-    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')
-    }
+    const callback = sandbox.stub()
+    await pubSub.subscribe('test-channel', callback)
+    t.ok(subscriberStub.subscribe.called, 'subscribe called')
     t.end()
   })
 
-  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()
+  pubSubTest.test('should subscribe using ssubscribe in cluster mode', async t => {
+    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
 
-    t.ok(pubSub.publisherClient.connect.calledOnce, 'publisherClient connect called once')
-    t.ok(pubSub.subscriberClient.connect.calledOnce, 'subscriberClient connect called once')
+    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.end()
   })
 
-  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()
+  pubSubTest.test('should unsubscribe from channel', async t => {
+    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
 
-    try {
-      await pubSub.connect()
-      t.fail('Should have thrown an error')
-    } catch (err) {
-      t.deepEqual(err, constructSystemExtensionError(error, '["redis"]'), 'Error thrown and rethrown correctly')
-    }
+    await pubSub.unsubscribe('test-channel')
+    t.ok(subscriberStub.unsubscribe.calledWith('test-channel'), 'unsubscribe called')
     t.end()
   })
 
-  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)
+  pubSubTest.test('should unsubscribe using sunsubscribe in cluster mode', async t => {
+    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
 
-    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')
+    pubSub.isCluster = true
+    subscriberStub.sunsubscribe = sandbox.stub().resolves()
+    await pubSub.unsubscribe('test-channel')
+    t.ok(subscriberStub.sunsubscribe.calledWith('test-channel'), 'sunsubscribe called')
     t.end()
   })
 
-  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()
+  pubSubTest.test('should broadcast message to multiple channels', async t => {
+    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
 
-    t.ok(pubSub.publisherClient.connect.calledOnce, 'publisherClient connect called once')
-    t.ok(pubSub.subscriberClient.connect.calledOnce, 'subscriberClient connect called once')
+    sandbox.stub(pubSub, 'publish').resolves()
+    await pubSub.broadcast(['a', 'b'], { foo: 'bar' })
+    t.ok(pubSub.publish.calledTwice, 'publish called for each channel')
     t.end()
   })
 
-  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()
+  pubSubTest.test('should handle error on connect', async t => {
+    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
 
+    publisherStub.connect.rejects(new Error('connect error'))
     try {
       await pubSub.connect()
-      t.fail('Should have thrown an error')
+      t.fail('Expected error not thrown')
     } catch (err) {
-      t.deepEqual(err, constructSystemExtensionError(error, '["redis"]'), 'Error thrown and rethrown correctly')
+      t.match(err.message, /connect error/, 'throws error on connect failure')
     }
     t.end()
   })
 
-  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'
-
-    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()
-  })
-
-  t.test('should disconnect Redis clients successfully', async (t) => {
-    const config = {}
-    const pubSub = new PubSub(config)
-
-    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()
-  })
-
-  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()
+  pubSubTest.test('should handle error on disconnect', async t => {
+    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
 
+    publisherStub.quit.rejects(new Error('disconnect error'))
     try {
       await pubSub.disconnect()
-      t.fail('Should have thrown an error')
+      t.fail('Expected error not thrown')
     } catch (err) {
-      t.deepEqual(err, constructSystemExtensionError(error, '["redis"]'), 'Error thrown and rethrown correctly')
+      t.match(err.message, /disconnect error/, 'throws error on disconnect failure')
     }
     t.end()
   })
 
-  t.test('should perform health check and return true if both clients are healthy', async (t) => {
-    const config = {}
-    const pubSub = new PubSub(config)
-
-    sandbox.stub(pubSub.publisherClient, 'ping').resolves('PONG')
-    sandbox.stub(pubSub.subscriberClient, 'ping').resolves('PONG')
-
-    const isHealthy = await pubSub.healthCheck()
+  pubSubTest.test('should handle error on publish', async t => {
+    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
 
-    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')
+    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')
+    }
     t.end()
   })
 
-  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.publisherClient, 'ping').resolves('PONG')
-    sandbox.stub(pubSub.subscriberClient, 'ping').resolves('ERROR')
-
-    const isHealthy = await pubSub.healthCheck()
+  pubSubTest.test('should handle error on subscribe', async t => {
+    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
 
-    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')
+    subscriberStub.subscribe.rejects(new Error('subscribe error'))
+    try {
+      await pubSub.subscribe('chan', () => {})
+      t.fail('Expected error not thrown')
+    } catch (err) {
+      t.match(err.message, /subscribe error/, 'throws error on subscribe failure')
+    }
     t.end()
   })
 
-  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')
+  pubSubTest.test('should handle error on unsubscribe', async t => {
+    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
 
-    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')
+    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')
+    }
     t.end()
   })
 
-  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
+  pubSubTest.test('should handle error on broadcast', async t => {
+    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
 
-    t.deepEqual(connectionStatus, { publisherConnected: true, subscriberConnected: true }, 'isConnected returns correct statuses')
+    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')
+    }
     t.end()
   })
 
-  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
+  pubSubTest.test('should call callback with parsed message on subscribe', async t => {
+    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
 
-    t.deepEqual(connectionStatus, { publisherConnected: false, subscriberConnected: false }, 'isConnected returns false statuses when clients are not connected')
+    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')
     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' }
-
-    sandbox.stub(pubSub.publisherClient, 'spublish').resolves()
 
-    await pubSub.publish(channel, message)
+  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.ok(pubSub.publisherClient.spublish.calledWith(channel, JSON.stringify(message)), 'spublish called with correct arguments')
+    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.end()
   })
 
-  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)
-    const channel = 'cluster-channel'
-    const message = { key: 'cluster-value' }
-    const error = new Error('Cluster spublish error')
-
-    sandbox.stub(pubSub.publisherClient, 'spublish').rejects(error)
+  pubSubTest.test('should not call callback if subscribedChannel does not match', async t => {
+    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
 
-    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')
-    }
+    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.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' })
+  pubSubTest.test('should add event listeners to publisher and subscriber clients', t => {
+    pubSub = new PubSub({ host: 'localhost', port: 6379 }, publisherStub, subscriberStub)
 
-    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')
+    // 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}'`
+      )
+    }
     t.end()
   })
 
-  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 }] }
+  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
     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')
+    // 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()
+    }
+    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()
   })
 
-  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')
+  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.end()
   })
 
-  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')
+  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.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')
+  pubSubTest.test('should log info on subscriber client ready 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 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()
   })
 
-  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')
+  pubSubTest.test('should log info on subscriber 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 = 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()
   })
 
-  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')
+  pubSubTest.test('should log error on subscriber 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 = 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()
   })
-  t.end()
+  pubSubTest.end()
 })