"""
Property-Based Tests for API Integration Enhancement
Feature: api-integration-enhancement

Tests correctness properties using Hypothesis for property-based testing.
"""

import pytest
from hypothesis import given, strategies as st, settings, HealthCheck
from unittest.mock import Mock, patch, AsyncMock
import httpx
import json


# ============================================================================
# Property 1: Result type consistency
# Feature: api-integration-enhancement, Property 1: Result type consistency
# Validates: Requirements 9.1, 9.2
# ============================================================================

@given(
    status_code=st.integers(min_value=200, max_value=599),
    response_data=st.one_of(
        st.dictionaries(st.text(max_size=10), st.text(max_size=10), max_size=5),
        st.lists(st.integers(), max_size=5),
        st.none()
    )
)
@settings(max_examples=100, suppress_health_check=[HealthCheck.too_slow])
def test_result_type_consistency(status_code, response_data):
    """
    Property: For any API response, the result should have either
    (ok=True and data field) OR (ok=False and error field), never both or neither.
    """
    # Simulate API response
    mock_response = Mock()
    mock_response.status_code = status_code
    mock_response.ok = 200 <= status_code < 300
    
    if response_data is not None:
        mock_response.json.return_value = response_data
    else:
        mock_response.json.side_effect = json.JSONDecodeError("", "", 0)
    
    # Simulate Result pattern logic
    if mock_response.ok:
        try:
            data = mock_response.json()
            result = {"ok": True, "data": data}
        except json.JSONDecodeError:
            result = {"ok": False, "error": "Parse error"}
    else:
        result = {"ok": False, "error": f"HTTP {status_code}"}
    
    # Verify Result type consistency
    if result["ok"]:
        assert "data" in result, "Success result must have 'data' field"
        assert "error" not in result, "Success result must not have 'error' field"
    else:
        assert "error" in result, "Error result must have 'error' field"
        assert "data" not in result, "Error result must not have 'data' field"


# ============================================================================
# Property 3: Error message descriptiveness
# Feature: api-integration-enhancement, Property 3: Error message descriptiveness
# Validates: Requirements 9.4, 9.5
# ============================================================================

@given(status_code=st.integers(min_value=400, max_value=599))
@settings(max_examples=100)
def test_error_message_descriptiveness(status_code):
    """
    Property: For any failed API call, the error message should contain
    sufficient information to identify the failure cause (HTTP status).
    """
    # Simulate error response
    result = {"ok": False, "error": f"HTTP {status_code}"}
    
    # Verify error message contains status code
    assert not result["ok"]
    assert "error" in result
    assert str(status_code) in result["error"], \
        f"Error message should contain status code {status_code}"


# ============================================================================
# Property 2: API key injection
# Feature: api-integration-enhancement, Property 2: API key injection
# Validates: Requirements 2.3, 2.4
# ============================================================================

@given(
    provider=st.sampled_from(['etherscan', 'bscscan', 'tronscan', 'newsapi', 'coinmarketcap']),
    endpoint=st.text(min_size=1, max_size=50),
    api_key=st.text(min_size=10, max_size=50)
)
@settings(max_examples=100)
def test_api_key_injection(provider, endpoint, api_key):
    """
    Property: For any backend proxy request requiring authentication,
    the API key should be injected from config but not exposed in the response.
    """
    # Mock config
    mock_config = {provider: api_key}
    
    # Simulate proxy request
    with patch('config.API_KEYS', mock_config):
        # Simulate making request with injected key
        request_headers = {}
        request_params = {}
        
        if provider in ['etherscan', 'bscscan']:
            request_params['apikey'] = api_key
        elif provider == 'tronscan':
            request_headers['TRON-PRO-API-KEY'] = api_key
        elif provider in ['newsapi', 'coinmarketcap']:
            request_headers['X-API-KEY'] = api_key
        
        # Simulate response (should not contain API key)
        response_body = {"data": "some data", "status": "success"}
        response_str = json.dumps(response_body)
        
        # Verify API key is not in response
        assert api_key not in response_str, \
            f"API key should not be exposed in response for {provider}"


# ============================================================================
# Property 8: Fallback key usage
# Feature: api-integration-enhancement, Property 8: Fallback key usage
# Validates: Requirements 2.5
# ============================================================================

@given(
    primary_fails=st.booleans(),
    backup_fails=st.booleans()
)
@settings(max_examples=100)
def test_fallback_key_usage(primary_fails, backup_fails):
    """
    Property: For any Etherscan API call that fails with the primary key,
    the system should automatically retry with the backup key.
    """
    primary_key = "primary_key_123"
    backup_key = "backup_key_456"
    
    call_count = 0
    keys_used = []
    
    def mock_api_call(api_key):
        nonlocal call_count
        call_count += 1
        keys_used.append(api_key)
        
        if api_key == primary_key and primary_fails:
            raise Exception("401 Unauthorized")
        elif api_key == backup_key and backup_fails:
            raise Exception("401 Unauthorized")
        else:
            return {"ok": True, "data": "success"}
    
    # Simulate fallback logic
    try:
        result = mock_api_call(primary_key)
    except Exception:
        if backup_key:
            try:
                result = mock_api_call(backup_key)
            except Exception:
                result = {"ok": False, "error": "All keys failed"}
        else:
            result = {"ok": False, "error": "Primary key failed"}
    
    # Verify fallback behavior
    if primary_fails and not backup_fails:
        assert call_count == 2, "Should try backup key after primary fails"
        assert keys_used == [primary_key, backup_key]
        assert result["ok"], "Should succeed with backup key"
    elif primary_fails and backup_fails:
        assert call_count == 2, "Should try both keys"
        assert not result["ok"], "Should fail when both keys fail"
    elif not primary_fails:
        assert call_count == 1, "Should succeed with primary key"
        assert result["ok"], "Should succeed with primary key"


# ============================================================================
# Property 5: Endpoint routing correctness
# Feature: api-integration-enhancement, Property 5: Endpoint routing correctness
# Validates: Requirements 1.5, 8.1
# ============================================================================

@given(
    category=st.sampled_from(['market', 'indices', 'social', 'news', 'local']),
    endpoint_path=st.text(min_size=1, max_size=50)
)
@settings(max_examples=100)
def test_endpoint_routing_correctness(category, endpoint_path):
    """
    Property: For any endpoint call, if category is 'local', it should route
    to backend proxy. Otherwise, it should route to external API.
    """
    # Simulate routing logic
    if category == 'local':
        # Should route to backend (starts with /)
        routed_url = f"/api/{endpoint_path}"
        assert routed_url.startswith('/'), \
            "Local endpoints should route to backend (start with /)"
    else:
        # Should route to external API (starts with http)
        routed_url = f"https://api.example.com/{endpoint_path}"
        assert routed_url.startswith('http'), \
            "External endpoints should route to external API (start with http)"


