@pioneer-platform/pioneer-cache 1.0.0 → 1.0.2

package/test/redis-persistence.test.ts

@@ -0,0 +1,265 @@
+/*
+    CRITICAL: Redis Persistence Diagnostic Test
+
+    This test validates that Redis writes are ACTUALLY persisting to the Redis server.
+    It will catch the bug where writes appear successful but data isn't stored.
+*/
+
+import { describe, it, expect, beforeAll, afterAll } from 'bun:test';
+
+// @ts-ignore
+const TAG = ' | REDIS-PERSISTENCE-TEST | ';
+
+describe('Redis Persistence Validation', () => {
+    let redis: any;
+    let redisModule: any;
+
+    beforeAll(async () => {
+        console.log(TAG, '🔍 Starting Redis persistence diagnostic...');
+
+        // Force load REAL Redis, not mock
+        delete require.cache[require.resolve('@pioneer-platform/default-redis')];
+        const originalEnv = process.env.NODE_ENV;
+        delete process.env.NODE_ENV; // Ensure we don't use mock
+
+        redisModule = require('@pioneer-platform/default-redis');
+        redis = redisModule.redis;
+
+        console.log(TAG, '✅ Redis module loaded');
+        console.log(TAG, `   NODE_ENV: ${process.env.NODE_ENV || '(not set)'}`);
+        console.log(TAG, `   Redis constructor: ${redis.constructor.name}`);
+        console.log(TAG, `   Is mock?: ${redis.constructor.name === 'RedisMock' ? '⚠️ YES - THIS IS THE BUG!' : '✅ NO'}`);
+
+        // Test basic connection
+        const ping = await redis.ping();
+        console.log(TAG, `   Ping: ${ping}`);
+
+        // Verify connection details
+        const options = redis.options;
+        console.log(TAG, `   Host: ${options.host}:${options.port}`);
+    });
+
+    afterAll(async () => {
+        // Clean up test keys
+        const testKeys = await redis.keys('test:*');
+        if (testKeys.length > 0) {
+            await redis.del(...testKeys);
+        }
+
+        // Don't disconnect - other tests might be using it
+        console.log(TAG, '🧹 Cleaned up test keys');
+    });
+
+    it('should verify Redis is real not mock', async () => {
+        expect(redis.constructor.name).not.toBe('RedisMock');
+        expect(redis.constructor.name).toBe('Redis');
+    });
+
+    it('should write and immediately read back the same value', async () => {
+        const key = 'test:simple:write';
+        const value = JSON.stringify({ test: 'data', timestamp: Date.now() });
+
+        // Write
+        await redis.set(key, value);
+        console.log(TAG, `✅ Wrote key: ${key}`);
+
+        // Read immediately
+        const result = await redis.get(key);
+        console.log(TAG, `✅ Read back: ${result ? 'SUCCESS' : '❌ FAILED - NULL'}`);
+
+        expect(result).toBe(value);
+    });
+
+    it('should persist data with TTL', async () => {
+        const key = 'test:ttl:write';
+        const value = JSON.stringify({ test: 'ttl-data', timestamp: Date.now() });
+        const ttlSeconds = 60;
+
+        // Write with TTL
+        await redis.set(key, value, 'EX', ttlSeconds);
+        console.log(TAG, `✅ Wrote key with ${ttlSeconds}s TTL: ${key}`);
+
+        // Verify it exists
+        const result = await redis.get(key);
+        expect(result).toBe(value);
+
+        // Check TTL is set
+        const ttl = await redis.ttl(key);
+        console.log(TAG, `   TTL remaining: ${ttl}s`);
+        expect(ttl).toBeGreaterThan(0);
+        expect(ttl).toBeLessThanOrEqual(ttlSeconds);
+    });
+
+    it('should detect if writes disappear after small delay', async () => {
+        const key = 'test:delayed:read';
+        const value = JSON.stringify({ test: 'delayed-data', timestamp: Date.now() });
+
+        // Write
+        await redis.set(key, value);
+        console.log(TAG, `✅ Wrote key: ${key}`);
+
+        // Wait 100ms
+        await new Promise(resolve => setTimeout(resolve, 100));
+
+        // Read after delay
+        const result = await redis.get(key);
+        console.log(TAG, `   Read after 100ms: ${result ? 'SUCCESS' : '❌ FAILED - DATA DISAPPEARED!'}`);
+
+        expect(result).toBe(value);
+    });
+
+    it('should verify balance_v2 cache format works', async () => {
+        const key = 'balance_v2:eip155:1:0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb';
+        const cacheValue = {
+            value: {
+                caip: 'eip155:1/slip44:60',
+                pubkey: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
+                balance: '123456789'
+            },
+            timestamp: Date.now(),
+            source: 'test',
+            lastUpdated: new Date().toISOString()
+        };
+
+        const ttlSeconds = 300;
+
+        // Write balance cache
+        await redis.set(key, JSON.stringify(cacheValue), 'EX', ttlSeconds);
+        console.log(TAG, `✅ Wrote balance cache: ${key}`);
+
+        // Read back
+        const result = await redis.get(key);
+        expect(result).not.toBeNull();
+
+        const parsed = JSON.parse(result);
+        expect(parsed.value.balance).toBe('123456789');
+
+        // Check TTL
+        const ttl = await redis.ttl(key);
+        console.log(TAG, `   TTL: ${ttl}s`);
+        expect(ttl).toBeGreaterThan(0);
+    });
+
+    it('should detect keys using SCAN command', async () => {
+        const keyPrefix = 'test:scan:';
+        const numKeys = 5;
+
+        // Write multiple keys
+        for (let i = 0; i < numKeys; i++) {
+            await redis.set(`${keyPrefix}${i}`, `value${i}`);
+        }
+
+        // Use SCAN to find them
+        let cursor = '0';
+        const foundKeys: string[] = [];
+
+        do {
+            const result = await redis.scan(cursor, 'MATCH', `${keyPrefix}*`, 'COUNT', 10);
+            cursor = result[0];
+            foundKeys.push(...result[1]);
+        } while (cursor !== '0');
+
+        console.log(TAG, `   SCAN found ${foundKeys.length} keys with pattern ${keyPrefix}*`);
+        expect(foundKeys.length).toBeGreaterThanOrEqual(numKeys);
+    });
+
+    it('should verify connection string is correct', async () => {
+        const options = redis.options;
+
+        console.log(TAG, '📋 Redis Connection Details:');
+        console.log(TAG, `   Host: ${options.host}`);
+        console.log(TAG, `   Port: ${options.port}`);
+        console.log(TAG, `   DB: ${options.db || 0}`);
+        console.log(TAG, `   Family: ${options.family || 4}`);
+
+        expect(options.host).toBe('127.0.0.1');
+        expect(options.port).toBe(6379);
+    });
+
+    it('should test actual BalanceCache class persistence', async () => {
+        // Import after Redis is loaded
+        const { BalanceCache } = require('../src/stores/balance-cache');
+        const balanceModule = require('@pioneer-platform/pioneer-balance');
+
+        const cache = new BalanceCache(redis, balanceModule, {
+            logCacheHits: true,
+            logCacheMisses: true,
+            enableQueue: false // Disable queue for this test
+        });
+
+        const testKey = 'balance_v2:eip155:1:0xTESTADDRESS';
+        const testData = {
+            caip: 'eip155:1/slip44:60',
+            pubkey: '0xTESTADDRESS',
+            balance: '999999999'
+        };
+
+        // Write via BalanceCache
+        console.log(TAG, '   Writing via BalanceCache.updateCache()...');
+        await cache.updateCache(testKey, testData);
+
+        // Verify it actually wrote
+        const result = await redis.get(testKey);
+        console.log(TAG, `   Direct Redis read: ${result ? 'SUCCESS' : '❌ FAILED'}`);
+
+        expect(result).not.toBeNull();
+
+        if (result) {
+            const parsed = JSON.parse(result);
+            expect(parsed.value.balance).toBe('999999999');
+
+            // Check TTL is set
+            const ttl = await redis.ttl(testKey);
+            console.log(TAG, `   TTL: ${ttl}s (expected: 300s)`);
+            expect(ttl).toBeGreaterThan(0);
+        }
+
+        // Clean up
+        await redis.del(testKey);
+    });
+
+    it('should run comprehensive persistence check', async () => {
+        console.log(TAG, '\n🔬 COMPREHENSIVE PERSISTENCE CHECK:');
+
+        const testKey = 'test:comprehensive';
+        const testValue = 'persistence-check-' + Date.now();
+
+        // 1. Write
+        console.log(TAG, '   Step 1: Writing value...');
+        await redis.set(testKey, testValue);
+
+        // 2. Confirm with GET
+        console.log(TAG, '   Step 2: Reading back immediately...');
+        const read1 = await redis.get(testKey);
+        console.log(TAG, `      Read: ${read1 === testValue ? '✅ MATCH' : '❌ MISMATCH'}`);
+        expect(read1).toBe(testValue);
+
+        // 3. Check EXISTS
+        console.log(TAG, '   Step 3: Checking EXISTS...');
+        const exists = await redis.exists(testKey);
+        console.log(TAG, `      EXISTS: ${exists === 1 ? '✅ TRUE' : '❌ FALSE'}`);
+        expect(exists).toBe(1);
+
+        // 4. Check with KEYS pattern
+        console.log(TAG, '   Step 4: Searching with KEYS...');
+        const keys = await redis.keys('test:comprehensive');
+        console.log(TAG, `      KEYS found: ${keys.length === 1 ? '✅ 1' : '❌ ' + keys.length}`);
+        expect(keys.length).toBe(1);
+
+        // 5. Wait and re-read
+        console.log(TAG, '   Step 5: Waiting 200ms and re-reading...');
+        await new Promise(resolve => setTimeout(resolve, 200));
+        const read2 = await redis.get(testKey);
+        console.log(TAG, `      Read: ${read2 === testValue ? '✅ STILL THERE' : '❌ DISAPPEARED!'}`);
+        expect(read2).toBe(testValue);
+
+        // 6. DEL and verify
+        console.log(TAG, '   Step 6: Deleting and verifying...');
+        await redis.del(testKey);
+        const read3 = await redis.get(testKey);
+        console.log(TAG, `      After DEL: ${read3 === null ? '✅ DELETED' : '❌ STILL EXISTS!'}`);
+        expect(read3).toBeNull();
+
+        console.log(TAG, '✅ All persistence checks PASSED!\n');
+    });
+});