MBTAclient 0.2.7__tar.gz → 0.2.8__tar.gz

{mbtaclient-0.2.7 → mbtaclient-0.2.8}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: MBTAclient
-Version: 0.2.7
+Version: 0.2.8
 Summary: A Python client for interacting with the MBTA API
 Author-email: Luca Chiabrera <luca.chiabrera@gmail.com>
 License: MIT
 Project-URL: Homepage, https://github.com/chiabre/MBTAclient
 Project-URL: Issues, https://github.com/chiabre/MBTAclient/issues
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.12

{mbtaclient-0.2.7 → mbtaclient-0.2.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "MBTAclient"
-version = "0.2.7"
+version = "0.2.8"
 description = "A Python client for interacting with the MBTA API"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -15,7 +15,7 @@ dependencies = [
 license = { text = "MIT" }
 classifiers = [
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.12",
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent"
 ]

{mbtaclient-0.2.7 → mbtaclient-0.2.8}/src/MBTAclient.egg-info/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: MBTAclient
-Version: 0.2.7
+Version: 0.2.8
 Summary: A Python client for interacting with the MBTA API
 Author-email: Luca Chiabrera <luca.chiabrera@gmail.com>
 License: MIT
 Project-URL: Homepage, https://github.com/chiabre/MBTAclient
 Project-URL: Issues, https://github.com/chiabre/MBTAclient/issues
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.12

{mbtaclient-0.2.7 → mbtaclient-0.2.8}/src/MBTAclient.egg-info/SOURCES.txt

@@ -20,4 +20,13 @@ src/mbtaclient/mbta_schedule.py
 src/mbtaclient/mbta_stop.py
 src/mbtaclient/mbta_trip.py
 src/mbtaclient/mbta_utils.py
-src/mbtaclient/trip_handler.py
+src/mbtaclient/trip_handler.py
+tests/test_journey_stop.py
+tests/test_mbta_alert.py
+tests/test_mbta_client.py
+tests/test_mbta_prediction.py
+tests/test_mbta_route.py
+tests/test_mbta_schedule.py
+tests/test_mbta_stop.py
+tests/test_mbta_trip.py
+tests/test_mbta_utils.py

{mbtaclient-0.2.7 → mbtaclient-0.2.8}/src/mbtaclient/journey_stop.py

@@ -50,7 +50,7 @@ class JourneyStop:
                 self.real_departure_time = MBTAUtils.parse_datetime(departure_time)
                 if self.departure_time is not None:
                     self.departure_delay = MBTAUtils.calculate_time_difference(self.real_departure_time, self.departure_time)
-
+            
     def get_time(self) -> Optional[datetime]:
         """Return the most relevant time for the stop."""
         if self.real_arrival_time is not None:

{mbtaclient-0.2.7 → mbtaclient-0.2.8}/src/mbtaclient/mbta_client.py

@@ -92,12 +92,12 @@ class MBTAClient:
             response = await self.request("get", endpoint, params)
             data = await response.json() 
             if 'data' not in data:
-                raise ValueError("Unexpected response format")
+                raise ValueError("missing 'data'")
             return data
         except Exception as error:
             self.logger.error(f"Error fetching data: {error}")
             raise
-        
+            
     async def request(
         self, method: str, path: str, params: Optional[dict[str, Any]] = None) -> aiohttp.ClientResponse:
         """Make an HTTP request with Optional query parameters and JSON body."""

{mbtaclient-0.2.7 → mbtaclient-0.2.8}/src/mbtaclient/mbta_utils.py

@@ -39,6 +39,16 @@ class MBTAUtils:
         if time is None:
             logger.warning("time_to: Provided 'time' is None.")
             return None
+        # Check if both datetime objects have timezone info
+        if time.tzinfo != now.tzinfo:
+            # Make both datetimes the same type: either both naive or both aware
+            if time.tzinfo is None and now.tzinfo is not None:
+                # Convert time to aware by using the timezone of `now`
+                time = time.replace(tzinfo=now.tzinfo)
+            elif time.tzinfo is not None and now.tzinfo is None:
+                # Convert now to naive by stripping timezone info
+                now = now.replace(tzinfo=None)
+        # Now perform the calculation
         return (time - now).total_seconds()
 
     @staticmethod

mbtaclient-0.2.8/tests/test_journey_stop.py

@@ -0,0 +1,167 @@
+import pytest
+from datetime import datetime, timedelta
+from src.mbtaclient.mbta_stop import MBTAStop
+from src.mbtaclient.mbta_utils import MBTAUtils
+from src.mbtaclient.journey_stop import JourneyStop
+
+
+def test_journey_stop_init():
+    """Test initialization of JourneyStop object."""
+    stop = MBTAStop(stop={"id": "test_stop_id", "name": "Test Stop"})
+    future_time = datetime.now() + timedelta(minutes=30)
+
+    journey_stop = JourneyStop(
+        stop,
+        arrival_time=future_time.isoformat(),
+        departure_time=future_time.isoformat(),
+        stop_sequence=1,
+        status="Scheduled",
+    )
+
+    assert journey_stop.stop == stop
+    assert journey_stop.arrival_time == future_time
+    assert journey_stop.real_arrival_time is None
+    assert journey_stop.arrival_delay is None
+    assert journey_stop.departure_time == future_time
+    assert journey_stop.real_departure_time is None
+    assert journey_stop.departure_delay is None
+    assert journey_stop.status == "Scheduled"
+    assert journey_stop.stop_sequence == 1
+
+
+def test_journey_stop_update_stop_with_real_times():
+    """Test update_stop with real arrival and departure times."""
+    stop = MBTAStop(stop={"id": "test_stop_id", "name": "Test Stop"})
+    future_time = datetime.now() + timedelta(minutes=30)
+    real_arrival_time_str = (future_time + timedelta(minutes=5)).isoformat()
+    real_departure_time_str = (future_time + timedelta(minutes=10)).isoformat()
+
+    journey_stop = JourneyStop(
+        stop,
+        arrival_time=future_time.isoformat(),
+        departure_time=future_time.isoformat(),
+        stop_sequence=1,
+        status="Scheduled",
+    )
+
+    journey_stop.update_stop(
+        stop, real_arrival_time_str, real_departure_time_str, 1, "On Time"
+    )
+
+    assert journey_stop.real_arrival_time == future_time + timedelta(minutes=5)
+    assert journey_stop.arrival_delay == timedelta(minutes=5).total_seconds()
+    assert journey_stop.real_departure_time == future_time + timedelta(minutes=10)
+    assert journey_stop.departure_delay == timedelta(minutes=10).total_seconds()
+
+
+def test_journey_stop_update_stop_with_none_times():
+    """Test update_stop with None times."""
+    stop = MBTAStop(stop={"id": "test_stop_id", "name": "Test Stop"})
+    future_time = datetime.now() + timedelta(minutes=30)
+
+    journey_stop = JourneyStop(
+        stop,
+        arrival_time=future_time.isoformat(),
+        departure_time=future_time.isoformat(),
+        stop_sequence=1,
+        status="Scheduled",
+    )
+
+    journey_stop.update_stop(stop, None, None, 1, "Cancelled")
+
+    assert journey_stop.real_arrival_time is None
+    assert journey_stop.arrival_delay is None
+    assert journey_stop.real_departure_time is None
+    assert journey_stop.departure_delay is None
+
+
+def test_journey_stop_get_time():
+    """Test get_time method."""
+    stop = MBTAStop(stop={"id": "test_stop_id", "name": "Test Stop"})
+    future_time = datetime.now() + timedelta(minutes=30)
+    past_time = datetime.now() - timedelta(minutes=10)
+
+    journey_stop = JourneyStop(
+        stop, arrival_time=future_time.isoformat(), departure_time=None, stop_sequence=1, status="Scheduled"
+    )
+    assert journey_stop.get_time() == future_time
+
+    journey_stop.update_stop(stop, None, future_time.isoformat(), 1, "Scheduled")
+    assert journey_stop.get_time() == future_time
+
+    journey_stop.update_stop(stop, past_time.isoformat(), None, 1, "Scheduled")
+    assert journey_stop.get_time() == past_time
+
+    journey_stop.update_stop(stop, None, None, 1, "Cancelled")
+    assert journey_stop.get_time() is None
+
+
+def test_journey_stop_get_delay():
+    """Test get_delay method."""
+    stop = MBTAStop(stop={"id": "test_stop_id", "name": "Test Stop"})
+    future_time = datetime.now() + timedelta(minutes=30)
+
+    journey_stop = JourneyStop(
+        stop,
+        arrival_time=future_time.isoformat(),
+        departure_time=future_time.isoformat(),
+        stop_sequence=1,
+        status="Scheduled",
+    )
+
+    # First, test with departure time set (arrival time is None)
+    journey_stop.update_stop(
+        stop,
+        None,
+        (future_time + timedelta(minutes=5)).isoformat(),  # 5 minutes late departure
+        1,
+        "Scheduled",
+    )
+    # Assert that departure delay is returned
+    assert journey_stop.get_delay() == timedelta(minutes=5).total_seconds()
+
+    # Now update with arrival time (set arrival delay)
+    journey_stop.update_stop(
+        stop,
+        (future_time + timedelta(minutes=5)).isoformat(),  # 5 minutes late arrival
+        None,
+        1,
+        "Scheduled",
+    )
+    # Assert that arrival delay is returned (since arrival delay is more relevant)
+    assert journey_stop.get_delay() == timedelta(minutes=5).total_seconds()
+
+    # Now update with departure time (set departure delay)
+    journey_stop.update_stop(
+        stop,
+        None,
+        (future_time + timedelta(minutes=10)).isoformat(),  # 10 minutes late departure again
+        1,
+        "Scheduled",
+    )
+    # Assert that arrival delay is still returned (since arrival delay is more relevant)
+    assert journey_stop.get_delay() == timedelta(minutes=5).total_seconds()
+
+
+def test_journey_stop_get_time_to():
+    """Test get_time_to method."""
+    stop = MBTAStop(stop={"id": "test_stop_id", "name": "Test Stop"})
+    future_time = datetime.now() + timedelta(minutes=30)
+    past_time = datetime.now() - timedelta(minutes=10)
+
+    journey_stop = JourneyStop(
+        stop, arrival_time=future_time.isoformat(), departure_time=None, stop_sequence=1, status="Scheduled"
+    )
+    time_to = journey_stop.get_time_to()
+    assert time_to >= 0
+
+    journey_stop.update_stop(stop, None, future_time.isoformat(), 1, "Scheduled")
+    time_to = journey_stop.get_time_to()
+    assert time_to >= 0
+
+    journey_stop.update_stop(stop, past_time.isoformat(), None, 1, "Scheduled")
+    time_to = journey_stop.get_time_to()
+    assert time_to <= 0
+
+    journey_stop.update_stop(stop, None, None, 1, "Cancelled")
+    assert journey_stop.get_time_to() is None

mbtaclient-0.2.8/tests/test_mbta_alert.py

@@ -0,0 +1,139 @@
+import pytest
+from src.mbtaclient.mbta_alert import MBTAAlert
+
+
+def test_mbta_alert_init():
+    """Test initialization of MBTAAlert object."""
+    alert_data = {
+        "id": "12345",
+        "attributes": {
+            "active_period": [
+                {
+                    "start": "2024-07-04T10:00:00-04:00",
+                    "end": "2024-07-04T12:00:00-04:00"
+                }
+            ],
+            "cause": "Accident",
+            "effect": "Delays",
+            "header": "Green Line Delays",
+            "description": "Accident on the tracks near Park Street station.",
+            "severity": 1,
+            "informed_entity": [
+                {
+                    "route": "Green",
+                    "route_type": 13
+                },
+                {
+                    "stop": "place-park"
+                }
+            ]
+        }
+    }
+
+    alert = MBTAAlert(alert_data)
+
+    assert alert.id == "12345"
+    assert alert.cause == "Accident"
+    assert alert.effect == "Delays"
+    assert alert.header_text == "Green Line Delays"
+    assert alert.severity == 1
+    assert len(alert.informed_entities) == 2
+
+
+def test_mbta_alert_get_informed_stops():
+    """Test get_informed_stops method."""
+    alert_data = {
+        "id": "12345",
+        "attributes": {
+            "active_period": [
+                {
+                    "start": "2024-07-04T10:00:00-04:00",
+                    "end": "2024-07-04T12:00:00-04:00"
+                }
+            ],
+            "cause": "Accident",
+            "effect": "Delays",
+            "header": "Green Line Delays",
+            "description": "Accident on the tracks near Park Street station.",
+            "severity": 1,
+            "informed_entity": [
+                {
+                    "route": "Green",
+                    "route_type": 13
+                },
+                {
+                    "stop": "place-park"
+                }
+            ]
+        }
+    }
+
+    alert = MBTAAlert(alert_data)
+
+    assert alert.get_informed_stops() == ["place-park"]
+
+
+def test_mbta_alert_get_informed_trips():
+    """Test get_informed_trips method."""
+    alert_data = {
+        "id": "12345",
+        "attributes": {
+            "active_period": [
+                {
+                    "start": "2024-07-04T10:00:00-04:00",
+                    "end": "2024-07-04T12:00:00-04:00"
+                }
+            ],
+            "cause": "Accident",
+            "effect": "Delays",
+            "header": "Green Line Delays",
+            "description": "Accident on the tracks near Park Street station.",
+            "severity": 1,
+            "informed_entity": [
+                {
+                    "route": "Green",
+                    "route_type": 13
+                },
+                {
+                    "stop": "place-park"
+                }
+            ]
+        }
+    }
+
+    alert = MBTAAlert(alert_data)
+
+    assert alert.get_informed_trips() == []
+
+
+def test_mbta_alert_get_informed_routes():
+    """Test get_informed_routes method."""
+    alert_data = {
+        "id": "12345",
+        "attributes": {
+            "active_period": [
+                {
+                    "start": "2024-07-04T10:00:00-04:00",
+                    "end": "2024-07-04T12:00:00-04:00"
+                }
+            ],
+            "cause": "Accident",
+            "effect": "Delays",
+            "header": "Green Line Delays",
+            "description": "Accident on the tracks near Park Street station.",
+            "severity": 1,
+            "informed_entity": [
+                {
+                    "route": "Green",
+                    "route_type": 13
+                },
+                {
+                    "stop": "place-park"
+                }
+            ]
+        }
+    }
+
+    alert = MBTAAlert(alert_data)
+
+    assert alert.get_informed_routes() == ["Green"]

mbtaclient-0.2.8/tests/test_mbta_client.py

@@ -0,0 +1,109 @@
+import pytest
+
+from unittest.mock import AsyncMock, MagicMock, patch
+from aiohttp import ClientConnectionError, ClientResponseError, RequestInfo
+from yarl import URL
+
+from src.mbtaclient.mbta_client import MBTAClient, MBTA_DEFAULT_HOST, ENDPOINTS
+from src.mbtaclient.mbta_route import MBTARoute
+
+
+@pytest.mark.asyncio
+async def test_get_route():
+    async def mock_fetch_data(url, params):
+        return {'data': {'id': 'route-xyz'}}
+
+    client = MBTAClient()
+    client._fetch_data = AsyncMock(side_effect=mock_fetch_data)
+    route = await client.get_route('route-xyz')
+    assert route.id == 'route-xyz'
+    client._fetch_data.assert_called_once_with(f'{ENDPOINTS["ROUTES"]}/route-xyz', None)
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_get_route_error():
+    async def mock_request(method, url, params=None):
+        return MagicMock(json=AsyncMock(return_value={}))
+
+    client = MBTAClient()
+    client.request = AsyncMock(side_effect=mock_request)
+    with patch.object(client, 'logger', MagicMock()) as mock_logger:
+        with pytest.raises(ValueError) as excinfo:
+            await client.get_route('route-xyz')
+        assert str(excinfo.value) == "missing 'data'"
+        mock_logger.error.assert_called_once_with("Error fetching data: missing 'data'")
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_list_routes():
+    async def mock_fetch_data(url, params):
+        return {'data': [{'id': 'route-1'}, {'id': 'route-2'}]}
+
+    client = MBTAClient()
+    client._fetch_data = AsyncMock(side_effect=mock_fetch_data)
+    routes = await client.list_routes()
+    assert len(routes) == 2
+    assert isinstance(routes[0], MBTARoute)
+    client._fetch_data.assert_called_once_with(ENDPOINTS['ROUTES'], None)
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_request_connection_error():
+    async def mock_request(*args, **kwargs):
+        raise ClientConnectionError('Connection error')
+
+    client = MBTAClient()
+    client._session.request = AsyncMock(side_effect=mock_request)
+    with patch.object(client, 'logger', MagicMock()) as mock_logger:
+        with pytest.raises(ClientConnectionError):
+            await client.request('get', '/test')
+        mock_logger.error.assert_called_once_with('Connection error: Connection error')
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_request_client_response_error():
+    request_info = RequestInfo(
+        url=URL("https://api-v3.mbta.com/test"),
+        method="GET",
+        headers={},
+    )
+
+    async def mock_request(*args, **kwargs):
+        raise ClientResponseError(
+            request_info=request_info,
+            history=None,
+            status=404,
+            message="Not Found",
+            headers=None,
+        )
+
+    client = MBTAClient()
+    client._session.request = AsyncMock(side_effect=mock_request)
+    with patch.object(client, 'logger', MagicMock()) as mock_logger:
+        with pytest.raises(ClientResponseError):
+            await client.request('get', '/test')
+        mock_logger.error.assert_called_once_with(
+            'Client response error: 404 - 404, message=\'Not Found\', url=\'https://api-v3.mbta.com/test\''
+        )
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_request_success():
+    async def mock_request(*args, **kwargs):
+        return MagicMock(status=200, json=AsyncMock(return_value={}))
+
+    client = MBTAClient()
+    client._session.request = AsyncMock(side_effect=mock_request)
+    response = await client.request('get', 'test')
+    assert response.status == 200
+    client._session.request.assert_called_once_with(
+        'get',
+        f'https://{MBTA_DEFAULT_HOST}/test',
+        params={},
+    )
+    await client.close()

mbtaclient-0.2.8/tests/test_mbta_prediction.py

@@ -0,0 +1,97 @@
+import pytest
+from typing import Dict, Optional
+
+from src.mbtaclient.mbta_prediction import MBTAPrediction
+from src.mbtaclient.mbta_utils import MBTAUtils
+
+
+@pytest.mark.parametrize(
+    "prediction_data",
+    [
+        {
+            "id": "prediction-456",
+            "attributes": {
+                "arrival_time": "2023-01-08T10:00:00-05:00",
+                "arrival_uncertainty": "120",
+                "departure_time": "2023-01-08T10:01:00-05:00",
+                "departure_uncertainty": "300",
+                "direction_id": 1,
+                "last_trip": True,
+                "revenue": True,
+                "schedule_relationship": "SCHEDULED",
+                "status": "ACTIVE",
+                "stop_sequence": 5,
+                "update_type": "PREDICTED",
+            },
+            "relationships": {
+                "route": {"data": {"id": "route-xyz"}},
+                "stop": {"data": {"id": "stop-abc"}},
+                "trip": {"data": {"id": "trip-def"}},
+            },
+        },
+        # Test case with missing data
+        {"id": "prediction-456"},
+    ],
+)
+def test_init(prediction_data):
+    """Tests that MBTAPrediction is initialized correctly with or without data."""
+
+    prediction = MBTAPrediction(prediction_data)
+
+    # Test expected attributes
+    assert prediction.id == prediction_data["id"]
+    assert prediction.arrival_time == prediction_data.get("attributes", {}).get(
+        "arrival_time", ""
+    )
+    assert prediction.arrival_uncertainty == MBTAUtils.get_uncertainty_description(
+        prediction_data.get("attributes", {}).get("arrival_uncertainty", "")
+    )
+    assert prediction.departure_time == prediction_data.get("attributes", {}).get(
+        "departure_time", ""
+    )
+    assert prediction.departure_uncertainty == MBTAUtils.get_uncertainty_description(
+        prediction_data.get("attributes", {}).get("departure_uncertainty", "")
+    )
+    assert prediction.direction_id == prediction_data.get("attributes", {}).get(
+        "direction_id", 0
+    )
+    assert prediction.last_trip is prediction_data.get("attributes", {}).get(
+        "last_trip"
+    )
+    assert prediction.revenue is prediction_data.get("attributes", {}).get("revenue")
+    assert prediction.schedule_relationship == prediction_data.get("attributes", {}).get(
+        "schedule_relationship", ""
+    )
+    assert prediction.status == prediction_data.get("attributes", {}).get("status", "")
+    assert prediction.stop_sequence == prediction_data.get("attributes", {}).get(
+        "stop_sequence", 0
+    )
+    assert prediction.update_type == prediction_data.get("attributes", {}).get(
+        "update_type", ""
+    )
+
+    # Test relationships
+    assert prediction.route_id == (
+        prediction_data.get("relationships", {}).get("route", {}).get("data", {}).get(
+            "id", ""
+        )
+    )
+    assert prediction.stop_id == (
+        prediction_data.get("relationships", {}).get("stop", {}).get("data", {}).get(
+            "id", ""
+        )
+    )
+    assert prediction.trip_id == (
+        prediction_data.get("relationships", {}).get("trip", {}).get("data", {}).get(
+            "id", ""
+        )
+    )
+
+
+def test_repr():
+    """Tests that the __repr__ method returns a string representation."""
+
+    prediction_data = {"id": "prediction-456"}
+    prediction = MBTAPrediction(prediction_data)
+
+    assert repr(prediction) == "MBTAprediction(id=prediction-456)"

mbtaclient-0.2.8/tests/test_mbta_route.py

@@ -0,0 +1,58 @@
+import pytest
+from typing import Dict
+
+from src.mbtaclient.mbta_route import MBTARoute
+
+
+@pytest.mark.parametrize(
+    "route_data",
+    [
+        {
+            "id": "route-123",
+            "attributes": {
+                "color": "#0099CC",
+                "description": "Green Line B",
+                "direction_destinations": ["Bowdoin", "Cleaveland Circle"],
+                "direction_names": ["Outbound", "Inbound"],
+                "fare_class": "1",
+                "long_name": "Green Line B",
+                "short_name": "B",
+                "sort_order": 3,
+                "text_color": "#FFFFFF",
+                "type": "light_rail",
+            },
+        },
+        # Test case with missing data
+        {"id": "route-123"},
+    ],
+)
+def test_init(route_data):
+    """Tests that MBTARoute is initialized correctly with or without data."""
+
+    route = MBTARoute(route_data)
+
+    # Test expected attributes
+    assert route.id == route_data["id"]
+    assert route.color == route_data.get("attributes", {}).get("color", "")
+    assert route.description == route_data.get("attributes", {}).get("description", "")
+    assert route.direction_destinations == route_data.get(
+        "attributes", {}
+    ).get("direction_destinations", [])
+    assert route.direction_names == route_data.get("attributes", {}).get(
+        "direction_names", []
+    )
+    assert route.fare_class == route_data.get("attributes", {}).get("fare_class", "")
+    assert route.long_name == route_data.get("attributes", {}).get("long_name", "")
+    assert route.short_name == route_data.get("attributes", {}).get("short_name", "")
+    assert route.sort_order == route_data.get("attributes", {}).get("sort_order", 0)
+    assert route.text_color == route_data.get("attributes", {}).get("text_color", "")
+    assert route.type == route_data.get("attributes", {}).get("type", "")
+
+
+def test_repr():
+    """Tests that the __repr__ method returns a string representation."""
+
+    route_data = {"id": "route-123"}
+    route = MBTARoute(route_data)
+
+    assert repr(route) == "MBTAroute(id=route-123)"

mbtaclient-0.2.8/tests/test_mbta_schedule.py

@@ -0,0 +1,88 @@
+import pytest
+from typing import Dict
+
+from src.mbtaclient.mbta_schedule import MBTASchedule
+
+
+@pytest.mark.parametrize(
+    "schedule_data",
+    [
+        {
+            "id": "sched_1234",
+            "attributes": {
+                "arrival_time": "2023-01-08T09:00:00-05:00",
+                "departure_time": "2023-01-08T09:01:00-05:00",
+                "direction_id": 1,
+                "drop_off_type": "2",
+                "pickup_type": "1",
+                "stop_headsign": "Riverside",
+                "stop_sequence": 3,
+                "timepoint": True,
+            },
+            "relationships": {
+                "route": {"data": {"id": "route-xyz"}},
+                "stop": {"data": {"id": "stop-abc"}},
+                "trip": {"data": {"id": "trip-def"}},
+            },
+        },
+        # Test case with missing data
+        {"id": "sched_1234"},
+    ],
+)
+def test_init(schedule_data):
+    """Tests that MBTASchedule is initialized correctly with or without data."""
+
+    schedule = MBTASchedule(schedule_data)
+
+    # Test expected attributes
+    assert schedule.id == schedule_data["id"]
+    assert schedule.arrival_time == schedule_data.get("attributes", {}).get(
+        "arrival_time", ""
+    )
+    assert schedule.departure_time == schedule_data.get("attributes", {}).get(
+        "departure_time", ""
+    )
+    assert schedule.direction_id == schedule_data.get("attributes", {}).get(
+        "direction_id", 0
+    )
+    assert schedule.drop_off_type == schedule_data.get("attributes", {}).get(
+        "drop_off_type", ""
+    )
+    assert schedule.pickup_type == schedule_data.get("attributes", {}).get(
+        "pickup_type", ""
+    )
+    assert schedule.stop_headsign == schedule_data.get("attributes", {}).get(
+        "stop_headsign", ""
+    )
+    assert schedule.stop_sequence == schedule_data.get("attributes", {}).get(
+        "stop_sequence", 0
+    )
+    assert schedule.timepoint is schedule_data.get("attributes", {}).get(
+        "timepoint", False
+    )
+
+    # Test relationships
+    assert schedule.route_id == (
+        schedule_data.get("relationships", {}).get("route", {}).get("data", {}).get(
+            "id", ""
+        )
+    )
+    assert schedule.stop_id == (
+        schedule_data.get("relationships", {}).get("stop", {}).get("data", {}).get(
+            "id", ""
+        )
+    )
+    assert schedule.trip_id == (
+        schedule_data.get("relationships", {}).get("trip", {}).get("data", {}).get(
+            "id", ""
+        )
+    )
+
+
+def test_repr():
+    """Tests that the __repr__ method returns a string representation."""
+
+    schedule_data = {"id": "sched_1234"}
+    schedule = MBTASchedule(schedule_data)
+
+    assert repr(schedule) == "MBTAschedule(id=sched_1234)"

mbtaclient-0.2.8/tests/test_mbta_stop.py

@@ -0,0 +1,68 @@
+import pytest
+from typing import Dict
+
+from src.mbtaclient.mbta_stop import MBTAStop
+
+
+@pytest.mark.parametrize(
+    "stop_data",
+    [
+        {
+            "id": "place-dit9",
+            "attributes": {
+                "address": "100 Mystic Ave, Medford, MA 02155",
+                "at_street": "Mystic Ave",
+                "description": "Sullivan Square",
+                "latitude": 42.408733,
+                "location_type": 1,
+                "longitude": -71.060088,
+                "municipality": "Medford",
+                "name": "Sullivan Square",
+                "on_street": "Mystic Ave",
+                "platform_code": "",
+                "platform_name": "",
+                "vehicle_type": 0,
+                "wheelchair_boarding": 1,
+            },
+        },
+        # Test case with missing data
+        {"id": "place-dit9"},
+    ],
+)
+def test_init(stop_data):
+    """Tests that MBTAStop is initialized correctly with or without data."""
+
+    stop = MBTAStop(stop_data)
+
+    # Test expected attributes
+    assert stop.id == stop_data["id"]
+    assert stop.address == stop_data.get("attributes", {}).get("address", "")
+    assert stop.at_street == stop_data.get("attributes", {}).get("at_street", "")
+    assert stop.description == stop_data.get("attributes", {}).get("description", "")
+    assert stop.location_type == stop_data.get("attributes", {}).get("location_type", 0)
+    assert stop.municipality == stop_data.get("attributes", {}).get("municipality", "")
+    assert stop.name == stop_data.get("attributes", {}).get("name", "")
+    assert stop.on_street == stop_data.get("attributes", {}).get("on_street", "")
+    assert stop.platform_code == stop_data.get("attributes", {}).get("platform_code", "")
+    assert stop.platform_name == stop_data.get("attributes", {}).get("platform_name", "")
+    assert stop.vehicle_type == stop_data.get("attributes", {}).get("vehicle_type", 0)
+    assert stop.wheelchair_boarding == stop_data.get("attributes", {}).get(
+        "wheelchair_boarding", 0
+    )
+
+    # Use pytest.approx for floating-point comparisons
+    assert pytest.approx(stop.latitude) == stop_data.get("attributes", {}).get(
+        "latitude", 0.0
+    )
+    assert pytest.approx(stop.longitude) == stop_data.get("attributes", {}).get(
+        "longitude", 0.0
+    )
+
+
+def test_repr():
+    """Tests that the __repr__ method returns a string representation."""
+
+    stop_data = {"id": "place-dit9"}
+    stop = MBTAStop(stop_data)
+
+    assert repr(stop) == "MBTAstop(id=place-dit9)"

mbtaclient-0.2.8/tests/test_mbta_trip.py

@@ -0,0 +1,68 @@
+import pytest
+from typing import Dict
+
+from src.mbtaclient.mbta_trip import MBTATrip
+
+
+@pytest.mark.parametrize(
+    "trip_data",
+    [
+        {
+            "id": "1234",
+            "attributes": {
+                "name": "Green Line B",
+                "headsign": "Cleveland Circle",
+                "direction_id": 1,
+                "block_id": "b123",
+                "shape_id": "s456",
+                "wheelchair_accessible": True,
+                "bikes_allowed": False,
+                "schedule_relationship": "weekday",
+            },
+            "relationships": {
+                "route": {"data": {"id": "route_id_1"}},
+                "service": {"data": {"id": "service_id_1"}},
+            },
+        },
+        # Test case with missing data
+        {
+            "id": "5678",
+            "attributes": {"name": "Red Line"},
+            "relationships": {"route": {"data": {}}},
+        },
+    ],
+)
+def test_init(trip_data):
+    """Tests that MBTATrip is initialized correctly with or without data."""
+
+    trip = MBTATrip(trip_data)
+
+    # Test expected attributes
+    assert trip.id == trip_data["id"]
+    assert trip.name == trip_data.get("attributes", {}).get("name", "")
+    assert trip.headsign == trip_data.get("attributes", {}).get("headsign", "")
+    assert trip.direction_id == trip_data.get("attributes", {}).get("direction_id", 0)
+    assert trip.block_id == trip_data.get("attributes", {}).get("block_id", "")
+    assert trip.shape_id == trip_data.get("attributes", {}).get("shape_id", "")
+    assert trip.wheelchair_accessible is trip_data.get(
+        "attributes", {}
+    ).get("wheelchair_accessible")
+    assert trip.bikes_allowed is trip_data.get("attributes", {}).get("bikes_allowed")
+    assert trip.schedule_relationship == trip_data.get(
+        "attributes", {}
+    ).get("schedule_relationship", "")
+
+    # Test relationships
+    assert trip.route_id == (
+        trip_data.get("relationships", {}).get("route", {}).get("data", {}).get(
+            "id", ""
+        )
+    )
+    assert trip.service_id == (
+        trip_data.get("relationships", {}).get("service", {}).get("data", {}).get(
+            "id", ""
+        )
+    )
+
+
+# Add more test cases for different scenarios (e.g., invalid data types, edge cases)

mbtaclient-0.2.8/tests/test_mbta_utils.py

@@ -0,0 +1,126 @@
+import pytest
+from datetime import datetime, timedelta
+from unittest.mock import patch, MagicMock
+from zoneinfo import ZoneInfo
+
+from src.mbtaclient.mbta_utils import MBTAUtils, memoize_async
+
+
+class TestMBTAUtils:
+    @pytest.fixture
+    def now(self):
+        return datetime.now()
+
+    @staticmethod
+    def make_hashable(item):
+        if isinstance(item, dict):
+            return frozenset((TestMBTAUtils.make_hashable(k), TestMBTAUtils.make_hashable(v)) for k, v in item.items())
+        return str(item)
+
+    def test_get_route_type_desc_by_type_id(self):
+        assert MBTAUtils.get_route_type_desc_by_type_id(0) == "Subway"
+        assert MBTAUtils.get_route_type_desc_by_type_id(1) == "Subway"
+        assert MBTAUtils.get_route_type_desc_by_type_id(2) == "Commuter Rail"
+        assert MBTAUtils.get_route_type_desc_by_type_id(3) == "Bus"
+        assert MBTAUtils.get_route_type_desc_by_type_id(4) == "Ferry"
+        assert MBTAUtils.get_route_type_desc_by_type_id(5) == "Unknown"
+
+    def test_get_uncertainty_description(self):
+        assert MBTAUtils.get_uncertainty_description("60") == "Trip that has already started"
+        assert MBTAUtils.get_uncertainty_description("120") == (
+            "Trip not started and a vehicle is awaiting departure at the origin"
+        )
+        assert MBTAUtils.get_uncertainty_description("300") == "Vehicle has not yet been assigned to the trip"
+        assert MBTAUtils.get_uncertainty_description("301") == (
+            "Vehicle appears to be stalled or significantly delayed"
+        )
+        assert MBTAUtils.get_uncertainty_description("360") == (
+            "Trip not started and a vehicle is completing a previous trip"
+        )
+        assert MBTAUtils.get_uncertainty_description("invalid") == "None"
+
+    def test_time_to(self, now):
+        future_time = now + timedelta(minutes=10)
+        past_time = now - timedelta(minutes=5)
+
+        # Test with valid time
+        assert pytest.approx(MBTAUtils.time_to(future_time, now)) == 600, 1
+
+        # Test with past time
+        assert pytest.approx(MBTAUtils.time_to(past_time, now)) == -300, 1
+
+        # Test with None time
+        assert MBTAUtils.time_to(None, now) is None
+
+        # Test with different timezones
+        aware_time1 = now.replace(tzinfo=ZoneInfo("America/Los_Angeles"))
+        aware_time2 = now.replace(tzinfo=ZoneInfo("Europe/Berlin"))
+        assert pytest.approx(MBTAUtils.time_to(aware_time1, aware_time2)) == 32400.0, 1
+
+    def test_calculate_time_difference(self, now):
+        real_time = now + timedelta(minutes=5)
+        scheduled_time = now
+
+        # Test with valid times
+        assert pytest.approx(MBTAUtils.calculate_time_difference(real_time, scheduled_time)) == 300, 1
+
+        # Test with None times
+        assert MBTAUtils.calculate_time_difference(None, scheduled_time) is None
+        assert MBTAUtils.calculate_time_difference(real_time, None) is None
+        assert MBTAUtils.calculate_time_difference(None, None) is None
+
+    def test_parse_datetime(self):
+        time_str = "2023-11-20T10:30:00+00:00"
+
+        # Test with valid ISO 8601 string
+        parsed_time = MBTAUtils.parse_datetime(time_str)
+        assert parsed_time is not None
+        assert parsed_time.isoformat() == time_str
+
+        # Test with invalid string
+        time_str = "invalid_time"
+        parsed_time = MBTAUtils.parse_datetime(time_str)
+        assert parsed_time is None
+
+        # Test with non-string input
+        parsed_time = MBTAUtils.parse_datetime(123)
+        assert parsed_time is None
+
+        @pytest.mark.asyncio
+        @patch('src.mbtaclient.mbta_utils.logger.debug')
+        @patch('src.mbtaclient.mbta_utils.logger.error')
+        async def test_memoize_async(self, mock_error, mock_debug):
+            @memoize_async()
+            async def my_func(arg1, arg2):
+                return arg1 + arg2
+
+            # First call should miss the cache
+            result1 = await my_func(1, 2)
+            assert result1 == 3
+
+            # Assert that both the 'Cache miss' and 'Cache updated' logs are called
+            mock_debug.assert_any_call(f"Cache miss for my_func with arguments {(TestMBTAUtils.make_hashable(1), TestMBTAUtils.make_hashable(2))} at {datetime.now().isoformat()}")
+            mock_debug.assert_any_call(f"Cache updated for key: {(TestMBTAUtils.make_hashable(1), TestMBTAUtils.make_hashable(2))} at {datetime.now().isoformat()}")
+
+            # Second call should hit the cache
+            result2 = await my_func(1, 2)
+            assert result2 == 3
+
+            # Check if cache hit log is called
+            mock_debug.assert_any_call(f"Cache hit for my_func with arguments {(TestMBTAUtils.make_hashable(1), TestMBTAUtils.make_hashable(2))} at {datetime.now().isoformat()}")
+
+            # Call with different arguments should miss the cache
+            result3 = await my_func(1, 3)
+            assert result3 == 4
+            mock_debug.assert_any_call(f"Cache miss for my_func with arguments {(TestMBTAUtils.make_hashable(1), TestMBTAUtils.make_hashable(3))} at {datetime.now().isoformat()}")
+            mock_debug.assert_any_call(f"Cache updated for key: {(TestMBTAUtils.make_hashable(1), TestMBTAUtils.make_hashable(3))} at {datetime.now().isoformat()}")
+
+            # Test error handling
+            @memoize_async()
+            async def my_func_error(arg):
+                raise ValueError("Test error")
+
+            with pytest.raises(ValueError):
+                await my_func_error(1)
+            mock_error.assert_called_with(f"Error occurred while executing my_func_error with arguments (1,): Test error")
+