fixup! Implement GetMicrogridMetadata

Add tests for Location.

Author: llucax

tests/test_location.py

@@ -0,0 +1,203 @@
+# License: MIT
+# Copyright © 2025 Frequenz Energy-as-a-Service GmbH
+
+"""Tests for the microgrid metadata types."""
+
+from collections.abc import Iterator
+from dataclasses import dataclass
+from unittest.mock import MagicMock, patch
+from zoneinfo import ZoneInfo
+
+import pytest
+from frequenz.api.common.v1 import location_pb2
+
+from frequenz.client.microgrid import Location
+from frequenz.client.microgrid._location_proto import location_from_proto
+
+
+@dataclass(frozen=True, kw_only=True)
+class ProtoConversionTestCase:  # pylint: disable=too-many-instance-attributes
+    """Test case for protobuf conversion."""
+
+    name: str
+    """The description of the test case."""
+
+    latitude: float
+    """The latitude to set in the protobuf message."""
+
+    longitude: float
+    """The longitude to set in the protobuf message."""
+
+    country_code: str
+    """The country code to set in the protobuf message."""
+
+    expected_latitude: float | None
+    """The expected latitude in the resulting Location."""
+
+    expected_longitude: float | None
+    """The expected longitude in the resulting Location."""
+
+    expected_country_code: str | None
+    """The expected country code in the resulting Location."""
+
+    expect_warning: bool
+    """Whether to expect a warning during conversion."""
+
+
+@pytest.fixture
+def timezone_finder() -> Iterator[MagicMock]:
+    """Return a mock timezone finder."""
+    with patch(
+        "frequenz.client.microgrid._location._timezone_finder", autospec=True
+    ) as mock_timezone_finder:
+        yield mock_timezone_finder
+
+
+def test_location_timezone_constructor() -> None:
+    """Test the location timezone is not looked up if it is not used."""
+    location = Location(latitude=52.52, longitude=13.405, country_code="DE")
+
+    assert location.latitude == 52.52
+    assert location.longitude == 13.405
+    assert location.country_code == "DE"
+
+
+def test_location_timezone_not_looked_up_if_unused(timezone_finder: MagicMock) -> None:
+    """Test the location timezone is not looked up if it is not used."""
+    _ = Location(latitude=52.52, longitude=13.405, country_code="DE")
+    timezone_finder.timezone_at.assert_not_called()
+
+
+def test_location_timezone_looked_up_but_not_found(timezone_finder: MagicMock) -> None:
+    """Test the location timezone is not looked up if it is not used."""
+    timezone_finder.timezone_at.return_value = None
+
+    location = Location(latitude=52.52, longitude=13.405, country_code="DE")
+
+    assert location.timezone is None
+    timezone_finder.timezone_at.assert_called_once_with(lat=52.52, lng=13.405)
+
+
+def test_location_timezone_looked_up_and_found(timezone_finder: MagicMock) -> None:
+    """Test the location timezone is not looked up if it is not used."""
+    timezone_finder.timezone_at.return_value = "Europe/Berlin"
+
+    location = Location(latitude=52.52, longitude=13.405, country_code="DE")
+
+    assert location.timezone == ZoneInfo(key="Europe/Berlin")
+    timezone_finder.timezone_at.assert_called_once_with(lat=52.52, lng=13.405)
+
+
+@pytest.mark.parametrize(
+    "case",
+    [
+        ProtoConversionTestCase(
+            name="valid location",
+            latitude=52.52,
+            longitude=13.405,
+            country_code="DE",
+            expected_latitude=52.52,
+            expected_longitude=13.405,
+            expected_country_code="DE",
+            expect_warning=False,
+        ),
+        ProtoConversionTestCase(
+            name="invalid latitude",
+            latitude=91.0,
+            longitude=13.405,
+            country_code="DE",
+            expected_latitude=None,
+            expected_longitude=13.405,
+            expected_country_code="DE",
+            expect_warning=True,
+        ),
+        ProtoConversionTestCase(
+            name="invalid longitude",
+            latitude=52.52,
+            longitude=181.0,
+            country_code="DE",
+            expected_latitude=52.52,
+            expected_longitude=None,
+            expected_country_code="DE",
+            expect_warning=True,
+        ),
+        ProtoConversionTestCase(
+            name="empty country code",
+            latitude=52.52,
+            longitude=13.405,
+            country_code="",
+            expected_latitude=52.52,
+            expected_longitude=13.405,
+            expected_country_code=None,
+            expect_warning=True,
+        ),
+        ProtoConversionTestCase(
+            name="all fields invalid",
+            latitude=-91.0,
+            longitude=181.0,
+            country_code="",
+            expected_latitude=None,
+            expected_longitude=None,
+            expected_country_code=None,
+            expect_warning=True,
+        ),
+        ProtoConversionTestCase(
+            name="boundary latitude values",
+            latitude=90.0,
+            longitude=13.405,
+            country_code="DE",
+            expected_latitude=90.0,
+            expected_longitude=13.405,
+            expected_country_code="DE",
+            expect_warning=False,
+        ),
+        ProtoConversionTestCase(
+            name="boundary longitude values",
+            latitude=52.52,
+            longitude=180.0,
+            country_code="DE",
+            expected_latitude=52.52,
+            expected_longitude=180.0,
+            expected_country_code="DE",
+            expect_warning=False,
+        ),
+    ],
+    ids=lambda case: case.name,
+)
+def test_location_from_proto(
+    caplog: pytest.LogCaptureFixture, case: ProtoConversionTestCase
+) -> None:
+    """Test conversion from protobuf message to Location.
+
+    Args:
+        caplog: Fixture to capture log messages
+        case: Test case parameters
+
+    Raises:
+        AssertionError: If any of the test assertions fail
+    """
+    proto = location_pb2.Location(
+        latitude=case.latitude,
+        longitude=case.longitude,
+        country_code=case.country_code,
+    )
+    with caplog.at_level("WARNING"):
+        location = location_from_proto(proto)
+
+    if case.expected_latitude is None:
+        assert location.latitude is None
+    else:
+        assert location.latitude == pytest.approx(case.expected_latitude)
+
+    if case.expected_longitude is None:
+        assert location.longitude is None
+    else:
+        assert location.longitude == pytest.approx(case.expected_longitude)
+
+    assert location.country_code == case.expected_country_code
+
+    if case.expect_warning:
+        assert len(caplog.records) > 0
+        assert "Found issues in location:" in caplog.records[0].message
+    else:
+        assert len(caplog.records) == 0