@onlineapps/conn-base-cache 1.0.0

package/test/unit/CacheConnector.test.js

@@ -0,0 +1,811 @@
+'use strict';
+
+/**
+ * Unit tests for CacheConnector
+ * Tests individual methods in isolation with mocked Redis client
+ */
+
+jest.mock('ioredis');
+const Redis = require('ioredis');
+const CacheConnector = require('../../src/index');
+
+describe('CacheConnector - Unit Tests', () => {
+  let cacheConnector;
+  let mockRedisClient;
+
+  beforeEach(() => {
+    // Create mock Redis client with all methods
+    mockRedisClient = {
+      get: jest.fn(),
+      set: jest.fn(),
+      setex: jest.fn(),
+      del: jest.fn(),
+      exists: jest.fn(),
+      expire: jest.fn(),
+      ttl: jest.fn(),
+      keys: jest.fn(),
+      scan: jest.fn(),
+      mget: jest.fn(),
+      pipeline: jest.fn(),
+      incr: jest.fn(),
+      decr: jest.fn(),
+      incrby: jest.fn(),
+      decrby: jest.fn(),
+      on: jest.fn(),
+      connect: jest.fn().mockResolvedValue(),
+      ping: jest.fn().mockResolvedValue('PONG'),
+      quit: jest.fn().mockResolvedValue('OK')
+    };
+
+    // Mock Redis constructor
+    Redis.mockImplementation(() => mockRedisClient);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should initialize with default configuration', () => {
+      const cache = new CacheConnector();
+      expect(cache.config.host).toBe('localhost');
+      expect(cache.config.port).toBe(6379);
+      expect(cache.config.keyPrefix).toBe('cache:');
+      expect(cache.config.defaultTTL).toBe(3600);
+      expect(cache.namespace).toBe('');
+      expect(cache.connected).toBe(false);
+    });
+
+    it('should use custom configuration', () => {
+      const cache = new CacheConnector({
+        host: 'redis.example.com',
+        port: 6380,
+        namespace: 'my-service',
+        defaultTTL: 1800
+      });
+
+      expect(cache.config.host).toBe('redis.example.com');
+      expect(cache.config.port).toBe(6380);
+      expect(cache.namespace).toBe('my-service');
+      expect(cache.config.defaultTTL).toBe(1800);
+    });
+
+    it('should use environment variables', () => {
+      process.env.REDIS_HOST = 'env-redis';
+      process.env.REDIS_PORT = '6381';
+
+      const cache = new CacheConnector();
+
+      expect(cache.config.host).toBe('env-redis');
+      expect(cache.config.port).toBe('6381');
+
+      delete process.env.REDIS_HOST;
+      delete process.env.REDIS_PORT;
+    });
+
+    it('should initialize statistics', () => {
+      const cache = new CacheConnector();
+      expect(cache.stats).toEqual({
+        hits: 0,
+        misses: 0,
+        sets: 0,
+        deletes: 0,
+        errors: 0
+      });
+    });
+  });
+
+  describe('connect', () => {
+    beforeEach(() => {
+      cacheConnector = new CacheConnector({
+        namespace: 'test-service'
+      });
+    });
+
+    it('should establish Redis connection', async () => {
+      await cacheConnector.connect();
+
+      expect(Redis).toHaveBeenCalledWith(
+        expect.objectContaining({
+          host: 'localhost',
+          port: 6379,
+          keyPrefix: 'cache:'
+        })
+      );
+      expect(mockRedisClient.connect).toHaveBeenCalled();
+      expect(cacheConnector.connected).toBe(true);
+    });
+
+    it('should setup event listeners', async () => {
+      await cacheConnector.connect();
+
+      expect(mockRedisClient.on).toHaveBeenCalledWith('connect', expect.any(Function));
+      expect(mockRedisClient.on).toHaveBeenCalledWith('error', expect.any(Function));
+      expect(mockRedisClient.on).toHaveBeenCalledWith('close', expect.any(Function));
+    });
+
+    it('should not reconnect if already connected', async () => {
+      await cacheConnector.connect();
+      jest.clearAllMocks();
+
+      const result = await cacheConnector.connect();
+
+      expect(Redis).not.toHaveBeenCalled();
+      expect(result).toBe(true);
+    });
+
+    it('should handle connection errors', async () => {
+      mockRedisClient.connect.mockRejectedValueOnce(new Error('Connection refused'));
+
+      await expect(cacheConnector.connect()).rejects.toThrow('Failed to connect to Redis');
+    });
+  });
+
+  describe('disconnect', () => {
+    beforeEach(async () => {
+      cacheConnector = new CacheConnector({
+        namespace: 'test-service'
+      });
+      await cacheConnector.connect();
+    });
+
+    it('should close Redis connection', async () => {
+      await cacheConnector.disconnect();
+
+      expect(mockRedisClient.quit).toHaveBeenCalled();
+      expect(cacheConnector.connected).toBe(false);
+      expect(cacheConnector.client).toBe(null);
+    });
+
+    it('should handle disconnect when not connected', async () => {
+      cacheConnector.connected = false;
+      cacheConnector.client = null;
+
+      await cacheConnector.disconnect();
+
+      expect(mockRedisClient.quit).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('get', () => {
+    beforeEach(async () => {
+      cacheConnector = new CacheConnector({
+        namespace: 'test-service'
+      });
+      await cacheConnector.connect();
+    });
+
+    it('should get and deserialize JSON value', async () => {
+      mockRedisClient.get.mockResolvedValue(JSON.stringify({ data: 'test' }));
+
+      const result = await cacheConnector.get('key1');
+
+      expect(mockRedisClient.get).toHaveBeenCalledWith('test-service:key1');
+      expect(result).toEqual({ data: 'test' });
+      expect(cacheConnector.stats.hits).toBe(1);
+    });
+
+    it('should return string value as-is', async () => {
+      mockRedisClient.get.mockResolvedValue('plain string');
+
+      const result = await cacheConnector.get('key2');
+
+      expect(result).toBe('plain string');
+      expect(cacheConnector.stats.hits).toBe(1);
+    });
+
+    it('should return null for missing key', async () => {
+      mockRedisClient.get.mockResolvedValue(null);
+
+      const result = await cacheConnector.get('missing');
+
+      expect(result).toBe(null);
+      expect(cacheConnector.stats.misses).toBe(1);
+    });
+
+    it('should handle get errors', async () => {
+      mockRedisClient.get.mockRejectedValue(new Error('Redis error'));
+
+      await expect(cacheConnector.get('key')).rejects.toThrow('Cache get failed');
+      expect(cacheConnector.stats.errors).toBe(1);
+    });
+
+    it('should work without namespace', async () => {
+      const cache = new CacheConnector();
+      await cache.connect();
+      cache.client = mockRedisClient;
+
+      mockRedisClient.get.mockResolvedValue('"value"');
+      await cache.get('key');
+
+      expect(mockRedisClient.get).toHaveBeenCalledWith('key');
+    });
+  });
+
+  describe('set', () => {
+    beforeEach(async () => {
+      cacheConnector = new CacheConnector({
+        namespace: 'test-service',
+        defaultTTL: 3600
+      });
+      await cacheConnector.connect();
+    });
+
+    it('should set value with TTL', async () => {
+      mockRedisClient.setex.mockResolvedValue('OK');
+
+      const result = await cacheConnector.set('key1', { data: 'test' }, 300);
+
+      expect(mockRedisClient.setex).toHaveBeenCalledWith(
+        'test-service:key1',
+        300,
+        JSON.stringify({ data: 'test' })
+      );
+      expect(result).toBe(true);
+      expect(cacheConnector.stats.sets).toBe(1);
+    });
+
+    it('should use default TTL if not provided', async () => {
+      mockRedisClient.setex.mockResolvedValue('OK');
+
+      await cacheConnector.set('key2', 'value');
+
+      expect(mockRedisClient.setex).toHaveBeenCalledWith(
+        'test-service:key2',
+        3600,
+        'value'  // strings are not JSON serialized
+      );
+    });
+
+    it('should use default TTL with TTL 0', async () => {
+      mockRedisClient.setex.mockResolvedValue('OK');
+
+      await cacheConnector.set('permanent', 'forever', 0);
+
+      expect(mockRedisClient.setex).toHaveBeenCalledWith(
+        'test-service:permanent',
+        3600,  // uses default TTL
+        'forever'  // strings are not JSON serialized
+      );
+    });
+
+    it('should handle string values', async () => {
+      mockRedisClient.setex.mockResolvedValue('OK');
+
+      await cacheConnector.set('string', 'plain text', 100);
+
+      expect(mockRedisClient.setex).toHaveBeenCalledWith(
+        'test-service:string',
+        100,
+        'plain text'
+      );
+    });
+
+    it('should handle set errors', async () => {
+      mockRedisClient.setex.mockRejectedValue(new Error('Redis error'));
+
+      await expect(cacheConnector.set('key', 'value')).rejects.toThrow('Cache set failed');
+      expect(cacheConnector.stats.errors).toBe(1);
+    });
+  });
+
+  describe('delete', () => {
+    beforeEach(async () => {
+      cacheConnector = new CacheConnector({
+        namespace: 'test-service'
+      });
+      await cacheConnector.connect();
+    });
+
+    it('should delete single key', async () => {
+      mockRedisClient.del.mockResolvedValue(1);
+
+      const result = await cacheConnector.delete('key1');
+
+      expect(mockRedisClient.del).toHaveBeenCalledWith('test-service:key1');
+      expect(result).toBe(true);
+      expect(cacheConnector.stats.deletes).toBe(1);
+    });
+
+    it('should return false for non-existent key', async () => {
+      mockRedisClient.del.mockResolvedValue(0);
+
+      const result = await cacheConnector.delete('missing');
+
+      expect(result).toBe(false);
+      expect(cacheConnector.stats.deletes).toBe(1);
+    });
+
+    it('should handle delete errors', async () => {
+      mockRedisClient.del.mockRejectedValue(new Error('Redis error'));
+
+      await expect(cacheConnector.delete('key')).rejects.toThrow('Cache delete failed');
+      expect(cacheConnector.stats.errors).toBe(1);
+    });
+  });
+
+  describe('deleteByPattern', () => {
+    beforeEach(async () => {
+      cacheConnector = new CacheConnector({
+        namespace: 'test-service'
+      });
+      await cacheConnector.connect();
+    });
+
+    it('should delete keys matching pattern', async () => {
+      mockRedisClient.keys.mockResolvedValue([
+        'cache:test-service:user:1',
+        'cache:test-service:user:2'
+      ]);
+      mockRedisClient.del.mockResolvedValue(2);
+
+      const result = await cacheConnector.deleteByPattern('user:*');
+
+      expect(mockRedisClient.keys).toHaveBeenCalledWith('cache:test-service:user:*');
+      expect(mockRedisClient.del).toHaveBeenCalledWith(
+        'test-service:user:1',
+        'test-service:user:2'
+      );
+      expect(result).toBe(2);
+      expect(cacheConnector.stats.deletes).toBe(2);
+    });
+
+    it('should handle no matching keys', async () => {
+      mockRedisClient.keys.mockResolvedValue([]);
+
+      const result = await cacheConnector.deleteByPattern('nomatch:*');
+
+      expect(result).toBe(0);
+      expect(mockRedisClient.del).not.toHaveBeenCalled();
+    });
+
+    it('should handle pattern errors', async () => {
+      mockRedisClient.keys.mockRejectedValue(new Error('Redis error'));
+
+      await expect(cacheConnector.deleteByPattern('*')).rejects.toThrow('Pattern delete failed');
+      expect(cacheConnector.stats.errors).toBe(1);
+    });
+  });
+
+  describe('exists', () => {
+    beforeEach(async () => {
+      cacheConnector = new CacheConnector({
+        namespace: 'test-service'
+      });
+      await cacheConnector.connect();
+    });
+
+    it('should check if key exists', async () => {
+      mockRedisClient.exists.mockResolvedValue(1);
+
+      const result = await cacheConnector.exists('key1');
+
+      expect(mockRedisClient.exists).toHaveBeenCalledWith('test-service:key1');
+      expect(result).toBe(true);
+    });
+
+    it('should return false for non-existent key', async () => {
+      mockRedisClient.exists.mockResolvedValue(0);
+
+      const result = await cacheConnector.exists('missing');
+
+      expect(result).toBe(false);
+    });
+
+    it('should handle exists errors', async () => {
+      mockRedisClient.exists.mockRejectedValue(new Error('Redis error'));
+
+      await expect(cacheConnector.exists('key')).rejects.toThrow('Cache exists check failed');
+      expect(cacheConnector.stats.errors).toBe(1);
+    });
+  });
+
+  describe('ttl', () => {
+    beforeEach(async () => {
+      cacheConnector = new CacheConnector({
+        namespace: 'test-service'
+      });
+      await cacheConnector.connect();
+    });
+
+    it('should get TTL for key', async () => {
+      mockRedisClient.ttl.mockResolvedValue(300);
+
+      const result = await cacheConnector.ttl('key1');
+
+      expect(mockRedisClient.ttl).toHaveBeenCalledWith('test-service:key1');
+      expect(result).toBe(300);
+    });
+
+    it('should return -1 for non-expiring key', async () => {
+      mockRedisClient.ttl.mockResolvedValue(-1);
+
+      const result = await cacheConnector.ttl('permanent');
+
+      expect(result).toBe(-1);
+    });
+
+    it('should return -2 for non-existent key', async () => {
+      mockRedisClient.ttl.mockResolvedValue(-2);
+
+      const result = await cacheConnector.ttl('missing');
+
+      expect(result).toBe(-2);
+    });
+
+    it('should handle ttl errors', async () => {
+      mockRedisClient.ttl.mockRejectedValue(new Error('Redis error'));
+
+      await expect(cacheConnector.ttl('key')).rejects.toThrow('TTL check failed');
+      expect(cacheConnector.stats.errors).toBe(1);
+    });
+  });
+
+  describe('expire', () => {
+    beforeEach(async () => {
+      cacheConnector = new CacheConnector({
+        namespace: 'test-service'
+      });
+      await cacheConnector.connect();
+    });
+
+    it('should set expiration on key', async () => {
+      mockRedisClient.expire.mockResolvedValue(1);
+
+      const result = await cacheConnector.expire('key1', 600);
+
+      expect(mockRedisClient.expire).toHaveBeenCalledWith('test-service:key1', 600);
+      expect(result).toBe(true);
+    });
+
+    it('should return false for non-existent key', async () => {
+      mockRedisClient.expire.mockResolvedValue(0);
+
+      const result = await cacheConnector.expire('missing', 600);
+
+      expect(result).toBe(false);
+    });
+
+    it('should handle expire errors', async () => {
+      mockRedisClient.expire.mockRejectedValue(new Error('Redis error'));
+
+      await expect(cacheConnector.expire('key', 100)).rejects.toThrow('Expire failed');
+      expect(cacheConnector.stats.errors).toBe(1);
+    });
+  });
+
+  describe('incr/decr', () => {
+    beforeEach(async () => {
+      cacheConnector = new CacheConnector({
+        namespace: 'test-service'
+      });
+      await cacheConnector.connect();
+    });
+
+    it('should increment value by 1', async () => {
+      mockRedisClient.incr.mockResolvedValue(11);
+
+      const result = await cacheConnector.incr('counter');
+
+      expect(mockRedisClient.incr).toHaveBeenCalledWith('test-service:counter');
+      expect(result).toBe(11);
+    });
+
+    it('should increment value by custom amount', async () => {
+      mockRedisClient.incrby.mockResolvedValue(15);
+
+      const result = await cacheConnector.incr('counter', 5);
+
+      expect(mockRedisClient.incrby).toHaveBeenCalledWith('test-service:counter', 5);
+      expect(result).toBe(15);
+    });
+
+    it('should decrement value by 1', async () => {
+      mockRedisClient.decr.mockResolvedValue(9);
+
+      const result = await cacheConnector.decr('counter');
+
+      expect(mockRedisClient.decr).toHaveBeenCalledWith('test-service:counter');
+      expect(result).toBe(9);
+    });
+
+    it('should decrement value by custom amount', async () => {
+      mockRedisClient.decrby.mockResolvedValue(5);
+
+      const result = await cacheConnector.decr('counter', 3);
+
+      expect(mockRedisClient.decrby).toHaveBeenCalledWith('test-service:counter', 3);
+      expect(result).toBe(5);
+    });
+
+    it('should handle increment by default 1', async () => {
+      mockRedisClient.incr.mockResolvedValue(1);
+
+      const result = await cacheConnector.incr('new');
+
+      expect(mockRedisClient.incr).toHaveBeenCalledWith('test-service:new');
+      expect(result).toBe(1);
+    });
+
+    it('should handle incr errors', async () => {
+      mockRedisClient.incr.mockRejectedValue(new Error('Redis error'));
+
+      await expect(cacheConnector.incr('key')).rejects.toThrow('Increment failed');
+      expect(cacheConnector.stats.errors).toBe(1);
+    });
+
+    it('should handle decr errors', async () => {
+      mockRedisClient.decr.mockRejectedValue(new Error('Redis error'));
+
+      await expect(cacheConnector.decr('key')).rejects.toThrow('Decrement failed');
+      expect(cacheConnector.stats.errors).toBe(1);
+    });
+  });
+
+  describe('mget/mset', () => {
+    beforeEach(async () => {
+      cacheConnector = new CacheConnector({
+        namespace: 'test-service'
+      });
+      await cacheConnector.connect();
+    });
+
+    it('should get multiple values', async () => {
+      mockRedisClient.mget.mockResolvedValue([
+        JSON.stringify({ data: 'value1' }),
+        null,
+        JSON.stringify('value3')
+      ]);
+
+      const result = await cacheConnector.mget(['key1', 'key2', 'key3']);
+
+      expect(mockRedisClient.mget).toHaveBeenCalledWith(
+        'test-service:key1',
+        'test-service:key2',
+        'test-service:key3'
+      );
+      expect(result).toEqual({
+        key1: { data: 'value1' },
+        key3: 'value3'
+      });
+    });
+
+    it('should set multiple values', async () => {
+      const mockPipeline = {
+        setex: jest.fn().mockReturnThis(),
+        exec: jest.fn().mockResolvedValue([])
+      };
+      mockRedisClient.pipeline = jest.fn().mockReturnValue(mockPipeline);
+
+      const result = await cacheConnector.mset({
+        key1: 'value1',
+        key2: { data: 'value2' }
+      }, 300);
+
+      expect(mockRedisClient.pipeline).toHaveBeenCalled();
+      expect(mockPipeline.setex).toHaveBeenCalledWith(
+        'test-service:key1', 300, 'value1'
+      );
+      expect(mockPipeline.setex).toHaveBeenCalledWith(
+        'test-service:key2', 300, JSON.stringify({ data: 'value2' })
+      );
+      expect(mockPipeline.exec).toHaveBeenCalled();
+      expect(result).toBe(true);
+      expect(cacheConnector.stats.sets).toBe(2);
+    });
+
+    it('should handle mget errors', async () => {
+      mockRedisClient.mget.mockRejectedValue(new Error('Redis error'));
+
+      await expect(cacheConnector.mget(['key'])).rejects.toThrow('Multi-get failed');
+      expect(cacheConnector.stats.errors).toBe(1);
+    });
+
+    it('should handle mset errors', async () => {
+      const mockPipeline = {
+        setex: jest.fn().mockReturnThis(),
+        exec: jest.fn().mockRejectedValue(new Error('Redis error'))
+      };
+      mockRedisClient.pipeline = jest.fn().mockReturnValue(mockPipeline);
+
+      await expect(cacheConnector.mset({ key: 'value' })).rejects.toThrow('Multi-set failed');
+      expect(cacheConnector.stats.errors).toBe(1);
+    });
+  });
+
+  describe('flush', () => {
+    beforeEach(async () => {
+      cacheConnector = new CacheConnector({
+        namespace: 'test-service'
+      });
+      await cacheConnector.connect();
+    });
+
+    it('should flush database with confirmation', async () => {
+      mockRedisClient.keys.mockResolvedValue([
+        'cache:test-service:key1',
+        'cache:test-service:key2'
+      ]);
+      mockRedisClient.del.mockResolvedValue(2);
+
+      const result = await cacheConnector.flush(true);
+
+      expect(mockRedisClient.keys).toHaveBeenCalledWith('cache:*');
+      expect(mockRedisClient.del).toHaveBeenCalledWith(
+        'test-service:key1',
+        'test-service:key2'
+      );
+      expect(result).toBe(true);
+    });
+
+    it('should throw without confirmation', async () => {
+      await expect(cacheConnector.flush(false)).rejects.toThrow('Flush requires confirmation parameter to be true');
+    });
+
+    it('should throw without any parameter', async () => {
+      await expect(cacheConnector.flush()).rejects.toThrow('Flush requires confirmation parameter to be true');
+    });
+
+    it('should handle flush errors', async () => {
+      mockRedisClient.keys.mockRejectedValue(new Error('Redis error'));
+
+      await expect(cacheConnector.flush(true)).rejects.toThrow('Flush failed');
+      expect(cacheConnector.stats.errors).toBe(1);
+    });
+  });
+
+  describe('getStats', () => {
+    it('should return cache statistics', () => {
+      const cache = new CacheConnector();
+      cache.stats = {
+        hits: 10,
+        misses: 5,
+        sets: 15,
+        deletes: 3,
+        errors: 1
+      };
+
+      const stats = cache.getStats();
+
+      expect(stats.hits).toBe(10);
+      expect(stats.misses).toBe(5);
+      expect(stats.sets).toBe(15);
+      expect(stats.deletes).toBe(3);
+      expect(stats.errors).toBe(1);
+      // hitRate should be formatted as percentage string
+      expect(stats.hitRate).toBe('66.67%');
+    });
+
+    it('should handle zero operations', () => {
+      const cache = new CacheConnector();
+
+      const stats = cache.getStats();
+
+      expect(stats.hitRate).toBe('0%');
+    });
+
+    it('should handle only hits', () => {
+      const cache = new CacheConnector();
+      cache.stats.hits = 10;
+
+      const stats = cache.getStats();
+
+      expect(stats.hitRate).toBe('100.00%');
+    });
+  });
+
+  describe('resetStats', () => {
+    it('should reset all statistics', () => {
+      const cache = new CacheConnector();
+      cache.stats = {
+        hits: 10,
+        misses: 5,
+        sets: 15,
+        deletes: 3,
+        errors: 1
+      };
+
+      cache.resetStats();
+
+      expect(cache.stats).toEqual({
+        hits: 0,
+        misses: 0,
+        sets: 0,
+        deletes: 0,
+        errors: 0
+      });
+    });
+  });
+
+  describe('healthCheck', () => {
+    beforeEach(async () => {
+      cacheConnector = new CacheConnector();
+      await cacheConnector.connect();
+    });
+
+    it('should return true when healthy', async () => {
+      mockRedisClient.ping.mockResolvedValue('PONG');
+
+      const result = await cacheConnector.healthCheck();
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false when unhealthy', async () => {
+      mockRedisClient.ping.mockRejectedValue(new Error('Connection lost'));
+
+      const result = await cacheConnector.healthCheck();
+
+      expect(result).toBe(false);
+    });
+
+    it('should not throw when client is null', async () => {
+      cacheConnector.client = null;
+
+      const result = await cacheConnector.healthCheck();
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('static methods', () => {
+    it('should create instance with create method', () => {
+      const cache = CacheConnector.create({
+        namespace: 'static-test'
+      });
+
+      expect(cache).toBeInstanceOf(CacheConnector);
+      expect(cache.namespace).toBe('static-test');
+    });
+  });
+
+  describe('withNamespace', () => {
+    it('should create new instance with combined namespace', async () => {
+      const cache1 = new CacheConnector({ namespace: 'service1' });
+      const cache2 = cache1.withNamespace('subsection');
+
+      expect(cache2).toBeInstanceOf(CacheConnector);
+      expect(cache2.namespace).toBe('service1:subsection');
+      expect(cache1.namespace).toBe('service1');
+      expect(cache2).not.toBe(cache1);
+    });
+  });
+
+  describe('wrap function', () => {
+    beforeEach(async () => {
+      cacheConnector = new CacheConnector({ namespace: 'test' });
+      await cacheConnector.connect();
+    });
+
+    it('should cache function results', async () => {
+      const expensiveFn = jest.fn().mockResolvedValue({ data: 'result' });
+      const wrapped = cacheConnector.wrap(expensiveFn, {
+        keyPrefix: 'fn',
+        ttl: 300
+      });
+
+      mockRedisClient.get.mockResolvedValueOnce(null);
+      mockRedisClient.setex.mockResolvedValue('OK');
+
+      // First call - cache miss
+      const result1 = await wrapped('arg1', 'arg2');
+      expect(expensiveFn).toHaveBeenCalledWith('arg1', 'arg2');
+      expect(result1).toEqual({ data: 'result' });
+
+      // Second call - cache hit
+      mockRedisClient.get.mockResolvedValueOnce(JSON.stringify({ data: 'result' }));
+      const result2 = await wrapped('arg1', 'arg2');
+      expect(expensiveFn).toHaveBeenCalledTimes(1);
+      expect(result2).toEqual({ data: 'result' });
+    });
+
+    it('should handle wrap errors', async () => {
+      const failingFn = jest.fn().mockRejectedValue(new Error('Function failed'));
+      const wrapped = cacheConnector.wrap(failingFn);
+
+      mockRedisClient.get.mockResolvedValue(null);
+
+      await expect(wrapped('arg')).rejects.toThrow('Function failed');
+    });
+  });
+});