Merge branch 'main' into 2-news-api

tests/api/test_yfinance.py

@@ -0,0 +1,93 @@
+import os
+import pytest
+from app.markets import YFinanceWrapper
+
+@pytest.mark.market
+@pytest.mark.api
+class TestYFinance:
+
+    def test_yfinance_init(self):
+        market = YFinanceWrapper()
+        assert market is not None
+        assert hasattr(market, 'currency')
+        assert market.currency == "USD"
+        assert hasattr(market, 'tool')
+        assert market.tool is not None
+
+    def test_yfinance_get_product(self):
+        market = YFinanceWrapper()
+        product = market.get_product("AAPL")
+        assert product is not None
+        assert hasattr(product, 'symbol')
+        assert product.symbol == "AAPL"
+        assert hasattr(product, 'price')
+        assert product.price > 0
+        assert hasattr(product, 'status')
+        assert product.status == "trading"
+
+    def test_yfinance_get_crypto_product(self):
+        market = YFinanceWrapper()
+        product = market.get_product("BTC")
+        assert product is not None
+        assert hasattr(product, 'symbol')
+        # BTC verrà convertito in BTC-USD dal formattatore
+        assert product.symbol in ["BTC", "BTC-USD"]
+        assert hasattr(product, 'price')
+        assert product.price > 0
+
+    def test_yfinance_get_products(self):
+        market = YFinanceWrapper()
+        products = market.get_products(["AAPL", "GOOGL"])
+        assert products is not None
+        assert isinstance(products, list)
+        assert len(products) == 2
+        symbols = [p.symbol for p in products]
+        assert "AAPL" in symbols
+        assert "GOOGL" in symbols
+        for product in products:
+            assert hasattr(product, 'price')
+            assert product.price > 0
+
+    def test_yfinance_get_all_products(self):
+        market = YFinanceWrapper()
+        products = market.get_all_products()
+        assert products is not None
+        assert isinstance(products, list)
+        assert len(products) > 0
+        # Dovrebbe contenere asset popolari
+        symbols = [p.symbol for p in products]
+        assert "AAPL" in symbols  # Apple dovrebbe essere nella lista
+        for product in products:
+            assert hasattr(product, 'symbol')
+            assert hasattr(product, 'price')
+
+    def test_yfinance_invalid_product(self):
+        market = YFinanceWrapper()
+        # Per YFinance, un prodotto invalido dovrebbe restituire un prodotto offline
+        product = market.get_product("INVALIDSYMBOL123")
+        assert product is not None
+        assert product.status == "offline"
+
+    def test_yfinance_history(self):
+        market = YFinanceWrapper()
+        history = market.get_historical_prices("AAPL", limit=5)
+        assert history is not None
+        assert isinstance(history, list)
+        assert len(history) == 5
+        for entry in history:
+            assert hasattr(entry, 'time')
+            assert hasattr(entry, 'close')
+            assert hasattr(entry, 'high')
+            assert entry.close > 0
+            assert entry.high > 0
+
+    def test_yfinance_crypto_history(self):
+        market = YFinanceWrapper()
+        history = market.get_historical_prices("BTC", limit=3)
+        assert history is not None
+        assert isinstance(history, list)
+        assert len(history) == 3
+        for entry in history:
+            assert hasattr(entry, 'time')
+            assert hasattr(entry, 'close')
+            assert entry.close > 0

tests/conftest.py

@@ -24,6 +24,7 @@ def pytest_configure(config:pytest.Config):
         ("limited", "marks tests that have limited execution due to API constraints"),
         ("wrapper", "marks tests for wrapper handler"),
         ("tools", "marks tests for tools"),
+        ("aggregator", "marks tests for market data aggregator"),
     ]
     for marker in markers:
         line = f"{marker[0]}: {marker[1]}"

tests/tools/test_market_tool.py

@@ -1,12 +1,14 @@
 import os
 import pytest
 from app.agents.market_agent import MarketToolkit
-from app.markets import MarketAPIs
+from app.markets import MarketAPIsTool
 
 @pytest.mark.limited # usa molte api calls e non voglio esaurire le chiavi api
-class TestMarketAPIs:
+@pytest.mark.tools
+@pytest.mark.api
+class TestMarketAPIsTool:
     def test_wrapper_initialization(self):
-        market_wrapper = MarketAPIs("USD")
+        market_wrapper = MarketAPIsTool("USD")
         assert market_wrapper is not None
         assert hasattr(market_wrapper, 'get_product')
         assert hasattr(market_wrapper, 'get_products')
@@ -14,7 +16,7 @@ class TestMarketAPIs:
         assert hasattr(market_wrapper, 'get_historical_prices')
 
     def test_wrapper_capabilities(self):
