bulltrackers-module 1.0.733 → 1.0.734

package/functions/computation-system-v2/test/test-real-integration.js

@@ -0,0 +1,194 @@
+/**
+ * @fileoverview Real Integration Test (End-to-End)
+ * * 1. Auto-detects the LATEST date in BigQuery
+ * * 2. Fetches REAL data (which comes as a JSON string)
+ * * 3. Uses RULES to parse and analyze that string
+ * * 4. Saves the decoded output to test-results.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { BigQuery } = require('@google-cloud/bigquery');
+const { Orchestrator } = require('../framework/execution/Orchestrator');
+const { Computation } = require('../framework/core/Computation');
+const realConfig = require('../config/bulltrackers.config');
+
+// 1. DYNAMIC TEST COMPUTATION
+class LiveTestComputation extends Computation {
+    static setConfig(tableName, entityField) {
+        this.targetTable = tableName;
+        this.entityField = entityField;
+    }
+
+    static getConfig() {
+        const tableName = this.targetTable; 
+        return {
+            name: 'LiveTestComputation',
+            version: '1.0.0',
+            type: 'per-entity',
+            schedule: 'daily',
+            requires: {
+                [tableName]: { 
+                    mandatory: true
+                }
+            },
+            dependencies: []
+        };
+    }
+
+    async process(context) {
+        const { entityId, data, rules } = context;
+        const tableName = this.constructor.targetTable;
+        
+        // This is the RAW JSON STRING from BigQuery
+        const rawData = data[tableName]; 
+        
+        // 1. USE RULES TO PARSE DATA
+        // The rules engine handles the JSON parsing automatically
+        const positions = rules.portfolio.extractPositions(rawData);
+        const mirrors = rules.portfolio.extractMirrors(rawData);
+        
+        // 2. CALCULATE METRICS (Using Rules)
+        const totalValue = rules.portfolio.calculateTotalValue(positions);
+        const invested = rules.portfolio.calculateTotalInvested(positions);
+        const profit = rules.metrics.round(totalValue - invested, 2);
+        
+        // 3. GET TOP POSITIONS
+        const topHoldings = rules.portfolio.getTopPositions(positions, 3).map(pos => ({
+            symbol: rules.portfolio.getInstrumentId(pos),
+            value: rules.metrics.round(rules.portfolio.getValue(pos), 2),
+            direction: rules.portfolio.getDirection(pos)
+        }));
+
+        // 4. STORE RESULT
+        this.results[entityId] = {
+            entityId,
+            parsedSuccessfully: positions.length > 0 || mirrors.length > 0,
+            summary: {
+                positionCount: positions.length,
+                mirrorCount: mirrors.length,
+                totalValue: rules.metrics.round(totalValue, 2),
+                profit
+            },
+            topHoldings,
+            processedAt: new Date().toISOString(),
+            status: 'valid'
+        };
+    }
+}
+
+async function getLatestDate(config, tableName) {
+    const bq = new BigQuery({ projectId: config.bigquery.projectId });
+    const fullTable = `${config.bigquery.projectId}.${config.bigquery.dataset}.${tableName}`;
+    
+    console.log(`🔎 Finding latest data in ${fullTable}...`);
+    
+    try {
+        const query = `SELECT MAX(date) as latest_date FROM \`${fullTable}\``;
+        const [rows] = await bq.query(query);
+        if (rows.length && rows[0].latest_date) {
+            return rows[0].latest_date.value || rows[0].latest_date;
+        }
+    } catch (e) {
+        console.warn(`   Warning: Could not query MAX(date). Using yesterday.`);
+    }
+    
+    const d = new Date();
+    d.setDate(d.getDate() - 1);
+    return d.toISOString().split('T')[0];
+}
+
+async function runLiveTest() {
+    console.log('🔌 Connecting to Real Environment (BigQuery)...');
+
+    if (!realConfig.bigquery?.projectId) throw new Error('Missing projectId in config');
+    
+    const tableName = 'portfolio_snapshots';
+    const tableConfig = realConfig.tables[tableName];
+    
+    console.log(`   Target Table: ${tableName}`);
+
+    // 3. AUTO-DETECT DATE
+    const latestDate = await getLatestDate(realConfig, tableName);
+    console.log(`   Latest Available Date: ${latestDate}`);
+
+    LiveTestComputation.setConfig(tableName, tableConfig.entityField);
+    
+    const testConfig = {
+        ...realConfig,
+        computations: [LiveTestComputation],
+        execution: {
+            batchSize: 5,
+            entityConcurrency: 2
+        }
+    };
+
+    // 4. INITIALIZE ORCHESTRATOR
+    const orchestrator = new Orchestrator(testConfig, console);
+    await orchestrator.initialize();
+
+    // =========================================================================
+    // 5. INTERCEPT STORAGE
+    // =========================================================================
+    
+    const capturedResults = [];
+    
+    orchestrator.storageManager.commitResults = async (date, entry, results) => {
+        const count = Object.keys(results).length;
+        console.log(`   [MockStorage] Capturing batch of ${count} results...`);
+        Object.values(results).forEach(r => capturedResults.push(r));
+        return { rowCount: count };
+    };
+
+    // Silence other storage ops
+    orchestrator.storageManager.getLatestCheckpoint = async () => null;
+    orchestrator.storageManager.initCheckpoint = async () => {};
+    orchestrator.storageManager.updateCheckpoint = async () => {};
+    orchestrator.storageManager.completeCheckpoint = async () => {};
+    orchestrator.storageManager.savePerformanceReport = async () => {};
+
+    // =========================================================================
+    // 6. EXECUTION
+    // =========================================================================
+
+    const dateStr = typeof latestDate === 'string' ? latestDate : latestDate.toISOString().split('T')[0];
+    console.log(`🚀 Executing LiveTestComputation for ${dateStr}...`);
+    
+    const entry = orchestrator.manifest.find(c => c.name === 'livetestcomputation');
+    
+    const result = await orchestrator.runSingle(entry, dateStr, {
+        dryRun: false 
+    });
+
+    // =========================================================================
+    // 7. OUTPUT & VALIDATION
+    // =========================================================================
+    
+    console.log('\n📊 TEST COMPLETED');
+    console.log(`   Status: ${result.status}`);
+    console.log(`   Captured Rows: ${capturedResults.length}`);
+
+    if (capturedResults.length > 0) {
+        const sample = capturedResults[0];
+        console.log('\n🔍 Sample Result Inspection:');
+        console.log(`   Entity ID:       ${sample.entityId}`);
+        console.log(`   Parsed OK:       ${sample.parsedSuccessfully ? '✅ YES' : '❌ NO'}`);
+        console.log(`   Positions:       ${sample.summary.positionCount}`);
+        console.log(`   Total Value:     $${sample.summary.totalValue}`);
+        
+        if (sample.topHoldings.length > 0) {
+            console.log(`   Top Holding:     ${sample.topHoldings[0].symbol} ($${sample.topHoldings[0].value})`);
+        }
+
+        const outputPath = path.join(__dirname, 'test-results.json');
+        fs.writeFileSync(outputPath, JSON.stringify(capturedResults, null, 2));
+        console.log(`\n✅ Full results saved to: ${outputPath}`);
+    } else {
+        console.warn('\n⚠️  No results were captured.');
+    }
+}
+
+runLiveTest().catch(err => {
+    console.error('\n❌ FATAL ERROR:', err);
+    process.exit(1);
+});

package/functions/computation-system-v2/test/test-refactor-e2e.js

@@ -0,0 +1,131 @@
+/**
+ * @fileoverview End-to-End Test for Refactored Architecture
+ * Validates: Dispatcher -> Index -> Orchestrator -> RuleInjector -> TaskRunner
+ */
+
+const assert = require('assert');
+const { Orchestrator } = require('../framework/execution/Orchestrator');
+const TestComputation = require('../computations/TestComputation');
+const { RulesRegistry } = require('../framework/core/Rules');
+
+// MOCK DATA
+const MOCK_USERS = {
+    'user_1': { id: 'user_1', status: 'active' },
+    'user_2': { id: 'user_2', status: 'pending' }
+};
+
+const MOCK_TXS = [
+    { userId: 'user_1', amount: 100 },
+    { userId: 'user_1', amount: 50 },
+    { userId: 'user_2', amount: 200 }
+];
+
+// MOCK RULES
+class MockRulesRegistry extends RulesRegistry {
+    getContext() {
+        return {
+            math: {
+                double: (n) => n * 2
+            }
+        };
+    }
+}
+
+async function runTest() {
+    console.log('🧪 Starting End-to-End Refactor Test...\n');
+
+    // 1. SETUP: Initialize Orchestrator with Mocks
+    const config = {
+        computations: [TestComputation],
+        tables: {
+            users: { entityField: 'id' },
+            transactions: { entityField: 'userId' }
+        },
+        execution: { batchSize: 2 } // Small batch to test looping
+    };
+
+    const orchestrator = new Orchestrator(config, console);
+
+    // --- MONKEY PATCHING MOCKS (Simulating Infrastructure) ---
+    
+    // Mock Data Fetcher (Batching)
+    orchestrator.dataFetcher.fetchComputationBatched = async function* (requires, date, batchSize) {
+        console.log(`   [Mock] Fetching batch for ${date}...`);
+        yield {
+            entityIds: ['user_1', 'user_2'],
+            data: {
+                users: MOCK_USERS,
+                transactions: MOCK_TXS
+            }
+        };
+    };
+
+    // Mock Data Fetcher (Filter logic which usually runs in DB, we verify it runs in memory here)
+    orchestrator._filterDataForEntity = function(batchData, entityId) {
+        // Simple mock of the helper logic
+        return {
+            users: batchData.users[entityId],
+            transactions: batchData.transactions.filter(t => t.userId === entityId)
+        };
+    };
+
+    // Mock State Repository (Always fresh run)
+    orchestrator.stateRepository.getDailyStatus = async () => new Map();
+    orchestrator.stateRepository.updateStatusCache = async (d, n, s) => {
+        console.log(`   [Mock] Status Updated: ${n} -> EntityCount: ${s.entityCount}`);
+    };
+
+    // Mock Storage Manager (Capture results)
+    const storedResults = {};
+    orchestrator.storageManager.commitResults = async (date, comp, results) => {
+        Object.assign(storedResults, results);
+        console.log(`   [Mock] Storage Committed ${Object.keys(results).length} records.`);
+    };
+
+    // Mock Rule Registry (Inject our mock math rule)
+    orchestrator.ruleInjector.registry = new MockRulesRegistry(config);
+
+
+    // 2. EXECUTION: Run via the new "Worker" API
+    console.log('🚀 Triggering Execution...');
+    
+    // We simulate what the new index.js runComputation does:
+    // It finds the manifest entry and calls runSingle.
+    await orchestrator.initialize();
+    const entry = orchestrator.manifest.find(c => c.name === 'testcomputation');
+    
+    const result = await orchestrator.runSingle(entry, '2026-01-25', {
+        dryRun: false
+    });
+
+
+    // 3. VALIDATION: Assertions
+    console.log('\n📊 Validating Results...');
+
+    // Assertion 1: Execution Status
+    assert.strictEqual(result.status, 'completed', 'Status should be completed');
+    assert.strictEqual(result.resultCount, 2, 'Should process 2 entities');
+    console.log('   ✅ Execution Status OK');
+
+    // Assertion 2: User 1 Calculation
+    // Amount: 100 + 50 = 150. Multiplier (Rule): 2. Result: 300.
+    const r1 = storedResults['user_1'];
+    assert.ok(r1, 'User 1 result missing');
+    assert.strictEqual(r1.score, 300, `User 1 Score Wrong. Expected 300, got ${r1.score}`);
+    assert.strictEqual(r1.status, 'active', 'User 1 Status Wrong');
+    console.log('   ✅ User 1 Logic OK (Aggregation + Rule Injection)');
+
+    // Assertion 3: User 2 Calculation
+    // Amount: 200. Multiplier: 2. Result: 400.
+    const r2 = storedResults['user_2'];
+    assert.ok(r2, 'User 2 result missing');
+    assert.strictEqual(r2.score, 400, `User 2 Score Wrong. Expected 400, got ${r2.score}`);
+    console.log('   ✅ User 2 Logic OK');
+
+    console.log('\n🎉 ALL TESTS PASSED. The Orchestrator Refactor is FUNCTIONAL.');
+}
+
+runTest().catch(err => {
+    console.error('\n❌ TEST FAILED:', err);
+    process.exit(1);
+});

