@mojaloop/central-services-shared 18.23.3 → 18.24.0-snapshot.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojaloop/central-services-shared",
-  "version": "18.23.3",
+  "version": "18.24.0-snapshot.2",
   "description": "Shared code for mojaloop central services",
   "license": "Apache-2.0",
   "author": "ModusBox",

package/src/index.d.ts

@@ -1,5 +1,6 @@
 import { Utils as HapiUtil, Server } from '@hapi/hapi'
 import { ILogger } from '@mojaloop/central-services-logger/src/contextLogger'
+import IORedis from 'ioredis';
 
 declare namespace CentralServicesShared {
   interface ReturnCode {
@@ -663,7 +664,7 @@ declare namespace CentralServicesShared {
   type ProtocolResources = string[]
   type ProtocolVersions = (string | symbol)[]
   type ApiTypeValues = 'fspiop' | 'iso20022'
-  type APIDocumentationPluginOptions = 
+  type APIDocumentationPluginOptions =
   | { documentPath: string; document?: never }
   | { document?: string; documentPath?: never }
 
@@ -707,7 +708,7 @@ declare namespace CentralServicesShared {
       plugin: {
         name: string,
         register: (server: Server) => void
-      }      
+      }
     };
     customCurrencyCodeValidation: (joi: any) => {
       base: any;
@@ -735,6 +736,37 @@ declare namespace CentralServicesShared {
   }
   // todo: define the rest of the types
 
+  interface PubSub {
+    (config: object, publisherClient?: IORedis, subscriberClient?: IORedis): PubSub;
+    new (config: object, publisherClient: IORedis, subscriberClient: IORedis): PubSub;
+    connect(): Promise<void>;
+    disconnect(): Promise<boolean>;
+    healthCheck(): Promise<boolean>;
+    isConnected: { publisherConnected: boolean; subscriberConnected: boolean };
+    publish(channel: string, message: any): Promise<void>;
+    subscribe(channel: string, callback: (message: any) => void): Promise<string>;
+    unsubscribe(channel: string): Promise<void>;
+    broadcast(channels: string[], message: any): Promise<void>;
+  }
+
+  interface RedisCache {
+    (config: object, client?: IORedis): RedisCache;
+    new (config: object, client?: IORedis): RedisCache;
+    connect(): Promise<boolean>;
+    disconnect(): Promise<boolean>;
+    healthCheck(): Promise<boolean>;
+    isConnected: boolean;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, ttl?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    clearCache(): Promise<void>;
+  }
+
+  interface Redis {
+    PubSub: PubSub;
+    Cache: RedisCache;
+  }
+
   interface Util {
     Endpoints: Endpoints;
     Participants: Participants;
@@ -745,6 +777,7 @@ declare namespace CentralServicesShared {
     Request: Request;
     StreamingProtocol: StreamingProtocol;
     HeaderValidation: HeaderValidation;
+    Redis: Redis;
   }
 
   const Enum: Enum

package/src/util/createLogger.js

@@ -0,0 +1,37 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop Foundation under the Apache License, Version 2.0 (the "License") and you may not use these files except in compliance with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, the Mojaloop files are distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+ Contributors
+ --------------
+ This is the official list of the Mojaloop project contributors for this file.
+ Names of the original copyright holders (individuals or organizations)
+ should be listed with a '*' in the first column. People who have
+ contributed from an organization can be listed under the organization
+ that actually holds the copyright for their contributions (see the
+ Mojaloop Foundation for an example). Those individuals should have
+ their names indented and be marked with a '-'. Email address can be added
+ optionally within square brackets <email>.
+
+ * Mojaloop Foundation
+ - Name Surname <name.surname@mojaloop.io>
+
+ * Kevin Leyow <kevin.leyow@infitx.com>
+
+ --------------
+ ******/
+
+const { logger } = require('../logger')
+const config = require('../config')
+
+exports.createLogger = (component) => {
+  const log = logger.child({ component })
+  log.setLevel(config.get('logLevel'))
+  return log
+}

package/src/util/index.js

@@ -31,8 +31,6 @@
 'use strict'
 
 const _ = require('lodash')
-const { logger } = require('../logger')
-const config = require('../config')
 
 const Kafka = require('./kafka')
 const Endpoints = require('./endpoints')
@@ -55,6 +53,8 @@ const Schema = require('./schema')
 const OpenapiBackend = require('./openapiBackend')
 const id = require('./id')
 const rethrow = require('./rethrow')
+const Redis = require('./redis')
+const createLogger = require('./createLogger')
 
 const omitNil = (object) => {
   return _.omitBy(object, _.isNil)
@@ -226,12 +226,6 @@ const filterExtensions = (extensionsArray, exclKeysArray, exclValuesArray) => {
   })
 }
 
-const createLogger = (component) => {
-  const log = logger.child({ component })
-  log.setLevel(config.get('logLevel'))
-  return log
-}
-
 module.exports = {
   createLogger,
   assign,
@@ -272,5 +266,6 @@ module.exports = {
   OpenapiBackend,
   id,
   resourceVersions: Helpers.resourceVersions,
-  rethrow
+  rethrow,
+  Redis
 }

package/src/util/redis/index.js

@@ -0,0 +1,36 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop Foundation under the Apache License, Version 2.0 (the "License") and you may not use these files except in compliance with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, the Mojaloop files are distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+ Contributors
+ --------------
+ This is the official list of the Mojaloop project contributors for this file.
+ Names of the original copyright holders (individuals or organizations)
+ should be listed with a '*' in the first column. People who have
+ contributed from an organization can be listed under the organization
+ that actually holds the copyright for their contributions (see the
+ Mojaloop Foundation for an example). Those individuals should have
+ their names indented and be marked with a '-'. Email address can be added
+ optionally within square brackets <email>.
+
+ * Mojaloop Foundation
+ - Name Surname <name.surname@mojaloop.io>
+
+ * Kevin Leyow <kevin.leyow@infitx.com>
+
+ --------------
+ ******/
+
+const RedisCache = require('./redisCache')
+const PubSub = require('./pubSub')
+
+module.exports = {
+  RedisCache,
+  PubSub
+}

package/src/util/redis/pubSub.js

@@ -0,0 +1,163 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop Foundation under the Apache License, Version 2.0 (the "License") and you may not use these files except in compliance with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, the Mojaloop files are distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+ Contributors
+ --------------
+ This is the official list of the Mojaloop project contributors for this file.
+ Names of the original copyright holders (individuals or organizations)
+ should be listed with a '*' in the first column. People who have
+ contributed from an organization can be listed under the organization
+ that actually holds the copyright for their contributions (see the
+ Mojaloop Foundation for an example). Those individuals should have
+ their names indented and be marked with a '-'. Email address can be added
+ optionally within square brackets <email>.
+
+ * Mojaloop Foundation
+ - Name Surname <name.surname@mojaloop.io>
+
+ * Kevin Leyow <kevin.leyow@infitx.com>
+
+ --------------
+ ******/
+
+'use strict'
+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)
+    this.publisherClient = publisherClient || this.createRedisClient()
+    this.subscriberClient = subscriberClient || this.createRedisClient()
+    this.addEventListeners(this.publisherClient)
+    this.addEventListeners(this.subscriberClient)
+  }
+
+  createRedisClient () {
+    this.config.lazyConnect ??= true
+    return this.isCluster
+      ? new Redis.Cluster(this.config.cluster, this.config)
+      : new Redis(this.config)
+  }
+
+  async connect () {
+    try {
+      await this.publisherClient.connect()
+      await this.subscriberClient.connect()
+      this.log.info('Redis clients connected successfully')
+    } catch (err) {
+      this.log.error('Error connecting Redis clients:', err)
+      rethrowRedisError(err)
+    }
+  }
+
+  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()
+      this.log.info('Redis clients disconnected successfully')
+      return isDisconnected
+    } catch (err) {
+      this.log.error('Error disconnecting Redis clients:', err)
+      rethrowRedisError(err)
+    }
+  }
+
+  async healthCheck () {
+    try {
+      const publisherStatus = await this.publisherClient.ping()
+      const subscriberStatus = await this.subscriberClient.ping()
+      const isHealthy = publisherStatus === 'PONG' && subscriberStatus === 'PONG'
+      this.log.debug(`Redis health check: ${isHealthy ? 'Healthy' : 'Unhealthy'}`)
+      return isHealthy
+    } catch (err) {
+      this.log.error('Error performing Redis health check:', err)
+      return false
+    }
+  }
+
+  get isConnected () {
+    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
+    })
+    return { publisherConnected, subscriberConnected }
+  }
+
+  addEventListeners (client) {
+    client.on('connect', () => this.log.info('Redis client connected'))
+    client.on('error', (err) => this.log.error('Redis client error:', err))
+  }
+
+  async publish (channel, message) {
+    try {
+      await this.publisherClient.publish(channel, JSON.stringify(message))
+      this.log.info(`Message published to channel: ${channel}`)
+    } catch (err) {
+      this.log.error('Error publishing message:', err)
+      rethrowRedisError(err)
+    }
+  }
+
+  async subscribe (channel, callback) {
+    try {
+      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}`)
+      return channel
+    } catch (err) {
+      this.log.error('Error subscribing to channel:', err)
+      rethrowRedisError(err)
+    }
+  }
+
+  async unsubscribe (channel) {
+    try {
+      await this.subscriberClient.unsubscribe(channel)
+      this.log.info(`Unsubscribed from channel: ${channel}`)
+    } catch (err) {
+      this.log.error('Error unsubscribing from channel:', err)
+      rethrowRedisError(err)
+    }
+  }
+
+  async broadcast (channels, message) {
+    try {
+      for (const channel of channels) {
+        await this.publish(channel, message)
+      }
+      this.log.info(`Message broadcasted to channels: ${channels.join(', ')}`)
+    } catch (err) {
+      this.log.error('Error broadcasting message:', err)
+      rethrowRedisError(err)
+    }
+  }
+}
+
+module.exports = PubSub

package/src/util/redis/redisCache.js

@@ -1,5 +1,34 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop Foundation under the Apache License, Version 2.0 (the "License") and you may not use these files except in compliance with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, the Mojaloop files are distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+ Contributors
+ --------------
+ This is the official list of the Mojaloop project contributors for this file.
+ Names of the original copyright holders (individuals or organizations)
+ should be listed with a '*' in the first column. People who have
+ contributed from an organization can be listed under the organization
+ that actually holds the copyright for their contributions (see the
+ Mojaloop Foundation for an example). Those individuals should have
+ their names indented and be marked with a '-'. Email address can be added
+ optionally within square brackets <email>.
+
+ * Mojaloop Foundation
+ - Name Surname <name.surname@mojaloop.io>
+
+ * Kevin Leyow <kevin.leyow@infitx.com>
+
+ --------------
+ ******/
+
 const Redis = require('ioredis')
-const { createLogger } = require('../index')
+const { createLogger } = require('../createLogger')
 const { REDIS_SUCCESS, REDIS_IS_CONNECTED_STATUSES } = require('../../constants')
 const isClusterConfig = (config) => { return 'cluster' in config }
 const { rethrowRedisError } = require('../rethrow')

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

@@ -0,0 +1,375 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop Foundation under the Apache License, Version 2.0 (the "License") and you may not use these files except in compliance with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, the Mojaloop files are distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+ Contributors
+ --------------
+ This is the official list of the Mojaloop project contributors for this file.
+ Names of the original copyright holders (individuals or organizations)
+ should be listed with a '*' in the first column. People who have
+ contributed from an organization can be listed under the organization
+ that actually holds the copyright for their contributions (see the
+ Mojaloop Foundation for an example). Those individuals should have
+ their names indented and be marked with a '-'. Email address can be added
+ optionally within square brackets <email>.
+
+ * Mojaloop Foundation
+ - Name Surname <name.surname@mojaloop.io>
+
+ * Kevin Leyow <kevin.leyow@modusbox.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')
+
+Test('PubSub', (t) => {
+  let sandbox
+
+  t.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')
+    t.end()
+  })
+
+  t.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)
+
+    t.ok(pubSub.publisherClient.publish.calledWith(channel, JSON.stringify(message)), 'publish called with correct arguments')
+    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)
+
+    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()
+  })
+
+  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)
+
+    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()
+  })
+
+  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')
+
+    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()
+  })
+
+  t.test('should unsubscribe from a channel', async (t) => {
+    const config = {}
+    const pubSub = new PubSub(config)
+    const channel = 'test-channel'
+
+    await pubSub.unsubscribe(channel)
+
+    t.ok(pubSub.subscriberClient.unsubscribe.calledWith(channel), 'unsubscribe called with correct channel')
+    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)
+
+    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()
+  })
+
+  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)
+
+    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()
+  })
+
+  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)
+
+    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()
+  })
+
+  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()
+
+    t.ok(pubSub.publisherClient.connect.calledOnce, 'publisherClient connect called once')
+    t.ok(pubSub.subscriberClient.connect.calledOnce, 'subscriberClient connect called once')
+    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()
+
+    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()
+  })
+
+  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)
+
+    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()
+  })
+
+  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()
+
+    t.ok(pubSub.publisherClient.connect.calledOnce, 'publisherClient connect called once')
+    t.ok(pubSub.subscriberClient.connect.calledOnce, 'subscriberClient connect called once')
+    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()
+
+    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()
+  })
+
+  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()
+
+    try {
+      await pubSub.disconnect()
+      t.fail('Should have thrown an error')
+    } catch (err) {
+      t.deepEqual(err, constructSystemExtensionError(error, '["redis"]'), 'Error thrown and rethrown correctly')
+    }
+    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()
+
+    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()
+  })
+
+  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()
+
+    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()
+  })
+
+  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')
+
+    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()
+  })
+
+  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
+
+    t.deepEqual(connectionStatus, { publisherConnected: true, subscriberConnected: true }, 'isConnected returns correct statuses')
+    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
+
+    t.deepEqual(connectionStatus, { publisherConnected: false, subscriberConnected: false }, 'isConnected returns false statuses when clients are not connected')
+    t.end()
+  })
+  t.end()
+})