@onlineapps/conn-base-cache 1.0.0

package/test/unit/CacheConnector.edge.test.js

@@ -0,0 +1,532 @@
+'use strict';
+
+/**
+ * Edge case tests for CacheConnector
+ * Tests boundary conditions, edge cases, and error scenarios for better coverage
+ */
+
+jest.mock('ioredis');
+const Redis = require('ioredis');
+const CacheConnector = require('../../src/index');
+
+describe('CacheConnector - Edge Cases & Full Coverage', () => {
+  let cacheConnector;
+  let mockRedisClient;
+
+  beforeEach(() => {
+    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(),
+      mset: jest.fn(),
+      flushdb: jest.fn(),
+      on: jest.fn(),
+      connect: jest.fn().mockResolvedValue(),
+      ping: jest.fn().mockResolvedValue('PONG'),
+      quit: jest.fn().mockResolvedValue('OK'),
+      disconnect: jest.fn().mockResolvedValue('OK')
+    };
+
+    Redis.mockImplementation(() => mockRedisClient);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('Constructor Edge Cases', () => {
+    it('should handle undefined config', () => {
+      const cache = new CacheConnector(undefined);
+      expect(cache.config).toBeDefined();
+      expect(cache.config.host).toBe('localhost');
+    });
+
+    it('should handle null config', () => {
+      const cache = new CacheConnector(null);
+      expect(cache.config).toBeDefined();
+    });
+
+    it('should use environment variables when available', () => {
+      process.env.REDIS_HOST = 'env-host';
+      process.env.REDIS_PORT = '6380';
+      process.env.REDIS_PASSWORD = 'secret';
+      process.env.REDIS_DB = '2';
+
+      const cache = new CacheConnector();
+
+      expect(cache.config.host).toBe('env-host');
+      expect(cache.config.port).toBe('6380');
+      expect(cache.config.password).toBe('secret');
+      expect(cache.config.db).toBe('2');
+
+      // Cleanup
+      delete process.env.REDIS_HOST;
+      delete process.env.REDIS_PORT;
+      delete process.env.REDIS_PASSWORD;
+      delete process.env.REDIS_DB;
+    });
+
+    it('should handle empty namespace', () => {
+      const cache = new CacheConnector({ namespace: '' });
+      expect(cache.namespace).toBe('');
+    });
+
+    it('should handle very long namespace', () => {
+      const longNamespace = 'a'.repeat(1000);
+      const cache = new CacheConnector({ namespace: longNamespace });
+      expect(cache.namespace).toBe(longNamespace);
+    });
+  });
+
+  describe('Connection Edge Cases', () => {
+    beforeEach(() => {
+      cacheConnector = new CacheConnector();
+    });
+
+    it('should handle connection timeout', async () => {
+      mockRedisClient.on.mockImplementation((event, handler) => {
+        if (event === 'error') {
+          setTimeout(() => handler(new Error('Connection timeout')), 0);
+        }
+      });
+
+      await cacheConnector.connect();
+
+      expect(mockRedisClient.on).toHaveBeenCalledWith('error', expect.any(Function));
+    });
+
+    it('should handle Redis auth error', async () => {
+      Redis.mockImplementationOnce(() => {
+        throw new Error('ERR invalid password');
+      });
+
+      await expect(cacheConnector.connect()).rejects.toThrow('ERR invalid password');
+    });
+
+    it('should handle multiple rapid connect calls', async () => {
+      const promises = [
+        cacheConnector.connect(),
+        cacheConnector.connect(),
+        cacheConnector.connect()
+      ];
+
+      await Promise.all(promises);
+
+      // Should only create one Redis instance
+      expect(Redis).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle disconnect during operation', async () => {
+      await cacheConnector.connect();
+
+      // Simulate disconnect during operation
+      mockRedisClient.get.mockImplementation(() => {
+        cacheConnector.connected = false;
+        throw new Error('Connection lost');
+      });
+
+      await expect(cacheConnector.get('key')).rejects.toThrow();
+    });
+  });
+
+  describe('Data Type Edge Cases', () => {
+    beforeEach(async () => {
+      cacheConnector = new CacheConnector();
+      await cacheConnector.connect();
+    });
+
+    it('should handle null values', async () => {
+      mockRedisClient.setex.mockResolvedValue('OK');
+      await cacheConnector.set('null', null);
+
+      mockRedisClient.get.mockResolvedValue(JSON.stringify(null));
+      const value = await cacheConnector.get('null');
+
+      expect(value).toBe(null);
+    });
+
+    it('should handle undefined values', async () => {
+      mockRedisClient.setex.mockResolvedValue('OK');
+      await cacheConnector.set('undefined', undefined);
+
+      mockRedisClient.get.mockResolvedValue(JSON.stringify(undefined));
+      const value = await cacheConnector.get('undefined');
+
+      expect(value).toBe(undefined);
+    });
+
+    it('should handle empty string', async () => {
+      mockRedisClient.setex.mockResolvedValue('OK');
+      await cacheConnector.set('empty', '');
+
+      mockRedisClient.get.mockResolvedValue(JSON.stringify(''));
+      const value = await cacheConnector.get('empty');
+
+      expect(value).toBe('');
+    });
+
+    it('should handle special characters in keys', async () => {
+      const specialKey = 'key:with:colons:and-dashes_underscores.dots';
+      mockRedisClient.setex.mockResolvedValue('OK');
+
+      await cacheConnector.set(specialKey, 'value');
+
+      expect(mockRedisClient.setex).toHaveBeenCalledWith(
+        expect.stringContaining(specialKey),
+        expect.any(Number),
+        expect.any(String)
+      );
+    });
+
+    it('should handle very large strings', async () => {
+      const largeString = 'x'.repeat(1024 * 1024); // 1MB string
+      mockRedisClient.setex.mockResolvedValue('OK');
+
+      await cacheConnector.set('large', largeString);
+
+      expect(mockRedisClient.setex).toHaveBeenCalled();
+    });
+
+    it('should handle special numbers', async () => {
+      mockRedisClient.setex.mockResolvedValue('OK');
+
+      // Infinity
+      await cacheConnector.set('infinity', Infinity);
+      // NaN
+      await cacheConnector.set('nan', NaN);
+      // Very large number
+      await cacheConnector.set('large-num', Number.MAX_SAFE_INTEGER);
+      // Very small number
+      await cacheConnector.set('small-num', Number.MIN_SAFE_INTEGER);
+
+      expect(mockRedisClient.setex).toHaveBeenCalledTimes(4);
+    });
+
+    it('should handle dates', async () => {
+      const date = new Date('2024-01-01');
+      mockRedisClient.setex.mockResolvedValue('OK');
+
+      await cacheConnector.set('date', date);
+
+      mockRedisClient.get.mockResolvedValue(JSON.stringify(date));
+      const retrieved = await cacheConnector.get('date');
+
+      expect(new Date(retrieved)).toEqual(date);
+    });
+  });
+
+  describe('TTL Edge Cases', () => {
+    beforeEach(async () => {
+      cacheConnector = new CacheConnector({ defaultTTL: 100 });
+      await cacheConnector.connect();
+    });
+
+    it('should handle zero TTL', async () => {
+      mockRedisClient.setex.mockResolvedValue('OK');
+
+      await cacheConnector.set('zero-ttl', 'value', 0);
+
+      // Should use default TTL when 0 is provided
+      expect(mockRedisClient.setex).toHaveBeenCalledWith(
+        expect.any(String),
+        100, // default TTL
+        expect.any(String)
+      );
+    });
+
+    it('should handle negative TTL', async () => {
+      mockRedisClient.setex.mockResolvedValue('OK');
+
+      await cacheConnector.set('neg-ttl', 'value', -1);
+
+      // Should use default TTL for negative values
+      expect(mockRedisClient.setex).toHaveBeenCalledWith(
+        expect.any(String),
+        100, // default TTL
+        expect.any(String)
+      );
+    });
+
+    it('should handle very large TTL', async () => {
+      mockRedisClient.setex.mockResolvedValue('OK');
+
+      const maxTTL = Number.MAX_SAFE_INTEGER;
+      await cacheConnector.set('max-ttl', 'value', maxTTL);
+
+      expect(mockRedisClient.setex).toHaveBeenCalledWith(
+        expect.any(String),
+        maxTTL,
+        expect.any(String)
+      );
+    });
+
+    it('should handle non-numeric TTL', async () => {
+      mockRedisClient.setex.mockResolvedValue('OK');
+
+      await cacheConnector.set('string-ttl', 'value', 'not-a-number');
+
+      // Should use default TTL for invalid values
+      expect(mockRedisClient.setex).toHaveBeenCalledWith(
+        expect.any(String),
+        100, // default TTL
+        expect.any(String)
+      );
+    });
+  });
+
+  describe('Batch Operations Edge Cases', () => {
+    beforeEach(async () => {
+      cacheConnector = new CacheConnector();
+      await cacheConnector.connect();
+    });
+
+    it('should handle empty array in del', async () => {
+      const result = await cacheConnector.del([]);
+      expect(result).toBe(0);
+    });
+
+    it('should handle single string in del (not array)', async () => {
+      mockRedisClient.del.mockResolvedValue(1);
+
+      const result = await cacheConnector.del('single-key');
+
+      expect(mockRedisClient.del).toHaveBeenCalledWith(
+        expect.stringContaining('single-key')
+      );
+      expect(result).toBe(1);
+    });
+
+    it('should handle very large batch delete', async () => {
+      const keys = Array.from({ length: 10000 }, (_, i) => `key${i}`);
+      mockRedisClient.del.mockResolvedValue(keys.length);
+
+      const result = await cacheConnector.del(keys);
+
+      expect(result).toBe(10000);
+    });
+
+    it('should handle empty array in mget', async () => {
+      const result = await cacheConnector.mget([]);
+      expect(result).toEqual([]);
+    });
+
+    it('should handle null responses in mget', async () => {
+      mockRedisClient.mget.mockResolvedValue([
+        JSON.stringify('value1'),
+        null,
+        JSON.stringify('value3')
+      ]);
+
+      const result = await cacheConnector.mget(['key1', 'key2', 'key3']);
+
+      expect(result).toEqual(['value1', null, 'value3']);
+    });
+  });
+
+  describe('Clear Operations Edge Cases', () => {
+    beforeEach(async () => {
+      cacheConnector = new CacheConnector({ namespace: 'test' });
+      await cacheConnector.connect();
+    });
+
+    it('should handle clear with no matching keys', async () => {
+      mockRedisClient.keys.mockResolvedValue([]);
+
+      const result = await cacheConnector.clear();
+
+      expect(result).toBe(0);
+      expect(mockRedisClient.del).not.toHaveBeenCalled();
+    });
+
+    it('should handle clear with pattern matching error', async () => {
+      mockRedisClient.keys.mockRejectedValue(new Error('Pattern error'));
+
+      await expect(cacheConnector.clear()).rejects.toThrow('Pattern error');
+    });
+
+    it('should handle partial delete failure', async () => {
+      mockRedisClient.keys.mockResolvedValue(['key1', 'key2', 'key3']);
+      mockRedisClient.del.mockResolvedValue(2); // Only 2 deleted instead of 3
+
+      const result = await cacheConnector.clear();
+
+      expect(result).toBe(2);
+    });
+  });
+
+  describe('Statistics Edge Cases', () => {
+    beforeEach(() => {
+      cacheConnector = new CacheConnector();
+    });
+
+    it('should handle stats when no operations performed', () => {
+      const stats = cacheConnector.getStats();
+
+      expect(stats).toEqual({
+        hits: 0,
+        misses: 0,
+        sets: 0,
+        deletes: 0,
+        errors: 0,
+        hitRate: 0,
+        totalOperations: 0
+      });
+    });
+
+    it('should handle hitRate with only misses', () => {
+      cacheConnector.stats.misses = 10;
+
+      const stats = cacheConnector.getStats();
+
+      expect(stats.hitRate).toBe(0);
+    });
+
+    it('should handle hitRate with only hits', () => {
+      cacheConnector.stats.hits = 10;
+
+      const stats = cacheConnector.getStats();
+
+      expect(stats.hitRate).toBe(1);
+    });
+
+    it('should handle integer overflow in stats', () => {
+      cacheConnector.stats = {
+        hits: Number.MAX_SAFE_INTEGER,
+        misses: Number.MAX_SAFE_INTEGER,
+        sets: Number.MAX_SAFE_INTEGER,
+        deletes: Number.MAX_SAFE_INTEGER,
+        errors: Number.MAX_SAFE_INTEGER
+      };
+
+      const stats = cacheConnector.getStats();
+
+      expect(stats.totalOperations).toBeDefined();
+      expect(stats.hitRate).toBe(0.5);
+    });
+  });
+
+  describe('Error Propagation', () => {
+    beforeEach(async () => {
+      cacheConnector = new CacheConnector();
+      await cacheConnector.connect();
+    });
+
+    it('should propagate Redis errors with context', async () => {
+      const redisError = new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
+      mockRedisClient.get.mockRejectedValue(redisError);
+
+      await expect(cacheConnector.get('key')).rejects.toThrow('WRONGTYPE');
+      expect(cacheConnector.stats.errors).toBe(1);
+    });
+
+    it('should handle out of memory errors', async () => {
+      const oomError = new Error('OOM command not allowed when used memory > maxmemory');
+      mockRedisClient.setex.mockRejectedValue(oomError);
+
+      await expect(cacheConnector.set('key', 'value')).rejects.toThrow('OOM');
+      expect(cacheConnector.stats.errors).toBe(1);
+    });
+
+    it('should handle script errors', async () => {
+      const scriptError = new Error('ERR Error running script');
+      mockRedisClient.get.mockRejectedValue(scriptError);
+
+      await expect(cacheConnector.get('key')).rejects.toThrow('ERR Error');
+      expect(cacheConnector.stats.errors).toBe(1);
+    });
+  });
+
+  describe('Method Aliases and Helpers', () => {
+    beforeEach(async () => {
+      cacheConnector = new CacheConnector();
+      await cacheConnector.connect();
+    });
+
+    it('should have working expire method', async () => {
+      mockRedisClient.expire.mockResolvedValue(1);
+
+      const result = await cacheConnector.expire('key', 300);
+
+      expect(mockRedisClient.expire).toHaveBeenCalledWith(
+        expect.stringContaining('key'),
+        300
+      );
+      expect(result).toBe(1);
+    });
+
+    it('should have working resetStats method', () => {
+      cacheConnector.stats = {
+        hits: 100,
+        misses: 50,
+        sets: 75,
+        deletes: 25,
+        errors: 5
+      };
+
+      cacheConnector.resetStats();
+
+      expect(cacheConnector.stats).toEqual({
+        hits: 0,
+        misses: 0,
+        sets: 0,
+        deletes: 0,
+        errors: 0
+      });
+    });
+
+    it('should have working isConnected method', () => {
+      expect(cacheConnector.isConnected()).toBe(true);
+
+      cacheConnector.connected = false;
+      expect(cacheConnector.isConnected()).toBe(false);
+    });
+  });
+
+  describe('Concurrent Operations', () => {
+    beforeEach(async () => {
+      cacheConnector = new CacheConnector();
+      await cacheConnector.connect();
+    });
+
+    it('should handle concurrent sets correctly', async () => {
+      mockRedisClient.setex.mockResolvedValue('OK');
+
+      const operations = Array.from({ length: 100 }, (_, i) =>
+        cacheConnector.set(`concurrent:${i}`, `value${i}`)
+      );
+
+      const results = await Promise.all(operations);
+
+      expect(results).toHaveLength(100);
+      expect(results.every(r => r === 'OK')).toBe(true);
+      expect(cacheConnector.stats.sets).toBe(100);
+    });
+
+    it('should handle mixed concurrent operations', async () => {
+      mockRedisClient.setex.mockResolvedValue('OK');
+      mockRedisClient.get.mockResolvedValue(JSON.stringify('value'));
+      mockRedisClient.del.mockResolvedValue(1);
+      mockRedisClient.exists.mockResolvedValue(1);
+
+      const operations = [
+        ...Array.from({ length: 25 }, () => cacheConnector.set('key', 'value')),
+        ...Array.from({ length: 25 }, () => cacheConnector.get('key')),
+        ...Array.from({ length: 25 }, () => cacheConnector.del('key')),
+        ...Array.from({ length: 25 }, () => cacheConnector.exists('key'))
+      ];
+
+      await Promise.all(operations);
+
+      expect(cacheConnector.stats.sets).toBe(25);
+      expect(cacheConnector.stats.hits + cacheConnector.stats.misses).toBe(25);
+      expect(cacheConnector.stats.deletes).toBe(25);
+    });
+  });
+});