feat(core): implement SettingsManager and JSON config

- New: Aggiunto 'src/settings_manager.py' con logica Fail-Fast (Strict).
- Config: Aggiunto 'config/strategies.json' con parametri di default.
- Test: Aggiunti unit test per SettingsManager (I/O, Error Handling).
- Ref: Issue #1 completata.

Author: lbitto-sdg

config/strategies.json

@@ -0,0 +1,16 @@
+{
+    "active_strategy": "RSI",
+    "strategies_params": {
+        "EMA": {
+            "short_window": 50,
+            "long_window": 200,
+            "atr_period": 14
+        },
+        "RSI": {
+            "rsi_period": 14,
+            "rsi_lower": 30,
+            "rsi_upper": 70,
+            "atr_period": 14
+        }
+    }
+}

src/settings_manager.py

@@ -0,0 +1,74 @@
+import json
+import os
+from pathlib import Path
+from typing import Dict, Any
+from src.logger import get_logger
+
+class SettingsManager:
+    """
+    Gestisce la configurazione dinamica delle strategie (JSON).
+    Policy: FAIL FAST. Se il file manca o è corrotto, solleva eccezioni.
+    """
+    
+    def __init__(self, config_path: str = "config/strategies.json"):
+        self.logger = get_logger(self.__class__.__name__)
+        
+        # Risolviamo il path assoluto
+        base_path = Path(__file__).parent.parent
+        self.file_path = base_path / config_path
+        
+        # Check esistenza file all'avvio
+        if not self.file_path.exists():
+            msg = f"CRITICAL: File di configurazione non trovato in {self.file_path}"
+            self.logger.critical(msg)
+            raise FileNotFoundError(msg)
+
+    def load_config(self) -> Dict[str, Any]:
+        """Legge la configurazione dal disco."""
+        try:
+            with open(self.file_path, 'r') as f:
+                return json.load(f)
+        except json.JSONDecodeError as e:
+            self.logger.error(f"Il file {self.file_path} non è un JSON valido: {e}")
+            raise
+
+    def save_config(self, new_config: Dict[str, Any]):
+        """Salva la nuova configurazione su disco."""
+        try:
+            # Creiamo la cartella se non esiste (utile solo al primo deploy se file iniettato)
+            self.file_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            with open(self.file_path, 'w') as f:
+                json.dump(new_config, f, indent=4)
+            self.logger.info("Configurazione salvata correttamente.")
+        except Exception as e:
+            self.logger.error(f"Errore salvataggio config: {e}")
+            raise
+
+    def get_active_strategy_name(self) -> str:
+        """Ritorna il nome della strategia attiva. Errore se manca."""
+        cfg = self.load_config()
+        if "active_strategy" not in cfg:
+            raise ValueError(f"Chiave 'active_strategy' mancante in {self.file_path}")
+        return cfg["active_strategy"]
+
+    def get_strategy_params(self, strategy_name: str = None) -> Dict[str, Any]:
+        """
+        Ritorna i parametri per una specifica strategia.
+        Se strategy_name è None, usa quella attiva.
+        Errore se la strategia non è configurata.
+        """
+        cfg = self.load_config()
+        
+        # Determina quale strategia cercare
+        target = strategy_name if strategy_name else cfg.get("active_strategy")
+        
+        if not target:
+             raise ValueError("Impossibile determinare la strategia target (active_strategy mancante?)")
+
+        # Cerca i parametri
+        all_params = cfg.get("strategies_params", {})
+        if target not in all_params:
+            raise ValueError(f"Parametri per strategia '{target}' non trovati in 'strategies_params'.")
+            
+        return all_params[target]

tests/test_core/test_settings_manager.py

@@ -0,0 +1,107 @@
+import pytest
+import json
+from src.settings_manager import SettingsManager
+
+# --- FIXTURES ---
+
+@pytest.fixture
+def valid_config_data():
+    """Dati validi per i test."""
+    return {
+        "active_strategy": "EMA",
+        "strategies_params": {
+            "EMA": {"short": 10, "long": 20},
+            "RSI": {"period": 14}
+        }
+    }
+
+@pytest.fixture
+def temp_config_file(tmp_path, valid_config_data):
+    """
+    Crea un file JSON reale in una directory temporanea isolata.
+    Ritorna il percorso completo (Path object).
+    """
+    d = tmp_path / "config"
+    d.mkdir()
+    f = d / "strategies.json"
+    
+    # Scriviamo dati validi iniziali
+    with open(f, "w") as file:
+        json.dump(valid_config_data, file)
+        
+    return f
+
+# --- TESTS ---
+
+def test_init_fail_if_missing(tmp_path):
+    """Deve crashare se il file non esiste (nessun default automatico)."""
+    fake_path = tmp_path / "non_existent.json"
+    
+    # Verifichiamo che alzi l'eccezione giusta
+    with pytest.raises(FileNotFoundError):
+        SettingsManager(config_path=str(fake_path))
+
+def test_load_success(temp_config_file):
+    """Deve caricare correttamente un file valido."""
+    # Passiamo il path temporaneo al manager
+    manager = SettingsManager(config_path=str(temp_config_file))
+    
+    # Test active strategy
+    assert manager.get_active_strategy_name() == "EMA"
+    
+    # Test params
+    params = manager.get_strategy_params()
+    assert params["short"] == 10
+    assert params["long"] == 20
+
+def test_missing_active_strategy_key(temp_config_file):
+    """Deve alzare ValueError se manca la chiave 'active_strategy'."""
+    # Sovrascriviamo il file con dati incompleti
+    bad_data = {"strategies_params": {}}
+    with open(temp_config_file, "w") as f:
+        json.dump(bad_data, f)
+        
+    manager = SettingsManager(config_path=str(temp_config_file))
+    
+    with pytest.raises(ValueError, match="active_strategy"):
+        manager.get_active_strategy_name()
+
+def test_missing_strategy_params(temp_config_file):
+    """Deve alzare ValueError se la strategia attiva non ha parametri definiti."""
+    # Configuriamo EMA come attiva, ma non mettiamo i parametri per EMA
+    bad_data = {
+        "active_strategy": "EMA",
+        "strategies_params": {
+            "RSI": {"period": 14} 
+            # Manca EMA!
+        }
+    }
+    with open(temp_config_file, "w") as f:
+        json.dump(bad_data, f)
+        
+    manager = SettingsManager(config_path=str(temp_config_file))
+    
+    with pytest.raises(ValueError, match="non trovati"):
+        manager.get_strategy_params()
+
+def test_save_config(temp_config_file):
+    """Deve salvare correttamente le modifiche su disco."""
+    manager = SettingsManager(config_path=str(temp_config_file))
+    
+    # 1. Modifichiamo la configurazione
+    new_config = {
+        "active_strategy": "RSI",
+        "strategies_params": {
+            "RSI": {"period": 99}
+        }
+    }
+    
+    # 2. Salviamo
+    manager.save_config(new_config)
+    
+    # 3. Rileggiamo direttamente dal file (bypassando il manager per sicurezza)
+    with open(temp_config_file, "r") as f:
+        content = json.load(f)
+        
+    assert content["active_strategy"] == "RSI"
+    assert content["strategies_params"]["RSI"]["period"] == 99