# ============================================================================
# Property 6: Sentiment aggregation weighting
# Feature: api-integration-enhancement, Property 6: Sentiment aggregation weighting
# Validates: Requirements 10.2
# ============================================================================

@given(
    fear_greed_score=st.floats(min_value=-1, max_value=1, allow_nan=False, allow_infinity=False),
    market_tilt=st.floats(min_value=-1, max_value=1, allow_nan=False, allow_infinity=False)
)
@settings(max_examples=100)
def test_sentiment_aggregation_weighting(fear_greed_score, market_tilt):
    """
    Property: For any sentiment snapshot calculation, the composite score
    should be calculated as 0.4 * fearGreedScore + 0.6 * marketTilt,
    normalized to the range [-1, 1].
    """
    # Calculate composite score
    composite_score = 0.4 * fear_greed_score + 0.6 * market_tilt
    
    # Verify weighting
    expected = 0.4 * fear_greed_score + 0.6 * market_tilt
    assert abs(composite_score - expected) < 0.0001, \
        f"Composite score should be 0.4*{fear_greed_score} + 0.6*{market_tilt}"
    
    # Verify range
    assert -1 <= composite_score <= 1, \
        f"Composite score {composite_score} should be in range [-1, 1]"


# ============================================================================
# Property 7: Cache TTL compliance
# Feature: api-integration-enhancement, Property 7: Cache TTL compliance
# Validates: Requirements 8.4
# ============================================================================

@given(
    ttl_seconds=st.integers(min_value=1, max_value=3600),
    elapsed_seconds=st.integers(min_value=0, max_value=7200)
)
@settings(max_examples=100)
def test_cache_ttl_compliance(ttl_seconds, elapsed_seconds):
    """
    Property: For any cached response, the system should not serve
    cached data older than the configured TTL.
    """
    import time
    
    # Simulate cache entry
    cache_timestamp = time.time()
    current_time = cache_timestamp + elapsed_seconds
    
    # Check if cache is valid
    cache_age = current_time - cache_timestamp
    is_valid = cache_age < ttl_seconds
    
    # Verify TTL compliance
    if elapsed_seconds < ttl_seconds:
        assert is_valid, \
            f"Cache should be valid when age ({elapsed_seconds}s) < TTL ({ttl_seconds}s)"
    else:
        assert not is_valid, \
            f"Cache should be invalid when age ({elapsed_seconds}s) >= TTL ({ttl_seconds}s)"


# ============================================================================
# Unit Tests for External API Functions
# Requirements: 1.3, 4.1, 7.1
# ============================================================================

class TestExternalAPIURLConstruction:
    """Test URL construction for external API functions"""
    
    def test_coingecko_simple_price_url(self):
        """Test CoinGecko simple price URL construction"""
        ids = ['bitcoin', 'ethereum']
        expected_url = 'https://api.coingecko.com/api/v3/simple/price?ids=bitcoin,ethereum&vs_currencies=usd&include_24hr_change=true&include_market_cap=true'
        
        # Simulate URL construction from getCoinGeckoSimplePrice
        ids_param = ','.join(ids)
        actual_url = f'https://api.coingecko.com/api/v3/simple/price?ids={ids_param}&vs_currencies=usd&include_24hr_change=true&include_market_cap=true'
        
        assert actual_url == expected_url
    
    def test_coingecko_simple_price_single_coin(self):
        """Test CoinGecko URL with single coin"""
        ids = ['bitcoin']
        expected_url = 'https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd&include_24hr_change=true&include_market_cap=true'
        
        ids_param = ','.join(ids)
        actual_url = f'https://api.coingecko.com/api/v3/simple/price?ids={ids_param}&vs_currencies=usd&include_24hr_change=true&include_market_cap=true'
        
        assert actual_url == expected_url
    
    def test_coingecko_trending_url(self):
        """Test CoinGecko trending URL construction"""
        expected_url = 'https://api.coingecko.com/api/v3/search/trending'
        actual_url = 'https://api.coingecko.com/api/v3/search/trending'
        
        assert actual_url == expected_url
    
    def test_binance_klines_url(self):
        """Test Binance klines URL construction"""
        symbol = 'BTCUSDT'
        interval = '1h'
        limit = 100
        expected_url = f'https://api.binance.com/api/v3/klines?symbol={symbol}&interval={interval}&limit={limit}'
        
        # Simulate URL construction from getBinanceKlines
        actual_url = f'https://api.binance.com/api/v3/klines?symbol={symbol}&interval={interval}&limit={limit}'
        
        assert actual_url == expected_url
    
    def test_binance_klines_url_custom_limit(self):
        """Test Binance klines URL with custom limit"""
        symbol = 'ETHUSDT'
        interval = '1d'
        limit = 500
        expected_url = f'https://api.binance.com/api/v3/klines?symbol={symbol}&interval={interval}&limit={limit}'
        
        actual_url = f'https://api.binance.com/api/v3/klines?symbol={symbol}&interval={interval}&limit={limit}'
        
        assert actual_url == expected_url
    
    def test_fear_greed_url(self):
        """Test Fear & Greed Index URL construction"""
        expected_url = 'https://api.alternative.me/fng/?limit=1'
        actual_url = 'https://api.alternative.me/fng/?limit=1'
        
        assert actual_url == expected_url


