bulltrackers-module 1.0.735 → 1.0.736

package/functions/computation-system-v2/test/test-worker-pool.js

@@ -0,0 +1,494 @@
+/**
+ * @fileoverview Worker Pool Test Harness
+ * 
+ * Tests the serverless worker pool functionality in LOCAL MODE.
+ * No GCS or HTTP required - workers run in-process.
+ * 
+ * USAGE:
+ *   node test-worker-pool.js [computation-name]
+ * 
+ * EXAMPLES:
+ *   node test-worker-pool.js                           # Test with mock data
+ *   node test-worker-pool.js UserPortfolioSummary      # Test specific computation
+ * 
+ * FEATURES:
+ *   - Tests worker handler directly (no HTTP)
+ *   - Tests RemoteTaskRunner in local mode
+ *   - Tests full Orchestrator with worker pool
+ *   - Measures performance and validates results
+ */
+
+const path = require('path');
+
+// Set local mode BEFORE importing modules
+process.env.WORKER_LOCAL_MODE = 'true';
+process.env.WORKER_POOL_ENABLED = 'true';
+
+// Import modules
+const { executeLocal, loadComputation, workerHandler } = require('../handlers/worker');
+const { RemoteTaskRunner } = require('../framework/execution/RemoteTaskRunner');
+
+// ============================================================================
+// MOCK DATA GENERATORS
+// ============================================================================
+
+/**
+ * Generate mock portfolio data for testing
+ */
+function generateMockPortfolioData(userId, positionCount = 5) {
+    const positions = [];
+    const instruments = ['AAPL', 'GOOGL', 'MSFT', 'AMZN', 'TSLA', 'META', 'NVDA', 'BRK.B', 'JPM', 'V'];
+    
+    for (let i = 0; i < positionCount; i++) {
+        const investedAmount = Math.random() * 10000 + 1000;
+        const profitPercent = (Math.random() * 100 - 20); // -20% to +80%
+        
+        positions.push({
+            InstrumentID: 1000 + i,
+            Ticker: instruments[i % instruments.length],
+            Direction: Math.random() > 0.1 ? 'Buy' : 'Sell',
+            InvestedAmount: investedAmount,
+            Value: investedAmount * (1 + profitPercent / 100),
+            Profit: investedAmount * profitPercent / 100,
+            ProfitPercent: profitPercent,
+            OpenedDate: new Date(Date.now() - Math.random() * 365 * 24 * 60 * 60 * 1000).toISOString()
+        });
+    }
+
+    return {
+        Positions: positions,
+        TotalEquity: positions.reduce((sum, p) => sum + p.Value, 0),
+        TotalInvestedAmount: positions.reduce((sum, p) => sum + p.InvestedAmount, 0)
+    };
+}
+
+/**
+ * Generate mock asset prices
+ */
+function generateMockAssetPrices() {
+    return {
+        AAPL: { close: 175.50, change: 1.2 },
+        GOOGL: { close: 142.30, change: -0.5 },
+        MSFT: { close: 378.90, change: 0.8 },
+        AMZN: { close: 178.25, change: 2.1 },
+        TSLA: { close: 248.50, change: -1.5 },
+        META: { close: 505.75, change: 1.8 },
+        NVDA: { close: 875.20, change: 3.2 },
+        'BRK.B': { close: 410.30, change: 0.3 },
+        JPM: { close: 195.80, change: 0.9 },
+        V: { close: 275.40, change: 0.6 }
+    };
+}
+
+// ============================================================================
+// TEST CASES
+// ============================================================================
+
+/**
+ * Test 1: Direct worker execution (executeLocal)
+ */
+async function testDirectWorkerExecution() {
+    console.log('\n📦 TEST 1: Direct Worker Execution (executeLocal)');
+    console.log('=' .repeat(60));
+    
+    const entityId = 'user-test-001';
+    const date = new Date().toISOString().slice(0, 10);
+    
+    const contextPackage = {
+        entityData: {
+            'portfolio_snapshots': generateMockPortfolioData(entityId, 5),
+            'asset_prices': generateMockAssetPrices()
+        },
+        references: {},
+        dependencies: {},
+        config: {}
+    };
+
+    const startTime = Date.now();
+    
+    try {
+        const result = await executeLocal({
+            computationName: 'UserPortfolioSummary',
+            entityId,
+            date,
+            contextPackage
+        });
+        
+        const duration = Date.now() - startTime;
+        
+        console.log(`✅ Worker executed successfully in ${duration}ms`);
+        console.log(`   Entity ID: ${result.entityId}`);
+        console.log(`   Result:`, JSON.stringify(result.result, null, 2));
+        
+        // Validate result structure
+        if (result.result) {
+            console.log(`   ✓ Has userId: ${!!result.result.userId}`);
+            console.log(`   ✓ Has totalValue: ${!!result.result.totalValue}`);
+            console.log(`   ✓ Has positionCount: ${result.result.positionCount}`);
+        }
+        
+        return { success: true, duration, result: result.result };
+    } catch (error) {
+        console.log(`❌ Worker execution failed: ${error.message}`);
+        console.log(error.stack);
+        return { success: false, error: error.message };
+    }
+}
+
+/**
+ * Test 2: Worker HTTP handler simulation
+ */
+async function testWorkerHttpHandler() {
+    console.log('\n📦 TEST 2: Worker HTTP Handler (workerHandler)');
+    console.log('='.repeat(60));
+    
+    const entityId = 'user-http-001';
+    const date = new Date().toISOString().slice(0, 10);
+    
+    // Create mock request/response objects
+    const mockReq = {
+        body: {
+            computationName: 'UserPortfolioSummary',
+            entityId,
+            date,
+            localContext: {
+                entityData: {
+                    'portfolio_snapshots': generateMockPortfolioData(entityId, 3),
+                    'asset_prices': generateMockAssetPrices()
+                },
+                references: {},
+                dependencies: {},
+                config: {}
+            }
+        }
+    };
+    
+    let responseData = null;
+    let responseStatus = null;
+    
+    const mockRes = {
+        status: (code) => {
+            responseStatus = code;
+            return mockRes;
+        },
+        json: (data) => {
+            responseData = data;
+            return mockRes;
+        }
+    };
+
+    const startTime = Date.now();
+    
+    try {
+        await workerHandler(mockReq, mockRes);
+        
+        const duration = Date.now() - startTime;
+        
+        console.log(`✅ HTTP handler completed in ${duration}ms`);
+        console.log(`   Status: ${responseStatus}`);
+        console.log(`   Response status: ${responseData?.status}`);
+        
+        if (responseData?.result) {
+            console.log(`   Total Value: $${responseData.result.totalValue?.toFixed(2)}`);
+            console.log(`   Positions: ${responseData.result.positionCount}`);
+        }
+        
+        return { success: responseStatus === 200, duration, response: responseData };
+    } catch (error) {
+        console.log(`❌ HTTP handler failed: ${error.message}`);
+        return { success: false, error: error.message };
+    }
+}
+
+/**
+ * Test 3: RemoteTaskRunner in local mode
+ */
+async function testRemoteTaskRunnerLocal() {
+    console.log('\n📦 TEST 3: RemoteTaskRunner (Local Mode)');
+    console.log('='.repeat(60));
+    
+    const config = {
+        workerPool: {
+            enabled: true,
+            localMode: true,
+            concurrency: 10
+        }
+    };
+    
+    const runner = new RemoteTaskRunner(config, console);
+    
+    // Create mock manifest entry
+    const entry = {
+        name: 'userportfoliosummary',
+        originalName: 'UserPortfolioSummary',
+        type: 'per-entity'
+    };
+    
+    const dateStr = new Date().toISOString().slice(0, 10);
+    const baseContext = {
+        references: {},
+        config: {}
+    };
+    
+    // Generate test entities
+    const entityIds = ['user-batch-001', 'user-batch-002', 'user-batch-003', 'user-batch-004', 'user-batch-005'];
+    const entityDataMap = new Map();
+    
+    for (const entityId of entityIds) {
+        entityDataMap.set(entityId, {
+            'portfolio_snapshots': generateMockPortfolioData(entityId, Math.floor(Math.random() * 8) + 2),
+            'asset_prices': generateMockAssetPrices()
+        });
+    }
+    
+    const depResults = {};
+
+    const startTime = Date.now();
+    
+    try {
+        const { results, errors } = await runner.runBatch(
+            entry,
+            dateStr,
+            baseContext,
+            entityIds,
+            entityDataMap,
+            depResults
+        );
+        
+        const duration = Date.now() - startTime;
+        
+        console.log(`✅ Batch completed in ${duration}ms`);
+        console.log(`   Entities processed: ${Object.keys(results).length}/${entityIds.length}`);
+        console.log(`   Errors: ${errors.length}`);
+        console.log(`   Throughput: ${(entityIds.length / (duration / 1000)).toFixed(2)} entities/sec`);
+        
+        // Show sample results
+        const firstResult = Object.values(results)[0];
+        if (firstResult) {
+            console.log(`   Sample result - Total Value: $${firstResult.totalValue?.toFixed(2)}`);
+        }
+        
+        if (errors.length > 0) {
+            console.log(`   First error: ${errors[0].error}`);
+        }
+        
+        return { success: errors.length === 0, duration, resultCount: Object.keys(results).length };
+    } catch (error) {
+        console.log(`❌ RemoteTaskRunner failed: ${error.message}`);
+        console.log(error.stack);
+        return { success: false, error: error.message };
+    }
+}
+
+/**
+ * Test 4: Performance test with larger batch
+ */
+async function testPerformance() {
+    console.log('\n📦 TEST 4: Performance Test (Large Batch)');
+    console.log('='.repeat(60));
+    
+    const config = {
+        workerPool: {
+            enabled: true,
+            localMode: true,
+            concurrency: 50  // Higher concurrency for perf test
+        }
+    };
+    
+    const runner = new RemoteTaskRunner(config, console);
+    
+    const entry = {
+        name: 'userportfoliosummary',
+        originalName: 'UserPortfolioSummary',
+        type: 'per-entity'
+    };
+    
+    const dateStr = new Date().toISOString().slice(0, 10);
+    const baseContext = { references: {}, config: {} };
+    
+    // Generate 100 test entities
+    const entityCount = 100;
+    const entityIds = Array.from({ length: entityCount }, (_, i) => `user-perf-${i.toString().padStart(4, '0')}`);
+    const entityDataMap = new Map();
+    
+    console.log(`   Generating ${entityCount} test entities...`);
+    
+    for (const entityId of entityIds) {
+        entityDataMap.set(entityId, {
+            'portfolio_snapshots': generateMockPortfolioData(entityId, Math.floor(Math.random() * 10) + 1),
+            'asset_prices': generateMockAssetPrices()
+        });
+    }
+    
+    console.log(`   Running batch...`);
+    const startTime = Date.now();
+    
+    try {
+        const { results, errors } = await runner.runBatch(
+            entry,
+            dateStr,
+            baseContext,
+            entityIds,
+            entityDataMap,
+            {}
+        );
+        
+        const duration = Date.now() - startTime;
+        const throughput = (entityCount / (duration / 1000)).toFixed(2);
+        
+        console.log(`\n   📊 PERFORMANCE RESULTS:`);
+        console.log(`   ─────────────────────────`);
+        console.log(`   Total entities:     ${entityCount}`);
+        console.log(`   Successful:         ${Object.keys(results).length}`);
+        console.log(`   Failed:             ${errors.length}`);
+        console.log(`   Total duration:     ${duration}ms`);
+        console.log(`   Throughput:         ${throughput} entities/sec`);
+        console.log(`   Avg per entity:     ${(duration / entityCount).toFixed(2)}ms`);
+        
+        return { 
+            success: errors.length === 0, 
+            duration, 
+            throughput: parseFloat(throughput),
+            resultCount: Object.keys(results).length 
+        };
+    } catch (error) {
+        console.log(`❌ Performance test failed: ${error.message}`);
+        return { success: false, error: error.message };
+    }
+}
+
+/**
+ * Test 5: Error handling
+ */
+async function testErrorHandling() {
+    console.log('\n📦 TEST 5: Error Handling');
+    console.log('='.repeat(60));
+    
+    // Test 5a: Unknown computation
+    console.log('\n   5a. Unknown computation name:');
+    try {
+        const result = await executeLocal({
+            computationName: 'NonExistentComputation',
+            entityId: 'test',
+            date: '2026-01-25',
+            contextPackage: {}
+        });
+        console.log(`   ❌ Should have thrown error, got: ${JSON.stringify(result)}`);
+    } catch (error) {
+        console.log(`   ✅ Correctly threw error: ${error.message}`);
+    }
+    
+    // Test 5b: Missing data
+    console.log('\n   5b. Missing required data:');
+    try {
+        const result = await executeLocal({
+            computationName: 'UserPortfolioSummary',
+            entityId: 'test-missing-data',
+            date: '2026-01-25',
+            contextPackage: {
+                entityData: {},  // No portfolio data
+                references: {},
+                dependencies: {}
+            }
+        });
+        console.log(`   ✅ Handled gracefully: ${result.result === null ? 'null result' : JSON.stringify(result.result)}`);
+    } catch (error) {
+        console.log(`   ⚠️ Error (may be expected): ${error.message}`);
+    }
+    
+    return { success: true };
+}
+
+/**
+ * Test 6: Load all computations
+ */
+async function testLoadComputations() {
+    console.log('\n📦 TEST 6: Load All Computations');
+    console.log('='.repeat(60));
+    
+    const computationNames = [
+        'UserPortfolioSummary',
+        'PopularInvestorProfileMetrics',
+        'PopularInvestorRiskAssessment',
+        'PopularInvestorRiskMetrics'
+    ];
+    
+    const results = [];
+    
+    for (const name of computationNames) {
+        try {
+            const cls = loadComputation(name);
+            if (cls) {
+                console.log(`   ✅ ${name}: Loaded successfully`);
+                results.push({ name, success: true });
+            } else {
+                console.log(`   ❌ ${name}: Failed to load (returned null)`);
+                results.push({ name, success: false });
+            }
+        } catch (error) {
+            console.log(`   ❌ ${name}: ${error.message}`);
+            results.push({ name, success: false, error: error.message });
+        }
+    }
+    
+    const successCount = results.filter(r => r.success).length;
+    console.log(`\n   Summary: ${successCount}/${computationNames.length} loaded successfully`);
+    
+    return { success: successCount === computationNames.length, results };
+}
+
+// ============================================================================
+// MAIN TEST RUNNER
+// ============================================================================
+
+async function runAllTests() {
+    console.log('\n');
+    console.log('╔════════════════════════════════════════════════════════════╗');
+    console.log('║           WORKER POOL LOCAL TEST HARNESS                  ║');
+    console.log('╚════════════════════════════════════════════════════════════╝');
+    console.log(`\n📅 Date: ${new Date().toISOString()}`);
+    console.log(`🔧 Mode: LOCAL (WORKER_LOCAL_MODE=true)`);
+    console.log(`🔧 Worker Pool: ENABLED (WORKER_POOL_ENABLED=true)`);
+    
+    const results = {};
+    
+    // Run all tests
+    results.directExecution = await testDirectWorkerExecution();
+    results.httpHandler = await testWorkerHttpHandler();
+    results.remoteTaskRunner = await testRemoteTaskRunnerLocal();
+    results.performance = await testPerformance();
+    results.errorHandling = await testErrorHandling();
+    results.loadComputations = await testLoadComputations();
+    
+    // Summary
+    console.log('\n');
+    console.log('╔════════════════════════════════════════════════════════════╗');
+    console.log('║                      TEST SUMMARY                          ║');
+    console.log('╚════════════════════════════════════════════════════════════╝');
+    
+    let passCount = 0;
+    let failCount = 0;
+    
+    for (const [name, result] of Object.entries(results)) {
+        const icon = result.success ? '✅' : '❌';
+        const status = result.success ? 'PASS' : 'FAIL';
+        console.log(`${icon} ${name}: ${status}`);
+        if (result.success) passCount++;
+        else failCount++;
+    }
+    
+    console.log(`\n📊 Results: ${passCount} passed, ${failCount} failed`);
+    
+    if (results.performance && results.performance.throughput) {
+        console.log(`📈 Performance: ${results.performance.throughput} entities/sec`);
+    }
+    
+    // Exit with appropriate code
+    process.exit(failCount > 0 ? 1 : 0);
+}
+
+// Run tests
+runAllTests().catch(err => {
+    console.error('Fatal test error:', err);
+    process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.735",
+  "version": "1.0.736",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [

package/functions/computation-system-v2/computations/TestComputation.js

@@ -1,46 +0,0 @@
-/**
- * @fileoverview Test Computation for E2E Verification
- */
-const { Computation } = require('../framework');
-
-class TestComputation extends Computation {
-    static getConfig() {
-        return {
-            name: 'TestComputation',
-            version: '1.0.0',
-            type: 'per-entity', // Forces the Streaming/Batching path
-            schedule: 'daily',
-            requires: {
-                // We will mock these tables in the test
-                users: { fields: ['id', 'status'], mandatory: true },
-                transactions: { fields: ['userId', 'amount'], mandatory: false }
-            },
-            dependencies: []
-        };
-    }
-
-    async process(context) {
-        const { entityId, data, rules } = context;
-        
-        // 1. Validate Data Injection
-        const user = data.users;
-        const txs = data.transactions || []; // Should be array of transactions for this user
-
-        // 2. Validate Rule Injection (Dynamic)
-        // We expect the test framework to provide a mock rule named 'math'
-        const multiplier = rules.math ? rules.math.double(1) : 1; 
-
-        // 3. Perform Calculation
-        const totalAmount = txs.reduce((sum, t) => sum + t.amount, 0);
-        
-        // 4. Return Result
-        this.results[entityId] = {
-            userId: entityId,
-            score: totalAmount * multiplier,
-            status: user.status,
-            processedAt: new Date().toISOString()
-        };
-    }
-}
-
-module.exports = TestComputation;