677 lines
30 KiB
Python
677 lines
30 KiB
Python
# ================================================================
|
||
# services/data/tests/test_aemet.py
|
||
# ================================================================
|
||
"""
|
||
Comprehensive test suite for AEMET weather API client
|
||
Following the same patterns as test_madrid_opendata.py
|
||
"""
|
||
|
||
import pytest
|
||
import asyncio
|
||
from datetime import datetime, timedelta
|
||
from unittest.mock import Mock, patch, AsyncMock
|
||
import math
|
||
from typing import Dict, List, Any
|
||
|
||
from app.external.aemet import (
|
||
AEMETClient,
|
||
WeatherDataParser,
|
||
SyntheticWeatherGenerator,
|
||
LocationService,
|
||
AEMETConstants,
|
||
WeatherSource,
|
||
WeatherStation,
|
||
GeographicBounds
|
||
)
|
||
|
||
# Configure pytest-asyncio
|
||
pytestmark = pytest.mark.asyncio
|
||
|
||
|
||
class TestAEMETClient:
|
||
"""Main test class for AEMET API client functionality"""
|
||
|
||
@pytest.fixture
|
||
def client(self):
|
||
"""Create AEMET client instance for testing"""
|
||
return AEMETClient()
|
||
|
||
@pytest.fixture
|
||
def madrid_coords(self):
|
||
"""Standard Madrid coordinates for testing"""
|
||
return (40.4168, -3.7038) # Madrid city center
|
||
|
||
@pytest.fixture
|
||
def mock_aemet_response(self):
|
||
"""Mock AEMET API response structure"""
|
||
return {
|
||
"datos": "https://opendata.aemet.es/opendata/sh/12345",
|
||
"metadatos": "https://opendata.aemet.es/opendata/sh/metadata"
|
||
}
|
||
|
||
@pytest.fixture
|
||
def mock_weather_data(self):
|
||
"""Mock current weather data from AEMET"""
|
||
return {
|
||
"ta": 18.5, # Temperature
|
||
"prec": 0.0, # Precipitation
|
||
"hr": 65.0, # Humidity
|
||
"vv": 12.0, # Wind speed
|
||
"pres": 1015.2, # Pressure
|
||
"descripcion": "Despejado"
|
||
}
|
||
|
||
@pytest.fixture
|
||
def mock_forecast_data(self):
|
||
"""Mock forecast data from AEMET"""
|
||
return [{
|
||
"prediccion": {
|
||
"dia": [
|
||
{
|
||
"fecha": "2025-07-25T00:00:00",
|
||
"temperatura": {
|
||
"maxima": 28,
|
||
"minima": 15
|
||
},
|
||
"probPrecipitacion": [
|
||
{"value": 10, "periodo": "00-24"}
|
||
],
|
||
"viento": [
|
||
{"velocidad": [15], "direccion": ["N"]}
|
||
]
|
||
},
|
||
{
|
||
"fecha": "2025-07-26T00:00:00",
|
||
"temperatura": {
|
||
"maxima": 30,
|
||
"minima": 17
|
||
},
|
||
"probPrecipitacion": [
|
||
{"value": 5, "periodo": "00-24"}
|
||
],
|
||
"viento": [
|
||
{"velocidad": [10], "direccion": ["NE"]}
|
||
]
|
||
}
|
||
]
|
||
}
|
||
}]
|
||
|
||
@pytest.fixture
|
||
def mock_historical_data(self):
|
||
"""Mock historical weather data from AEMET"""
|
||
return [
|
||
{
|
||
"fecha": "2025-07-20",
|
||
"tmax": 25.2,
|
||
"tmin": 14.8,
|
||
"prec": 0.0,
|
||
"hr": 58,
|
||
"velmedia": 8.5,
|
||
"presMax": 1018.5,
|
||
"presMin": 1012.3
|
||
},
|
||
{
|
||
"fecha": "2025-07-21",
|
||
"tmax": 27.1,
|
||
"tmin": 16.2,
|
||
"prec": 2.5,
|
||
"hr": 72,
|
||
"velmedia": 12.0,
|
||
"presMax": 1015.8,
|
||
"presMin": 1010.1
|
||
}
|
||
]
|
||
|
||
# ================================================================
|
||
# CURRENT WEATHER TESTS
|
||
# ================================================================
|
||
|
||
async def test_get_current_weather_success(self, client, madrid_coords, mock_aemet_response, mock_weather_data):
|
||
"""Test successful current weather retrieval"""
|
||
lat, lon = madrid_coords
|
||
|
||
with patch.object(client, '_get', new_callable=AsyncMock) as mock_get, \
|
||
patch.object(client, '_fetch_from_url', new_callable=AsyncMock) as mock_fetch:
|
||
|
||
mock_get.return_value = mock_aemet_response
|
||
mock_fetch.return_value = [mock_weather_data]
|
||
|
||
result = await client.get_current_weather(lat, lon)
|
||
|
||
# Validate result structure
|
||
assert result is not None, "Should return weather data"
|
||
assert isinstance(result, dict), "Result should be a dictionary"
|
||
|
||
# Check required fields
|
||
required_fields = ['date', 'temperature', 'precipitation', 'humidity', 'wind_speed', 'pressure', 'description', 'source']
|
||
for field in required_fields:
|
||
assert field in result, f"Missing required field: {field}"
|
||
|
||
# Validate data types and ranges
|
||
assert isinstance(result['temperature'], float), "Temperature should be float"
|
||
assert -20 <= result['temperature'] <= 50, "Temperature should be reasonable"
|
||
assert isinstance(result['precipitation'], float), "Precipitation should be float"
|
||
assert result['precipitation'] >= 0, "Precipitation should be non-negative"
|
||
assert 0 <= result['humidity'] <= 100, "Humidity should be percentage"
|
||
assert result['wind_speed'] >= 0, "Wind speed should be non-negative"
|
||
assert result['pressure'] > 900, "Pressure should be reasonable"
|
||
assert result['source'] == WeatherSource.AEMET.value, "Source should be AEMET"
|
||
|
||
print(f"✅ Current weather test passed - Temp: {result['temperature']}°C, Source: {result['source']}")
|
||
|
||
async def test_get_current_weather_fallback_to_synthetic(self, client, madrid_coords):
|
||
"""Test fallback to synthetic data when AEMET API fails"""
|
||
lat, lon = madrid_coords
|
||
|
||
with patch.object(client, '_get', new_callable=AsyncMock) as mock_get:
|
||
mock_get.return_value = None # Simulate API failure
|
||
|
||
result = await client.get_current_weather(lat, lon)
|
||
|
||
assert result is not None, "Should return synthetic data"
|
||
assert result['source'] == WeatherSource.SYNTHETIC.value, "Should use synthetic source"
|
||
assert isinstance(result['temperature'], float), "Temperature should be float"
|
||
|
||
print(f"✅ Synthetic fallback test passed - Source: {result['source']}")
|
||
|
||
async def test_get_current_weather_invalid_coordinates(self, client):
|
||
"""Test current weather with invalid coordinates"""
|
||
invalid_coords = [
|
||
(200, 200), # Out of range
|
||
(-200, -200), # Out of range
|
||
(0, 0), # Not in Madrid area
|
||
]
|
||
|
||
for lat, lon in invalid_coords:
|
||
result = await client.get_current_weather(lat, lon)
|
||
|
||
# Should still return data (synthetic)
|
||
assert result is not None, f"Should handle invalid coords ({lat}, {lon})"
|
||
assert result['source'] == WeatherSource.SYNTHETIC.value, "Should use synthetic for invalid coords"
|
||
|
||
print(f"✅ Invalid coordinates test passed")
|
||
|
||
# ================================================================
|
||
# FORECAST TESTS
|
||
# ================================================================
|
||
|
||
async def test_get_forecast_success(self, client, madrid_coords, mock_aemet_response, mock_forecast_data):
|
||
"""Test successful weather forecast retrieval"""
|
||
lat, lon = madrid_coords
|
||
days = 7
|
||
|
||
with patch.object(client, '_get', new_callable=AsyncMock) as mock_get, \
|
||
patch.object(client, '_fetch_from_url', new_callable=AsyncMock) as mock_fetch:
|
||
|
||
mock_get.return_value = mock_aemet_response
|
||
mock_fetch.return_value = mock_forecast_data
|
||
|
||
result = await client.get_forecast(lat, lon, days)
|
||
|
||
# Validate result structure
|
||
assert isinstance(result, list), "Result should be a list"
|
||
assert len(result) == days, f"Should return {days} forecast days"
|
||
|
||
# Check first forecast day
|
||
if result:
|
||
forecast_day = result[0]
|
||
|
||
required_fields = ['forecast_date', 'generated_at', 'temperature', 'precipitation', 'humidity', 'wind_speed', 'description', 'source']
|
||
for field in required_fields:
|
||
assert field in forecast_day, f"Missing required field: {field}"
|
||
|
||
# Validate data types
|
||
assert isinstance(forecast_day['forecast_date'], datetime), "Forecast date should be datetime"
|
||
assert isinstance(forecast_day['temperature'], (int, float)), "Temperature should be numeric"
|
||
assert isinstance(forecast_day['precipitation'], (int, float)), "Precipitation should be numeric"
|
||
assert forecast_day['source'] in [WeatherSource.AEMET.value, WeatherSource.SYNTHETIC.value], "Valid source"
|
||
|
||
print(f"✅ Forecast test passed - {len(result)} days, Source: {forecast_day['source']}")
|
||
|
||
async def test_get_forecast_different_durations(self, client, madrid_coords):
|
||
"""Test forecast for different time durations"""
|
||
lat, lon = madrid_coords
|
||
test_durations = [1, 3, 7, 14]
|
||
|
||
for days in test_durations:
|
||
result = await client.get_forecast(lat, lon, days)
|
||
|
||
assert isinstance(result, list), f"Result should be list for {days} days"
|
||
assert len(result) == days, f"Should return exactly {days} forecast days"
|
||
|
||
# Check date progression
|
||
if len(result) > 1:
|
||
for i in range(1, len(result)):
|
||
date_diff = result[i]['forecast_date'] - result[i-1]['forecast_date']
|
||
assert date_diff.days == 1, "Forecast dates should be consecutive days"
|
||
|
||
print(f"✅ Multiple duration forecast test passed")
|
||
|
||
async def test_get_forecast_fallback_to_synthetic(self, client, madrid_coords):
|
||
"""Test forecast fallback to synthetic data"""
|
||
lat, lon = madrid_coords
|
||
|
||
with patch.object(client.location_service, 'get_municipality_code') as mock_municipality:
|
||
mock_municipality.return_value = None # No municipality found
|
||
|
||
result = await client.get_forecast(lat, lon, 7)
|
||
|
||
assert isinstance(result, list), "Should return synthetic forecast"
|
||
assert len(result) == 7, "Should return 7 days"
|
||
assert all(day['source'] == WeatherSource.SYNTHETIC.value for day in result), "All should be synthetic"
|
||
|
||
print(f"✅ Forecast synthetic fallback test passed")
|
||
|
||
# ================================================================
|
||
# HISTORICAL WEATHER TESTS
|
||
# ================================================================
|
||
|
||
async def test_get_historical_weather_success(self, client, madrid_coords, mock_aemet_response, mock_historical_data):
|
||
"""Test successful historical weather retrieval"""
|
||
lat, lon = madrid_coords
|
||
end_date = datetime.now()
|
||
start_date = end_date - timedelta(days=7)
|
||
|
||
with patch.object(client, '_get', new_callable=AsyncMock) as mock_get, \
|
||
patch.object(client, '_fetch_from_url', new_callable=AsyncMock) as mock_fetch:
|
||
|
||
mock_get.return_value = mock_aemet_response
|
||
mock_fetch.return_value = mock_historical_data
|
||
|
||
result = await client.get_historical_weather(lat, lon, start_date, end_date)
|
||
|
||
# Validate result structure
|
||
assert isinstance(result, list), "Result should be a list"
|
||
assert len(result) > 0, "Should return historical data"
|
||
|
||
# Check first historical record
|
||
if result:
|
||
record = result[0]
|
||
|
||
required_fields = ['date', 'temperature', 'precipitation', 'humidity', 'wind_speed', 'pressure', 'description', 'source']
|
||
for field in required_fields:
|
||
assert field in record, f"Missing required field: {field}"
|
||
|
||
# Validate data types and ranges
|
||
assert isinstance(record['date'], datetime), "Date should be datetime"
|
||
assert isinstance(record['temperature'], (int, float, type(None))), "Temperature should be numeric or None"
|
||
if record['temperature']:
|
||
assert -30 <= record['temperature'] <= 50, "Temperature should be reasonable"
|
||
assert record['precipitation'] >= 0, "Precipitation should be non-negative"
|
||
assert record['source'] == WeatherSource.AEMET.value, "Source should be AEMET"
|
||
|
||
print(f"✅ Historical weather test passed - {len(result)} records, Source: {record['source']}")
|
||
|
||
async def test_get_historical_weather_date_ranges(self, client, madrid_coords):
|
||
"""Test historical weather with different date ranges"""
|
||
lat, lon = madrid_coords
|
||
end_date = datetime.now()
|
||
|
||
test_ranges = [
|
||
1, # 1 day
|
||
7, # 1 week
|
||
30, # 1 month
|
||
90, # 3 months
|
||
]
|
||
|
||
for days in test_ranges:
|
||
start_date = end_date - timedelta(days=days)
|
||
|
||
result = await client.get_historical_weather(lat, lon, start_date, end_date)
|
||
|
||
assert isinstance(result, list), f"Result should be list for {days} days"
|
||
# Note: Actual count may vary due to chunking and data availability
|
||
assert len(result) >= 0, f"Should return non-negative count for {days} days"
|
||
|
||
if result:
|
||
# Check date ordering
|
||
dates = [r['date'] for r in result if 'date' in r]
|
||
if len(dates) > 1:
|
||
assert dates == sorted(dates), "Historical dates should be in chronological order"
|
||
|
||
print(f"✅ Historical date ranges test passed")
|
||
|
||
async def test_get_historical_weather_chunking(self, client, madrid_coords):
|
||
"""Test historical weather data chunking for large date ranges"""
|
||
lat, lon = madrid_coords
|
||
end_date = datetime.now()
|
||
start_date = end_date - timedelta(days=65) # More than 30 days to trigger chunking
|
||
|
||
with patch.object(client, '_fetch_historical_chunk', new_callable=AsyncMock) as mock_chunk:
|
||
mock_chunk.return_value = [] # Empty chunks
|
||
|
||
result = await client.get_historical_weather(lat, lon, start_date, end_date)
|
||
|
||
# Should have called chunking at least twice (65 days > 30 day limit)
|
||
assert mock_chunk.call_count >= 2, "Should chunk large date ranges"
|
||
|
||
print(f"✅ Historical chunking test passed - {mock_chunk.call_count} chunks")
|
||
|
||
# ================================================================
|
||
# COMPONENT TESTS
|
||
# ================================================================
|
||
@pytest.mark.skip_asyncio
|
||
def test_weather_data_parser(self):
|
||
"""Test WeatherDataParser functionality"""
|
||
parser = WeatherDataParser()
|
||
|
||
# Test safe_float
|
||
assert parser.safe_float("15.5", 0.0) == 15.5
|
||
assert parser.safe_float(None, 10.0) == 10.0
|
||
assert parser.safe_float("invalid", 5.0) == 5.0
|
||
assert parser.safe_float(20) == 20.0
|
||
|
||
# Test extract_temperature_value
|
||
assert parser.extract_temperature_value(25.5) == 25.5
|
||
assert parser.extract_temperature_value("20.0") == 20.0
|
||
assert parser.extract_temperature_value({"valor": 18.5}) == 18.5
|
||
assert parser.extract_temperature_value([{"valor": 22.0}]) == 22.0
|
||
assert parser.extract_temperature_value(None) is None
|
||
|
||
# Test generate_weather_description
|
||
assert "Lluvioso" in parser.generate_weather_description(20, 6.0, 60)
|
||
assert "Nuboso con lluvia" in parser.generate_weather_description(20, 1.0, 60)
|
||
assert "Nuboso" in parser.generate_weather_description(20, 0, 85)
|
||
assert "Soleado y cálido" in parser.generate_weather_description(30, 0, 60)
|
||
assert "Frío" in parser.generate_weather_description(2, 0, 60)
|
||
|
||
print(f"✅ WeatherDataParser tests passed")
|
||
|
||
@pytest.mark.skip_asyncio
|
||
def test_synthetic_weather_generator(self):
|
||
"""Test SyntheticWeatherGenerator functionality"""
|
||
generator = SyntheticWeatherGenerator()
|
||
|
||
# Test current weather generation
|
||
current = generator.generate_current_weather()
|
||
|
||
assert isinstance(current, dict), "Should return dictionary"
|
||
assert 'temperature' in current, "Should have temperature"
|
||
assert 'precipitation' in current, "Should have precipitation"
|
||
assert current['source'] == WeatherSource.SYNTHETIC.value, "Should be synthetic source"
|
||
assert isinstance(current['date'], datetime), "Should have datetime"
|
||
|
||
# Test forecast generation
|
||
forecast = generator.generate_forecast_sync(5)
|
||
|
||
assert isinstance(forecast, list), "Should return list"
|
||
assert len(forecast) == 5, "Should return requested days"
|
||
assert all('forecast_date' in day for day in forecast), "All days should have forecast_date"
|
||
assert all(day['source'] == WeatherSource.SYNTHETIC.value for day in forecast), "All should be synthetic"
|
||
|
||
# Test historical generation
|
||
end_date = datetime.now()
|
||
start_date = end_date - timedelta(days=7)
|
||
historical = generator.generate_historical_data(start_date, end_date)
|
||
|
||
assert isinstance(historical, list), "Should return list"
|
||
assert len(historical) == 8, "Should return 8 days (inclusive)"
|
||
assert all('date' in day for day in historical), "All days should have date"
|
||
assert all(day['source'] == WeatherSource.SYNTHETIC.value for day in historical), "All should be synthetic"
|
||
|
||
print(f"✅ SyntheticWeatherGenerator tests passed")
|
||
|
||
@pytest.mark.skip_asyncio
|
||
def test_location_service(self):
|
||
"""Test LocationService functionality"""
|
||
# Test distance calculation
|
||
madrid_center = (40.4168, -3.7038)
|
||
madrid_north = (40.4677, -3.5552)
|
||
|
||
distance = LocationService.calculate_distance(
|
||
madrid_center[0], madrid_center[1],
|
||
madrid_north[0], madrid_north[1]
|
||
)
|
||
|
||
assert isinstance(distance, float), "Distance should be float"
|
||
assert 0 < distance < 50, "Distance should be reasonable for Madrid area"
|
||
|
||
# Test nearest station finding
|
||
station_id = LocationService.find_nearest_station(madrid_center[0], madrid_center[1])
|
||
|
||
assert station_id is not None, "Should find a station"
|
||
assert station_id in [station.id for station in AEMETConstants.MADRID_STATIONS], "Should be valid station"
|
||
|
||
# Test municipality code
|
||
municipality = LocationService.get_municipality_code(madrid_center[0], madrid_center[1])
|
||
assert municipality == AEMETConstants.MADRID_MUNICIPALITY_CODE, "Should return Madrid code"
|
||
|
||
# Test outside Madrid
|
||
outside_madrid = LocationService.get_municipality_code(41.0, -4.0) # Outside bounds
|
||
assert outside_madrid is None, "Should return None for outside Madrid"
|
||
|
||
print(f"✅ LocationService tests passed")
|
||
|
||
@pytest.mark.skip_asyncio
|
||
def test_constants_and_enums(self):
|
||
"""Test constants and enum definitions"""
|
||
# Test WeatherSource enum
|
||
assert WeatherSource.AEMET.value == "aemet"
|
||
assert WeatherSource.SYNTHETIC.value == "synthetic"
|
||
assert WeatherSource.DEFAULT.value == "default"
|
||
|
||
# Test GeographicBounds
|
||
bounds = AEMETConstants.MADRID_BOUNDS
|
||
assert bounds.contains(40.4168, -3.7038), "Should contain Madrid center"
|
||
assert not bounds.contains(41.0, -4.0), "Should not contain coordinates outside Madrid"
|
||
|
||
# Test WeatherStation
|
||
station = AEMETConstants.MADRID_STATIONS[0]
|
||
assert isinstance(station, WeatherStation), "Should be WeatherStation instance"
|
||
assert station.id is not None, "Station should have ID"
|
||
assert station.name is not None, "Station should have name"
|
||
|
||
print(f"✅ Constants and enums tests passed")
|
||
|
||
# ================================================================
|
||
# ERROR HANDLING TESTS
|
||
# ================================================================
|
||
|
||
async def test_api_error_handling(self, client, madrid_coords):
|
||
"""Test handling of various API errors"""
|
||
lat, lon = madrid_coords
|
||
|
||
# Test network error
|
||
with patch.object(client, '_get', side_effect=Exception("Network error")):
|
||
result = await client.get_current_weather(lat, lon)
|
||
assert result['source'] == WeatherSource.SYNTHETIC.value, "Should fallback on network error"
|
||
|
||
# Test invalid API response
|
||
with patch.object(client, '_get', new_callable=AsyncMock) as mock_get:
|
||
mock_get.return_value = {"error": "Invalid API key"}
|
||
result = await client.get_current_weather(lat, lon)
|
||
assert result['source'] == WeatherSource.SYNTHETIC.value, "Should fallback on API error"
|
||
|
||
# Test malformed data
|
||
with patch.object(client, '_get', new_callable=AsyncMock) as mock_get, \
|
||
patch.object(client, '_fetch_from_url', new_callable=AsyncMock) as mock_fetch:
|
||
|
||
mock_get.return_value = {"datos": "http://example.com"}
|
||
mock_fetch.return_value = [{"invalid": "data"}] # Missing expected fields
|
||
|
||
result = await client.get_current_weather(lat, lon)
|
||
assert result is not None, "Should handle malformed data gracefully"
|
||
|
||
print(f"✅ API error handling tests passed")
|
||
|
||
async def test_timeout_handling(self, client, madrid_coords):
|
||
"""Test timeout handling"""
|
||
lat, lon = madrid_coords
|
||
|
||
with patch.object(client, '_get', side_effect=asyncio.TimeoutError("Request timeout")):
|
||
result = await client.get_current_weather(lat, lon)
|
||
assert result['source'] == WeatherSource.SYNTHETIC.value, "Should fallback on timeout"
|
||
|
||
print(f"✅ Timeout handling test passed")
|
||
|
||
# ================================================================
|
||
# PERFORMANCE TESTS
|
||
# ================================================================
|
||
|
||
async def test_performance_current_weather(self, client, madrid_coords):
|
||
"""Test current weather performance"""
|
||
lat, lon = madrid_coords
|
||
|
||
start_time = datetime.now()
|
||
result = await client.get_current_weather(lat, lon)
|
||
execution_time = (datetime.now() - start_time).total_seconds() * 1000
|
||
|
||
assert result is not None, "Should return weather data"
|
||
assert execution_time < 5000, "Should execute within 5 seconds"
|
||
|
||
print(f"✅ Current weather performance test passed - {execution_time:.0f}ms")
|
||
|
||
async def test_performance_forecast(self, client, madrid_coords):
|
||
"""Test forecast performance"""
|
||
lat, lon = madrid_coords
|
||
|
||
start_time = datetime.now()
|
||
result = await client.get_forecast(lat, lon, 7)
|
||
execution_time = (datetime.now() - start_time).total_seconds() * 1000
|
||
|
||
assert isinstance(result, list), "Should return forecast list"
|
||
assert len(result) == 7, "Should return 7 days"
|
||
assert execution_time < 5000, "Should execute within 5 seconds"
|
||
|
||
print(f"✅ Forecast performance test passed - {execution_time:.0f}ms")
|
||
|
||
async def test_performance_historical(self, client, madrid_coords):
|
||
"""Test historical weather performance"""
|
||
lat, lon = madrid_coords
|
||
end_date = datetime.now()
|
||
start_date = end_date - timedelta(days=7)
|
||
|
||
start_time = datetime.now()
|
||
result = await client.get_historical_weather(lat, lon, start_date, end_date)
|
||
execution_time = (datetime.now() - start_time).total_seconds() * 1000
|
||
|
||
assert isinstance(result, list), "Should return historical list"
|
||
assert execution_time < 10000, "Should execute within 10 seconds (allowing for API calls)"
|
||
|
||
print(f"✅ Historical performance test passed - {execution_time:.0f}ms")
|
||
|
||
# ================================================================
|
||
# INTEGRATION TESTS
|
||
# ================================================================
|
||
|
||
async def test_real_aemet_api_access(self, client, madrid_coords):
|
||
"""Test actual AEMET API access (if API key is available)"""
|
||
lat, lon = madrid_coords
|
||
|
||
try:
|
||
# Test current weather
|
||
current_result = await client.get_current_weather(lat, lon)
|
||
assert current_result is not None, "Should get current weather"
|
||
|
||
if current_result['source'] == WeatherSource.AEMET.value:
|
||
print(f"🎉 SUCCESS: Got real AEMET current weather data!")
|
||
print(f" Temperature: {current_result['temperature']}°C")
|
||
print(f" Description: {current_result['description']}")
|
||
else:
|
||
print(f"ℹ️ Got synthetic current weather (API key may not be configured)")
|
||
|
||
# Test forecast
|
||
forecast_result = await client.get_forecast(lat, lon, 3)
|
||
assert len(forecast_result) == 3, "Should get 3-day forecast"
|
||
|
||
if forecast_result[0]['source'] == WeatherSource.AEMET.value:
|
||
print(f"🎉 SUCCESS: Got real AEMET forecast data!")
|
||
print(f" Tomorrow: {forecast_result[1]['temperature']}°C - {forecast_result[1]['description']}")
|
||
else:
|
||
print(f"ℹ️ Got synthetic forecast (API key may not be configured)")
|
||
|
||
# Test historical (last week)
|
||
end_date = datetime.now()
|
||
start_date = end_date - timedelta(days=7)
|
||
historical_result = await client.get_historical_weather(lat, lon, start_date, end_date)
|
||
|
||
assert isinstance(historical_result, list), "Should get historical data"
|
||
|
||
real_historical = [r for r in historical_result if r['source'] == WeatherSource.AEMET.value]
|
||
if real_historical:
|
||
print(f"🎉 SUCCESS: Got real AEMET historical data!")
|
||
print(f" Records: {len(real_historical)} real + {len(historical_result) - len(real_historical)} synthetic")
|
||
else:
|
||
print(f"ℹ️ Got synthetic historical data (API limitations or key issues)")
|
||
|
||
print(f"✅ Real AEMET API integration test completed")
|
||
|
||
except Exception as e:
|
||
print(f"⚠️ AEMET API integration test failed: {e}")
|
||
# This is acceptable if API key is not configured
|
||
|
||
async def test_data_consistency(self, client, madrid_coords):
|
||
"""Test data consistency across different methods"""
|
||
lat, lon = madrid_coords
|
||
|
||
# Get current weather
|
||
current = await client.get_current_weather(lat, lon)
|
||
|
||
# Get today's forecast
|
||
forecast = await client.get_forecast(lat, lon, 1)
|
||
today_forecast = forecast[0] if forecast else None
|
||
|
||
if current and today_forecast:
|
||
# Temperature should be somewhat consistent
|
||
temp_diff = abs(current['temperature'] - today_forecast['temperature'])
|
||
assert temp_diff < 15, "Current and forecast temperature should be reasonably consistent"
|
||
|
||
# Both should use same source type preference
|
||
if current['source'] == WeatherSource.AEMET.value:
|
||
assert today_forecast['source'] == WeatherSource.AEMET.value, "Should use consistent data sources"
|
||
|
||
print(f"✅ Data consistency test passed")
|
||
|
||
|
||
# ================================================================
|
||
# STANDALONE TEST FUNCTIONS
|
||
# ================================================================
|
||
|
||
async def run_manual_test():
|
||
"""Manual test function that can be run directly"""
|
||
print("="*60)
|
||
print("AEMET WEATHER CLIENT TEST - JULY 2025")
|
||
print("="*60)
|
||
|
||
client = AEMETClient()
|
||
madrid_lat, madrid_lon = 40.4168, -3.7038 # Madrid center
|
||
|
||
print(f"\n=== Testing Madrid Weather ({madrid_lat}, {madrid_lon}) ===")
|
||
|
||
# Test current weather
|
||
print(f"\n1. Testing Current Weather...")
|
||
current = await client.get_current_weather(madrid_lat, madrid_lon)
|
||
if current:
|
||
print(f" Temperature: {current['temperature']}°C")
|
||
print(f" Description: {current['description']}")
|
||
print(f" Humidity: {current['humidity']}%")
|
||
print(f" Wind: {current['wind_speed']} km/h")
|
||
print(f" Source: {current['source']}")
|
||
|
||
# Test forecast
|
||
print(f"\n2. Testing 7-Day Forecast...")
|
||
forecast = await client.get_forecast(madrid_lat, madrid_lon, 7)
|
||
if forecast:
|
||
print(f" Forecast days: {len(forecast)}")
|
||
print(f" Tomorrow: {forecast[1]['temperature']}°C - {forecast[1]['description']}")
|
||
print(f" Source: {forecast[0]['source']}")
|
||
|
||
# Test historical
|
||
print(f"\n3. Testing Historical Weather (last 7 days)...")
|
||
end_date = datetime.now()
|
||
start_date = end_date - timedelta(days=7)
|
||
historical = await client.get_historical_weather(madrid_lat, madrid_lon, start_date, end_date)
|
||
if historical:
|
||
print(f" Historical records: {len(historical)}")
|
||
if historical:
|
||
real_count = len([r for r in historical if r['source'] == WeatherSource.AEMET.value])
|
||
synthetic_count = len(historical) - real_count
|
||
print(f" Real data: {real_count}, Synthetic: {synthetic_count}")
|
||
|
||
print(f"\n✅ Manual test completed!")
|
||
|
||
|
||
if __name__ == "__main__":
|
||
# If run directly, execute manual test
|
||
asyncio.run(run_manual_test()) |