class TestExternalAPIResponseParsing:
    """Test response parsing for external API functions"""
    
    def test_fear_greed_parsing_extreme_fear(self):
        """Test Fear & Greed parsing for extreme fear (0-20)"""
        mock_response = {
            "data": [{
                "value": "15",
                "timestamp": "1234567890"
            }]
        }
        
        # Simulate parsing from getFearGreed
        raw = mock_response["data"][0]
        score = int(raw["value"])
        
        classification = 'Neutral'
        if score <= 20:
            classification = 'Extreme Fear'
        elif score <= 40:
            classification = 'Fear'
        elif score <= 60:
            classification = 'Neutral'
        elif score <= 80:
            classification = 'Greed'
        else:
            classification = 'Extreme Greed'
        
        assert score == 15
        assert classification == 'Extreme Fear'
        assert 0 <= score <= 100
    
    def test_fear_greed_parsing_fear(self):
        """Test Fear & Greed parsing for fear (21-40)"""
        mock_response = {
            "data": [{
                "value": "35",
                "timestamp": "1234567890"
            }]
        }
        
        raw = mock_response["data"][0]
        score = int(raw["value"])
        
        classification = 'Neutral'
        if score <= 20:
            classification = 'Extreme Fear'
        elif score <= 40:
            classification = 'Fear'
        elif score <= 60:
            classification = 'Neutral'
        elif score <= 80:
            classification = 'Greed'
        else:
            classification = 'Extreme Greed'
        
        assert score == 35
        assert classification == 'Fear'
    
    def test_fear_greed_parsing_neutral(self):
        """Test Fear & Greed parsing for neutral (41-60)"""
        mock_response = {
            "data": [{
                "value": "50",
                "timestamp": "1234567890"
            }]
        }
        
        raw = mock_response["data"][0]
        score = int(raw["value"])
        
        classification = 'Neutral'
        if score <= 20:
            classification = 'Extreme Fear'
        elif score <= 40:
            classification = 'Fear'
        elif score <= 60:
            classification = 'Neutral'
        elif score <= 80:
            classification = 'Greed'
        else:
            classification = 'Extreme Greed'
        
        assert score == 50
        assert classification == 'Neutral'
    
    def test_fear_greed_parsing_greed(self):
        """Test Fear & Greed parsing for greed (61-80)"""
        mock_response = {
            "data": [{
                "value": "75",
                "timestamp": "1234567890"
            }]
        }
        
        raw = mock_response["data"][0]
        score = int(raw["value"])
        
        classification = 'Neutral'
        if score <= 20:
            classification = 'Extreme Fear'
        elif score <= 40:
            classification = 'Fear'
        elif score <= 60:
            classification = 'Neutral'
        elif score <= 80:
            classification = 'Greed'
        else:
            classification = 'Extreme Greed'
        
        assert score == 75
        assert classification == 'Greed'
    
    def test_fear_greed_parsing_extreme_greed(self):
        """Test Fear & Greed parsing for extreme greed (81-100)"""
        mock_response = {
            "data": [{
                "value": "95",
                "timestamp": "1234567890"
            }]
        }
        
        raw = mock_response["data"][0]
        score = int(raw["value"])
        
        classification = 'Neutral'
        if score <= 20:
            classification = 'Extreme Fear'
        elif score <= 40:
            classification = 'Fear'
        elif score <= 60:
            classification = 'Neutral'
        elif score <= 80:
            classification = 'Greed'
        else:
            classification = 'Extreme Greed'
        
        assert score == 95
        assert classification == 'Extreme Greed'
    
    def test_fear_greed_timestamp_parsing(self):
        """Test Fear & Greed timestamp parsing"""
        mock_response = {
            "data": [{
                "value": "50",
                "timestamp": "1234567890"
            }]
        }
        
        raw = mock_response["data"][0]
        timestamp = int(raw["timestamp"]) * 1000  # Convert to milliseconds
        
        assert timestamp == 1234567890000
    
    def test_binance_klines_structure(self):
        """Test Binance klines response structure"""
        mock_kline = [
            1234567890000,  # Open time
            "50000.00",     # Open
            "51000.00",     # High
            "49000.00",     # Low
            "50500.00",     # Close
            "1000.50",      # Volume
            1234571490000,  # Close time
            "50250000.00",  # Quote asset volume
            5000,           # Number of trades
            "500.25",       # Taker buy base asset volume
            "25125000.00",  # Taker buy quote asset volume
            "0"             # Ignore
        ]
        
        # Verify structure
        assert len(mock_kline) == 12
        assert isinstance(mock_kline[0], int)  # Open time
        assert isinstance(mock_kline[1], str)  # Open price
        assert float(mock_kline[1]) > 0  # Valid price


class TestExternalAPIErrorScenarios:
    """Test error handling for external API functions"""
    
    def test_network_error_result(self):
        """Test Result pattern for network errors"""
        result = {"ok": False, "error": "Network error"}
        
        assert not result["ok"]
        assert "error" in result
        assert "Network" in result["error"]
    
    def test_http_404_error_result(self):
        """Test Result pattern for HTTP 404 errors"""
        result = {"ok": False, "error": "HTTP 404: Not Found"}
        
        assert not result["ok"]
        assert "404" in result["error"]
    
    def test_http_500_error_result(self):
        """Test Result pattern for HTTP 500 errors"""
        result = {"ok": False, "error": "HTTP 500: Internal Server Error"}
        
        assert not result["ok"]
        assert "500" in result["error"]
    
    def test_http_429_rate_limit_error(self):
        """Test Result pattern for rate limit errors"""
        result = {"ok": False, "error": "HTTP 429: Too Many Requests"}
        
        assert not result["ok"]
        assert "429" in result["error"]
    
    def test_json_parse_error_result(self):
        """Test Result pattern for JSON parsing errors"""
        result = {"ok": False, "error": "Parse error"}
        
        assert not result["ok"]
        assert "Parse" in result["error"]
    
    def test_fear_greed_parse_error_handling(self):
        """Test Fear & Greed parsing error handling"""
        # Simulate malformed response
        mock_response = {
            "data": [{
                "invalid_field": "not_a_number"
            }]
        }
        
        # Simulate parsing with error handling
        try:
            raw = mock_response["data"][0]
            score = int(raw["value"])  # This will raise KeyError
            result = {"ok": True, "data": {"score": score}}
        except (KeyError, ValueError):
            result = {"ok": False, "error": "Failed to parse Fear & Greed data"}
        
        assert not result["ok"]
        assert "parse" in result["error"].lower()
    
    def test_empty_response_handling(self):
        """Test handling of empty responses"""
        mock_response = {"data": []}
        
        # Simulate parsing with error handling
        try:
            raw = mock_response["data"][0]  # This will raise IndexError
            result = {"ok": True, "data": raw}
        except IndexError:
            result = {"ok": False, "error": "Empty response"}
        
        assert not result["ok"]
        assert "Empty" in result["error"]
    
    def test_success_result_structure(self):
        """Test Result pattern for successful responses"""
        result = {"ok": True, "data": {"price": 50000}}
        
        assert result["ok"]
        assert "data" in result
        assert "error" not in result
        assert result["data"]["price"] == 50000


# ============================================================================
# Integration Tests
# Requirements: 8.1, 8.2, 8.3, 8.4
# ============================================================================

