292 lines
8.5 KiB
Python
292 lines
8.5 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
TSNet Phase 2 - Test Directo sin MCP
|
|
Test directo de funcionalidad TSNet mediante ejecución local
|
|
"""
|
|
|
|
import subprocess
|
|
import time
|
|
import os
|
|
from datetime import datetime
|
|
|
|
|
|
def run_csharp_test(test_name, code):
|
|
"""Ejecutar código C# directamente usando dotnet script"""
|
|
print(f"\n🧪 Testing: {test_name}")
|
|
|
|
# Crear archivo temporal de test
|
|
test_file = f"temp_test_{int(time.time())}.csx"
|
|
|
|
full_code = f"""
|
|
#r "d:\\Proyectos\\VisualStudio\\CtrEditor\\bin\\Debug\\net8.0-windows8.0\\CtrEditor.dll"
|
|
#r "d:\\Proyectos\\VisualStudio\\CtrEditor\\bin\\Debug\\net8.0-windows8.0\\CommunityToolkit.Mvvm.dll"
|
|
|
|
using System;
|
|
using CtrEditor.ObjetosSim;
|
|
using CtrEditor.HydraulicSimulator.TSNet;
|
|
using CtrEditor.HydraulicSimulator.TSNet.Components;
|
|
|
|
try {{
|
|
Console.WriteLine("=== {test_name} ===");
|
|
{code}
|
|
Console.WriteLine("✅ Test PASSED");
|
|
}} catch (Exception ex) {{
|
|
Console.WriteLine($"❌ Test FAILED: {{ex.Message}}");
|
|
Console.WriteLine($"Stack trace: {{ex.StackTrace}}");
|
|
}}
|
|
"""
|
|
|
|
try:
|
|
with open(test_file, "w", encoding="utf-8") as f:
|
|
f.write(full_code)
|
|
|
|
# Ejecutar con dotnet script
|
|
result = subprocess.run(
|
|
["dotnet", "script", test_file],
|
|
capture_output=True,
|
|
text=True,
|
|
timeout=30,
|
|
cwd="d:\\Proyectos\\VisualStudio\\CtrEditor",
|
|
)
|
|
|
|
print(f"Exit code: {result.returncode}")
|
|
if result.stdout:
|
|
print("Output:", result.stdout)
|
|
if result.stderr:
|
|
print("Errors:", result.stderr)
|
|
|
|
return result.returncode == 0
|
|
|
|
except Exception as e:
|
|
print(f"❌ Test execution failed: {e}")
|
|
return False
|
|
finally:
|
|
# Limpiar archivo temporal
|
|
if os.path.exists(test_file):
|
|
os.remove(test_file)
|
|
|
|
|
|
def test_1_basic_object_creation():
|
|
"""Test 1: Creación básica de objetos hidráulicos"""
|
|
code = """
|
|
// Test creación de objetos hidráulicos básicos
|
|
var tank = new osHydTank();
|
|
Console.WriteLine($"Tank created: {tank != null}");
|
|
|
|
var pump = new osHydPump();
|
|
Console.WriteLine($"Pump created: {pump != null}");
|
|
|
|
var pipe = new osHydPipe();
|
|
Console.WriteLine($"Pipe created: {pipe != null}");
|
|
|
|
Console.WriteLine("Basic object creation successful");
|
|
"""
|
|
return run_csharp_test("Basic Object Creation", code)
|
|
|
|
|
|
def test_2_checkdata_initialization():
|
|
"""Test 2: Inicialización con CheckData"""
|
|
code = """
|
|
// Test inicialización correcta de IDs
|
|
var tank = new osHydTank();
|
|
Console.WriteLine($"Tank ID before CheckData: {tank.Id?.Value}");
|
|
|
|
tank.CheckData();
|
|
Console.WriteLine($"Tank ID after CheckData: {tank.Id?.Value}");
|
|
|
|
if (tank.Id?.Value > 0) {
|
|
Console.WriteLine("CheckData initialization successful");
|
|
} else {
|
|
throw new Exception("CheckData failed to initialize ID");
|
|
}
|
|
"""
|
|
return run_csharp_test("CheckData Initialization", code)
|
|
|
|
|
|
def test_3_adapter_creation_with_valid_id():
|
|
"""Test 3: Creación de adaptador con ID válido"""
|
|
code = """
|
|
// Test creación de adaptador con ID válido
|
|
var tank = new osHydTank();
|
|
tank.CheckData(); // Asegurar ID válido
|
|
|
|
var adapter = new TSNetTankAdapter(tank);
|
|
Console.WriteLine($"Adapter created with TankId: {adapter.TankId}");
|
|
|
|
if (adapter.TankId.StartsWith("TANK_")) {
|
|
Console.WriteLine("Adapter creation with valid ID successful");
|
|
} else {
|
|
throw new Exception($"Invalid adapter ID format: {adapter.TankId}");
|
|
}
|
|
"""
|
|
return run_csharp_test("Adapter Creation with Valid ID", code)
|
|
|
|
|
|
def test_4_adapter_creation_without_id():
|
|
"""Test 4: Prevención de NullReference sin ID"""
|
|
code = """
|
|
// Test prevención de NullReference
|
|
var tank = new osHydTank();
|
|
// NO llamar CheckData() intencionalmente
|
|
|
|
try {
|
|
var adapter = new TSNetTankAdapter(tank);
|
|
throw new Exception("Should have failed with null ID validation");
|
|
} catch (InvalidOperationException ex) {
|
|
if (ex.Message.Contains("Id válido")) {
|
|
Console.WriteLine("Proper validation error caught - NullReference prevention working");
|
|
} else {
|
|
throw new Exception($"Wrong exception type: {ex.Message}");
|
|
}
|
|
} catch (Exception ex) {
|
|
throw new Exception($"Unexpected exception: {ex.GetType().Name}: {ex.Message}");
|
|
}
|
|
"""
|
|
return run_csharp_test("NullReference Prevention", code)
|
|
|
|
|
|
def test_5_configuration_capture():
|
|
"""Test 5: Captura de configuración"""
|
|
code = """
|
|
// Test captura de configuración
|
|
var tank = new osHydTank();
|
|
tank.CheckData();
|
|
tank.MinLevelM = 0.5;
|
|
tank.MaxLevelM = 3.0;
|
|
tank.CurrentLevelM = 1.5;
|
|
|
|
var adapter = new TSNetTankAdapter(tank);
|
|
adapter.CaptureConfigurationForSimulation();
|
|
|
|
Console.WriteLine($"Configuration captured: {adapter.Configuration != null}");
|
|
Console.WriteLine($"MinLevel: {adapter.Configuration?.MinLevelM}");
|
|
Console.WriteLine($"MaxLevel: {adapter.Configuration?.MaxLevelM}");
|
|
Console.WriteLine($"InitialLevel: {adapter.Configuration?.InitialLevelM}");
|
|
|
|
if (adapter.Configuration != null &&
|
|
adapter.Configuration.MinLevelM == 0.5 &&
|
|
adapter.Configuration.MaxLevelM == 3.0) {
|
|
Console.WriteLine("Configuration capture successful");
|
|
} else {
|
|
throw new Exception("Configuration capture failed");
|
|
}
|
|
"""
|
|
return run_csharp_test("Configuration Capture", code)
|
|
|
|
|
|
def test_6_configuration_validation():
|
|
"""Test 6: Validación de configuración"""
|
|
code = """
|
|
// Test validación con valores inválidos
|
|
var tank = new osHydTank();
|
|
tank.CheckData();
|
|
tank.MinLevelM = -1.0; // Valor inválido
|
|
tank.MaxLevelM = 0.5; // Menor que min (inválido)
|
|
|
|
var adapter = new TSNetTankAdapter(tank);
|
|
adapter.CaptureConfigurationForSimulation();
|
|
|
|
var errors = adapter.ValidateConfiguration();
|
|
Console.WriteLine($"Validation errors found: {errors.Count}");
|
|
|
|
foreach (var error in errors) {
|
|
Console.WriteLine($"Error: {error}");
|
|
}
|
|
|
|
if (errors.Count >= 2) {
|
|
Console.WriteLine("Configuration validation working correctly");
|
|
} else {
|
|
throw new Exception($"Expected at least 2 validation errors, got {errors.Count}");
|
|
}
|
|
"""
|
|
return run_csharp_test("Configuration Validation", code)
|
|
|
|
|
|
def test_7_simulation_manager():
|
|
"""Test 7: TSNetSimulationManager básico"""
|
|
code = """
|
|
// Test TSNetSimulationManager
|
|
var manager = new TSNetSimulationManager();
|
|
Console.WriteLine($"Simulation manager created: {manager != null}");
|
|
|
|
// Test reset
|
|
manager.ResetAllCalculatedValues();
|
|
Console.WriteLine("Reset completed successfully");
|
|
|
|
Console.WriteLine("Simulation manager basic functionality working");
|
|
"""
|
|
return run_csharp_test("Simulation Manager Basic", code)
|
|
|
|
|
|
def run_all_tests():
|
|
"""Ejecutar todos los tests directos"""
|
|
print("🧪 TSNet Phase 2 - Direct Tests (No MCP Required)")
|
|
print("=" * 60)
|
|
print(f"Started at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
|
|
|
|
tests = [
|
|
test_1_basic_object_creation,
|
|
test_2_checkdata_initialization,
|
|
test_3_adapter_creation_with_valid_id,
|
|
test_4_adapter_creation_without_id,
|
|
test_5_configuration_capture,
|
|
test_6_configuration_validation,
|
|
test_7_simulation_manager,
|
|
]
|
|
|
|
results = []
|
|
|
|
for test_func in tests:
|
|
try:
|
|
result = test_func()
|
|
results.append(result)
|
|
print(f"Result: {'✅ PASS' if result else '❌ FAIL'}")
|
|
except Exception as e:
|
|
print(f"❌ Test execution error: {e}")
|
|
results.append(False)
|
|
|
|
time.sleep(1)
|
|
|
|
# Resumen
|
|
print("\n" + "=" * 60)
|
|
print("📊 DIRECT TESTS SUMMARY")
|
|
print("=" * 60)
|
|
|
|
passed = sum(results)
|
|
total = len(results)
|
|
|
|
print(f"Tests Executed: {total}")
|
|
print(f"Passed: {passed} ✅")
|
|
print(f"Failed: {total - passed} ❌")
|
|
print(f"Success Rate: {passed/total*100:.1f}%")
|
|
|
|
if passed == total:
|
|
print("\n🎉 ALL DIRECT TESTS PASSED!")
|
|
print("✅ TSNet Phase 2 core functionality is working correctly")
|
|
print("✅ NullReference issues have been resolved")
|
|
print("✅ Error handling is robust")
|
|
elif passed >= total * 0.8:
|
|
print("\n✅ Most tests passed - TSNet Phase 2 is largely functional")
|
|
else:
|
|
print("\n⚠️ Multiple test failures - Review implementation")
|
|
|
|
print(f"\nCompleted at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
|
|
return passed == total
|
|
|
|
|
|
def main():
|
|
# Verificar que dotnet está disponible
|
|
try:
|
|
result = subprocess.run(["dotnet", "--version"], capture_output=True, text=True)
|
|
print(f"Using .NET version: {result.stdout.strip()}")
|
|
except:
|
|
print("❌ .NET not found - cannot run direct tests")
|
|
return False
|
|
|
|
return run_all_tests()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
success = main()
|
|
exit(0 if success else 1)
|