bulltrackers-module 1.0.768 → 1.0.769

package/functions/computation-system-v2/scripts/test-invalidation-scenarios.js

@@ -0,0 +1,234 @@
+/**
+ * @fileoverview Real-World Invalidation Simulator
+ * Dynamically loads ALL computation AND rule code to verify:
+ * 1. Code Hash Generation (using real files).
+ * 2. Invalidation logic (Simulated DB vs Real Disk Hash).
+ * 3. Dependency chains (Dynamic discovery of chains).
+ * * Usage: node scripts/test-real-scenarios.js
+ */
+
+const fs = require('fs');
+const path = require('path');
+const assert = require('assert');
+
+// Framework Components
+const { RunAnalyzer } = require('../framework/core/RunAnalyzer');
+const { Orchestrator } = require('../framework/execution/Orchestrator');
+const { ManifestBuilder } = require('../framework/core/Manifest');
+
+// -----------------------------------------------------------------------------
+// 1. MOCKS (Virtual Environment)
+// -----------------------------------------------------------------------------
+
+class MockDataFetcher {
+    async checkAvailability() { return { canRun: true, missing: [] }; }
+}
+
+class MockStateRepository {
+    constructor() {
+        this.statusMap = new Map();
+        this.results = new Map();
+    }
+
+    setDailyStatus(date, compName, status) {
+        if (!this.statusMap.has(date)) this.statusMap.set(date, new Map());
+        this.statusMap.get(date).set(compName.toLowerCase(), status);
+    }
+
+    async getDailyStatus(date) {
+        return this.statusMap.get(date) || new Map();
+    }
+    
+    // Simulate finding history for backfills
+    async getRunDates(compName) { return ['2024-01-01', '2024-01-02']; }
+
+    // Mock Result fetching
+    async getResult(date, compName) { return this.results.get(`${date}:${compName}`); }
+}
+
+class TestOrchestrator extends Orchestrator {
+    constructor(config, stateRepo) {
+        super(config);
+        this.stateRepository = stateRepo;
+        this.scheduledTasks = [];
+    }
+    async _scheduleCloudTask(name, date, source, delay) {
+        this.scheduledTasks.push({ name, date, source });
+    }
+    _log(level, msg) { /* console.log(`[${level}] ${msg}`); */ }
+}
+
+// -----------------------------------------------------------------------------
+// 2. HELPER: Dynamic Loader
+// -----------------------------------------------------------------------------
+function loadModulesFromDir(directory, label) {
+    let modules = [];
+    try {
+        if (fs.existsSync(directory)) {
+            const files = fs.readdirSync(directory).filter(f => f.endsWith('.js') && f !== 'index.js');
+            console.log(`INFO: Found ${files.length} ${label} files in ${directory}`);
+            
+            modules = files.map(file => {
+                try {
+                    return require(path.join(directory, file));
+                } catch (e) {
+                    console.warn(`WARN: Failed to load ${file}: ${e.message}`);
+                    return null;
+                }
+            }).filter(c => c !== null);
+        } else {
+            console.warn(`WARN: ${label} directory not found at ${directory}`);
+        }
+    } catch (e) {
+        console.error(`ERROR: Could not load ${label}: ${e.message}`);
+    }
+    return modules;
+}
+
+// -----------------------------------------------------------------------------
+// 3. TEST SUITE
+// -----------------------------------------------------------------------------
+
+async function runRealWorldTests() {
+    console.log('┌────────────────────────────────────────────────────────┐');
+    console.log('│           REAL CODE SIMULATION SUITE                   │');
+    console.log('└────────────────────────────────────────────────────────┘');
+
+    // 1. LOAD ARTIFACTS
+    const computationsDir = path.join(__dirname, '../computations');
+    const rulesDir = path.join(__dirname, '../rules');
+
+    const computationClasses = loadModulesFromDir(computationsDir, 'computation');
+    const ruleModules = loadModulesFromDir(rulesDir, 'rule'); // <--- NEW: Load Rules
+
+    if (computationClasses.length === 0) {
+        console.error("❌ ABORT: No valid computations found to test.");
+        return;
+    }
+
+    // 2. BUILD REAL MANIFEST
+    const config = {
+        computations: computationClasses,
+        rules: ruleModules // <--- NEW: Pass Rules to Config
+    };
+    
+    // Initialize ManifestBuilder (this internally initializes RulesRegistry too)
+    const builder = new ManifestBuilder(config, console);
+    const realManifest = builder.build(config.computations);
+    
+    console.log(`INFO: Successfully built manifest with ${realManifest.length} entries.`);
+
+    // 3. RUN TESTS
+    await test_RealCodeInvalidation(realManifest);
+    await test_DynamicDependencyCascading(realManifest, config);
+}
+
+/**
+ * SCENARIO 1: Simulate a Deployment (Code Change)
+ */
+async function test_RealCodeInvalidation(manifest) {
+    // Pick 'RiskScoreIncrease' if available, otherwise the first one
+    let target = manifest.find(c => c.name === 'riskscoreincrease');
+    if (!target) target = manifest[0];
+
+    console.log(`\n🧪 Test 1: Real Code Hash Mismatch (${target.originalName})`);
+
+    const analyzer = new RunAnalyzer(manifest, new MockDataFetcher());
+    const date = '2024-06-01';
+    
+    // CONDITION: The DB has an old/different hash
+    const dailyStatus = new Map();
+    dailyStatus.set(target.name, { 
+        hash: 'OLD_DEPLOYMENT_HASH_123', 
+        resultHash: 'res_v1', 
+        updatedAt: new Date().toISOString() 
+    });
+
+    // ANALYZE
+    const result = await analyzer._evaluateEntry(target, date, true, dailyStatus, new Map());
+
+    // ASSERT
+    try {
+        assert.strictEqual(result.type, 'reRuns', 'Should trigger re-run');
+        assert.strictEqual(result.payload.reason, 'Code changed', 'Reason must be code change');
+        
+        console.log(`   [Current Disk Hash]: ${target.hash.substring(0, 16)}...`);
+        console.log(`   [Simulated DB Hash]: OLD_DEPLOYMENT_HASH_123`);
+        console.log('✅ PASS: System correctly detected the code mismatch.');
+    } catch (e) {
+        console.error('❌ FAIL:', e.message);
+        console.log('   Decision:', result);
+    }
+}
+
+/**
+ * SCENARIO 2: Dynamic Dependency Propagation
+ */
+async function test_DynamicDependencyCascading(manifest, config) {
+    console.log('\n🧪 Test 2: Dependency Propagation (Dynamic Chain Detection)');
+
+    // 1. Find a valid dependency chain (Parent -> Child)
+    let upstream = null;
+    let downstream = null;
+
+    for (const child of manifest) {
+        if (child.dependencies && child.dependencies.length > 0) {
+            // Find the parent object
+            const parentName = child.dependencies[0]; // normalized name usually
+            const parent = manifest.find(c => c.name === parentName); // match normalized names
+            
+            if (parent) {
+                upstream = parent;
+                downstream = child;
+                break; // Found a pair!
+            }
+        }
+    }
+
+    // 2. Handle Case: No Chains Found
+    if (!upstream || !downstream) {
+        console.log('⚠️  SKIPPED: No valid dependency chains found in the loaded computations.');
+        console.log('   (This is NOT a failure. It simply means all loaded computations are independent)');
+        console.log('✅ PASS: Skipped due to lack of testable chains.');
+        return;
+    }
+
+    console.log(`   Found chain: ${upstream.originalName} -> ${downstream.originalName}`);
+
+    // 3. Setup Orchestrator
+    const mockState = new MockStateRepository();
+    const orch = new TestOrchestrator({ ...config, bigquery: {}, tables: {} }, mockState);
+    orch.manifest = manifest;
+    orch._buildDependentsIndex();
+
+    const date = '2024-06-01';
+
+    // 4. Simulate Upstream Finishing
+    mockState.setDailyStatus(date, upstream.name, {
+        hash: upstream.hash,
+        resultHash: 'NEW_RESULT_HASH_XYZ',
+        updatedAt: new Date().toISOString()
+    });
+
+    // 5. Trigger Cascading Logic
+    await orch._scheduleDependents(upstream, date);
+
+    // 6. Assert
+    try {
+        const task = orch.scheduledTasks.find(t => t.name === downstream.originalName);
+        if (task) {
+             console.log(`   [Triggered]: ${task.name} due to update in ${upstream.name}`);
+             console.log('✅ PASS: Dependency chain resolved and task scheduled.');
+        } else {
+             console.error(`❌ FAIL: Downstream task (${downstream.name}) was NOT scheduled.`);
+             console.log('   Dependents Map keys:', Array.from(orch.dependentsByName.keys()));
+        }
+    } catch (e) {
+        console.error('❌ FAIL:', e.message);
+    }
+}
+
+// EXECUTE
+runRealWorldTests().catch(e => {
+    console.error('FATAL:', e);
+});

package/package.json

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