bulltrackers-module 1.0.765 → 1.0.768

package/functions/computation-system-v2/test/other/test-scheduler.js

@@ -1,204 +0,0 @@
-/**
- * @fileoverview Test Unified Scheduler
- * 
- * Tests the scheduler logic:
- * 1. Clock drift handling (floor to minute)
- * 2. Schedule matching (isScheduleDue)
- * 3. Finding due computations
- */
-
-const schedulerModule = require('../../handlers/scheduler');
-
-// ============================================================================
-// Test Clock Drift Handling
-// ============================================================================
-
-function testClockDrift() {
-    console.log('\n=== Test Clock Drift Handling ===\n');
-    
-    const floorToMinute = schedulerModule._floorToMinute;
-    
-    // Test case 1: Late by 58 seconds
-    const late = new Date('2026-01-24T14:00:58.123Z');
-    const floored1 = floorToMinute(late);
-    console.log(`  14:00:58.123 → ${floored1.toISOString()}`);
-    console.assert(floored1.getUTCMinutes() === 0, 'Should floor to minute 0');
-    console.assert(floored1.getUTCSeconds() === 0, 'Seconds should be 0');
-    console.assert(floored1.getUTCMilliseconds() === 0, 'Milliseconds should be 0');
-    
-    // Test case 2: Exactly on time
-    const exact = new Date('2026-01-24T14:00:00.000Z');
-    const floored2 = floorToMinute(exact);
-    console.log(`  14:00:00.000 → ${floored2.toISOString()}`);
-    console.assert(floored2.getTime() === exact.getTime(), 'Should remain unchanged');
-    
-    // Test case 3: Early (1ms into the minute)
-    const early = new Date('2026-01-24T14:00:00.001Z');
-    const floored3 = floorToMinute(early);
-    console.log(`  14:00:00.001 → ${floored3.toISOString()}`);
-    console.assert(floored3.getUTCMilliseconds() === 0, 'Milliseconds should be 0');
-    
-    console.log('\n✅ Clock drift handling tests complete');
-}
-
-// ============================================================================
-// Test Schedule Matching
-// ============================================================================
-
-function testScheduleMatching() {
-    console.log('\n=== Test Schedule Matching ===\n');
-    
-    const isScheduleDue = schedulerModule._isScheduleDue;
-    
-    // Daily schedule at 14:00
-    const dailySchedule = { frequency: 'daily', time: '14:00' };
-    
-    console.log('Testing daily schedule at 14:00...');
-    console.log(`  At 14:00: ${isScheduleDue(dailySchedule, '14:00', 0, 1)}`);
-    console.assert(isScheduleDue(dailySchedule, '14:00', 0, 1) === true, 'Should match at 14:00');
-    
-    console.log(`  At 14:01: ${isScheduleDue(dailySchedule, '14:01', 0, 1)}`);
-    console.assert(isScheduleDue(dailySchedule, '14:01', 0, 1) === false, 'Should not match at 14:01');
-    
-    console.log(`  At 13:59: ${isScheduleDue(dailySchedule, '13:59', 0, 1)}`);
-    console.assert(isScheduleDue(dailySchedule, '13:59', 0, 1) === false, 'Should not match at 13:59');
-    
-    // Weekly schedule (Monday at 06:00)
-    const weeklySchedule = { frequency: 'weekly', time: '06:00', dayOfWeek: 1 };
-    
-    console.log('\nTesting weekly schedule (Monday 06:00)...');
-    console.log(`  Monday 06:00: ${isScheduleDue(weeklySchedule, '06:00', 1, 15)}`);
-    console.assert(isScheduleDue(weeklySchedule, '06:00', 1, 15) === true, 'Should match Monday at 06:00');
-    
-    console.log(`  Tuesday 06:00: ${isScheduleDue(weeklySchedule, '06:00', 2, 16)}`);
-    console.assert(isScheduleDue(weeklySchedule, '06:00', 2, 16) === false, 'Should not match Tuesday');
-    
-    console.log(`  Monday 07:00: ${isScheduleDue(weeklySchedule, '07:00', 1, 15)}`);
-    console.assert(isScheduleDue(weeklySchedule, '07:00', 1, 15) === false, 'Should not match wrong time');
-    
-    // Monthly schedule (1st at 02:00)
-    const monthlySchedule = { frequency: 'monthly', time: '02:00', dayOfMonth: 1 };
-    
-    console.log('\nTesting monthly schedule (1st at 02:00)...');
-    console.log(`  1st at 02:00: ${isScheduleDue(monthlySchedule, '02:00', 4, 1)}`);
-    console.assert(isScheduleDue(monthlySchedule, '02:00', 4, 1) === true, 'Should match 1st at 02:00');
-    
-    console.log(`  15th at 02:00: ${isScheduleDue(monthlySchedule, '02:00', 4, 15)}`);
-    console.assert(isScheduleDue(monthlySchedule, '02:00', 4, 15) === false, 'Should not match 15th');
-    
-    // Hourly schedule (at :30)
-    const hourlySchedule = { frequency: 'hourly', time: '00:30' };
-    
-    console.log('\nTesting hourly schedule (at :30)...');
-    console.log(`  14:30: ${isScheduleDue(hourlySchedule, '14:30', 0, 1)}`);
-    console.assert(isScheduleDue(hourlySchedule, '14:30', 0, 1) === true, 'Should match at :30');
-    
-    console.log(`  14:00: ${isScheduleDue(hourlySchedule, '14:00', 0, 1)}`);
-    console.assert(isScheduleDue(hourlySchedule, '14:00', 0, 1) === false, 'Should not match at :00');
-    
-    console.log('\n✅ Schedule matching tests complete');
-}
-
-// ============================================================================
-// Test Finding Due Computations
-// ============================================================================
-
-async function testFindDueComputations() {
-    console.log('\n=== Test Finding Due Computations ===\n');
-    
-    // Initialize scheduler with test computations
-    await schedulerModule.initialize();
-    
-    const findDueComputations = schedulerModule._findDueComputations;
-    
-    // Test at 02:00 (default schedule time)
-    const time0200 = new Date('2026-01-24T02:00:00.000Z');
-    const due0200 = findDueComputations(time0200);
-    console.log(`  At 02:00: ${due0200.length} computations due`);
-    due0200.forEach(c => console.log(`    - ${c.originalName}`));
-    
-    // Test at 14:00 (no default schedules)
-    const time1400 = new Date('2026-01-24T14:00:00.000Z');
-    const due1400 = findDueComputations(time1400);
-    console.log(`  At 14:00: ${due1400.length} computations due`);
-    
-    // Test clock drift scenario
-    const driftedTime = new Date('2026-01-24T02:00:58.999Z');
-    const flooredTime = schedulerModule._floorToMinute(driftedTime);
-    const dueDrifted = findDueComputations(flooredTime);
-    console.log(`  At 02:00:58 (floored): ${dueDrifted.length} computations due`);
-    console.assert(dueDrifted.length === due0200.length, 'Drifted time should match exact time');
-    
-    console.log('\n✅ Finding due computations tests complete');
-}
-
-// ============================================================================
-// Test End-to-End Scenario
-// ============================================================================
-
-function testEndToEndScenario() {
-    console.log('\n=== Test End-to-End Scenario ===\n');
-    
-    console.log('Scenario: Scheduler triggers late at 14:00:58');
-    console.log('');
-    
-    const floorToMinute = schedulerModule._floorToMinute;
-    const isScheduleDue = schedulerModule._isScheduleDue;
-    
-    // Step 1: Scheduler triggers at 14:00:58
-    const triggerTime = new Date('2026-01-24T14:00:58.500Z');
-    console.log(`1. Trigger time: ${triggerTime.toISOString()}`);
-    
-    // Step 2: Floor to minute boundary
-    const now = floorToMinute(triggerTime);
-    console.log(`2. Floored time: ${now.toISOString()}`);
-    console.assert(now.getUTCSeconds() === 0, 'Seconds should be 0');
-    
-    // Step 3: Extract time for schedule check
-    const currentTime = `${String(now.getUTCHours()).padStart(2, '0')}:${String(now.getUTCMinutes()).padStart(2, '0')}`;
-    console.log(`3. Current time for check: ${currentTime}`);
-    console.assert(currentTime === '14:00', 'Time should be 14:00');
-    
-    // Step 4: Check against schedule
-    const schedule = { frequency: 'daily', time: '14:00' };
-    const isDue = isScheduleDue(schedule, currentTime, now.getUTCDay(), now.getUTCDate());
-    console.log(`4. Is schedule due? ${isDue}`);
-    console.assert(isDue === true, 'Schedule should be due');
-    
-    // Step 5: Generate payload
-    const targetDate = now.toISOString().split('T')[0];
-    console.log(`5. Target date for payload: ${targetDate}`);
-    console.assert(targetDate === '2026-01-24', 'Date should be correct');
-    
-    console.log('');
-    console.log('Result: System behaves exactly as if it ran at 14:00:00 ✓');
-    
-    console.log('\n✅ End-to-end scenario test complete');
-}
-
-// ============================================================================
-// Main
-// ============================================================================
-
-async function main() {
-    console.log('╔════════════════════════════════════════════════════════════╗');
-    console.log('║      Computation System v2 - Unified Scheduler Tests       ║');
-    console.log('╚════════════════════════════════════════════════════════════╝');
-    
-    try {
-        testClockDrift();
-        testScheduleMatching();
-        testEndToEndScenario();
-        await testFindDueComputations();
-        
-        console.log('\n╔════════════════════════════════════════════════════════════╗');
-        console.log('║                  All Tests Passed! ✅                       ║');
-        console.log('╚════════════════════════════════════════════════════════════╝\n');
-        
-    } catch (error) {
-        console.error('\n❌ Test failed:', error);
-        process.exit(1);
-    }
-}
-
-main();