class TestEndToEndIntegration:
    """
    Integration tests for end-to-end flow: Frontend → Backend → External API
    Tests with mocked external APIs to avoid rate limits and ensure reliability
    """
    
    def _create_mock_client(self, response_data, status_code=200):
        """Helper to create a properly mocked AsyncClient"""
        mock_resp = AsyncMock()
        mock_resp.status_code = status_code
        mock_resp.json = AsyncMock(return_value=response_data)
        mock_resp.raise_for_status = AsyncMock()
        
        mock_client = AsyncMock()
        mock_client.get = AsyncMock(return_value=mock_resp)
        mock_client.post = AsyncMock(return_value=mock_resp)
        mock_client.__aenter__ = AsyncMock(return_value=mock_client)
        mock_client.__aexit__ = AsyncMock(return_value=None)
        
        return mock_client
    
    def test_market_quotes_end_to_end(self):
        """Test market quotes flow from frontend through backend to external API"""
        from api.api_hub_endpoints import router
        from fastapi.testclient import TestClient
        from fastapi import FastAPI
        
        app = FastAPI()
        app.include_router(router)
        client = TestClient(app)
        
        # Mock external API response
        mock_cmc_response = {
            "status": {"error_code": 0},
            "data": {
                "BTC": {
                    "quote": {
                        "USD": {
                            "price": 50000.0,
                            "percent_change_24h": 5.5,
                            "market_cap": 1000000000000,
                            "volume_24h": 50000000000,
                            "last_updated": "2024-01-01T00:00:00Z"
                        }
                    }
                }
            }
        }
        
        mock_client = self._create_mock_client(mock_cmc_response)
        
        with patch('httpx.AsyncClient', return_value=mock_client):
            # Simulate frontend call to backend
            response = client.get("/api/market/quotes?symbols=BTC")
            
            assert response.status_code == 200
            data = response.json()
            assert "quotes" in data
            assert len(data["quotes"]) > 0
            assert data["quotes"][0]["symbol"] == "BTC"
            assert data["quotes"][0]["price"] == 50000.0
            assert data["source"] == "coinmarketcap"
    
    @pytest.mark.asyncio
    async def test_blockchain_balance_with_fallback(self):
        """Test blockchain balance with fallback to backup key"""
        from api.api_hub_endpoints import router
        from fastapi.testclient import TestClient
        from fastapi import FastAPI
        
        app = FastAPI()
        app.include_router(router)
        client = TestClient(app)
        
        # Mock responses: first call fails, second succeeds
        mock_responses = [
            # First call with primary key fails
            AsyncMock(
                status_code=200,
                json=Mock(return_value={"status": "0", "message": "Invalid API Key"}),
                raise_for_status=Mock()
            ),
            # Second call with backup key succeeds
            AsyncMock(
                status_code=200,
                json=Mock(return_value={"status": "1", "result": "1000000000000000000"}),
                raise_for_status=Mock()
            )
        ]
        
        with patch('httpx.AsyncClient.get', side_effect=mock_responses):
            response = client.get("/api/blockchain/eth/balance?address=0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb")
            
            assert response.status_code == 200
            data = response.json()
            assert "balance_eth" in data
            assert data["balance_eth"] == 1.0
            assert data["source"] == "etherscan_backup"
    
    @pytest.mark.asyncio
    async def test_news_api_integration(self):
        """Test news API integration with backend proxy"""
        from api.api_hub_endpoints import router
        from fastapi.testclient import TestClient
        from fastapi import FastAPI
        
        app = FastAPI()
        app.include_router(router)
        client = TestClient(app)
        
        mock_news_response = {
            "status": "ok",
            "articles": [
                {
                    "title": "Bitcoin reaches new high",
                    "description": "Bitcoin price surges",
                    "content": "Full article content",
                    "source": {"name": "CryptoNews"},
                    "url": "https://example.com/article",
                    "publishedAt": "2024-01-01T00:00:00Z",
                    "urlToImage": "https://example.com/image.jpg"
                }
            ]
        }
        
        with patch('httpx.AsyncClient.get') as mock_get:
            mock_response = AsyncMock()
            mock_response.status_code = 200
            mock_response.json.return_value = mock_news_response
            mock_response.raise_for_status = Mock()
            mock_get.return_value = mock_response
            
            response = client.get("/api/news/crypto?limit=10")
            
            assert response.status_code == 200
            data = response.json()
            assert "articles" in data
            assert len(data["articles"]) > 0
            assert data["articles"][0]["title"] == "Bitcoin reaches new high"
            assert data["source"] == "newsapi"
    
    @pytest.mark.asyncio
    async def test_hf_sentiment_integration(self):
        """Test HuggingFace sentiment analysis integration"""
        from api.api_hub_endpoints import router
        from fastapi.testclient import TestClient
        from fastapi import FastAPI
        
        app = FastAPI()
        app.include_router(router)
        client = TestClient(app)
        
        mock_hf_response = [
            [
                {"label": "POSITIVE", "score": 0.95},
                {"label": "NEGATIVE", "score": 0.03},
                {"label": "NEUTRAL", "score": 0.02}
            ]
        ]
        
        with patch('httpx.AsyncClient.post') as mock_post:
            mock_response = AsyncMock()
            mock_response.status_code = 200
            mock_response.json.return_value = mock_hf_response
            mock_response.raise_for_status = Mock()
            mock_post.return_value = mock_response
            
            response = client.post(
                "/api/hf/sentiment",
                json={"texts": ["Bitcoin is going to the moon!"]}
            )
            
            assert response.status_code == 200
            data = response.json()
            assert "results" in data or "sentiment" in data


