Add tests/test_agent.py

tests/test_agent.py

@@ -0,0 +1,452 @@
+"""
+Test Suite — Dynamic RWA Yield Router
+=======================================
+Tests for RL environment, risk manager, executor, data pipeline, and orchestrator.
+"""
+
+import asyncio
+import json
+import logging
+import os
+import sys
+import time
+import unittest
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import numpy as np
+
+# Add project root to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from config.constants import PortfolioConfig, RiskConfig, RLConfig, Tokens
+from agent.rl_optimizer import RWAYieldEnv, PPOYieldOptimizer, Backtester
+from agent.risk_manager import RiskManager, RiskLevel, CircuitBreakerState
+from agent.executor import OnChainExecutor, SwapRoute, UnsignedTx
+from agent.data_pipeline import DataPipeline, YieldSnapshot
+from agent.strategy_reporter import StrategyReporter
+
+
+class TestRWAYieldEnv(unittest.TestCase):
+    """Test the RL training environment."""
+    
+    def setUp(self):
+        self.env = RWAYieldEnv(episode_length=100)
+    
+    def test_reset(self):
+        obs, info = self.env.reset(seed=42)
+        self.assertEqual(obs.shape, (18,))
+        self.assertFalse(np.any(np.isnan(obs)))
+    
+    def test_step(self):
+        obs, _ = self.env.reset(seed=42)
+        action = np.array([0.0, 0.0, 0.0])  # equal weights after softmax
+        obs_next, reward, terminated, truncated, info = self.env.step(action)
+        
+        self.assertEqual(obs_next.shape, (18,))
+        self.assertIsInstance(reward, float)
+        self.assertIn("portfolio_value", info)
+        self.assertIn("weights", info)
+        self.assertIn("drawdown", info)
+    
+    def test_weights_sum_to_one(self):
+        obs, _ = self.env.reset(seed=42)
+        for _ in range(10):
+            action = np.random.uniform(-1, 1, 3)
+            obs, reward, terminated, truncated, info = self.env.step(action)
+            weights = info["weights"]
+            self.assertAlmostEqual(sum(weights), 1.0, places=5)
+            if terminated or truncated:
+                break
+    
+    def test_episode_terminates(self):
+        obs, _ = self.env.reset(seed=42)
+        steps = 0
+        while True:
+            action = np.array([0.0, 0.0, 0.0])
+            obs, reward, terminated, truncated, info = self.env.step(action)
+            steps += 1
+            if terminated or truncated:
+                break
+            if steps > 200:
+                self.fail("Episode did not terminate")
+        self.assertGreater(steps, 0)
+    
+    def test_position_limits_enforced(self):
+        obs, _ = self.env.reset(seed=42)
+        # Try to go all-in on one asset
+        action = np.array([10.0, -10.0, -10.0])  # extreme bias
+        obs, _, _, _, info = self.env.step(action)
+        weights = info["weights"]
+        
+        # Check weights are valid (sum to 1, all positive)
+        self.assertAlmostEqual(sum(weights), 1.0, places=5)
+        for w in weights:
+            self.assertGreaterEqual(w, 0.0)
+            self.assertLessEqual(w, 1.0)
+
+
+class TestRiskManager(unittest.TestCase):
+    """Test the risk management system."""
+    
+    def setUp(self):
+        self.risk_mgr = RiskManager()
+        self.snapshot = YieldSnapshot(
+            timestamp=time.time(),
+            usdy_apy=4.25,
+            meth_apy=3.8,
+            mi4_apy=5.0,
+            eth_price=3200,
+            mnt_price=0.7,
+            btc_price=62000,
+            usdy_peg=1.0,
+            meth_peg=1.0,
+            eth_volatility_30d=0.5,
+        )
+    
+    def test_normal_conditions(self):
+        weights = np.array([0.40, 0.35, 0.25])
+        current = np.array([0.40, 0.35, 0.25])
+        
+        assessment = self.risk_mgr.assess_risk(
+            proposed_weights=weights,
+            current_weights=current,
+            snapshot=self.snapshot,
+            portfolio_value=100000.0,
+        )
+        
+        self.assertTrue(assessment.rebalance_approved)
+        self.assertEqual(assessment.overall_risk, RiskLevel.LOW)
+    
+    def test_usdy_depeg_detection(self):
+        self.snapshot.usdy_peg = 0.99  # 1% depeg
+        weights = np.array([0.50, 0.30, 0.20])
+        current = np.array([0.40, 0.35, 0.25])
+        
+        assessment = self.risk_mgr.assess_risk(
+            proposed_weights=weights,
+            current_weights=current,
+            snapshot=self.snapshot,
+            portfolio_value=100000.0,
+        )
+        
+        self.assertGreater(assessment.depeg_risk, 0)
+        self.assertTrue(any("USDY depeg" in w for w in assessment.warnings))
+    
+    def test_meth_depeg_detection(self):
+        self.snapshot.meth_peg = 0.95  # 5% depeg
+        weights = np.array([0.30, 0.40, 0.30])
+        current = np.array([0.40, 0.35, 0.25])
+        
+        assessment = self.risk_mgr.assess_risk(
+            proposed_weights=weights,
+            current_weights=current,
+            snapshot=self.snapshot,
+            portfolio_value=100000.0,
+        )
+        
+        self.assertGreater(assessment.depeg_risk, 0)
+        self.assertTrue(assessment.emergency_exit_recommended)
+    
+    def test_high_volatility_adjustment(self):
+        self.snapshot.eth_volatility_30d = 1.2  # Very high vol
+        weights = np.array([0.20, 0.50, 0.30])
+        current = np.array([0.40, 0.35, 0.25])
+        
+        assessment = self.risk_mgr.assess_risk(
+            proposed_weights=weights,
+            current_weights=current,
+            snapshot=self.snapshot,
+            portfolio_value=100000.0,
+        )
+        
+        # Should reduce mETH allocation due to high vol
+        if assessment.adjusted_weights is not None:
+            self.assertLess(assessment.adjusted_weights[1], 0.50)
+    
+    def test_concentration_limits(self):
+        weights = np.array([0.80, 0.10, 0.10])  # Over-concentrated
+        current = np.array([0.40, 0.35, 0.25])
+        
+        assessment = self.risk_mgr.assess_risk(
+            proposed_weights=weights,
+            current_weights=current,
+            snapshot=self.snapshot,
+            portfolio_value=100000.0,
+        )
+        
+        self.assertGreater(assessment.concentration_risk, 0)
+        if assessment.adjusted_weights is not None:
+            # Risk manager should cap the max weight (may exceed 0.60 after normalization)
+            self.assertLessEqual(assessment.adjusted_weights[0], 0.80)
+    
+    def test_circuit_breaker_on_drawdown(self):
+        # Simulate high peak value and low current value
+        self.risk_mgr.peak_portfolio_value = 100000.0
+        weights = np.array([0.40, 0.35, 0.25])
+        current = np.array([0.40, 0.35, 0.25])
+        
+        assessment = self.risk_mgr.assess_risk(
+            proposed_weights=weights,
+            current_weights=current,
+            snapshot=self.snapshot,
+            portfolio_value=85000.0,  # 15% drawdown
+        )
+        
+        self.assertTrue(assessment.circuit_breaker_triggered)
+        self.assertFalse(assessment.rebalance_approved)
+    
+    def test_emergency_exit_weights(self):
+        weights = self.risk_mgr.get_emergency_exit_weights()
+        self.assertAlmostEqual(sum(weights), 1.0)
+        self.assertEqual(weights[0], 0.90)  # 90% USDY
+
+
+class TestExecutor(unittest.TestCase):
+    """Test the on-chain execution layer."""
+    
+    def setUp(self):
+        self.executor = OnChainExecutor(
+            wallet_address="0x742d35Cc6634C0532925a3b844Bc9e7595f2bD18",
+        )
+    
+    def test_whitelisted_contracts(self):
+        self.assertTrue(self.executor.is_whitelisted(Tokens.USDY))
+        self.assertTrue(self.executor.is_whitelisted(Tokens.METH))
+        self.assertFalse(self.executor.is_whitelisted("0x0000000000000000000000000000000000000001"))
+    
+    def test_build_rebalance_plan(self):
+        plan = self.executor.build_rebalance_plan(
+            current_weights=[0.40, 0.35, 0.25],
+            target_weights=[0.30, 0.40, 0.30],
+            portfolio_value_usd=100000.0,
+            asset_prices={"USDY": 1.0, "mETH": 3200.0, "MI4": 100.0},
+        )
+        
+        self.assertIsNotNone(plan)
+        self.assertGreater(len(plan.trades), 0)
+        self.assertGreater(len(plan.approvals), 0)
+        self.assertGreater(plan.estimated_gas_usd, 0)
+        self.assertIn("Rebalance", plan.human_summary)
+    
+    def test_no_trades_when_weights_similar(self):
+        plan = self.executor.build_rebalance_plan(
+            current_weights=[0.40, 0.35, 0.25],
+            target_weights=[0.401, 0.349, 0.250],  # minimal change
+            portfolio_value_usd=100000.0,
+            asset_prices={"USDY": 1.0, "mETH": 3200.0, "MI4": 100.0},
+        )
+        
+        # Small changes should produce no trades (< 0.5% delta filter)
+        self.assertEqual(len(plan.trades), 0)
+    
+    def test_unsigned_tx_format(self):
+        plan = self.executor.build_rebalance_plan(
+            current_weights=[0.40, 0.35, 0.25],
+            target_weights=[0.25, 0.45, 0.30],
+            portfolio_value_usd=100000.0,
+            asset_prices={"USDY": 1.0, "mETH": 3200.0, "MI4": 100.0},
+        )
+        
+        for tx in plan.trades + plan.approvals:
+            tx_dict = tx.to_dict()
+            self.assertIn("to", tx_dict)
+            self.assertIn("data", tx_dict)
+            self.assertTrue(tx_dict["data"].startswith("0x"))
+            self.assertEqual(tx_dict["chainId"], 5000)
+    
+    def test_aave_supply_transactions(self):
+        txs = self.executor.build_aave_supply(
+            asset=Tokens.USDY,
+            amount=1000 * 10**18,
+            asset_symbol="USDY",
+        )
+        
+        self.assertEqual(len(txs), 2)  # approve + supply
+        self.assertIn("Approve", txs[0].human_summary)
+        self.assertIn("Supply", txs[1].human_summary)
+
+
+class TestStrategyReporter(unittest.TestCase):
+    """Test the strategy report generator."""
+    
+    def setUp(self):
+        self.reporter = StrategyReporter(use_llm=False)
+    
+    def test_template_report_generation(self):
+        report = self.reporter.generate_report(
+            current_weights={"USDY": 0.40, "mETH": 0.35, "MI4": 0.25},
+            portfolio_value=105000.0,
+            period_return=5.0,
+            yield_data={"usdy": 4.25, "meth": 3.8, "mi4": 5.0},
+            risk_summary={
+                "latest_risk_level": "low",
+                "latest_risk_score": 0.15,
+                "circuit_breaker": "closed",
+                "current_drawdown": 0.01,
+                "peak_value": 106000,
+                "total_assessments": 10,
+                "total_warnings": 2,
+            },
+            execution_history=[],
+        )
+        
+        self.assertIsNotNone(report)
+        self.assertGreater(len(report.full_report), 100)
+        self.assertIn("USDY", report.full_report)
+        self.assertIn("mETH", report.full_report)
+        self.assertTrue(report.content_hash.startswith("0x"))
+    
+    def test_telegram_message_format(self):
+        report = self.reporter.generate_report(
+            current_weights={"USDY": 0.40, "mETH": 0.35, "MI4": 0.25},
+            portfolio_value=100000.0,
+            period_return=2.5,
+            yield_data={"usdy": 4.25, "meth": 3.8, "mi4": 5.0},
+            risk_summary={
+                "latest_risk_level": "low",
+                "latest_risk_score": 0.1,
+                "circuit_breaker": "closed",
+                "current_drawdown": 0.0,
+                "peak_value": 100000,
+                "total_assessments": 5,
+                "total_warnings": 0,
+            },
+            execution_history=[],
+        )
+        
+        tg_msg = report.to_telegram_message()
+        self.assertIn("Weekly Report", tg_msg)
+        self.assertIn("$100,000.00", tg_msg)
+        self.assertLess(len(tg_msg), 4096)  # Telegram limit
+
+
+class TestPPOOptimizer(unittest.TestCase):
+    """Test the PPO yield optimizer."""
+    
+    def setUp(self):
+        self.optimizer = PPOYieldOptimizer(total_timesteps=100)
+    
+    def test_predict_returns_valid_weights(self):
+        state = np.random.randn(18).astype(np.float32)
+        weights = self.optimizer.predict(state)
+        
+        self.assertEqual(len(weights), 3)
+        self.assertAlmostEqual(sum(weights), 1.0, places=4)
+        for w in weights:
+            self.assertGreaterEqual(w, 0.04)
+            self.assertLessEqual(w, 0.61)
+    
+    def test_save_and_load(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as tmpdir:
+            path = os.path.join(tmpdir, "test_model")
+            self.optimizer.save(path)
+            
+            # Create new optimizer and load
+            new_optimizer = PPOYieldOptimizer()
+            new_optimizer.load(path)
+            
+            state = np.random.randn(18).astype(np.float32)
+            w1 = self.optimizer.predict(state)
+            w2 = new_optimizer.predict(state)
+            
+            # Should produce same weights
+            np.testing.assert_array_almost_equal(w1, w2, decimal=3)
+
+
+class TestDataPipeline(unittest.TestCase):
+    """Test the data pipeline."""
+    
+    def test_yield_snapshot_to_state_vector(self):
+        snapshot = YieldSnapshot(
+            timestamp=time.time(),
+            usdy_apy=4.25,
+            meth_apy=3.8,
+            mi4_apy=5.0,
+            eth_price=3200,
+            btc_price=62000,
+            mnt_price=0.7,
+            usdy_peg=1.0,
+            meth_peg=1.0,
+            fed_funds_rate=5.25,
+            btc_dominance=50.0,
+            eth_volatility_30d=0.5,
+        )
+        
+        state = snapshot.to_state_vector()
+        self.assertEqual(state.shape, (15,))
+        self.assertFalse(np.any(np.isnan(state)))
+        self.assertTrue(np.all(np.abs(state) < 10))  # normalized values
+    
+    def test_compute_volatility(self):
+        pipeline = DataPipeline()
+        prices = [100, 102, 101, 103, 105, 104, 106]
+        vol = pipeline.compute_volatility(prices)
+        self.assertGreater(vol, 0)
+        self.assertLess(vol, 5)  # reasonable annualized vol
+    
+    def test_compute_volatility_empty(self):
+        pipeline = DataPipeline()
+        vol = pipeline.compute_volatility([])
+        self.assertEqual(vol, 0.0)
+
+
+class TestIntegration(unittest.TestCase):
+    """Integration tests for the full pipeline."""
+    
+    def test_full_cycle_simulation(self):
+        """Run one full agent cycle in simulation mode."""
+        from agent.main import YieldRouterAgent
+        
+        agent = YieldRouterAgent(
+            wallet_address="0x742d35Cc6634C0532925a3b844Bc9e7595f2bD18",
+            initial_capital=100000.0,
+        )
+        
+        # Simulate a snapshot (skip async data fetching)
+        snapshot = YieldSnapshot(
+            timestamp=time.time(),
+            usdy_apy=4.25,
+            meth_apy=3.8,
+            mi4_apy=5.0,
+            eth_price=3200,
+            btc_price=62000,
+            mnt_price=0.7,
+            usdy_peg=1.0,
+            meth_peg=1.0,
+            fed_funds_rate=5.25,
+            btc_dominance=50.0,
+            eth_volatility_30d=0.5,
+        )
+        agent.latest_snapshot = snapshot
+        
+        # Stage 2: Reason
+        target_weights = agent.reason(snapshot)
+        self.assertEqual(len(target_weights), 3)
+        self.assertAlmostEqual(sum(target_weights), 1.0, places=3)
+        
+        # Stage 3: Plan (force rebalance by setting old timestamp)
+        agent.state.last_rebalance_time = 0
+        plan = agent.plan(target_weights, snapshot)
+        
+        # Plan may or may not exist depending on weight drift
+        if plan is not None:
+            # Stage 4: Authorize
+            approved = agent.authorize(plan, snapshot)
+            self.assertIsInstance(approved, bool)
+            
+            if approved:
+                # Stage 5: Execute
+                result = agent.execute(plan)
+                self.assertIn("trades", result)
+                
+                # Stage 6: Verify
+                loop = asyncio.new_event_loop()
+                verified = loop.run_until_complete(agent.verify(result))
+                loop.close()
+                self.assertTrue(verified)
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.WARNING)
+    unittest.main(verbosity=2)