package/functions/computation-system-v2/test/test-results.json

@@ -0,0 +1,31 @@
+[
+  {
+    "entityId": "24790725",
+    "parsedSuccessfully": true,
+    "summary": {
+      "positionCount": 29,
+      "mirrorCount": 0,
+      "totalValue": 99.54,
+      "profit": 0.16
+    },
+    "topHoldings": [
+      {
+        "symbol": 1002,
+        "value": 11.01,
+        "direction": "Buy"
+      },
+      {
+        "symbol": 4481,
+        "value": 7.95,
+        "direction": "Buy"
+      },
+      {
+        "symbol": 3006,
+        "value": 7.49,
+        "direction": "Buy"
+      }
+    ],
+    "processedAt": "2026-01-25T02:52:57.446Z",
+    "status": "valid"
+  }
+]

package/functions/computation-system-v2/test/test-risk-metrics-computation.js

@@ -0,0 +1,329 @@
+/**
+ * @fileoverview Test for PopularInvestorRiskMetrics Computation
+ * 
+ * Tests the full computation pipeline including:
+ * - Rule-based calculations
+ * - BigQuery storage
+ * - Firestore storage
+ */
+
+const { Executor, ManifestBuilder } = require('../framework');
+const { StorageManager } = require('../framework/storage/StorageManager');
+const PopularInvestorRiskMetrics = require('../computations/PopularInvestorRiskMetrics');
+const config = require('../config/bulltrackers.config');
+
+console.log('╔════════════════════════════════════════════════════════════╗');
+console.log('║     PopularInvestorRiskMetrics - Full Integration Test     ║');
+console.log('╚════════════════════════════════════════════════════════════╝\n');
+
+// Test logger
+const logger = {
+    log: (level, msg) => console.log(`[${level}] ${msg}`)
+};
+
+// =============================================================================
+// Test 1: Verify Manifest Entry
+// =============================================================================
+
+async function testManifestEntry() {
+    console.log('=== Test 1: Manifest Entry ===\n');
+    
+    const builder = new ManifestBuilder(config, logger);
+    const manifest = builder.build([PopularInvestorRiskMetrics]);
+    
+    const entry = manifest[0];
+    
+    console.log('Computation Entry:');
+    console.log(`  Name: ${entry.name}`);
+    console.log(`  Category: ${entry.category}`);
+    console.log(`  Type: ${entry.type}`);
+    console.log(`  Hash: ${entry.hash}`);
+    console.log(`  Schedule: ${JSON.stringify(entry.schedule)}`);
+    console.log('\nStorage Config:');
+    console.log(`  BigQuery: ${entry.storage.bigquery}`);
+    console.log(`  Firestore enabled: ${entry.storage.firestore.enabled}`);
+    console.log(`  Firestore path: ${entry.storage.firestore.path}`);
+    
+    const allCorrect = 
+        entry.name === 'popularinvestorriskmetrics' &&
+        entry.category === 'risk_analytics' &&
+        entry.type === 'per-entity' &&
+        entry.storage.bigquery === true &&
+        entry.storage.firestore.enabled === true;
+    
+    console.log(`\n✅ Manifest entry test ${allCorrect ? 'passed' : 'FAILED'}\n`);
+    return allCorrect;
+}
+
+// =============================================================================
+// Test 2: Test Computation Logic with Mock Data
+// =============================================================================
+
+async function testComputationLogic() {
+    console.log('=== Test 2: Computation Logic (Mock Data) ===\n');
+    
+    // Create a mock context with 30 days of portfolio history
+    const mockPortfolioHistory = [];
+    let baseValue = 100000;
+    
+    // Generate 30 days of portfolio snapshots
+    for (let i = 0; i < 30; i++) {
+        const date = new Date('2026-01-01');
+        date.setDate(date.getDate() + i);
+        
+        // Add some realistic variation (+/- 2% daily)
+        const dailyReturn = (Math.random() - 0.4) * 4;  // Slight positive bias
+        baseValue = baseValue * (1 + dailyReturn / 100);
+        
+        // Create positions with varying profits
+        const positions = [
+            { InstrumentID: '1', Amount: baseValue * 0.3, NetProfit: (Math.random() - 0.3) * 20, Value: baseValue * 0.3 },
+            { InstrumentID: '2', Amount: baseValue * 0.25, NetProfit: (Math.random() - 0.3) * 20, Value: baseValue * 0.25 },
+            { InstrumentID: '3', Amount: baseValue * 0.2, NetProfit: (Math.random() - 0.3) * 20, Value: baseValue * 0.2 },
+            { InstrumentID: '4', Amount: baseValue * 0.15, NetProfit: (Math.random() - 0.3) * 20, Value: baseValue * 0.15 },
+            { InstrumentID: '5', Amount: baseValue * 0.1, NetProfit: (Math.random() - 0.3) * 20, Value: baseValue * 0.1 },
+        ];
+        
+        mockPortfolioHistory.push({
+            date: date.toISOString().split('T')[0],
+            AggregatedPositions: positions
+        });
+    }
+    
+    // Build rules context
+    const rulesModules = config.rules || {};
+    const rulesContext = {};
+    for (const [name, moduleExports] of Object.entries(rulesModules)) {
+        rulesContext[name] = moduleExports;
+    }
+    
+    // Create mock context
+    const context = {
+        date: '2026-01-30',
+        entityId: 'test_user_001',
+        data: {
+            'portfolio_snapshots': mockPortfolioHistory
+        },
+        rules: rulesContext,
+        logger
+    };
+    
+    // Create computation instance
+    const computation = new PopularInvestorRiskMetrics();
+    computation._meta = { logger, config };
+    
+    // Run computation
+    await computation.process(context);
+    
+    // Get result (results are stored in computation.results object)
+    const allResults = await computation.getResult();
+    const result = allResults['test_user_001'];
+    
+    console.log('Computation Result:');
+    console.log(`  User ID: ${result.userId}`);
+    console.log(`  Portfolio Value: $${result.portfolioValue.toLocaleString()}`);
+    console.log(`  Position Count: ${result.positionCount}`);
+    console.log(`  Days Analyzed: ${result.daysAnalyzed}`);
+    console.log('\nRisk Metrics:');
+    console.log(`  Sharpe Ratio: ${result.sharpeRatio}`);
+    console.log(`  Sortino Ratio: ${result.sortinoRatio}`);
+    console.log(`  Max Drawdown: ${result.maxDrawdown}%`);
+    console.log(`  VaR (95%): ${result.valueAtRisk95}%`);
+    console.log('\nPerformance:');
+    console.log(`  Win Ratio: ${(result.winRatio * 100).toFixed(1)}%`);
+    console.log(`  Avg Daily Return: ${result.avgDailyReturn}%`);
+    console.log(`  Return Volatility: ${result.returnVolatility}%`);
+    console.log(`  Top 3 Concentration: ${result.top3Concentration}%`);
+    console.log(`\n  Risk Grade: ${result.riskGrade}`);
+    
+    const validResult = 
+        result.userId === 'test_user_001' &&
+        result.portfolioValue > 0 &&
+        result.daysAnalyzed === 30 &&
+        result.riskGrade !== 'N/A';
+    
+    console.log(`\n✅ Computation logic test ${validResult ? 'passed' : 'FAILED'}\n`);
+    return { passed: validResult, result };
+}
+
+// =============================================================================
+// Test 3: Test Full Storage Pipeline (BigQuery + Firestore)
+// =============================================================================
+
+async function testStoragePipeline(computationResult) {
+    console.log('=== Test 3: Storage Pipeline (BQ + Firestore) ===\n');
+    
+    const storageManager = new StorageManager(config, logger);
+    
+    // Create a mock manifest entry with storage config
+    const entry = {
+        name: 'popularinvestorriskmetrics',
+        originalName: 'PopularInvestorRiskMetrics',
+        category: 'risk_analytics',
+        type: 'per-entity',
+        hash: 'test_hash_789',
+        storage: {
+            bigquery: false,  // Skip BQ for this test
+            firestore: {
+                enabled: true,
+                path: '/test_users/{entityId}/computations/risk_metrics',
+                merge: false,
+                includeMetadata: true
+            }
+        }
+    };
+    
+    const results = {
+        'test_user_001': computationResult
+    };
+    
+    const dateStr = '2026-01-30';
+    
+    try {
+        console.log('  Writing computation results 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(`    BigQuery: ${writeResult.bigquery ? `${writeResult.bigquery.rowCount} rows` : 'skipped'}`);
+        console.log(`    Firestore: ${writeResult.firestore?.docCount || 0} documents`);
+        
+        // Verify in Firestore
+        const firestore = storageManager.firestore;
+        const docPath = 'test_users/test_user_001/computations/risk_metrics';
+        const doc = await firestore.doc(docPath).get();
+        
+        if (doc.exists) {
+            const data = doc.data();
+            console.log(`\n  Verified document at ${docPath}:`);
+            console.log(`    - sharpeRatio: ${data.sharpeRatio}`);
+            console.log(`    - riskGrade: ${data.riskGrade}`);
+            console.log(`    - _computedAt: ${data._computedAt ? 'present' : 'missing'}`);
+            console.log(`    - _computationDate: ${data._computationDate}`);
+            
+            // Cleanup
+            await firestore.doc(docPath).delete();
+            console.log('\n  Cleanup complete');
+            
+            console.log('\n✅ Storage pipeline test passed\n');
+            return true;
+        } else {
+            console.log(`\n  Document not found at ${docPath}`);
+            console.log('\n❌ Storage pipeline test FAILED\n');
+            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;
+    }
+}
+
+// =============================================================================
+// Test 4: Test with Real BigQuery Data (if available)
+// =============================================================================
+
+async function testWithRealData() {
+    console.log('=== Test 4: Integration with Real BigQuery Data ===\n');
+    
+    try {
+        // Create executor with real config
+        const executor = new Executor(config, logger);
+        await executor.initialize();
+        
+        // Add our computation to the manifest
+        const builder = new ManifestBuilder(config, logger);
+        const manifest = builder.build([PopularInvestorRiskMetrics]);
+        
+        console.log(`  Manifest: ${manifest.length} computations`);
+        console.log(`  Entry: ${manifest[0].name}`);
+        
+        // Try to run for a recent date
+        const targetDate = '2026-01-24';
+        console.log(`\n  Checking data availability for ${targetDate}...`);
+        
+        // Check if we have data
+        const availability = await executor.dataFetcher.checkAvailability(
+            manifest[0].requires,
+            targetDate
+        );
+        
+        console.log(`  Data available: ${availability.canRun}`);
+        
+        if (!availability.canRun) {
+            console.log('  Missing tables:', availability.missing?.join(', ') || 'unknown');
+            console.log('\n⏭️  Skipped: No real data available\n');
+            return 'skipped';
+        }
+        
+        // Run computation
+        console.log('\n  Running computation...');
+        const result = await executor.runSingle(manifest[0], targetDate, {
+            force: true  // Force run even if cached
+        });
+        
+        console.log('\n  Execution Result:');
+        console.log(`    Status: ${result.status}`);
+        console.log(`    Entities: ${result.entityCount}`);
+        console.log(`    Duration: ${result.duration}ms`);
+        
+        console.log('\n✅ Real data integration test passed\n');
+        return true;
+        
+    } catch (error) {
+        console.log(`  Error: ${error.message}`);
+        if (error.message.includes('credentials') || error.message.includes('project')) {
+            console.log('\n⏭️  Skipped: GCP credentials not configured\n');
+            return 'skipped';
+        }
+        console.log('\n❌ Real data integration test FAILED\n');
+        return false;
+    }
+}
+
+// =============================================================================
+// Run All Tests
+// =============================================================================
+
+async function runAllTests() {
+    const results = {};
+    
+    // Test 1: Manifest
+    results.manifestEntry = await testManifestEntry();
+    
+    // Test 2: Computation logic
+    const logicTest = await testComputationLogic();
+    results.computationLogic = logicTest.passed;
+    
+    // Test 3: Storage pipeline (uses result from test 2)
+    if (logicTest.passed) {
+        results.storagePipeline = await testStoragePipeline(logicTest.result);
+    } else {
+        results.storagePipeline = 'skipped';
+    }
+    
+    // Test 4: Real data (optional)
+    results.realDataIntegration = await testWithRealData();
+    
+    // Summary
+    console.log('╔════════════════════════════════════════════════════════════╗');
+    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);