class TestCachingBehavior:
    """
    Test caching behavior for backend proxy endpoints
    Requirements: 8.4
    """
    
    def test_cache_ttl_expiration(self):
        """Test that cache expires after TTL"""
        import time
        from config import PROVIDER_FALLBACK_STRATEGY
        
        # Get TTL for a provider
        ttl = PROVIDER_FALLBACK_STRATEGY.get("coinmarketcap", {}).get("cache_ttl", 300)
        
        # Simulate cache entry
        cache_time = time.time()
        current_time = cache_time + ttl + 1  # Past TTL
        
        # Check if expired
        is_expired = (current_time - cache_time) > ttl
        assert is_expired, "Cache should be expired after TTL"
    
    def test_cache_within_ttl(self):
        """Test that cache is valid within TTL"""
        import time
        from config import PROVIDER_FALLBACK_STRATEGY
        
        # Get TTL for a provider
        ttl = PROVIDER_FALLBACK_STRATEGY.get("coinmarketcap", {}).get("cache_ttl", 300)
        
        # Simulate cache entry
        cache_time = time.time()
        current_time = cache_time + ttl - 10  # Before TTL
        
        # Check if valid
        is_valid = (current_time - cache_time) < ttl
        assert is_valid, "Cache should be valid within TTL"
    
    @pytest.mark.asyncio
    async def test_cache_serves_on_rate_limit(self):
        """Test that cached data is served when rate limit is hit"""
        from api.api_hub_endpoints import router
        from fastapi.testclient import TestClient
        from fastapi import FastAPI
        
        app = FastAPI()
        app.include_router(router)
        client = TestClient(app)
        
        # First request succeeds
        mock_success_response = {
            "status": {"error_code": 0},
            "data": {
                "BTC": {
                    "quote": {
                        "USD": {
                            "price": 50000.0,
                            "percent_change_24h": 5.5,
                            "market_cap": 1000000000000,
                            "volume_24h": 50000000000,
                            "last_updated": "2024-01-01T00:00:00Z"
                        }
                    }
                }
            }
        }
        
        with patch('httpx.AsyncClient.get') as mock_get:
            mock_response = AsyncMock()
            mock_response.status_code = 200
            mock_response.json.return_value = mock_success_response
            mock_response.raise_for_status = Mock()
            mock_get.return_value = mock_response
            
            # First request should succeed
            response1 = client.get("/api/market/quotes?symbols=BTC")
            assert response1.status_code == 200
            
            # Note: In a real implementation with caching, the second request
            # would be served from cache. This test validates the concept.


class TestFallbackMechanisms:
    """
    Test fallback mechanisms when primary providers fail
    Requirements: 8.2, 8.3
    """
    
    @pytest.mark.asyncio
    async def test_etherscan_fallback_to_backup_key(self):
        """Test Etherscan falls back to backup key on auth failure"""
        from api.api_hub_endpoints import router
        from fastapi.testclient import TestClient
        from fastapi import FastAPI
        
        app = FastAPI()
        app.include_router(router)
        client = TestClient(app)
        
        call_count = 0
        
        async def mock_get_with_fallback(*args, **kwargs):
            nonlocal call_count
            call_count += 1
            
            if call_count == 1:
                # First call fails with auth error
                mock_resp = AsyncMock()
                mock_resp.status_code = 200
                mock_resp.json.return_value = {
                    "status": "0",
                    "message": "Invalid API Key"
                }
                mock_resp.raise_for_status = Mock()
                return mock_resp
            else:
                # Second call succeeds with backup key
                mock_resp = AsyncMock()
                mock_resp.status_code = 200
                mock_resp.json.return_value = {
                    "status": "1",
                    "result": "2000000000000000000"
                }
                mock_resp.raise_for_status = Mock()
                return mock_resp
        
        with patch('httpx.AsyncClient.get', side_effect=mock_get_with_fallback):
            response = client.get("/api/blockchain/eth/balance?address=0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb")
            
            assert response.status_code == 200
            assert call_count == 2, "Should have tried backup key"
            data = response.json()
            assert data["balance_eth"] == 2.0
    
    @pytest.mark.asyncio
    async def test_provider_disabled_returns_503(self):
        """Test that disabled providers return 503"""
        from api.api_hub_endpoints import router
        from fastapi.testclient import TestClient
        from fastapi import FastAPI
        
        app = FastAPI()
        app.include_router(router)
        client = TestClient(app)
        
        # Mock provider as disabled by removing API key
        with patch('config.EXTERNAL_PROVIDERS', {"coinmarketcap": {"enabled": True}}):
            response = client.get("/api/market/quotes?symbols=BTC")
            
            assert response.status_code == 503
            assert "not configured" in response.json()["detail"].lower()
    
    @pytest.mark.asyncio
    async def test_error_normalization(self):
        """Test that external API errors are normalized"""
        from api.api_hub_endpoints import router
        from fastapi.testclient import TestClient
        from fastapi import FastAPI
        
        app = FastAPI()
        app.include_router(router)
        client = TestClient(app)
        
        # Mock external API error
        with patch('httpx.AsyncClient.get') as mock_get:
            mock_response = AsyncMock()
            mock_response.status_code = 500
            mock_response.raise_for_status.side_effect = httpx.HTTPStatusError(
                "Server Error",
                request=Mock(),
                response=Mock(status_code=500)
            )
            mock_get.return_value = mock_response
            
            response = client.get("/api/market/quotes?symbols=BTC")
            
            # Should return normalized error
            assert response.status_code == 500


class TestRateLimiting:
    """
    Test rate limiting behavior
    Requirements: 8.2
    """
    
    def test_rate_limit_configuration(self):
        """Test that rate limits are properly configured"""
        from config import EXTERNAL_PROVIDERS
        
        # Check that providers have rate limit configuration
        for provider_name, config in EXTERNAL_PROVIDERS.items():
            if config.get("enabled"):
                rate_limit = config.get("rate_limit", {})
                # At least one rate limit should be defined
                has_rate_limit = any([
                    "requests_per_second" in rate_limit,
                    "requests_per_minute" in rate_limit,
                    "requests_per_hour" in rate_limit,
                    "requests_per_day" in rate_limit
                ])
                # Some free providers may not have rate limits
                # Just verify the structure exists
                assert isinstance(rate_limit, dict)
    
    def test_rate_limit_values_are_positive(self):
        """Test that rate limit values are positive integers"""
        from config import EXTERNAL_PROVIDERS
        
        for provider_name, config in EXTERNAL_PROVIDERS.items():
            rate_limit = config.get("rate_limit", {})
            for key, value in rate_limit.items():
                if isinstance(value, (int, float)):
                    assert value > 0, f"{provider_name}.{key} should be positive"


# ============================================================================
# Additional Integration Tests
# Requirements: 8.1, 8.2, 8.3, 8.4
# ============================================================================

