@onlineapps/conn-base-cache 1.0.0

package/test/integration/cache.integration.test.js

@@ -0,0 +1,356 @@
+'use strict';
+
+/**
+ * Integration tests for CacheConnector
+ * Tests with real Redis instance when available
+ */
+
+const CacheConnector = require('../../src/index');
+
+const SKIP_INTEGRATION = process.env.SKIP_INTEGRATION === 'true';
+const REDIS_HOST = process.env.REDIS_HOST || 'localhost';
+const REDIS_PORT = process.env.REDIS_PORT || 6379;
+
+describe('CacheConnector - Integration Tests', () => {
+  if (SKIP_INTEGRATION) {
+    it.skip('Skipping integration tests (SKIP_INTEGRATION=true)', () => {});
+    return;
+  }
+
+  let cacheConnector;
+  let testNamespace;
+
+  beforeAll(async () => {
+    testNamespace = `test-${Date.now()}`;
+
+    cacheConnector = new CacheConnector({
+      host: REDIS_HOST,
+      port: REDIS_PORT,
+      namespace: testNamespace,
+      defaultTTL: 60
+    });
+
+    try {
+      await cacheConnector.connect();
+    } catch (error) {
+      console.warn('Redis not available, skipping integration tests');
+      console.warn('Error:', error.message);
+      cacheConnector = null;
+    }
+  });
+
+  afterAll(async () => {
+    if (cacheConnector && cacheConnector.connected) {
+      // Clean up test data
+      await cacheConnector.clear();
+      await cacheConnector.disconnect();
+    }
+  });
+
+  beforeEach(async () => {
+    if (!cacheConnector) {
+      return;
+    }
+    // Clear cache before each test
+    await cacheConnector.clear();
+    cacheConnector.resetStats();
+  });
+
+  describe('Redis Connection', () => {
+    it('should connect to Redis successfully', async () => {
+      if (!cacheConnector) {
+        pending('Redis not available');
+        return;
+      }
+
+      expect(cacheConnector.connected).toBe(true);
+
+      const pong = await cacheConnector.client.ping();
+      expect(pong).toBe('PONG');
+    });
+
+    it('should handle reconnection', async () => {
+      if (!cacheConnector) {
+        pending('Redis not available');
+        return;
+      }
+
+      await cacheConnector.disconnect();
+      expect(cacheConnector.connected).toBe(false);
+
+      await cacheConnector.connect();
+      expect(cacheConnector.connected).toBe(true);
+    });
+  });
+
+  describe('Real-world Caching Scenarios', () => {
+    it('should cache API response data', async () => {
+      if (!cacheConnector) {
+        pending('Redis not available');
+        return;
+      }
+
+      const apiResponse = {
+        users: [
+          { id: 1, name: 'John Doe', email: 'john@example.com' },
+          { id: 2, name: 'Jane Smith', email: 'jane@example.com' }
+        ],
+        total: 2,
+        page: 1,
+        timestamp: Date.now()
+      };
+
+      await cacheConnector.set('api:users:page:1', apiResponse, 300);
+
+      const cached = await cacheConnector.get('api:users:page:1');
+      expect(cached).toEqual(apiResponse);
+    });
+
+    it('should handle high-volume operations', async () => {
+      if (!cacheConnector) {
+        pending('Redis not available');
+        return;
+      }
+
+      const operations = [];
+      const startTime = Date.now();
+
+      // Perform 100 set operations
+      for (let i = 0; i < 100; i++) {
+        operations.push(
+          cacheConnector.set(`perf:key${i}`, { index: i, data: 'x'.repeat(100) })
+        );
+      }
+
+      await Promise.all(operations);
+
+      // Perform 100 get operations
+      const getOperations = [];
+      for (let i = 0; i < 100; i++) {
+        getOperations.push(cacheConnector.get(`perf:key${i}`));
+      }
+
+      const results = await Promise.all(getOperations);
+      const duration = Date.now() - startTime;
+
+      expect(results).toHaveLength(100);
+      expect(results[0]).toEqual({ index: 0, data: 'x'.repeat(100) });
+      expect(duration).toBeLessThan(5000); // Should complete within 5 seconds
+    });
+
+    it('should handle concurrent access correctly', async () => {
+      if (!cacheConnector) {
+        pending('Redis not available');
+        return;
+      }
+
+      const key = 'concurrent:counter';
+      let counter = 0;
+
+      // Simulate concurrent increments
+      const incrementOperations = Array.from({ length: 50 }, async () => {
+        const current = await cacheConnector.get(key) || 0;
+        const newValue = current + 1;
+        await cacheConnector.set(key, newValue, 60);
+        counter++;
+      });
+
+      await Promise.all(incrementOperations);
+
+      // Due to race conditions, final value might be less than 50
+      const finalValue = await cacheConnector.get(key);
+      expect(finalValue).toBeGreaterThan(0);
+      expect(finalValue).toBeLessThanOrEqual(50);
+      expect(counter).toBe(50);
+    });
+  });
+
+  describe('TTL and Expiration', () => {
+    it('should respect TTL on real Redis', async () => {
+      if (!cacheConnector) {
+        pending('Redis not available');
+        return;
+      }
+
+      await cacheConnector.set('ttl:test', 'value', 2); // 2 second TTL
+
+      // Check immediately
+      let value = await cacheConnector.get('ttl:test');
+      expect(value).toBe('value');
+
+      // Check TTL
+      const ttl = await cacheConnector.ttl('ttl:test');
+      expect(ttl).toBeGreaterThan(0);
+      expect(ttl).toBeLessThanOrEqual(2);
+
+      // Wait for expiry
+      await new Promise(resolve => setTimeout(resolve, 2100));
+
+      value = await cacheConnector.get('ttl:test');
+      expect(value).toBe(null);
+    });
+
+    it('should update TTL on existing keys', async () => {
+      if (!cacheConnector) {
+        pending('Redis not available');
+        return;
+      }
+
+      await cacheConnector.set('ttl:update', 'value', 10);
+
+      // Update with new TTL
+      await cacheConnector.expire('ttl:update', 30);
+
+      const ttl = await cacheConnector.ttl('ttl:update');
+      expect(ttl).toBeGreaterThan(25);
+      expect(ttl).toBeLessThanOrEqual(30);
+    });
+  });
+
+  describe('Namespace Isolation', () => {
+    it('should isolate data between different namespaces', async () => {
+      if (!cacheConnector) {
+        pending('Redis not available');
+        return;
+      }
+
+      // Create second cache with different namespace
+      const cache2 = new CacheConnector({
+        host: REDIS_HOST,
+        port: REDIS_PORT,
+        namespace: `${testNamespace}-2`
+      });
+      await cache2.connect();
+
+      try {
+        await cacheConnector.set('shared:key', 'value1');
+        await cache2.set('shared:key', 'value2');
+
+        const value1 = await cacheConnector.get('shared:key');
+        const value2 = await cache2.get('shared:key');
+
+        expect(value1).toBe('value1');
+        expect(value2).toBe('value2');
+
+        // Clear should only affect own namespace
+        await cache2.clear();
+
+        expect(await cacheConnector.get('shared:key')).toBe('value1');
+        expect(await cache2.get('shared:key')).toBe(null);
+
+      } finally {
+        await cache2.disconnect();
+      }
+    });
+  });
+
+  describe('Error Recovery', () => {
+    it('should handle temporary network issues', async () => {
+      if (!cacheConnector) {
+        pending('Redis not available');
+        return;
+      }
+
+      // Store original client
+      const originalClient = cacheConnector.client;
+
+      // Simulate network issue by replacing client
+      cacheConnector.client = {
+        get: jest.fn().mockRejectedValueOnce(new Error('ECONNRESET'))
+          .mockImplementation((...args) => originalClient.get(...args))
+      };
+
+      // First call fails
+      try {
+        await cacheConnector.get('test');
+      } catch (error) {
+        expect(error.message).toContain('ECONNRESET');
+      }
+
+      // Restore client
+      cacheConnector.client = originalClient;
+
+      // Should work again
+      await cacheConnector.set('recovery:test', 'recovered');
+      const value = await cacheConnector.get('recovery:test');
+      expect(value).toBe('recovered');
+    });
+  });
+
+  describe('Large Data Handling', () => {
+    it('should handle large JSON objects', async () => {
+      if (!cacheConnector) {
+        pending('Redis not available');
+        return;
+      }
+
+      const largeObject = {
+        data: Array.from({ length: 1000 }, (_, i) => ({
+          id: i,
+          name: `User ${i}`,
+          email: `user${i}@example.com`,
+          metadata: {
+            created: Date.now(),
+            tags: ['tag1', 'tag2', 'tag3'],
+            description: 'x'.repeat(100)
+          }
+        }))
+      };
+
+      await cacheConnector.set('large:object', largeObject, 60);
+      const retrieved = await cacheConnector.get('large:object');
+
+      expect(retrieved).toEqual(largeObject);
+      expect(retrieved.data).toHaveLength(1000);
+    });
+
+    it('should handle binary data (base64 encoded)', async () => {
+      if (!cacheConnector) {
+        pending('Redis not available');
+        return;
+      }
+
+      // Simulate binary data as base64
+      const binaryData = Buffer.from('Hello, World!').toString('base64');
+
+      await cacheConnector.set('binary:data', binaryData);
+      const retrieved = await cacheConnector.get('binary:data');
+
+      expect(retrieved).toBe(binaryData);
+
+      const decoded = Buffer.from(retrieved, 'base64').toString();
+      expect(decoded).toBe('Hello, World!');
+    });
+  });
+
+  describe('Performance Monitoring', () => {
+    it('should accurately track statistics', async () => {
+      if (!cacheConnector) {
+        pending('Redis not available');
+        return;
+      }
+
+      // Perform various operations
+      await cacheConnector.set('stat:1', 'value1');
+      await cacheConnector.set('stat:2', 'value2');
+      await cacheConnector.set('stat:3', 'value3');
+
+      await cacheConnector.get('stat:1'); // hit
+      await cacheConnector.get('stat:2'); // hit
+      await cacheConnector.get('stat:missing'); // miss
+      await cacheConnector.get('stat:missing2'); // miss
+
+      await cacheConnector.del('stat:1');
+      await cacheConnector.del(['stat:2', 'stat:3']);
+
+      const stats = cacheConnector.getStats();
+
+      expect(stats.sets).toBe(3);
+      expect(stats.hits).toBe(2);
+      expect(stats.misses).toBe(2);
+      expect(stats.deletes).toBe(2); // del operations, not key count
+      expect(stats.hitRate).toBe(0.5);
+      expect(stats.totalOperations).toBe(9);
+    });
+  });
+});