@onlineapps/conn-base-cache 1.0.0

package/test/component/cache.component.test.js

@@ -0,0 +1,428 @@
+'use strict';
+
+/**
+ * Component tests for CacheConnector
+ * Tests cache operations with in-memory Redis simulation
+ */
+
+const CacheConnector = require('../../src/index');
+
+// In-memory Redis simulation for component testing
+class RedisSimulator {
+  constructor() {
+    this.store = new Map();
+    this.expiry = new Map();
+    this.connected = false;
+  }
+
+  async connect() {
+    this.connected = true;
+    return 'OK';
+  }
+
+  async disconnect() {
+    this.connected = false;
+    this.store.clear();
+    this.expiry.clear();
+    return 'OK';
+  }
+
+  async get(key) {
+    if (!this.connected) throw new Error('Not connected');
+
+    // Check if key expired
+    if (this.expiry.has(key)) {
+      const expiryTime = this.expiry.get(key);
+      if (Date.now() > expiryTime) {
+        this.store.delete(key);
+        this.expiry.delete(key);
+        return null;
+      }
+    }
+
+    return this.store.get(key) || null;
+  }
+
+  async setex(key, ttl, value) {
+    if (!this.connected) throw new Error('Not connected');
+
+    this.store.set(key, value);
+    this.expiry.set(key, Date.now() + (ttl * 1000));
+    return 'OK';
+  }
+
+  async del(...keys) {
+    if (!this.connected) throw new Error('Not connected');
+
+    let deleted = 0;
+    for (const key of keys) {
+      if (this.store.has(key)) {
+        this.store.delete(key);
+        this.expiry.delete(key);
+        deleted++;
+      }
+    }
+    return deleted;
+  }
+
+  async exists(key) {
+    if (!this.connected) throw new Error('Not connected');
+    return this.store.has(key) ? 1 : 0;
+  }
+
+  async ttl(key) {
+    if (!this.connected) throw new Error('Not connected');
+
+    if (!this.store.has(key)) return -2;
+    if (!this.expiry.has(key)) return -1;
+
+    const remaining = Math.floor((this.expiry.get(key) - Date.now()) / 1000);
+    return remaining > 0 ? remaining : -2;
+  }
+
+  async keys(pattern) {
+    if (!this.connected) throw new Error('Not connected');
+
+    const regex = new RegExp(pattern.replace(/\*/g, '.*'));
+    return Array.from(this.store.keys()).filter(key => regex.test(key));
+  }
+
+  async mget(...keys) {
+    if (!this.connected) throw new Error('Not connected');
+    return keys.map(key => this.store.get(key) || null);
+  }
+
+  async ping() {
+    if (!this.connected) throw new Error('Not connected');
+    return 'PONG';
+  }
+
+  on(event, handler) {
+    // Simulate event handling
+    if (event === 'connect' && this.connected) {
+      setTimeout(() => handler(), 0);
+    }
+  }
+
+  async quit() {
+    return this.disconnect();
+  }
+}
+
+describe('CacheConnector - Component Tests', () => {
+  let cacheConnector;
+  let redisSimulator;
+
+  beforeEach(() => {
+    redisSimulator = new RedisSimulator();
+
+    // Inject Redis simulator
+    cacheConnector = new CacheConnector({
+      host: 'localhost',
+      port: 6379,
+      namespace: 'test-service',
+      defaultTTL: 60
+    });
+
+    // Replace Redis client with simulator
+    cacheConnector.client = redisSimulator;
+  });
+
+  afterEach(async () => {
+    if (cacheConnector.connected) {
+      await cacheConnector.disconnect();
+    }
+  });
+
+  describe('Basic Cache Operations', () => {
+    beforeEach(async () => {
+      await redisSimulator.connect();
+      cacheConnector.connected = true;
+    });
+
+    it('should perform set and get operations', async () => {
+      const testData = {
+        id: 123,
+        name: 'Test User',
+        email: 'test@example.com'
+      };
+
+      await cacheConnector.set('user:123', testData, 300);
+      const retrieved = await cacheConnector.get('user:123');
+
+      expect(retrieved).toEqual(testData);
+    });
+
+    it('should handle different data types', async () => {
+      // String
+      await cacheConnector.set('string', 'test string');
+      expect(await cacheConnector.get('string')).toBe('test string');
+
+      // Number
+      await cacheConnector.set('number', 42);
+      expect(await cacheConnector.get('number')).toBe(42);
+
+      // Boolean
+      await cacheConnector.set('boolean', true);
+      expect(await cacheConnector.get('boolean')).toBe(true);
+
+      // Array
+      await cacheConnector.set('array', [1, 2, 3]);
+      expect(await cacheConnector.get('array')).toEqual([1, 2, 3]);
+
+      // Object
+      await cacheConnector.set('object', { nested: { value: 'test' } });
+      expect(await cacheConnector.get('object')).toEqual({ nested: { value: 'test' } });
+    });
+
+    it('should respect TTL settings', async () => {
+      await cacheConnector.set('ttl-test', 'value', 1); // 1 second TTL
+
+      // Should exist immediately
+      expect(await cacheConnector.get('ttl-test')).toBe('value');
+
+      // Wait for expiry
+      await new Promise(resolve => setTimeout(resolve, 1100));
+
+      // Should be expired
+      expect(await cacheConnector.get('ttl-test')).toBe(null);
+    });
+  });
+
+  describe('Namespace Management', () => {
+    beforeEach(async () => {
+      await redisSimulator.connect();
+      cacheConnector.connected = true;
+    });
+
+    it('should isolate data by namespace', async () => {
+      // First service
+      await cacheConnector.set('key', 'value1');
+
+      // Second service with different namespace
+      const cache2 = new CacheConnector({
+        namespace: 'other-service'
+      });
+      cache2.client = redisSimulator;
+      cache2.connected = true;
+
+      await cache2.set('key', 'value2');
+
+      // Values should be isolated
+      expect(await cacheConnector.get('key')).toBe('value1');
+      expect(await cache2.get('key')).toBe('value2');
+    });
+
+    it('should clear only namespace-specific keys', async () => {
+      await cacheConnector.set('key1', 'value1');
+      await cacheConnector.set('key2', 'value2');
+
+      // Add key from different namespace directly to simulator
+      await redisSimulator.setex('other:key', 60, 'other');
+
+      // Delete all keys in our namespace
+      let cleared = 0;
+      if (await cacheConnector.delete('key1')) cleared++;
+      if (await cacheConnector.delete('key2')) cleared++;
+
+      expect(cleared).toBe(2); // Only namespace keys
+      expect(await redisSimulator.get('other:key')).toBe('other');
+    });
+  });
+
+  describe('Batch Operations', () => {
+    beforeEach(async () => {
+      await redisSimulator.connect();
+      cacheConnector.connected = true;
+    });
+
+    it('should delete multiple keys', async () => {
+      await cacheConnector.set('del1', 'value1');
+      await cacheConnector.set('del2', 'value2');
+      await cacheConnector.set('del3', 'value3');
+
+      // Delete multiple keys - implementation doesn't have bulk delete
+      let deleted = 0;
+      if (await cacheConnector.delete('del1')) deleted++;
+      if (await cacheConnector.delete('del2')) deleted++;
+
+      expect(deleted).toBe(2);
+      expect(await cacheConnector.get('del1')).toBe(null);
+      expect(await cacheConnector.get('del2')).toBe(null);
+      expect(await cacheConnector.get('del3')).toBe('value3');
+    });
+
+    it('should get multiple values', async () => {
+      await cacheConnector.set('multi1', 'value1');
+      await cacheConnector.set('multi2', 'value2');
+      await cacheConnector.set('multi3', 'value3');
+
+      const values = await cacheConnector.mget(['multi1', 'multi2', 'missing']);
+
+      expect(values).toEqual({
+        multi1: 'value1',
+        multi2: 'value2'
+        // missing key is not included in result
+      });
+    });
+  });
+
+  describe('Cache Patterns', () => {
+    beforeEach(async () => {
+      await redisSimulator.connect();
+      cacheConnector.connected = true;
+    });
+
+    it('should implement cache-aside pattern', async () => {
+      const fetchData = jest.fn().mockResolvedValue({ expensive: 'data' });
+
+      // Function to get with cache
+      const getWithCache = async (key) => {
+        let data = await cacheConnector.get(key);
+        if (!data) {
+          data = await fetchData(key);
+          await cacheConnector.set(key, data, 300);
+        }
+        return data;
+      };
+
+      // First call - fetches from source
+      const result1 = await getWithCache('expensive');
+      expect(fetchData).toHaveBeenCalledTimes(1);
+      expect(result1).toEqual({ expensive: 'data' });
+
+      // Second call - from cache
+      const result2 = await getWithCache('expensive');
+      expect(fetchData).toHaveBeenCalledTimes(1); // Not called again
+      expect(result2).toEqual({ expensive: 'data' });
+    });
+
+    it('should handle cache stampede prevention', async () => {
+      const locks = new Set();
+
+      const getWithLock = async (key, fetchFn) => {
+        if (locks.has(key)) {
+          // Wait for lock to release
+          await new Promise(resolve => setTimeout(resolve, 10));
+          return cacheConnector.get(key);
+        }
+
+        locks.add(key);
+        try {
+          let data = await cacheConnector.get(key);
+          if (!data) {
+            data = await fetchFn();
+            await cacheConnector.set(key, data);
+          }
+          return data;
+        } finally {
+          locks.delete(key);
+        }
+      };
+
+      const fetchFn = jest.fn().mockResolvedValue('fetched');
+
+      // Simulate concurrent requests
+      const results = await Promise.all([
+        getWithLock('stampede', fetchFn),
+        getWithLock('stampede', fetchFn),
+        getWithLock('stampede', fetchFn)
+      ]);
+
+      // Only one fetch should occur
+      expect(fetchFn).toHaveBeenCalledTimes(1);
+      expect(results).toEqual(['fetched', 'fetched', 'fetched']);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle connection failures gracefully', async () => {
+      // Simulate disconnected Redis client
+      redisSimulator.connected = false;
+
+      await expect(
+        cacheConnector.set('key', 'value')
+      ).rejects.toThrow('Not connected');
+
+      await expect(
+        cacheConnector.get('key')
+      ).rejects.toThrow('Not connected');
+    });
+
+    it('should handle serialization errors', async () => {
+      await redisSimulator.connect();
+      cacheConnector.connected = true;
+
+      // Create circular reference
+      const circular = { a: 1 };
+      circular.self = circular;
+
+      await expect(
+        cacheConnector.set('circular', circular)
+      ).rejects.toThrow();
+
+      expect(cacheConnector.stats.errors).toBe(1);
+    });
+
+    it('should handle non-JSON data as string', async () => {
+      await redisSimulator.connect();
+      cacheConnector.connected = true;
+
+      // Insert non-JSON data using the correct key
+      await redisSimulator.setex('test-service:text', 60, 'plain text');
+
+      const result = await cacheConnector.get('text');
+
+      // Should return as plain string
+      expect(result).toBe('plain text');
+      expect(cacheConnector.stats.hits).toBe(1);
+    });
+  });
+
+  describe('Statistics and Monitoring', () => {
+    beforeEach(async () => {
+      await redisSimulator.connect();
+      cacheConnector.connected = true;
+    });
+
+    it('should track cache performance metrics', async () => {
+      // Generate some activity
+      await cacheConnector.set('stat1', 'value1');
+      await cacheConnector.set('stat2', 'value2');
+      await cacheConnector.get('stat1'); // hit
+      await cacheConnector.get('stat2'); // hit
+      await cacheConnector.get('missing'); // miss
+      await cacheConnector.delete('stat1');
+
+      const stats = cacheConnector.getStats();
+
+      expect(stats.sets).toBe(2);
+      expect(stats.hits).toBe(2);
+      expect(stats.misses).toBe(1);
+      expect(stats.deletes).toBe(1);
+      expect(stats.hitRate).toBe('66.67%');
+      // totalOperations is not returned by getStats()
+    });
+
+    it('should reset statistics', () => {
+      cacheConnector.stats = {
+        hits: 10,
+        misses: 5,
+        sets: 15,
+        deletes: 3,
+        errors: 1
+      };
+
+      cacheConnector.resetStats();
+
+      expect(cacheConnector.getStats()).toEqual({
+        hits: 0,
+        misses: 0,
+        sets: 0,
+        deletes: 0,
+        errors: 0,
+        hitRate: '0%'
+      });
+    });
+  });
+});