class TestCompleteIntegrationFlow:
    """
    Comprehensive integration tests for complete end-to-end flows
    Tests: Frontend → Backend → External API with all error scenarios
    """
    
    def test_complete_market_data_flow(self):
        """Test complete market data flow with multiple symbols"""
        from api.api_hub_endpoints import router
        from fastapi.testclient import TestClient
        from fastapi import FastAPI
        
        app = FastAPI()
        app.include_router(router)
        client = TestClient(app)
        
        # Mock CoinMarketCap response with multiple symbols
        mock_response_data = {
            "status": {"error_code": 0},
            "data": {
                "BTC": {
                    "quote": {
                        "USD": {
                            "price": 50000.0,
                            "percent_change_24h": 5.5,
                            "market_cap": 1000000000000,
                            "volume_24h": 50000000000,
                            "last_updated": "2024-01-01T00:00:00Z"
                        }
                    }
                },
                "ETH": {
                    "quote": {
                        "USD": {
                            "price": 3000.0,
                            "percent_change_24h": 3.2,
                            "market_cap": 350000000000,
                            "volume_24h": 20000000000,
                            "last_updated": "2024-01-01T00:00:00Z"
                        }
                    }
                }
            }
        }
        
        # Create mock response
        mock_resp = AsyncMock()
        mock_resp.status_code = 200
        mock_resp.json = AsyncMock(return_value=mock_response_data)
        mock_resp.raise_for_status = AsyncMock()
        
        # Create mock client that returns mock response
        mock_client = AsyncMock()
        mock_client.get = AsyncMock(return_value=mock_resp)
        mock_client.__aenter__ = AsyncMock(return_value=mock_client)
        mock_client.__aexit__ = AsyncMock(return_value=None)
        
        with patch('httpx.AsyncClient', return_value=mock_client):
            response = client.get("/api/market/quotes?symbols=BTC,ETH")
            
            assert response.status_code == 200
            data = response.json()
            assert "quotes" in data
            assert len(data["quotes"]) == 2
            
            # Verify BTC data
            btc_quote = next(q for q in data["quotes"] if q["symbol"] == "BTC")
            assert btc_quote["price"] == 50000.0
            assert btc_quote["change_24h"] == 5.5
            
            # Verify ETH data
            eth_quote = next(q for q in data["quotes"] if q["symbol"] == "ETH")
            assert eth_quote["price"] == 3000.0
            assert eth_quote["change_24h"] == 3.2
    
    def test_blockchain_explorer_complete_flow(self):
        """Test complete blockchain explorer flow with all chains"""
        from api.api_hub_endpoints import router
        from fastapi.testclient import TestClient
        from fastapi import FastAPI
        
        app = FastAPI()
        app.include_router(router)
        client = TestClient(app)
        
        test_address = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb"
        
        # Create mock response
        mock_resp = AsyncMock()
        mock_resp.status_code = 200
        mock_resp.json = AsyncMock(return_value={
            "status": "1",
            "result": "5000000000000000000"  # 5 ETH
        })
        mock_resp.raise_for_status = AsyncMock()
        
        # Create mock client
        mock_client = AsyncMock()
        mock_client.get = AsyncMock(return_value=mock_resp)
        mock_client.__aenter__ = AsyncMock(return_value=mock_client)
        mock_client.__aexit__ = AsyncMock(return_value=None)
        
        with patch('httpx.AsyncClient', return_value=mock_client):
            response = client.get(f"/api/blockchain/eth/balance?address={test_address}")
            
            assert response.status_code == 200
            data = response.json()
            assert "balance_eth" in data
            assert data["balance_eth"] == 5.0
            assert data["source"] in ["etherscan", "etherscan_backup"]
    
    @pytest.mark.asyncio
    async def test_news_aggregation_flow(self):
        """Test news aggregation from multiple topics"""
        from api.api_hub_endpoints import router
        from fastapi.testclient import TestClient
        from fastapi import FastAPI
        
        app = FastAPI()
        app.include_router(router)
        client = TestClient(app)
        
        mock_news = {
            "status": "ok",
            "totalResults": 100,
            "articles": [
                {
                    "title": "Bitcoin Surges Past $50K",
                    "description": "Bitcoin reaches new milestone",
                    "content": "Full article content here",
                    "source": {"name": "CryptoNews"},
                    "url": "https://example.com/article1",
                    "publishedAt": "2024-01-01T12:00:00Z",
                    "urlToImage": "https://example.com/image1.jpg"
                },
                {
                    "title": "Ethereum 2.0 Update",
                    "description": "Major Ethereum upgrade announced",
                    "content": "Full article content here",
                    "source": {"name": "BlockchainDaily"},
                    "url": "https://example.com/article2",
                    "publishedAt": "2024-01-01T11:00:00Z",
                    "urlToImage": "https://example.com/image2.jpg"
                }
            ]
        }
        
        with patch('httpx.AsyncClient.get') as mock_get:
            mock_resp = AsyncMock()
            mock_resp.status_code = 200
            mock_resp.json.return_value = mock_news
            mock_resp.raise_for_status = Mock()
            mock_get.return_value = mock_resp
            
            response = client.get("/api/news/crypto?limit=30")
            
            assert response.status_code == 200
            data = response.json()
            assert "articles" in data
            assert len(data["articles"]) >= 2
            assert data["source"] == "newsapi"
            
            # Verify article structure
            article = data["articles"][0]
            assert "title" in article
            assert "description" in article
            assert "url" in article
            assert "publishedAt" in article
    
    @pytest.mark.asyncio
    async def test_sentiment_analysis_batch_flow(self):
        """Test sentiment analysis with batch processing"""
        from api.api_hub_endpoints import router
        from fastapi.testclient import TestClient
        from fastapi import FastAPI
        
        app = FastAPI()
        app.include_router(router)
        client = TestClient(app)
        
        # Mock HuggingFace batch response
        mock_hf_batch = [
            [
                {"label": "POSITIVE", "score": 0.95},
                {"label": "NEGATIVE", "score": 0.03},
                {"label": "NEUTRAL", "score": 0.02}
            ],
            [
                {"label": "NEGATIVE", "score": 0.85},
                {"label": "POSITIVE", "score": 0.10},
                {"label": "NEUTRAL", "score": 0.05}
            ],
            [
                {"label": "NEUTRAL", "score": 0.70},
                {"label": "POSITIVE", "score": 0.20},
                {"label": "NEGATIVE", "score": 0.10}
            ]
        ]
        
        with patch('httpx.AsyncClient.post') as mock_post:
            mock_resp = AsyncMock()
            mock_resp.status_code = 200
            mock_resp.json.return_value = mock_hf_batch
            mock_resp.raise_for_status = Mock()
            mock_post.return_value = mock_resp
            
            texts = [
                "Bitcoin is going to the moon!",
                "Market crash incoming, sell everything!",
                "Sideways movement expected this week."
            ]
            
            response = client.post("/api/hf/sentiment", json={"texts": texts})
            
            assert response.status_code == 200
            data = response.json()
            assert "results" in data or "sentiment" in data


