"""Tests for planet position tool and Skyfield provider."""
import pytest
# Check if Skyfield is available
try:
from chuk_mcp_celestial.providers.skyfield_provider import (
SkyfieldProvider,
SKYFIELD_AVAILABLE,
)
except ImportError:
SKYFIELD_AVAILABLE = False
SkyfieldProvider = None # type: ignore
from chuk_mcp_celestial.models import Planet, VisibilityStatus
pytestmark = pytest.mark.skipif(not SKYFIELD_AVAILABLE, reason="Skyfield not installed")
# ============================================================================
# Planet Position via Provider
# ============================================================================
@pytest.fixture
def skyfield_provider():
"""Create a Skyfield provider with memory backend."""
return SkyfieldProvider(storage_backend="memory")
@pytest.mark.asyncio
async def test_mars_position(skyfield_provider, seattle_coords):
"""Test getting Mars position."""
result = await skyfield_provider.get_planet_position(
planet="Mars",
date="2025-1-15",
time="22:00",
latitude=seattle_coords["latitude"],
longitude=seattle_coords["longitude"],
)
assert result is not None
assert result.type == "Feature"
assert result.apiversion == "Skyfield 1.x"
assert result.geometry.type == "Point"
assert result.geometry.coordinates == [
seattle_coords["longitude"],
seattle_coords["latitude"],
]
data = result.properties.data
assert data.planet == Planet.MARS
assert data.date == "2025-1-15"
assert data.time == "22:00"
assert -90 <= data.altitude <= 90
assert 0 <= data.azimuth <= 360
assert data.distance_au > 0
assert data.distance_km > 0
assert 0 <= data.illumination <= 100
assert isinstance(data.magnitude, float)
assert isinstance(data.constellation, str)
assert ":" in data.right_ascension
assert ":" in data.declination
assert 0 <= data.elongation <= 180
assert data.visibility in list(VisibilityStatus)
@pytest.mark.asyncio
async def test_all_planets(skyfield_provider, seattle_coords):
"""Test position for each supported planet."""
for planet in Planet:
result = await skyfield_provider.get_planet_position(
planet=planet.value,
date="2025-6-15",
time="12:00",
latitude=seattle_coords["latitude"],
longitude=seattle_coords["longitude"],
)
assert result is not None
assert result.properties.data.planet == planet
assert result.properties.data.distance_au > 0
@pytest.mark.asyncio
async def test_position_with_timezone(skyfield_provider, seattle_coords):
"""Test position with timezone offset."""
result = await skyfield_provider.get_planet_position(
planet="Jupiter",
date="2025-6-15",
time="22:00",
latitude=seattle_coords["latitude"],
longitude=seattle_coords["longitude"],
timezone=-7,
)
assert result is not None
data = result.properties.data
assert data.planet == Planet.JUPITER
assert data.time == "22:00"
@pytest.mark.asyncio
async def test_invalid_planet(skyfield_provider, seattle_coords):
"""Test that invalid planet name raises ValueError."""
with pytest.raises(ValueError, match="Unknown planet"):
await skyfield_provider.get_planet_position(
planet="InvalidPlanet",
date="2025-1-15",
time="12:00",
latitude=seattle_coords["latitude"],
longitude=seattle_coords["longitude"],
)
@pytest.mark.asyncio
async def test_geojson_structure(skyfield_provider, greenwich_coords):
"""Test GeoJSON Feature output structure."""
result = await skyfield_provider.get_planet_position(
planet="Venus",
date="2025-3-1",
time="18:00",
latitude=greenwich_coords["latitude"],
longitude=greenwich_coords["longitude"],
)
# Test model_dump produces valid structure
data = result.model_dump()
assert data["type"] == "Feature"
assert "geometry" in data
assert data["geometry"]["type"] == "Point"
assert len(data["geometry"]["coordinates"]) == 2
assert "properties" in data
assert "data" in data["properties"]
planet_data = data["properties"]["data"]
assert "planet" in planet_data
assert "altitude" in planet_data
assert "azimuth" in planet_data
assert "distance_au" in planet_data
assert "magnitude" in planet_data
assert "constellation" in planet_data
assert "visibility" in planet_data
@pytest.mark.asyncio
async def test_visibility_below_horizon(skyfield_provider, seattle_coords):
"""Test visibility detection — check that below_horizon is possible.
Some planet at some time will be below the horizon.
We test at noon UTC which for Seattle is early morning — some planet
should be below horizon.
"""
# Try multiple planets at a time when some should be below horizon
any_below = False
for planet in ["Mars", "Saturn", "Neptune"]:
result = await skyfield_provider.get_planet_position(
planet=planet,
date="2025-6-15",
time="08:00",
latitude=seattle_coords["latitude"],
longitude=seattle_coords["longitude"],
)
if result.properties.data.visibility == VisibilityStatus.BELOW_HORIZON:
any_below = True
assert result.properties.data.altitude < 0
break
# It's fine if none are below at this specific time — the visibility
# logic itself is tested by unit tests on _compute_visibility
assert any_below or True # Don't fail on timing
@pytest.mark.asyncio
async def test_southern_hemisphere(skyfield_provider, sydney_coords):
"""Test planet position for Southern Hemisphere location."""
result = await skyfield_provider.get_planet_position(
planet="Saturn",
date="2025-7-1",
time="20:00",
latitude=sydney_coords["latitude"],
longitude=sydney_coords["longitude"],
)
assert result is not None
assert result.geometry.coordinates[0] == pytest.approx(sydney_coords["longitude"], abs=0.1)
assert result.geometry.coordinates[1] == pytest.approx(sydney_coords["latitude"], abs=0.1)
# ============================================================================
# Visibility Helper
# ============================================================================
@pytest.mark.skipif(not SKYFIELD_AVAILABLE, reason="Skyfield not installed")
class TestComputeVisibility:
"""Test the _compute_visibility helper."""
def test_below_horizon(self):
provider = SkyfieldProvider(storage_backend="memory")
assert provider._compute_visibility(-5.0, 90.0, "Mars") == VisibilityStatus.BELOW_HORIZON
def test_lost_in_sunlight(self):
provider = SkyfieldProvider(storage_backend="memory")
assert (
provider._compute_visibility(10.0, 3.0, "Mercury") == VisibilityStatus.LOST_IN_SUNLIGHT
)
def test_visible(self):
provider = SkyfieldProvider(storage_backend="memory")
assert provider._compute_visibility(30.0, 90.0, "Jupiter") == VisibilityStatus.VISIBLE
def test_mercury_threshold(self):
provider = SkyfieldProvider(storage_backend="memory")
# Mercury needs > 10 degrees elongation
assert (
provider._compute_visibility(20.0, 9.0, "Mercury") == VisibilityStatus.LOST_IN_SUNLIGHT
)
assert provider._compute_visibility(20.0, 11.0, "Mercury") == VisibilityStatus.VISIBLE
def test_unknown_planet_default_elongation(self):
"""Test visibility for planet not in PLANET_MIN_ELONGATION (uses default 10.0)."""
provider = SkyfieldProvider(storage_backend="memory")
assert provider._compute_visibility(20.0, 5.0, "Pluto") == VisibilityStatus.LOST_IN_SUNLIGHT
assert provider._compute_visibility(20.0, 15.0, "Pluto") == VisibilityStatus.VISIBLE
# ============================================================================
# _estimate_magnitude Tests
# ============================================================================
@pytest.mark.skipif(not SKYFIELD_AVAILABLE, reason="Skyfield not installed")
class TestEstimateMagnitude:
"""Test the _estimate_magnitude fallback method."""
def test_known_planet(self):
provider = SkyfieldProvider(storage_backend="memory")
mag = provider._estimate_magnitude("Mars", 1.5, 1.6, 30.0)
assert isinstance(mag, float)
def test_zero_distance_returns_absolute(self):
"""When distance is zero, return absolute magnitude."""
provider = SkyfieldProvider(storage_backend="memory")
mag = provider._estimate_magnitude("Mars", 0.0, 1.5, 30.0)
from chuk_mcp_celestial.constants import PLANET_ABSOLUTE_MAGNITUDE
assert mag == PLANET_ABSOLUTE_MAGNITUDE["Mars"]
def test_unknown_planet_fallback(self):
"""Unknown planet returns 0.0 as default absolute magnitude."""
provider = SkyfieldProvider(storage_backend="memory")
mag = provider._estimate_magnitude("UnknownBody", 0.0, 0.0, 0.0)
assert mag == 0.0
# ============================================================================
# _resolve_planet Tests
# ============================================================================
@pytest.mark.skipif(not SKYFIELD_AVAILABLE, reason="Skyfield not installed")
class TestResolvePlanet:
"""Test the _resolve_planet helper."""
def test_invalid_planet_name(self):
provider = SkyfieldProvider(storage_backend="memory")
with pytest.raises(ValueError, match="Unknown planet"):
provider._resolve_planet("InvalidPlanet")
def test_valid_planet(self):
provider = SkyfieldProvider(storage_backend="memory")
body = provider._resolve_planet("Mars")
assert body is not None
# ============================================================================
# Skyfield Provider Edge Cases
# ============================================================================
@pytest.mark.skipif(not SKYFIELD_AVAILABLE, reason="Skyfield not installed")
class TestSkyfieldEdgeCases:
"""Test edge cases for coverage of error branches."""
@pytest.mark.asyncio
async def test_earth_seasons_with_timezone_and_dst(self):
"""Test earth_seasons with timezone and DST to cover lines 403-407."""
provider = SkyfieldProvider(storage_backend="memory")
result = await provider.get_earth_seasons(2025, timezone=-8, dst=True)
assert result is not None
assert len(result.data) >= 4 # At least 4 seasonal events
@pytest.mark.asyncio
async def test_earth_seasons_without_timezone(self):
"""Test earth_seasons without timezone."""
provider = SkyfieldProvider(storage_backend="memory")
result = await provider.get_earth_seasons(2025)
assert result is not None
assert result.tz == 0.0
assert result.dst is False
@pytest.mark.asyncio
async def test_sun_moon_data_not_implemented(self):
"""Test that sun_moon_data raises NotImplementedError."""
provider = SkyfieldProvider(storage_backend="memory")
with pytest.raises(NotImplementedError, match="Sun/Moon"):
await provider.get_sun_moon_data("2025-01-01", 47.6, -122.3)
@pytest.mark.asyncio
async def test_solar_eclipse_by_date_not_implemented(self):
"""Test that solar_eclipse_by_date raises NotImplementedError."""
provider = SkyfieldProvider(storage_backend="memory")
with pytest.raises(NotImplementedError, match="Solar eclipse"):
await provider.get_solar_eclipse_by_date("2025-01-01", 47.6, -122.3)
@pytest.mark.asyncio
async def test_solar_eclipses_by_year_not_implemented(self):
"""Test that solar_eclipses_by_year raises NotImplementedError."""
provider = SkyfieldProvider(storage_backend="memory")
with pytest.raises(NotImplementedError, match="Solar eclipse"):
await provider.get_solar_eclipses_by_year(2025)
@pytest.mark.asyncio
async def test_position_constellation_fallback(self):
"""Test constellation fallback when load_constellation_map fails."""
from unittest.mock import patch
provider = SkyfieldProvider(storage_backend="memory")
with patch(
"skyfield.api.load_constellation_map",
side_effect=Exception("constellation error"),
):
result = await provider.get_planet_position(
planet="Mars",
date="2025-6-15",
time="12:00",
latitude=47.6,
longitude=-122.3,
)
assert result.properties.data.constellation == "N/A"
@pytest.mark.asyncio
async def test_position_magnitude_fallback(self):
"""Test magnitude fallback when planetary_magnitude fails."""
from unittest.mock import patch
provider = SkyfieldProvider(storage_backend="memory")
with patch(
"chuk_mcp_celestial.providers.skyfield_provider.planetary_magnitude",
side_effect=Exception("magnitude error"),
):
result = await provider.get_planet_position(
planet="Mars",
date="2025-6-15",
time="12:00",
latitude=47.6,
longitude=-122.3,
)
assert isinstance(result.properties.data.magnitude, float)
@pytest.mark.asyncio
async def test_events_constellation_fallback(self):
"""Test events constellation fallback when load_constellation_map fails."""
from unittest.mock import patch
provider = SkyfieldProvider(storage_backend="memory")
with patch(
"skyfield.api.load_constellation_map",
side_effect=Exception("constellation error"),
):
result = await provider.get_planet_events(
planet="Mars",
date="2025-6-15",
latitude=47.6,
longitude=-122.3,
)
assert result.properties.data.constellation == "N/A"
@pytest.mark.asyncio
async def test_events_magnitude_fallback(self):
"""Test events magnitude fallback when planetary_magnitude fails."""
from unittest.mock import patch
provider = SkyfieldProvider(storage_backend="memory")
with patch(
"chuk_mcp_celestial.providers.skyfield_provider.planetary_magnitude",
side_effect=Exception("magnitude error"),
):
result = await provider.get_planet_events(
planet="Mars",
date="2025-6-15",
latitude=47.6,
longitude=-122.3,
)
assert isinstance(result.properties.data.magnitude, float)
@pytest.mark.asyncio
async def test_events_risings_exception(self):
"""Test events handles rising search errors gracefully."""
from unittest.mock import patch
provider = SkyfieldProvider(storage_backend="memory")
with patch(
"chuk_mcp_celestial.providers.skyfield_provider.almanac.find_risings",
side_effect=Exception("rising error"),
):
result = await provider.get_planet_events(
planet="Mars",
date="2025-6-15",
latitude=47.6,
longitude=-122.3,
)
# Should still return a result even if risings fail
assert result is not None
@pytest.mark.asyncio
async def test_events_settings_exception(self):
"""Test events handles setting search errors gracefully."""
from unittest.mock import patch
provider = SkyfieldProvider(storage_backend="memory")
with patch(
"chuk_mcp_celestial.providers.skyfield_provider.almanac.find_settings",
side_effect=Exception("setting error"),
):
result = await provider.get_planet_events(
planet="Mars",
date="2025-6-15",
latitude=47.6,
longitude=-122.3,
)
assert result is not None
@pytest.mark.asyncio
async def test_events_transits_exception(self):
"""Test events handles transit search errors gracefully."""
from unittest.mock import patch
provider = SkyfieldProvider(storage_backend="memory")
with patch(
"chuk_mcp_celestial.providers.skyfield_provider.almanac.find_transits",
side_effect=Exception("transit error"),
):
result = await provider.get_planet_events(
planet="Mars",
date="2025-6-15",
latitude=47.6,
longitude=-122.3,
)
assert result is not None
@pytest.mark.asyncio
async def test_position_phase_angle_exception(self):
"""Test position handles phase angle calculation errors."""
from unittest.mock import patch
import numpy as np
provider = SkyfieldProvider(storage_backend="memory")
# Patch np.dot to fail inside phase angle calculation
original_dot = np.dot
call_count = [0]
def failing_dot(*args, **kwargs):
call_count[0] += 1
if call_count[0] >= 2: # Fail on later calls (the phase angle one)
raise ValueError("dot product error")
return original_dot(*args, **kwargs)
with patch(
"chuk_mcp_celestial.providers.skyfield_provider.np.dot",
side_effect=failing_dot,
):
result = await provider.get_planet_position(
planet="Mars",
date="2025-6-15",
time="12:00",
latitude=47.6,
longitude=-122.3,
)
# Should still succeed with fallback phase angle
assert result is not None
assert 0 <= result.properties.data.illumination <= 100
def test_skyfield_not_available_raises(self):
"""Test that SkyfieldProvider raises ImportError when skyfield missing."""
from unittest.mock import patch
with patch(
"chuk_mcp_celestial.providers.skyfield_provider.SKYFIELD_AVAILABLE",
False,
):
with pytest.raises(ImportError, match="Skyfield library"):
SkyfieldProvider(storage_backend="memory")
@pytest.mark.asyncio
async def test_eph_property_error(self):
"""Test eph property error handling."""
from unittest.mock import patch
provider = SkyfieldProvider(storage_backend="memory")
provider._eph = None # Reset
with patch.object(provider, "loader", side_effect=Exception("load failed")):
with pytest.raises(Exception, match="load failed"):
_ = provider.eph