package/functions/computation-system-v2/test/other/test-storage.js

@@ -1,449 +0,0 @@
-/**
- * @fileoverview Storage Manager Tests
- * 
- * Tests for the unified storage system (BigQuery + Firestore)
- */
-
-const { StorageManager } = require('../../framework/storage/StorageManager');
-const config = require('../../config/bulltrackers.config');
-
-console.log('╔════════════════════════════════════════════════════════════╗');
-console.log('║          Computation System v2 - Storage Tests             ║');
-console.log('╚════════════════════════════════════════════════════════════╝\n');
-
-// Test logger
-const logger = {
-    log: (level, msg) => console.log(`[${level}] ${msg}`)
-};
-
-// =============================================================================
-// Test Path Resolution
-// =============================================================================
-
-console.log('=== Test Path Template Resolution ===\n');
-
-// Create a storage manager instance
-const storageManager = new StorageManager(config, logger);
-
-// Test the path resolution (we need to access the private method for testing)
-function testPathResolution() {
-    // Note: Firestore paths must have EVEN number of segments (collection/doc/collection/doc)
-    const testCases = [
-        {
-            template: '/users/{entityId}/computations/portfolio_summary',
-            values: { entityId: '12345', date: '2026-01-24', computationName: 'test' },
-            expected: 'users/12345/computations/portfolio_summary'
-        },
-        {
-            template: '/computations/{computationName}/dates/{date}',  // 4 segments
-            values: { entityId: '_global', date: '2026-01-24', computationName: 'marketsummary' },
-            expected: 'computations/marketsummary/dates/2026-01-24'
-        },
-        {
-            template: '/users/{entityId}/daily/{date}',
-            values: { entityId: 'user_abc', date: '2026-01-24', computationName: 'test' },
-            expected: 'users/user_abc/daily/2026-01-24'
-        },
-        {
-            template: '/analytics/{category}/computations/{computationName}',  // 4 segments
-            values: { entityId: '123', date: '2026-01-24', computationName: 'usermetrics', category: 'user_analytics' },
-            expected: 'analytics/user_analytics/computations/usermetrics'
-        }
-    ];
-    
-    let passed = 0;
-    for (const tc of testCases) {
-        const result = storageManager._resolvePath(tc.template, tc.values);
-        const success = result === tc.expected;
-        console.log(`  ${tc.template}`);
-        console.log(`    → ${result} ${success ? '✓' : '✗'}`);
-        if (!success) {
-            console.log(`    Expected: ${tc.expected}`);
-        }
-        if (success) passed++;
-    }
-    
-    console.log(`\n  Passed: ${passed}/${testCases.length}`);
-    return passed === testCases.length;
-}
-
-const pathTestsPassed = testPathResolution();
-console.log(`\n✅ Path resolution tests ${pathTestsPassed ? 'complete' : 'FAILED'}\n`);
-
-// =============================================================================
-// Test Path Validation (should reject odd segment counts)
-// =============================================================================
-
-console.log('=== Test Path Validation ===\n');
-
-function testPathValidation() {
-    const invalidPaths = [
-        '/users/{entityId}/computations',  // 3 segments - points to collection
-        '/single',                          // 1 segment
-        '/a/b/c',                           // 3 segments
-    ];
-    
-    const validPaths = [
-        '/users/{entityId}',                // 2 segments
-        '/a/b/c/d',                         // 4 segments
-        '/users/{entityId}/data/{date}',    // 4 segments
-    ];
-    
-    let passed = 0;
-    
-    console.log('  Invalid paths (should throw):');
-    for (const path of invalidPaths) {
-        try {
-            storageManager._resolvePath(path, { entityId: '123', date: '2026-01-24' });
-            console.log(`    ${path} → DID NOT THROW ✗`);
-        } catch (e) {
-            console.log(`    ${path} → Threw error ✓`);
-            passed++;
-        }
-    }
-    
-    console.log('\n  Valid paths (should not throw):');
-    for (const path of validPaths) {
-        try {
-            const resolved = storageManager._resolvePath(path, { entityId: '123', date: '2026-01-24' });
-            console.log(`    ${path} → ${resolved} ✓`);
-            passed++;
-        } catch (e) {
-            console.log(`    ${path} → THREW ERROR ✗: ${e.message}`);
-        }
-    }
-    
-    const total = invalidPaths.length + validPaths.length;
-    console.log(`\n  Passed: ${passed}/${total}`);
-    return passed === total;
-}
-
-const validationTestsPassed = testPathValidation();
-console.log(`\n✅ Path validation tests ${validationTestsPassed ? 'complete' : 'FAILED'}\n`);
-
-// =============================================================================
-// Test Storage Config Resolution
-// =============================================================================
-
-console.log('=== Test Storage Config Resolution ===\n');
-
-function testStorageConfigResolution() {
-    const testCases = [
-        {
-            name: 'Default (no config)',
-            input: { storage: undefined },
-            expected: { bigquery: true, firestore: { enabled: false, path: null, merge: false, includeMetadata: true } }
-        },
-        {
-            name: 'BigQuery only explicit',
-            input: { storage: { bigquery: true } },
-            expected: { bigquery: true, firestore: { enabled: false, path: null, merge: false, includeMetadata: true } }
-        },
-        {
-            name: 'BigQuery disabled',
-            input: { storage: { bigquery: false } },
-            expected: { bigquery: false, firestore: { enabled: false, path: null, merge: false, includeMetadata: true } }
-        },
-        {
-            name: 'Firestore enabled with path',
-            input: { 
-                storage: { 
-                    firestore: { 
-                        enabled: true, 
-                        path: '/users/{entityId}/data' 
-                    } 
-                } 
-            },
-            expected: { 
-                bigquery: true, 
-                firestore: { 
-                    enabled: true, 
-                    path: '/users/{entityId}/data',
-                    merge: false,
-                    includeMetadata: true
-                } 
-            }
-        },
-        {
-            name: 'Firestore with merge and no metadata',
-            input: { 
-                storage: { 
-                    firestore: { 
-                        enabled: true, 
-                        path: '/data/{entityId}',
-                        merge: true,
-                        includeMetadata: false
-                    } 
-                } 
-            },
-            expected: { 
-                bigquery: true, 
-                firestore: { 
-                    enabled: true, 
-                    path: '/data/{entityId}',
-                    merge: true,
-                    includeMetadata: false
-                } 
-            }
-        },
-        {
-            name: 'Firestore only (no BigQuery)',
-            input: { 
-                storage: { 
-                    bigquery: false,
-                    firestore: { 
-                        enabled: true, 
-                        path: '/users/{entityId}/cache' 
-                    } 
-                } 
-            },
-            expected: { 
-                bigquery: false, 
-                firestore: { 
-                    enabled: true, 
-                    path: '/users/{entityId}/cache',
-                    merge: false,
-                    includeMetadata: true
-                } 
-            }
-        }
-    ];
-    
-    let passed = 0;
-    for (const tc of testCases) {
-        const result = storageManager._resolveStorageConfig(tc.input);
-        
-        // Deep compare
-        const resultStr = JSON.stringify(result);
-        const expectedStr = JSON.stringify(tc.expected);
-        const success = resultStr === expectedStr;
-        
-        console.log(`  ${tc.name}:`);
-        console.log(`    Input: ${JSON.stringify(tc.input.storage || 'undefined')}`);
-        console.log(`    Result: ${success ? '✓' : '✗'}`);
-        
-        if (!success) {
-            console.log(`    Got:      ${resultStr}`);
-            console.log(`    Expected: ${expectedStr}`);
-        }
-        
-        if (success) passed++;
-    }
-    
-    console.log(`\n  Passed: ${passed}/${testCases.length}`);
-    return passed === testCases.length;
-}
-
-const configTestsPassed = testStorageConfigResolution();
-console.log(`\n✅ Storage config resolution tests ${configTestsPassed ? 'complete' : 'FAILED'}\n`);
-
-// =============================================================================
-// Test Live Firestore Write (requires real credentials)
-// =============================================================================
-
-console.log('=== Test Live Firestore Write ===\n');
-
-async function testLiveFirestoreWrite() {
-    // Create a mock entry with Firestore storage config
-    const entry = {
-        name: 'test_computation',
-        originalName: 'TestComputation',
-        category: 'test',
-        type: 'per-entity',
-        hash: 'test_hash_123',
-        storage: {
-            bigquery: false,  // Skip BigQuery for this test
-            firestore: {
-                enabled: true,
-                path: '/test_computations/{entityId}/results/{date}',
-                merge: false,
-                includeMetadata: true
-            }
-        }
-    };
-    
-    // Mock results for 3 entities
-    const results = {
-        'entity_001': { score: 85, rank: 1, metrics: { a: 1, b: 2 } },
-        'entity_002': { score: 72, rank: 2, metrics: { a: 3, b: 4 } },
-        'entity_003': { score: 65, rank: 3, metrics: { a: 5, b: 6 } }
-    };
-    
-    const dateStr = '2026-01-24';
-    
-    try {
-        console.log('  Writing test data to Firestore...');
-        console.log(`  Entry: ${entry.name} (${entry.type})`);
-        console.log(`  Path template: ${entry.storage.firestore.path}`);
-        console.log(`  Entities: ${Object.keys(results).join(', ')}`);
-        
-        const writeResult = await storageManager.commitResults(dateStr, entry, results, {});
-        
-        console.log('\n  Write Results:');
-        console.log(`    BigQuery: ${writeResult.bigquery ? `${writeResult.bigquery.rowCount} rows` : 'skipped'}`);
-        console.log(`    Firestore: ${writeResult.firestore?.docCount || 0} documents`);
-        
-        if (writeResult.firestore?.error) {
-            console.log(`    Firestore Error: ${writeResult.firestore.error}`);
-            return false;
-        }
-        
-        // Verify the documents were written by reading them back
-        console.log('\n  Verifying written documents...');
-        
-        const firestore = storageManager.firestore;
-        let verified = 0;
-        
-        for (const entityId of Object.keys(results)) {
-            const docPath = `test_computations/${entityId}/results/${dateStr}`;
-            const docRef = firestore.doc(docPath);
-            const doc = await docRef.get();
-            
-            if (doc.exists) {
-                const data = doc.data();
-                console.log(`    ${docPath}: ✓`);
-                console.log(`      - score: ${data.score}`);
-                console.log(`      - _computedAt: ${data._computedAt ? 'present' : 'missing'}`);
-                verified++;
-            } else {
-                console.log(`    ${docPath}: NOT FOUND ✗`);
-            }
-        }
-        
-        console.log(`\n  Verified: ${verified}/${Object.keys(results).length} documents`);
-        
-        // Clean up test data
-        console.log('\n  Cleaning up test data...');
-        for (const entityId of Object.keys(results)) {
-            const docPath = `test_computations/${entityId}/results/${dateStr}`;
-            await firestore.doc(docPath).delete();
-        }
-        // Also delete the parent documents/collections if empty
-        for (const entityId of Object.keys(results)) {
-            try {
-                await firestore.doc(`test_computations/${entityId}`).delete();
-            } catch (e) {
-                // Ignore if collection not empty
-            }
-        }
-        console.log('  Cleanup complete');
-        
-        return verified === Object.keys(results).length;
-        
-    } catch (error) {
-        console.log(`\n  Error: ${error.message}`);
-        
-        if (error.message.includes('Could not load the default credentials')) {
-            console.log('\n  Note: Firestore test requires GCP credentials.');
-            console.log('  Set GOOGLE_APPLICATION_CREDENTIALS or run in GCP environment.');
-            return 'skipped';
-        }
-        
-        return false;
-    }
-}
-
-// =============================================================================
-// Test Global Computation Storage
-// =============================================================================
-
-async function testGlobalComputationStorage() {
-    console.log('\n=== Test Global Computation Firestore Write ===\n');
-    
-    const entry = {
-        name: 'market_summary',
-        originalName: 'MarketSummary',
-        category: 'market',
-        type: 'global',
-        hash: 'global_hash_456',
-        storage: {
-            bigquery: false,
-            firestore: {
-                enabled: true,
-                // Path must have even segments: collection/doc/collection/doc
-                path: '/computations/{computationName}/dates/{date}',
-                merge: false,
-                includeMetadata: true
-            }
-        }
-    };
-    
-    const results = {
-        totalVolume: 1500000000,
-        topGainers: ['AAPL', 'MSFT', 'GOOGL'],
-        topLosers: ['META', 'NFLX'],
-        marketSentiment: 0.65
-    };
-    
-    const dateStr = '2026-01-24';
-    
-    try {
-        console.log('  Writing global computation to Firestore...');
-        console.log(`  Path template: ${entry.storage.firestore.path}`);
-        
-        const writeResult = await storageManager.commitResults(dateStr, entry, results, {});
-        
-        console.log('\n  Write Results:');
-        console.log(`    Firestore: ${writeResult.firestore?.docCount || 0} documents`);
-        
-        // Verify
-        const firestore = storageManager.firestore;
-        const docPath = `computations/market_summary/dates/${dateStr}`;
-        const doc = await firestore.doc(docPath).get();
-        
-        if (doc.exists) {
-            const data = doc.data();
-            console.log(`\n  Verified document at ${docPath}:`);
-            console.log(`    - totalVolume: ${data.totalVolume}`);
-            console.log(`    - marketSentiment: ${data.marketSentiment}`);
-            console.log(`    - _computedAt: ${data._computedAt ? 'present' : 'missing'}`);
-            
-            // Cleanup
-            await firestore.doc(docPath).delete();
-            console.log('\n  Cleanup complete');
-            
-            return true;
-        } else {
-            console.log(`\n  Document not found at ${docPath}`);
-            return false;
-        }
-        
-    } catch (error) {
-        if (error.message.includes('Could not load the default credentials')) {
-            console.log('  Skipped: No GCP credentials');
-            return 'skipped';
-        }
-        console.log(`  Error: ${error.message}`);
-        return false;
-    }
-}
-
-// =============================================================================
-// Run All Tests
-// =============================================================================
-
-async function runAllTests() {
-    const results = {
-        pathResolution: pathTestsPassed,
-        pathValidation: validationTestsPassed,
-        configResolution: configTestsPassed,
-        liveFirestore: await testLiveFirestoreWrite(),
-        globalComputation: await testGlobalComputationStorage()
-    };
-    
-    console.log('\n╔════════════════════════════════════════════════════════════╗');
-    console.log('║                    Test Summary                             ║');
-    console.log('╚════════════════════════════════════════════════════════════╝\n');
-    
-    let allPassed = true;
-    for (const [name, result] of Object.entries(results)) {
-        const status = result === true ? '✅ PASSED' : 
-                       result === 'skipped' ? '⏭️  SKIPPED' : '❌ FAILED';
-        console.log(`  ${name}: ${status}`);
-        if (result === false) allPassed = false;
-    }
-    
-    console.log('\n' + (allPassed ? '✅ All tests passed!' : '❌ Some tests failed'));
-}
-
-runAllTests().catch(console.error);