class TestFallbackScenarios:
    """
    Test various fallback scenarios when primary services fail
    Requirements: 8.2, 8.3
    """
    
    @pytest.mark.asyncio
    async def test_primary_to_backup_key_fallback(self):
        """Test automatic fallback from primary to backup API key"""
        from api.api_hub_endpoints import router
        from fastapi.testclient import TestClient
        from fastapi import FastAPI
        
        app = FastAPI()
        app.include_router(router)
        client = TestClient(app)
        
        call_count = 0
        
        async def mock_etherscan_calls(*args, **kwargs):
            nonlocal call_count
            call_count += 1
            
            mock_resp = AsyncMock()
            mock_resp.status_code = 200
            
            if call_count == 1:
                # First call fails with invalid API key
                mock_resp.json.return_value = {
                    "status": "0",
                    "message": "NOTOK",
                    "result": "Invalid API Key"
                }
            else:
                # Second call succeeds with backup key
                mock_resp.json.return_value = {
                    "status": "1",
                    "message": "OK",
                    "result": "3500000000000000000"  # 3.5 ETH
                }
            
            mock_resp.raise_for_status = Mock()
            return mock_resp
        
        with patch('httpx.AsyncClient.get', side_effect=mock_etherscan_calls):
            response = client.get("/api/blockchain/eth/balance?address=0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb")
            
            assert response.status_code == 200
            assert call_count == 2, "Should have tried backup key after primary failed"
            data = response.json()
            assert data["balance_eth"] == 3.5
            assert "backup" in data.get("source", "").lower()
    
    @pytest.mark.asyncio
    async def test_provider_to_provider_fallback(self):
        """Test fallback from one provider to another (e.g., CMC to CoinGecko)"""
        from api.api_hub_endpoints import router
        from fastapi.testclient import TestClient
        from fastapi import FastAPI
        from config import PROVIDER_FALLBACK_STRATEGY
        
        app = FastAPI()
        app.include_router(router)
        client = TestClient(app)
        
        # Verify fallback strategy exists
        assert "coinmarketcap" in PROVIDER_FALLBACK_STRATEGY
        fallback = PROVIDER_FALLBACK_STRATEGY["coinmarketcap"].get("fallback")
        assert fallback == "coingecko"
    
    @pytest.mark.asyncio
    async def test_all_providers_fail_gracefully(self):
        """Test graceful failure when all providers fail"""
        from api.api_hub_endpoints import router
        from fastapi.testclient import TestClient
        from fastapi import FastAPI
        
        app = FastAPI()
        app.include_router(router)
        client = TestClient(app)
        
        # Mock all calls to fail
        with patch('httpx.AsyncClient.get') as mock_get:
            mock_resp = AsyncMock()
            mock_resp.status_code = 500
            mock_resp.raise_for_status.side_effect = httpx.HTTPStatusError(
                "Server Error",
                request=Mock(),
                response=Mock(status_code=500)
            )
            mock_get.return_value = mock_resp
            
            response = client.get("/api/market/quotes?symbols=BTC")
            
            # Should return error but not crash
            assert response.status_code in [500, 503]
            data = response.json()
            assert "detail" in data or "error" in data


class TestCachingIntegration:
    """
    Test caching behavior in integration scenarios
    Requirements: 8.4
    """
    
    @pytest.mark.asyncio
    async def test_cache_reduces_external_calls(self):
        """Test that caching reduces calls to external APIs"""
        from api.api_hub_endpoints import router
        from fastapi.testclient import TestClient
        from fastapi import FastAPI
        
        app = FastAPI()
        app.include_router(router)
        client = TestClient(app)
        
        call_count = 0
        
        async def count_calls(*args, **kwargs):
            nonlocal call_count
            call_count += 1
            
            mock_resp = AsyncMock()
            mock_resp.status_code = 200
            mock_resp.json.return_value = {
                "status": {"error_code": 0},
                "data": {
                    "BTC": {
                        "quote": {
                            "USD": {
                                "price": 50000.0,
                                "percent_change_24h": 5.5,
                                "market_cap": 1000000000000,
                                "volume_24h": 50000000000,
                                "last_updated": "2024-01-01T00:00:00Z"
                            }
                        }
                    }
                }
            }
            mock_resp.raise_for_status = Mock()
            return mock_resp
        
        with patch('httpx.AsyncClient.get', side_effect=count_calls):
            # First request
            response1 = client.get("/api/market/quotes?symbols=BTC")
            assert response1.status_code == 200
            first_call_count = call_count
            
            # Note: In a real implementation with caching, subsequent requests
            # within TTL would not increment call_count
            # This test validates the concept
            assert first_call_count >= 1
    
    @pytest.mark.asyncio
    async def test_cache_serves_stale_on_error(self):
        """Test that cache serves stale data when external API fails"""
        from api.api_hub_endpoints import router
        from fastapi.testclient import TestClient
        from fastapi import FastAPI
        
        app = FastAPI()
        app.include_router(router)
        client = TestClient(app)
        
        call_count = 0
        
        async def mock_with_failure(*args, **kwargs):
            nonlocal call_count
            call_count += 1
            
            mock_resp = AsyncMock()
            
            if call_count == 1:
                # First call succeeds
                mock_resp.status_code = 200
                mock_resp.json.return_value = {
                    "status": {"error_code": 0},
                    "data": {
                        "BTC": {
                            "quote": {
                                "USD": {
                                    "price": 50000.0,
                                    "percent_change_24h": 5.5,
                                    "market_cap": 1000000000000,
                                    "volume_24h": 50000000000,
                                    "last_updated": "2024-01-01T00:00:00Z"
                                }
                            }
                        }
                    }
                }
                mock_resp.raise_for_status = Mock()
            else:
                # Subsequent calls fail
                mock_resp.status_code = 500
                mock_resp.raise_for_status.side_effect = httpx.HTTPStatusError(
                    "Server Error",
                    request=Mock(),
                    response=Mock(status_code=500)
                )
            
            return mock_resp
        
        with patch('httpx.AsyncClient.get', side_effect=mock_with_failure):
            # First request succeeds
            response1 = client.get("/api/market/quotes?symbols=BTC")
            assert response1.status_code == 200
            
            # In a real implementation with caching, this would serve from cache
            # even though the external API is failing


