653 lines
22 KiB
Python
653 lines
22 KiB
Python
# ================================================================
|
||
# services/data/tests/conftest.py - AEMET Test Configuration
|
||
# ================================================================
|
||
"""
|
||
Test configuration and fixtures for AEMET weather API client tests
|
||
Provides shared fixtures, mock data, and test utilities
|
||
"""
|
||
|
||
import pytest
|
||
import asyncio
|
||
from datetime import datetime, timedelta
|
||
from unittest.mock import Mock, AsyncMock, patch
|
||
from typing import Dict, List, Any, Generator
|
||
import os
|
||
|
||
# Import the classes we're testing
|
||
from app.external.aemet import (
|
||
AEMETClient,
|
||
WeatherDataParser,
|
||
SyntheticWeatherGenerator,
|
||
LocationService,
|
||
WeatherSource
|
||
)
|
||
|
||
|
||
# ================================================================
|
||
# PYTEST CONFIGURATION
|
||
# ================================================================
|
||
|
||
@pytest.fixture(scope="session")
|
||
def event_loop():
|
||
"""Create an instance of the default event loop for the test session."""
|
||
loop = asyncio.get_event_loop_policy().new_event_loop()
|
||
yield loop
|
||
loop.close()
|
||
|
||
|
||
# ================================================================
|
||
# CLIENT AND SERVICE FIXTURES
|
||
# ================================================================
|
||
|
||
@pytest.fixture
|
||
def aemet_client():
|
||
"""Create AEMET client instance for testing"""
|
||
return AEMETClient()
|
||
|
||
|
||
@pytest.fixture
|
||
def weather_parser():
|
||
"""Create WeatherDataParser instance for testing"""
|
||
return WeatherDataParser()
|
||
|
||
|
||
@pytest.fixture
|
||
def synthetic_generator():
|
||
"""Create SyntheticWeatherGenerator instance for testing"""
|
||
return SyntheticWeatherGenerator()
|
||
|
||
|
||
@pytest.fixture
|
||
def location_service():
|
||
"""Create LocationService instance for testing"""
|
||
return LocationService()
|
||
|
||
|
||
# ================================================================
|
||
# COORDINATE AND LOCATION FIXTURES
|
||
# ================================================================
|
||
|
||
@pytest.fixture
|
||
def madrid_coords():
|
||
"""Standard Madrid coordinates for testing"""
|
||
return (40.4168, -3.7038) # Madrid city center
|
||
|
||
|
||
@pytest.fixture
|
||
def madrid_coords_variants():
|
||
"""Various Madrid area coordinates for testing"""
|
||
return {
|
||
"center": (40.4168, -3.7038), # Madrid center
|
||
"north": (40.4677, -3.5552), # Madrid north (near station)
|
||
"south": (40.2987, -3.7216), # Madrid south (near station)
|
||
"east": (40.4200, -3.6500), # Madrid east
|
||
"west": (40.4100, -3.7500), # Madrid west
|
||
}
|
||
|
||
|
||
@pytest.fixture
|
||
def invalid_coords():
|
||
"""Invalid coordinates for error testing"""
|
||
return [
|
||
(200, 200), # Out of range
|
||
(-200, -200), # Out of range
|
||
(0, 0), # Not in Madrid area
|
||
(50, 10), # Europe but not Madrid
|
||
(None, None), # None values
|
||
]
|
||
|
||
|
||
# ================================================================
|
||
# DATE AND TIME FIXTURES
|
||
# ================================================================
|
||
|
||
@pytest.fixture
|
||
def test_dates():
|
||
"""Standard date ranges for testing"""
|
||
now = datetime.now()
|
||
return {
|
||
"now": now,
|
||
"yesterday": now - timedelta(days=1),
|
||
"last_week": now - timedelta(days=7),
|
||
"last_month": now - timedelta(days=30),
|
||
"last_quarter": now - timedelta(days=90),
|
||
"one_year_ago": now - timedelta(days=365),
|
||
}
|
||
|
||
|
||
@pytest.fixture
|
||
def historical_date_ranges():
|
||
"""Historical date ranges for testing"""
|
||
end_date = datetime.now()
|
||
return {
|
||
"one_day": {
|
||
"start": end_date - timedelta(days=1),
|
||
"end": end_date,
|
||
"expected_days": 1
|
||
},
|
||
"one_week": {
|
||
"start": end_date - timedelta(days=7),
|
||
"end": end_date,
|
||
"expected_days": 7
|
||
},
|
||
"one_month": {
|
||
"start": end_date - timedelta(days=30),
|
||
"end": end_date,
|
||
"expected_days": 30
|
||
},
|
||
"large_range": {
|
||
"start": end_date - timedelta(days=65),
|
||
"end": end_date,
|
||
"expected_days": 65
|
||
}
|
||
}
|
||
|
||
|
||
# ================================================================
|
||
# MOCK API RESPONSE FIXTURES
|
||
# ================================================================
|
||
|
||
@pytest.fixture
|
||
def mock_aemet_api_response():
|
||
"""Mock AEMET API initial response structure"""
|
||
return {
|
||
"datos": "https://opendata.aemet.es/opendata/sh/12345abcdef",
|
||
"metadatos": "https://opendata.aemet.es/opendata/sh/metadata123"
|
||
}
|
||
|
||
|
||
@pytest.fixture
|
||
def mock_aemet_error_response():
|
||
"""Mock AEMET API error response"""
|
||
return {
|
||
"descripcion": "Error en la petición",
|
||
"estado": 404
|
||
}
|
||
|
||
|
||
# ================================================================
|
||
# WEATHER DATA FIXTURES
|
||
# ================================================================
|
||
|
||
@pytest.fixture
|
||
def mock_current_weather_data():
|
||
"""Mock current weather data from AEMET API"""
|
||
return {
|
||
"idema": "3195", # Station ID
|
||
"ubi": "MADRID", # Location
|
||
"fint": "2025-07-24T14:00:00", # Observation time
|
||
"ta": 18.5, # Temperature (°C)
|
||
"tamin": 12.3, # Min temperature
|
||
"tamax": 25.7, # Max temperature
|
||
"hr": 65.0, # Humidity (%)
|
||
"prec": 0.0, # Precipitation (mm)
|
||
"vv": 12.0, # Wind speed (km/h)
|
||
"dv": 180, # Wind direction (degrees)
|
||
"pres": 1015.2, # Pressure (hPa)
|
||
"presMax": 1018.5, # Max pressure
|
||
"presMin": 1012.1, # Min pressure
|
||
"descripcion": "Despejado" # Description
|
||
}
|
||
|
||
|
||
@pytest.fixture
|
||
def mock_forecast_data():
|
||
"""Mock forecast data from AEMET API"""
|
||
return [{
|
||
"origen": {
|
||
"productor": "Agencia Estatal de Meteorología - AEMET"
|
||
},
|
||
"elaborado": "2025-07-24T12:00:00UTC",
|
||
"nombre": "Madrid",
|
||
"provincia": "Madrid",
|
||
"prediccion": {
|
||
"dia": [
|
||
{
|
||
"fecha": "2025-07-25T00:00:00",
|
||
"temperatura": {
|
||
"maxima": 28,
|
||
"minima": 15,
|
||
"dato": [
|
||
{"value": 15, "hora": 6},
|
||
{"value": 28, "hora": 15}
|
||
]
|
||
},
|
||
"sensTermica": {
|
||
"maxima": 30,
|
||
"minima": 16
|
||
},
|
||
"humedadRelativa": {
|
||
"maxima": 85,
|
||
"minima": 45,
|
||
"dato": [
|
||
{"value": 85, "hora": 6},
|
||
{"value": 45, "hora": 15}
|
||
]
|
||
},
|
||
"probPrecipitacion": [
|
||
{"value": 10, "periodo": "00-24"}
|
||
],
|
||
"viento": [
|
||
{
|
||
"direccion": ["N"],
|
||
"velocidad": [15],
|
||
"periodo": "00-24"
|
||
}
|
||
],
|
||
"estadoCielo": [
|
||
{
|
||
"value": "11",
|
||
"descripcion": "Despejado",
|
||
"periodo": "00-24"
|
||
}
|
||
]
|
||
},
|
||
{
|
||
"fecha": "2025-07-26T00:00:00",
|
||
"temperatura": {
|
||
"maxima": 30,
|
||
"minima": 17
|
||
},
|
||
"probPrecipitacion": [
|
||
{"value": 5, "periodo": "00-24"}
|
||
],
|
||
"viento": [
|
||
{
|
||
"direccion": ["NE"],
|
||
"velocidad": [10],
|
||
"periodo": "00-24"
|
||
}
|
||
]
|
||
}
|
||
]
|
||
}
|
||
}]
|
||
|
||
|
||
@pytest.fixture
|
||
def mock_historical_data():
|
||
"""Mock historical weather data from AEMET API"""
|
||
return [
|
||
{
|
||
"indicativo": "3195",
|
||
"nombre": "MADRID",
|
||
"fecha": "2025-07-20",
|
||
"tmax": 25.2,
|
||
"horatmax": "1530",
|
||
"tmin": 14.8,
|
||
"horatmin": "0630",
|
||
"tmed": 20.0,
|
||
"prec": 0.0,
|
||
"racha": 25.0,
|
||
"horaracha": "1445",
|
||
"sol": 8.5,
|
||
"presMax": 1018.5,
|
||
"horaPresMax": "1000",
|
||
"presMin": 1012.3,
|
||
"horaPresMin": "1700",
|
||
"hr": 58,
|
||
"velmedia": 8.5,
|
||
"dir": "180"
|
||
},
|
||
{
|
||
"indicativo": "3195",
|
||
"nombre": "MADRID",
|
||
"fecha": "2025-07-21",
|
||
"tmax": 27.1,
|
||
"horatmax": "1615",
|
||
"tmin": 16.2,
|
||
"horatmin": "0700",
|
||
"tmed": 21.6,
|
||
"prec": 2.5,
|
||
"racha": 30.0,
|
||
"horaracha": "1330",
|
||
"sol": 6.2,
|
||
"presMax": 1015.8,
|
||
"horaPresMax": "0930",
|
||
"presMin": 1010.1,
|
||
"horaPresMin": "1800",
|
||
"hr": 72,
|
||
"velmedia": 12.0,
|
||
"dir": "225"
|
||
},
|
||
{
|
||
"indicativo": "3195",
|
||
"nombre": "MADRID",
|
||
"fecha": "2025-07-22",
|
||
"tmax": 23.8,
|
||
"horatmax": "1500",
|
||
"tmin": 13.5,
|
||
"horatmin": "0615",
|
||
"tmed": 18.7,
|
||
"prec": 0.2,
|
||
"racha": 22.0,
|
||
"horaracha": "1200",
|
||
"sol": 7.8,
|
||
"presMax": 1020.2,
|
||
"horaPresMax": "1100",
|
||
"presMin": 1014.7,
|
||
"horaPresMin": "1900",
|
||
"hr": 63,
|
||
"velmedia": 9.2,
|
||
"dir": "270"
|
||
}
|
||
]
|
||
|
||
|
||
# ================================================================
|
||
# EXPECTED RESULT FIXTURES
|
||
# ================================================================
|
||
|
||
@pytest.fixture
|
||
def expected_current_weather_structure():
|
||
"""Expected structure for current weather results"""
|
||
return {
|
||
"required_fields": [
|
||
"date", "temperature", "precipitation", "humidity",
|
||
"wind_speed", "pressure", "description", "source"
|
||
],
|
||
"field_types": {
|
||
"date": datetime,
|
||
"temperature": (int, float),
|
||
"precipitation": (int, float),
|
||
"humidity": (int, float),
|
||
"wind_speed": (int, float),
|
||
"pressure": (int, float),
|
||
"description": str,
|
||
"source": str
|
||
},
|
||
"valid_ranges": {
|
||
"temperature": (-30, 50),
|
||
"precipitation": (0, 200),
|
||
"humidity": (0, 100),
|
||
"wind_speed": (0, 200),
|
||
"pressure": (900, 1100)
|
||
}
|
||
}
|
||
|
||
|
||
@pytest.fixture
|
||
def expected_forecast_structure():
|
||
"""Expected structure for forecast results"""
|
||
return {
|
||
"required_fields": [
|
||
"forecast_date", "generated_at", "temperature", "precipitation",
|
||
"humidity", "wind_speed", "description", "source"
|
||
],
|
||
"field_types": {
|
||
"forecast_date": datetime,
|
||
"generated_at": datetime,
|
||
"temperature": (int, float),
|
||
"precipitation": (int, float),
|
||
"humidity": (int, float),
|
||
"wind_speed": (int, float),
|
||
"description": str,
|
||
"source": str
|
||
}
|
||
}
|
||
|
||
|
||
@pytest.fixture
|
||
def expected_historical_structure():
|
||
"""Expected structure for historical weather results"""
|
||
return {
|
||
"required_fields": [
|
||
"date", "temperature", "precipitation", "humidity",
|
||
"wind_speed", "pressure", "description", "source"
|
||
],
|
||
"field_types": {
|
||
"date": datetime,
|
||
"temperature": (int, float, type(None)),
|
||
"precipitation": (int, float),
|
||
"humidity": (int, float, type(None)),
|
||
"wind_speed": (int, float, type(None)),
|
||
"pressure": (int, float, type(None)),
|
||
"description": str,
|
||
"source": str
|
||
}
|
||
}
|
||
|
||
|
||
# ================================================================
|
||
# MOCK AND PATCH FIXTURES
|
||
# ================================================================
|
||
|
||
@pytest.fixture
|
||
def mock_successful_api_calls():
|
||
"""Mock successful AEMET API calls"""
|
||
def _mock_api_calls(client, response_data, fetch_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 = response_data
|
||
mock_fetch.return_value = fetch_data
|
||
|
||
return mock_get, mock_fetch
|
||
|
||
return _mock_api_calls
|
||
|
||
|
||
@pytest.fixture
|
||
def mock_failed_api_calls():
|
||
"""Mock failed AEMET API calls"""
|
||
def _mock_failed_calls(client, error_type="network"):
|
||
if error_type == "network":
|
||
return patch.object(client, '_get', side_effect=Exception("Network error"))
|
||
elif error_type == "timeout":
|
||
return patch.object(client, '_get', side_effect=asyncio.TimeoutError("Request timeout"))
|
||
elif error_type == "invalid_response":
|
||
return patch.object(client, '_get', new_callable=AsyncMock, return_value=None)
|
||
else:
|
||
return patch.object(client, '_get', new_callable=AsyncMock, return_value={"error": "API error"})
|
||
|
||
return _mock_failed_calls
|
||
|
||
|
||
# ================================================================
|
||
# VALIDATION HELPER FIXTURES
|
||
# ================================================================
|
||
|
||
@pytest.fixture
|
||
def weather_data_validator():
|
||
"""Weather data validation helper functions"""
|
||
|
||
def validate_weather_record(record: Dict[str, Any], expected_structure: Dict[str, Any]) -> None:
|
||
"""Validate a weather record against expected structure"""
|
||
# Check required fields
|
||
for field in expected_structure["required_fields"]:
|
||
assert field in record, f"Missing required field: {field}"
|
||
|
||
# Check field types
|
||
for field, expected_type in expected_structure["field_types"].items():
|
||
if field in record and record[field] is not None:
|
||
assert isinstance(record[field], expected_type), f"Field {field} has wrong type: {type(record[field])}"
|
||
|
||
# Check valid ranges where applicable
|
||
if "valid_ranges" in expected_structure:
|
||
for field, (min_val, max_val) in expected_structure["valid_ranges"].items():
|
||
if field in record and record[field] is not None:
|
||
value = record[field]
|
||
assert min_val <= value <= max_val, f"Field {field} value {value} outside valid range [{min_val}, {max_val}]"
|
||
|
||
def validate_weather_list(records: List[Dict[str, Any]], expected_structure: Dict[str, Any]) -> None:
|
||
"""Validate a list of weather records"""
|
||
assert isinstance(records, list), "Records should be a list"
|
||
|
||
for i, record in enumerate(records):
|
||
try:
|
||
validate_weather_record(record, expected_structure)
|
||
except AssertionError as e:
|
||
raise AssertionError(f"Record {i} validation failed: {e}")
|
||
|
||
def validate_date_sequence(records: List[Dict[str, Any]], date_field: str = "date") -> None:
|
||
"""Validate that dates in records are in chronological order"""
|
||
dates = [r[date_field] for r in records if date_field in r and r[date_field] is not None]
|
||
|
||
if len(dates) > 1:
|
||
assert dates == sorted(dates), "Dates should be in chronological order"
|
||
|
||
return {
|
||
"validate_record": validate_weather_record,
|
||
"validate_list": validate_weather_list,
|
||
"validate_dates": validate_date_sequence
|
||
}
|
||
|
||
|
||
# ================================================================
|
||
# PERFORMANCE TESTING FIXTURES
|
||
# ================================================================
|
||
|
||
@pytest.fixture
|
||
def performance_tracker():
|
||
"""Performance tracking utilities for tests"""
|
||
|
||
class PerformanceTracker:
|
||
def __init__(self):
|
||
self.start_time = None
|
||
self.measurements = {}
|
||
|
||
def start(self, operation_name: str = "default"):
|
||
self.start_time = datetime.now()
|
||
self.operation_name = operation_name
|
||
|
||
def stop(self) -> float:
|
||
if self.start_time:
|
||
duration = (datetime.now() - self.start_time).total_seconds() * 1000
|
||
self.measurements[self.operation_name] = duration
|
||
return duration
|
||
return 0.0
|
||
|
||
def assert_performance(self, max_duration_ms: float, operation_name: str = "default"):
|
||
duration = self.measurements.get(operation_name, float('inf'))
|
||
assert duration <= max_duration_ms, f"Operation {operation_name} took {duration:.0f}ms, expected <= {max_duration_ms}ms"
|
||
|
||
return PerformanceTracker()
|
||
|
||
|
||
# ================================================================
|
||
# INTEGRATION TEST FIXTURES
|
||
# ================================================================
|
||
|
||
@pytest.fixture
|
||
def integration_test_config():
|
||
"""Configuration for integration tests"""
|
||
return {
|
||
"api_timeout_ms": 5000,
|
||
"max_retries": 3,
|
||
"test_api_key": os.getenv("AEMET_API_KEY_TEST", ""),
|
||
"skip_real_api_tests": os.getenv("SKIP_REAL_API_TESTS", "false").lower() == "true",
|
||
"madrid_test_coords": (40.4168, -3.7038),
|
||
"performance_thresholds": {
|
||
"current_weather_ms": 5000,
|
||
"forecast_ms": 5000,
|
||
"historical_ms": 10000
|
||
}
|
||
}
|
||
|
||
|
||
# ================================================================
|
||
# TEST REPORTING FIXTURES
|
||
# ================================================================
|
||
|
||
@pytest.fixture
|
||
def test_reporter():
|
||
"""Test reporting utilities"""
|
||
|
||
class TestReporter:
|
||
def __init__(self):
|
||
self.results = []
|
||
|
||
def log_success(self, test_name: str, details: str = ""):
|
||
message = f"✅ {test_name}"
|
||
if details:
|
||
message += f" - {details}"
|
||
print(message)
|
||
self.results.append({"test": test_name, "status": "PASS", "details": details})
|
||
|
||
def log_failure(self, test_name: str, error: str = ""):
|
||
message = f"❌ {test_name}"
|
||
if error:
|
||
message += f" - {error}"
|
||
print(message)
|
||
self.results.append({"test": test_name, "status": "FAIL", "error": error})
|
||
|
||
def log_info(self, test_name: str, info: str = ""):
|
||
message = f"ℹ️ {test_name}"
|
||
if info:
|
||
message += f" - {info}"
|
||
print(message)
|
||
self.results.append({"test": test_name, "status": "INFO", "info": info})
|
||
|
||
def summary(self):
|
||
passed = len([r for r in self.results if r["status"] == "PASS"])
|
||
failed = len([r for r in self.results if r["status"] == "FAIL"])
|
||
print(f"\n📊 Test Summary: {passed} passed, {failed} failed")
|
||
return passed, failed
|
||
|
||
return TestReporter()
|
||
|
||
|
||
# ================================================================
|
||
# CLEANUP FIXTURES
|
||
# ================================================================
|
||
|
||
@pytest.fixture(autouse=True)
|
||
def cleanup_after_test():
|
||
"""Automatic cleanup after each test"""
|
||
yield
|
||
# Add any cleanup logic here
|
||
# For example, clearing caches, resetting global state, etc.
|
||
pass
|
||
|
||
|
||
# ================================================================
|
||
# HELPER FUNCTIONS
|
||
# ================================================================
|
||
|
||
def assert_weather_data_structure(data: Dict[str, Any], data_type: str = "current"):
|
||
"""Assert that weather data has the correct structure"""
|
||
if data_type == "current":
|
||
required_fields = ["date", "temperature", "precipitation", "humidity", "wind_speed", "pressure", "description", "source"]
|
||
elif data_type == "forecast":
|
||
required_fields = ["forecast_date", "generated_at", "temperature", "precipitation", "humidity", "wind_speed", "description", "source"]
|
||
elif data_type == "historical":
|
||
required_fields = ["date", "temperature", "precipitation", "humidity", "wind_speed", "pressure", "description", "source"]
|
||
else:
|
||
raise ValueError(f"Unknown data type: {data_type}")
|
||
|
||
for field in required_fields:
|
||
assert field in data, f"Missing required field: {field}"
|
||
|
||
# Validate source
|
||
valid_sources = [WeatherSource.AEMET.value, WeatherSource.SYNTHETIC.value, WeatherSource.DEFAULT.value]
|
||
assert data["source"] in valid_sources, f"Invalid source: {data['source']}"
|
||
|
||
|
||
def assert_forecast_list_structure(forecast_list: List[Dict[str, Any]], expected_days: int):
|
||
"""Assert that forecast list has correct structure"""
|
||
assert isinstance(forecast_list, list), "Forecast should be a list"
|
||
assert len(forecast_list) == expected_days, f"Expected {expected_days} forecast days, got {len(forecast_list)}"
|
||
|
||
for i, day in enumerate(forecast_list):
|
||
assert_weather_data_structure(day, "forecast")
|
||
|
||
# Check date progression
|
||
if len(forecast_list) > 1:
|
||
for i in range(1, len(forecast_list)):
|
||
prev_date = forecast_list[i-1]["forecast_date"]
|
||
curr_date = forecast_list[i]["forecast_date"]
|
||
date_diff = (curr_date - prev_date).days
|
||
assert date_diff == 1, f"Forecast dates should be consecutive, got {date_diff} day difference"
|
||
|
||
|
||
def assert_historical_list_structure(historical_list: List[Dict[str, Any]]):
|
||
"""Assert that historical list has correct structure"""
|
||
assert isinstance(historical_list, list), "Historical data should be a list"
|
||
|
||
for i, record in enumerate(historical_list):
|
||
assert_weather_data_structure(record, "historical")
|
||
|
||
# Check date ordering
|
||
dates = [r["date"] for r in historical_list if "date" in r]
|
||
if len(dates) > 1:
|
||
assert dates == sorted(dates), "Historical dates should be in chronological order" |