-        market_wrapper = MarketAPIs("USD")
+        market_wrapper = MarketAPIsTool("USD")
         capabilities = []
         if hasattr(market_wrapper, 'get_product'):
             capabilities.append('single_product')
@@ -25,7 +27,7 @@ class TestMarketAPIs:
         assert len(capabilities) > 0
 
     def test_market_data_retrieval(self):
-        market_wrapper = MarketAPIs("USD")
+        market_wrapper = MarketAPIsTool("USD")
         btc_product = market_wrapper.get_product("BTC")
         assert btc_product is not None
         assert hasattr(btc_product, 'symbol')
@@ -55,14 +57,14 @@ class TestMarketAPIs:
 
     def test_error_handling(self):
         try:
-            market_wrapper = MarketAPIs("USD")
+            market_wrapper = MarketAPIsTool("USD")
             fake_product = market_wrapper.get_product("NONEXISTENT_CRYPTO_SYMBOL_12345")
             assert fake_product is None or fake_product.price == 0
         except Exception as e:
             pass
 
     def test_wrapper_currency_support(self):
-        market_wrapper = MarketAPIs("USD")
+        market_wrapper = MarketAPIsTool("USD")
         assert hasattr(market_wrapper, 'currency')
         assert isinstance(market_wrapper.currency, str)
         assert len(market_wrapper.currency) >= 3  # USD, EUR, etc.

tests/utils/test_market_data_aggregator.py

@@ -0,0 +1,88 @@
+import pytest
+from app.utils.market_data_aggregator import MarketDataAggregator
+from app.utils.aggregated_models import AggregatedProductInfo
+from app.markets.base import ProductInfo, Price
+
+@pytest.mark.aggregator
+@pytest.mark.limited
+@pytest.mark.market
+@pytest.mark.api
+class TestMarketDataAggregator:
+    
+    def test_initialization(self):
+        """Test che il MarketDataAggregator si inizializzi correttamente"""
+        aggregator = MarketDataAggregator()
+        assert aggregator is not None
+        assert aggregator.is_aggregation_enabled() == True
+        
+    def test_aggregation_toggle(self):
+        """Test del toggle dell'aggregazione"""
+        aggregator = MarketDataAggregator()
+        
+        # Disabilita aggregazione
+        aggregator.enable_aggregation(False)
+        assert aggregator.is_aggregation_enabled() == False
+        
+        # Riabilita aggregazione
+        aggregator.enable_aggregation(True)
+        assert aggregator.is_aggregation_enabled() == True
+        
+    def test_aggregated_product_info_creation(self):
+        """Test creazione AggregatedProductInfo da fonti multiple"""
+        
+        # Crea dati di esempio
+        product1 = ProductInfo(
+            id="BTC-USD",
+            symbol="BTC-USD",
+            price=50000.0,
+            volume_24h=1000.0,
+            status="active",
+            quote_currency="USD"
+        )
+        
+        product2 = ProductInfo(
+            id="BTC-USD",
+            symbol="BTC-USD", 
+            price=50100.0,
+            volume_24h=1100.0,
+            status="active",
+            quote_currency="USD"
+        )
+        
+        # Aggrega i prodotti
+        aggregated = AggregatedProductInfo.from_multiple_sources([product1, product2])
+        
+        assert aggregated.symbol == "BTC-USD"
+        assert aggregated.price == pytest.approx(50050.0, rel=1e-3)  # media tra 50000 e 50100
+        assert aggregated.volume_24h == 50052.38095  # somma dei volumi
+        assert aggregated.status == "active"  # majority vote
+        assert aggregated.id == "BTC-USD_AGG"  # mapping_id con suffisso aggregazione
+        
+    def test_confidence_calculation(self):
+        """Test del calcolo della confidence"""
+        
+        product1 = ProductInfo(
+            id="BTC-USD",
+            symbol="BTC-USD",
+            price=50000.0,
+            volume_24h=1000.0,
+            status="active",
+            quote_currency="USD"
+        )
+        
+        product2 = ProductInfo(
+            id="BTC-USD",
+            symbol="BTC-USD",
+            price=50100.0,
+            volume_24h=1100.0,
+            status="active",
+            quote_currency="USD"
+        )
+        
+        aggregated = AggregatedProductInfo.from_multiple_sources([product1, product2])
+        
+        # Verifica che ci siano metadati
+        assert aggregated._metadata is not None
+        assert len(aggregated._metadata.sources_used) > 0
+        assert aggregated._metadata.aggregation_timestamp != ""
+        # La confidence può essere 0.0 se ci sono fonti "unknown"