DOLPHIN/nautilus_dolphin/tests/test_strategy_registration.py

"""Tests for Strategy Registration.

Uses proper Nautilus initialization pattern from test_0_nautilus_bootstrap.py
"""

import pytest
from unittest.mock import Mock, patch


class TestDolphinStrategyConfig:
    """Test DolphinStrategyConfig initialization."""
    
    def test_default_config(self):
        """Test default strategy configuration values."""
        from nautilus_dolphin.nautilus.strategy_registration import DolphinStrategyConfig
        
        config = DolphinStrategyConfig()
        
        assert config.venue == "BINANCE_FUTURES"
        assert config.irp_alignment_min == 0.45
        assert config.momentum_magnitude_min == 0.000075
        assert config.excluded_assets == ['TUSDUSDT', 'USDCUSDT']
        assert config.min_leverage == 0.5
        assert config.max_leverage == 5.0
        assert config.leverage_convexity == 3.0
        assert config.capital_fraction == 0.20
        assert config.tp_bps == 99
        assert config.max_hold_bars == 120
        assert config.max_concurrent_positions == 10
        assert config.daily_loss_limit_pct == 10.0
        assert config.acb_enabled is True
    
    def test_custom_config(self):
        """Test custom strategy configuration."""
        from nautilus_dolphin.nautilus.strategy_registration import DolphinStrategyConfig
        
        config = DolphinStrategyConfig(
            venue="BINANCE_SPOT",
            max_leverage=3.0,
            acb_enabled=False,
            tp_bps=150
        )
        
        assert config.venue == "BINANCE_SPOT"
        assert config.max_leverage == 3.0
        assert config.acb_enabled is False
        assert config.tp_bps == 150
    
    def test_to_dict(self):
        """Test conversion to dictionary."""
        from nautilus_dolphin.nautilus.strategy_registration import DolphinStrategyConfig
        
        config = DolphinStrategyConfig(max_leverage=3.0)
        config_dict = config.to_dict()
        
        assert config_dict['venue'] == "BINANCE_FUTURES"
        assert config_dict['max_leverage'] == 3.0
        assert 'acb_enabled' in config_dict


class TestStrategyConfigCreation:
    """Test creation of Nautilus ImportableStrategyConfig."""
    
    def test_create_strategy_config(self):
        """Test creating ImportableStrategyConfig."""
        from nautilus_dolphin.nautilus.strategy_registration import (
            DolphinStrategyConfig, create_strategy_config
        )
        
        config = DolphinStrategyConfig(max_leverage=3.0)
        strategy_config = create_strategy_config(config)
        
        assert strategy_config is not None
        assert strategy_config.strategy_path == 'nautilus_dolphin.nautilus.strategy:DolphinExecutionStrategy'
        assert strategy_config.config_path == 'nautilus_dolphin.nautilus.strategy:DolphinExecutionStrategy'
    
    def test_create_strategy_config_content(self):
        """Test creating ImportableStrategyConfig has correct content."""
        from nautilus_dolphin.nautilus.strategy_registration import (
            DolphinStrategyConfig, create_strategy_config
        )
        
        config = DolphinStrategyConfig(max_leverage=3.0)
        strategy_config = create_strategy_config(config)
        
        assert strategy_config.config['max_leverage'] == 3.0
        assert strategy_config.strategy_path == 'nautilus_dolphin.nautilus.strategy:DolphinExecutionStrategy'
    
    def test_create_default_strategy_config(self):
        """Test creating default strategy config."""
        from nautilus_dolphin.nautilus.strategy_registration import create_default_strategy_config
        
        strategy_config = create_default_strategy_config()
        
        assert strategy_config is not None
        assert strategy_config.strategy_path == 'nautilus_dolphin.nautilus.strategy:DolphinExecutionStrategy'


class TestStrategyRegistry:
    """Test StrategyRegistry for managing multiple strategies."""
    
    def test_register_single_strategy(self):
        """Test registering a single strategy."""
        from nautilus_dolphin.nautilus.strategy_registration import (
            StrategyRegistry, DolphinStrategyConfig
        )
        
        registry = StrategyRegistry()
        config = DolphinStrategyConfig()
        
        strategy_config = registry.register("dolphin_001", config)
        
        assert strategy_config is not None
        assert len(registry.get_configs()) == 1
        assert registry.get_config("dolphin_001") == config
    
    def test_register_multiple_strategies(self):
        """Test registering multiple strategies."""
        from nautilus_dolphin.nautilus.strategy_registration import (
            StrategyRegistry, DolphinStrategyConfig
        )
        
        registry = StrategyRegistry()
        
        config1 = DolphinStrategyConfig(max_leverage=3.0)
        config2 = DolphinStrategyConfig(max_leverage=5.0)
        
        registry.register("dolphin_3x", config1)
        registry.register("dolphin_5x", config2)
        
        assert len(registry.get_configs()) == 2
        assert registry.get_config("dolphin_3x").max_leverage == 3.0
        assert registry.get_config("dolphin_5x").max_leverage == 5.0
    
    def test_create_backtest_strategies_default(self):
        """Test creating backtest strategies with default config."""
        from nautilus_dolphin.nautilus.strategy_registration import StrategyRegistry
        
        registry = StrategyRegistry()
        configs = registry.create_backtest_strategies()
        
        assert len(configs) == 1
    
    def test_create_backtest_strategies_variations(self):
        """Test creating backtest strategies with parameter variations."""
        from nautilus_dolphin.nautilus.strategy_registration import StrategyRegistry
        
        registry = StrategyRegistry()
        
        variations = [
            {'max_leverage': 3.0, 'tp_bps': 50},
            {'max_leverage': 5.0, 'tp_bps': 99},
        ]
        
        configs = registry.create_backtest_strategies(variations)
        
        assert len(configs) == 2


class TestStrategyConfigFromDict:
    """Test creating strategy config from dictionary."""
    
    def test_create_from_dict(self):
        """Test creating strategy config from dictionary."""
        from nautilus_dolphin.nautilus.strategy_registration import (
            create_strategy_configs_from_dict
        )
        
        config_dict = {
            'venue': 'BINANCE_FUTURES',
            'max_leverage': 3.0,
            'acb_enabled': False,
            'custom_param': 'value'  # Extra param goes to extra_config
        }
        
        strategy_config = create_strategy_configs_from_dict(config_dict)
        
        assert strategy_config is not None
        # Check that extra params are in the config dict
        assert strategy_config.config.get('custom_param') == 'value'


class TestStrategyIntegrationWithLauncher:
    """Test strategy integration with launcher."""
    
    def test_launcher_with_strategy_config(self):
        """Test launcher accepts strategy configuration."""
        from nautilus_dolphin.nautilus.launcher import NautilusDolphinLauncher
        
        launcher_config = {
            'venue': 'BINANCE_FUTURES',
            'environment': 'BACKTEST',
            'trader_id': 'TEST-001',
            'strategy': {
                'venue': 'BINANCE_FUTURES',
                'max_leverage': 3.0,
                'acb_enabled': True,
            }
        }
        
        launcher = NautilusDolphinLauncher(launcher_config)
        
        assert 'strategy' in launcher.config
        assert launcher.config['strategy']['max_leverage'] == 3.0