class TestErrorHandlingIntegration:
    """
    Test error handling across the integration stack
    Requirements: 8.3, 9.3, 9.4, 9.5
    """
    
    @pytest.mark.asyncio
    async def test_network_timeout_handling(self):
        """Test handling of network timeouts"""
        from api.api_hub_endpoints import router
        from fastapi.testclient import TestClient
        from fastapi import FastAPI
        import asyncio
        
        app = FastAPI()
        app.include_router(router)
        client = TestClient(app)
        
        with patch('httpx.AsyncClient.get') as mock_get:
            mock_get.side_effect = asyncio.TimeoutError("Request timeout")
            
            response = client.get("/api/market/quotes?symbols=BTC")
            
            # Should handle timeout gracefully
            assert response.status_code in [500, 503, 504]
            data = response.json()
            assert "detail" in data or "error" in data
    
    @pytest.mark.asyncio
    async def test_malformed_response_handling(self):
        """Test handling of malformed API responses"""
        from api.api_hub_endpoints import router
        from fastapi.testclient import TestClient
        from fastapi import FastAPI
        
        app = FastAPI()
        app.include_router(router)
        client = TestClient(app)
        
        with patch('httpx.AsyncClient.get') as mock_get:
            mock_resp = AsyncMock()
            mock_resp.status_code = 200
            mock_resp.json.side_effect = json.JSONDecodeError("Invalid JSON", "", 0)
            mock_resp.raise_for_status = Mock()
            mock_get.return_value = mock_resp
            
            response = client.get("/api/market/quotes?symbols=BTC")
            
            # Should handle parse error gracefully
            assert response.status_code in [500, 502]
            data = response.json()
            assert "detail" in data or "error" in data
    
    @pytest.mark.asyncio
    async def test_rate_limit_429_handling(self):
        """Test handling of rate limit (429) responses"""
        from api.api_hub_endpoints import router
        from fastapi.testclient import TestClient
        from fastapi import FastAPI
        
        app = FastAPI()
        app.include_router(router)
        client = TestClient(app)
        
        with patch('httpx.AsyncClient.get') as mock_get:
            mock_resp = AsyncMock()
            mock_resp.status_code = 429
            mock_resp.raise_for_status.side_effect = httpx.HTTPStatusError(
                "Too Many Requests",
                request=Mock(),
                response=Mock(status_code=429)
            )
            mock_get.return_value = mock_resp
            
            response = client.get("/api/market/quotes?symbols=BTC")
            
            # Should handle rate limit
            assert response.status_code in [429, 503]
            data = response.json()
            assert "detail" in data or "error" in data
    
    @pytest.mark.asyncio
    async def test_authentication_error_handling(self):
        """Test handling of authentication errors (401/403)"""
        from api.api_hub_endpoints import router
        from fastapi.testclient import TestClient
        from fastapi import FastAPI
        
        app = FastAPI()
        app.include_router(router)
        client = TestClient(app)
        
        with patch('httpx.AsyncClient.get') as mock_get:
            mock_resp = AsyncMock()
            mock_resp.status_code = 401
            mock_resp.raise_for_status.side_effect = httpx.HTTPStatusError(
                "Unauthorized",
                request=Mock(),
                response=Mock(status_code=401)
            )
            mock_get.return_value = mock_resp
            
            response = client.get("/api/market/quotes?symbols=BTC")
            
            # Should handle auth error
            assert response.status_code in [401, 403, 500, 503]
            data = response.json()
            assert "detail" in data or "error" in data


# ============================================================================
# Configuration Integration Tests
# Requirements: 2.1, 2.2, 2.3
# ============================================================================

class TestConfigurationIntegration:
    """
    Test that configuration is properly integrated
    """
    
    def test_external_providers_configured(self):
        """Test that external providers are properly configured"""
        from config import EXTERNAL_PROVIDERS
        
        required_providers = [
            "etherscan",
            "bscscan",
            "tronscan",
            "coinmarketcap",
            "newsapi"
        ]
        
        for provider in required_providers:
            assert provider in EXTERNAL_PROVIDERS, \
                f"Provider '{provider}' should be configured"
            
            config = EXTERNAL_PROVIDERS[provider]
            assert config.get("enabled") is not None
            assert "base_url" in config
    
    def test_api_keys_loaded_from_config(self):
        """Test that API keys are loaded from config"""
        from config import API_KEYS
        
        # Verify dict exists
        assert isinstance(API_KEYS, dict)
        
        # Verify keys are present (even if empty strings)
        key_providers = ["etherscan", "bscscan", "tronscan", "newsapi", "coinmarketcap"]
        for provider in key_providers:
            assert provider in API_KEYS
            key_value = API_KEYS[provider]
            # Only check non-empty if key is configured
            if key_value:
                assert isinstance(key_value, str)
                assert len(key_value) > 0
    
    def test_api_key_not_exposed_in_response(self):
        """Test that API keys are not exposed in responses"""
        from config import API_KEYS
        
        # Simulate a response that might contain data
        mock_response_data = {
            "quotes": [
                {
                    "symbol": "BTC",
                    "price": 50000.0,
                    "change_24h": 5.5
                }
            ],
            "source": "coinmarketcap"
        }
        
        response_text = json.dumps(mock_response_data)
        
        # Verify API keys are not in response
        for key_name, key_value in API_KEYS.items():
            if key_value and len(key_value) > 5:  # Only check non-empty keys with reasonable length
                assert key_value not in response_text, \
                    f"API key for '{key_name}' should not be exposed in response"
    
    def test_headers_contain_api_keys(self):
        """Test that requests to external APIs include API keys in headers"""
        from api.api_hub_endpoints import router
        from fastapi.testclient import TestClient
        from fastapi import FastAPI
        from config import API_KEYS
        
        app = FastAPI()
        app.include_router(router)
        client = TestClient(app)
        
        captured_headers = {}
        
        async def capture_headers(*args, **kwargs):
            captured_headers.update(kwargs.get('headers', {}))
            
            mock_resp = AsyncMock()
            mock_resp.status_code = 200
            mock_resp.json.return_value = {
                "status": {"error_code": 0},
                "data": {}
            }
            mock_resp.raise_for_status = Mock()
            return mock_resp
        
        with patch('httpx.AsyncClient.get', side_effect=capture_headers):
            response = client.get("/api/market/quotes?symbols=BTC")
            
            # Verify API key was included in headers
            # (The exact header name depends on the provider)
            assert any(k.lower() for k in captured_headers.keys() if "api" in k.lower())
    
    def test_fallback_strategy_configured(self):
        """Test that fallback strategies are configured"""
        from config import PROVIDER_FALLBACK_STRATEGY
        
        assert isinstance(PROVIDER_FALLBACK_STRATEGY, dict)
        
        # Verify structure
        for provider, strategy in PROVIDER_FALLBACK_STRATEGY.items():
            if strategy:
                # Just verify the structure exists
                assert isinstance(strategy, dict)
    
    def test_hf_config_present(self):
        """Test that HuggingFace configuration is present"""
        from config import HF_CONFIG
        
        assert isinstance(HF_CONFIG, dict)
        assert "token" in HF_CONFIG
        # Token may be empty in test environment
        assert isinstance(HF_CONFIG["token"], str)