MBTAclient 0.2.8__tar.gz → 0.2.9__tar.gz

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: MBTAclient
-Version: 0.2.8
+Version: 0.2.9
 Summary: A Python client for interacting with the MBTA API
 Author-email: Luca Chiabrera <luca.chiabrera@gmail.com>
 License: MIT
@@ -13,7 +13,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: aiohttp>=3.9.5
+Requires-Dist: aiohttp
 
 # MBTAclient
 

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

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "MBTAclient"
-version = "0.2.8"
+version = "0.2.9"
 description = "A Python client for interacting with the MBTA API"
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
-    "aiohttp>=3.9.5"
+    "aiohttp"
 ]
 
 license = { text = "MIT" }

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: MBTAclient
-Version: 0.2.8
+Version: 0.2.9
 Summary: A Python client for interacting with the MBTA API
 Author-email: Luca Chiabrera <luca.chiabrera@gmail.com>
 License: MIT
@@ -13,7 +13,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: aiohttp>=3.9.5
+Requires-Dist: aiohttp
 
 # MBTAclient
 

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

@@ -7,20 +7,20 @@ src/MBTAclient.egg-info/dependency_links.txt
 src/MBTAclient.egg-info/requires.txt
 src/MBTAclient.egg-info/top_level.txt
 src/mbtaclient/__init__.py
-src/mbtaclient/__version__.py
+src/mbtaclient/alert.py
 src/mbtaclient/base_handler.py
+src/mbtaclient/client.py
 src/mbtaclient/journey.py
 src/mbtaclient/journey_stop.py
 src/mbtaclient/journeys_handler.py
-src/mbtaclient/mbta_alert.py
-src/mbtaclient/mbta_client.py
-src/mbtaclient/mbta_prediction.py
-src/mbtaclient/mbta_route.py
-src/mbtaclient/mbta_schedule.py
-src/mbtaclient/mbta_stop.py
-src/mbtaclient/mbta_trip.py
-src/mbtaclient/mbta_utils.py
+src/mbtaclient/prediction.py
+src/mbtaclient/route.py
+src/mbtaclient/schedule.py
+src/mbtaclient/stop.py
+src/mbtaclient/trip.py
 src/mbtaclient/trip_handler.py
+src/mbtaclient/utils.py
+tests/test_journey.py
 tests/test_journey_stop.py
 tests/test_mbta_alert.py
 tests/test_mbta_client.py

mbtaclient-0.2.9/src/MBTAclient.egg-info/requires.txt

@@ -0,0 +1 @@
+aiohttp

{mbtaclient-0.2.8 → mbtaclient-0.2.9}/src/mbtaclient/__init__.py

@@ -4,13 +4,13 @@
 from .journey_stop import JourneyStop
 from .journey import Journey
 from .journeys_handler import JourneysHandler
-from .mbta_alert import MBTAAlert
-from .mbta_client import MBTAClient
-from .mbta_prediction import MBTAPrediction
-from .mbta_route import MBTARoute
-from .mbta_schedule import MBTASchedule
-from .mbta_stop import MBTAStop
-from .mbta_trip import MBTATrip
+from .alert import MBTAAlert
+from .client import MBTAClient
+from .prediction import MBTAPrediction
+from .route import MBTARoute
+from .schedule import MBTASchedule
+from .stop import MBTAStop
+from .trip import MBTATrip
 from .trip_handler import TripHandler
 from .__version__ import __version__
 

{mbtaclient-0.2.8 → mbtaclient-0.2.9}/src/mbtaclient/base_handler.py

@@ -3,15 +3,15 @@ import aiohttp
 
 from typing import Optional
 
-from .mbta_client import MBTAClient
+from .client import MBTAClient
 from .journey import Journey
-from .mbta_stop import MBTAStop
-from .mbta_route import MBTARoute
-from .mbta_schedule import MBTASchedule
-from .mbta_prediction import MBTAPrediction
-from .mbta_trip import MBTATrip
-from .mbta_alert import MBTAAlert
-from .mbta_utils import memoize_async
+from .stop import MBTAStop
+from .route import MBTARoute
+from .schedule import MBTASchedule
+from .prediction import MBTAPrediction
+from .trip import MBTATrip
+from .alert import MBTAAlert
+from .utils import memoize_async
 
 
 class BaseHandler:
@@ -32,7 +32,7 @@ class BaseHandler:
         
         client_session = session or aiohttp.ClientSession()
         self.mbta_client = MBTAClient(client_session, logger, api_key)
-
+        
         self.journeys: dict[str, Journey] = {} 
 
         self.logger: logging.Logger = logger or logging.getLogger(__name__)

mbtaclient-0.2.9/src/mbtaclient/client.py

@@ -0,0 +1,236 @@
+import aiohttp
+import asyncio
+import logging
+import time
+from aiohttp import ClientConnectionError, ClientResponseError
+from typing import Optional, Any, Dict, List, Type
+
+from .route import MBTARoute
+from .stop import MBTAStop
+from .schedule import MBTASchedule
+from .prediction import MBTAPrediction
+from .trip import MBTATrip
+from .alert import MBTAAlert
+
+MBTA_DEFAULT_HOST = "api-v3.mbta.com"
+
+ENDPOINTS = {
+    'STOPS': 'stops',
+    'ROUTES': 'routes',
+    'PREDICTIONS': 'predictions',
+    'SCHEDULES': 'schedules',
+    'TRIPS': 'trips',
+    'ALERTS': 'alerts',
+}
+
+MAX_CONCURRENT_REQUESTS = 10
+
+class MBTAAuthenticationError(Exception):
+    """Custom exception for MBTA authentication errors."""
+
+class MBTAClientError(Exception):
+    """Custom exception class for MBTA API errors."""
+
+class MBTAClient:
+    """Class to interact with the MBTA v3 API."""
+
+    def __init__(self, session: aiohttp.ClientSession = None, logger: logging.Logger = None, api_key: Optional[str] = None, max_concurrent_requests: int = MAX_CONCURRENT_REQUESTS):
+        self._session = session
+        self._api_key: Optional[str] = api_key
+        self._max_concurrent_requests = max_concurrent_requests
+
+        if self._session:
+            # If an external session is provided, pass it to SessionManager
+            SessionManager.configure(self._max_concurrent_requests, self._session, logger=logger)
+        else:
+            # If no session is provided, the SessionManager will manage it
+            SessionManager.configure(self._max_concurrent_requests, logger=logger)
+            
+        self._logger: logging.Logger = logger or logging.getLogger(__name__)
+
+    async def __aenter__(self):
+        """Enter the context and return the client."""
+        if not self._session:
+            # If session is not passed, get it from SessionManager
+            self._session = await SessionManager.get_session()
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        """Exit the context."""
+        await SessionManager.close_session()
+        SessionManager.cleanup()
+
+    # Generic fetch method for list operations
+    async def fetch_list(
+        self, endpoint: str, params: Optional[Dict[str, Any]], obj_class: Type
+    ) -> List[Any]:
+        """Fetch a list of objects from the MBTA API."""
+        self._logger.debug(f"Fetching list from endpoint: {endpoint} with params: {params}")
+        data = await self._fetch_data(endpoint, params)
+        # Generalize by ensuring each object is created dynamically
+        return [obj_class(item) for item in data["data"]]
+
+    # Fetch data helper with retries
+    async def _fetch_data(
+        self, path: str, params: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """Helper method to fetch data from the MBTA API."""
+        self._logger.debug(f"Fetching data from https://{MBTA_DEFAULT_HOST}/{path} with params: {params}")
+        try:
+            response = await self.request("GET", path, params)
+            data = await response.json()
+            if "data" not in data:
+                self._logger.error(f"Response missing 'data': {data}")
+                raise MBTAClientError(f"Invalid response from API: {data}")
+            return data
+        except MBTAClientError as error:
+            self._logger.error(f"MBTAClientError occurred: {error}")
+            raise
+        except Exception as error:
+            self._logger.error(f"Unexpected error while 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.
+        
+        Adds retry logic and configurable timeouts.
+        
+        Raises:
+            MBTAAuthenticationError: For 403 Forbidden errors (invalid API key).
+            MBTAClientError: For other HTTP or unexpected errors.
+        """
+        params = params or {}
+        if self._api_key:
+            params["api_key"] = self._api_key
+
+        url = f"https://{MBTA_DEFAULT_HOST}/{path}"
+        self._logger.debug(f"Making {method} request to {url} with params: {params}")
+
+        retries = 3
+        timeout = aiohttp.ClientTimeout(total=10)  # 10 seconds timeout
+
+        for attempt in range(retries):
+            try:
+                async with SessionManager._semaphore:
+                    response: aiohttp.ClientResponse = await self._session.request(method, url, params=params, timeout=timeout)
+                    self._logger.debug(f"Received response {response.status} for {url}")
+                    response.raise_for_status()  # Raise HTTP errors
+                    return response
+
+            except (ClientResponseError, ClientConnectionError) as error:
+                self._logger.error(f"Error on attempt {attempt + 1}/{retries}: {error}")
+                if attempt == retries - 1:
+                    self._logger.error(f"Final attempt failed: {error}")
+                    raise MBTAClientError(f"Request failed: {error}") from error
+                await asyncio.sleep(2)  # Wait before retrying
+
+            except Exception as error:
+                self._logger.error(f"Unexpected error during {method} request to {url}: {error}", exc_info=True)
+                raise MBTAClientError(f"Unexpected error: {error}") from error
+
+    # Specific API methods
+    async def get_route(self, id: str, params: Optional[Dict[str, Any]] = None) -> MBTARoute:
+        """Get a route by its ID."""
+        data = await self._fetch_data(f"{ENDPOINTS['ROUTES']}/{id}", params)
+        return MBTARoute(data["data"])
+
+    async def get_trip(self, id: str, params: Optional[Dict[str, Any]] = None) -> MBTATrip:
+        """Get a trip by its ID."""
+        data = await self._fetch_data(f"{ENDPOINTS['TRIPS']}/{id}", params)
+        return MBTATrip(data["data"])
+
+    async def get_stop(self, id: str, params: Optional[Dict[str, Any]] = None) -> MBTAStop:
+        """Get a stop by its ID."""
+        data = await self._fetch_data(f'{ENDPOINTS["STOPS"]}/{id}', params)
+        return MBTAStop(data['data'])
+
+    async def list_routes(self, params: Optional[Dict[str, Any]] = None) -> List[MBTARoute]:
+        """List all routes."""
+        return await self.fetch_list(ENDPOINTS["ROUTES"], params, MBTARoute)
+
+    async def list_trips(self, params: Optional[Dict[str, Any]] = None) -> List[MBTATrip]:
+        """List all trips."""
+        return await self.fetch_list(ENDPOINTS["TRIPS"], params, MBTATrip)
+
+    async def list_stops(self, params: Optional[Dict[str, Any]] = None) -> List[MBTAStop]:
+        """List all stops."""
+        data = await self._fetch_data(ENDPOINTS['STOPS'], params)
+        return [MBTAStop(item) for item in data["data"]]
+
+    async def list_schedules(self, params: Optional[Dict[str, Any]] = None) -> List[MBTASchedule]:
+        """List all schedules."""
+        data = await self._fetch_data(ENDPOINTS['SCHEDULES'], params)
+        return [MBTASchedule(item) for item in data["data"]]
+    
+    async def list_predictions(self, params: Optional[Dict[str, Any]] = None) -> List[MBTAPrediction]:
+        """List all predictions."""
+        data = await self._fetch_data(ENDPOINTS['PREDICTIONS'], params)
+        return [MBTAPrediction(item) for item in data["data"]]
+
+    async def list_alerts(self, params: Optional[Dict[str, Any]] = None) -> List[MBTAAlert]:
+        """List all alerts."""
+        data = await self._fetch_data(ENDPOINTS['ALERTS'], params)
+        return [MBTAAlert(item) for item in data["data"]]
+
+import logging
+import aiohttp
+import asyncio
+
+class SessionManager:
+    """Singleton class to manage a shared aiohttp.ClientSession."""
+
+    _session: Optional[aiohttp.ClientSession] = None
+    _semaphore: Optional[asyncio.Semaphore] = None
+    _max_concurrent_requests: int = 10  # Default maximum concurrent requests
+    _logger: logging.Logger = None
+
+    @classmethod
+    def configure(cls, max_concurrent_requests: int = 10, session: Optional[aiohttp.ClientSession] = None, logger: logging.Logger = None):
+        """
+        Configure the SessionManager with the maximum number of concurrent requests and optionally an external session.
+
+        Args:
+            max_concurrent_requests (int): The number of concurrent requests allowed.
+            session (aiohttp.ClientSession, optional): An external session to use.
+        """
+        cls._logger: logging.Logger = logger or logging.getLogger(__name__)
+        cls._max_concurrent_requests = max_concurrent_requests
+        cls._semaphore = asyncio.Semaphore(max_concurrent_requests)
+        if session:
+            cls._session = session
+            cls._logger.debug(f"Using provided external session: {session}")
+        else:
+            cls._logger.debug(f"Creating a new session with max concurrent requests: {max_concurrent_requests}")
+
+    @classmethod
+    async def get_session(cls) -> aiohttp.ClientSession:
+        """
+        Get the shared aiohttp.ClientSession instance, creating it if necessary.
+
+        Returns:
+            aiohttp.ClientSession: The shared session instance.
+        """
+        if cls._session is None or cls._session.closed:
+            cls._logger.debug("No active session found, creating a new one.")
+            cls._session = aiohttp.ClientSession()
+        else:
+            cls._logger.debug("Returning existing session.")
+        return cls._session
+
+    @classmethod
+    async def close_session(cls):
+        """Close the shared aiohttp.ClientSession."""
+        if cls._session and not cls._session.closed:
+            cls._logger.debug("Closing the shared session.")
+            await cls._session.close()
+            cls._session = None
+        else:
+            cls._logger.debug("No session to close or already closed.")
+
+    @classmethod
+    async def cleanup(cls):
+        """Clean up resources when shutting down."""
+        cls._logger.debug("Cleaning up resources and closing session.")
+        await cls.close_session()
+        cls._semaphore = None

{mbtaclient-0.2.8 → mbtaclient-0.2.9}/src/mbtaclient/journey.py

@@ -2,13 +2,13 @@ from typing import Union, Optional
 from datetime import datetime
 
 from .journey_stop import JourneyStop
-from .mbta_schedule import MBTASchedule
-from .mbta_prediction import MBTAPrediction
-from .mbta_stop import MBTAStop
-from .mbta_route import MBTARoute
-from .mbta_trip import MBTATrip
-from .mbta_alert import MBTAAlert
-from .mbta_utils import MBTAUtils
+from .schedule import MBTASchedule
+from .prediction import MBTAPrediction
+from .stop import MBTAStop
+from .route import MBTARoute
+from .trip import MBTATrip
+from .alert import MBTAAlert
+from .utils import MBTAUtils
 
 class Journey:
     """A class to manage a journey with multiple stops."""
@@ -115,7 +115,7 @@ class Journey:
     
     def get_trip_duration(self) -> Optional[str]:
         if self.duration:
-            return self.duration
+            return round(self.duration,0)
         return None
 
     def get_stop_name(self, stop_type: str) -> Optional[str]:

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

@@ -1,8 +1,8 @@
 from typing import Optional
 from datetime import datetime
 
-from .mbta_stop import MBTAStop
-from .mbta_utils import MBTAUtils
+from .stop import MBTAStop
+from .utils import MBTAUtils
 
 
 class JourneyStop:
@@ -63,12 +63,12 @@ class JourneyStop:
             return self.departure_time
         return None
     
-    def get_delay(self) -> Optional[float]:
+    def get_delay(self) -> Optional[int]:
         """Return the most relevant delay for the stop."""
         if self.arrival_delay is not None:
-            return self.arrival_delay
+            return int(round(self.arrival_delay,0))
         if self.departure_delay is not None:
-            return self.departure_delay
+            return int(round(self.departure_delay,0))
         return None
         
     def get_time_to(self) -> float:

{mbtaclient-0.2.8 → mbtaclient-0.2.9}/src/mbtaclient/journeys_handler.py

@@ -4,9 +4,9 @@ from datetime import datetime
 
 from .base_handler import BaseHandler
 from .journey import Journey
-from .mbta_route import MBTARoute
-from .mbta_trip import MBTATrip
-from .mbta_schedule import MBTASchedule
+from .route import MBTARoute
+from .trip import MBTATrip
+from .schedule import MBTASchedule
 
 
 class JourneysHandler(BaseHandler):

mbtaclient-0.2.8/src/mbtaclient/mbta_prediction.py → mbtaclient-0.2.9/src/mbtaclient/prediction.py

@@ -1,6 +1,6 @@
 
 from typing import Any, Optional
-from .mbta_utils import MBTAUtils
+from .utils import MBTAUtils
 
 class MBTAPrediction:
     """A prediction object to hold information about a prediction."""

{mbtaclient-0.2.8 → mbtaclient-0.2.9}/src/mbtaclient/trip_handler.py

@@ -4,9 +4,9 @@ import logging
 from datetime import datetime, timedelta
 from .base_handler import BaseHandler, MBTATripError
 from .journey import Journey
-from .mbta_route import MBTARoute
-from .mbta_trip import MBTATrip
-from .mbta_schedule import MBTASchedule
+from .route import MBTARoute
+from .trip import MBTATrip
+from .schedule import MBTASchedule
 
 class TripHandler(BaseHandler):
     """Handler for managing a specific trip."""

mbtaclient-0.2.8/src/mbtaclient/mbta_utils.py → mbtaclient-0.2.9/src/mbtaclient/utils.py

@@ -35,7 +35,7 @@ class MBTAUtils:
         return MBTAUtils.UNCERTAINTY.get(key, 'None')
     
     @staticmethod
-    def time_to(time: Optional[datetime], now: datetime) -> Optional[float]:
+    def time_to(time: Optional[datetime], now: datetime) -> Optional[int]:
         if time is None:
             logger.warning("time_to: Provided 'time' is None.")
             return None
@@ -49,13 +49,13 @@ class MBTAUtils:
                 # Convert now to naive by stripping timezone info
                 now = now.replace(tzinfo=None)
         # Now perform the calculation
-        return (time - now).total_seconds()
+        return int(round((time - now).total_seconds(),0))
 
     @staticmethod
-    def calculate_time_difference(real_time: Optional[datetime], time: Optional[datetime]) -> Optional[float]:
+    def calculate_time_difference(real_time: Optional[datetime], time: Optional[datetime]) -> Optional[int]:
         if real_time is None or time is None:
             return None
-        return (real_time - time).total_seconds()
+        return int(round((real_time - time).total_seconds(),0))
 
     @staticmethod
     def parse_datetime(time_str: str) -> Optional[datetime]:

mbtaclient-0.2.9/tests/test_journey.py

@@ -0,0 +1,95 @@
+import pytest
+from unittest.mock import MagicMock
+from datetime import datetime
+
+from src.mbtaclient.journey import Journey
+from src.mbtaclient.schedule import MBTASchedule
+from src.mbtaclient.prediction import MBTAPrediction
+from src.mbtaclient.stop import MBTAStop
+from src.mbtaclient.route import MBTARoute
+from src.mbtaclient.alert import MBTAAlert
+from src.mbtaclient.utils import MBTAUtils
+from src.mbtaclient.journey_stop import JourneyStop
+from tests.mock_data import VALID_ROUTE_RESPONSE_DATA, VALID_SCHEDULE_RESPONSE_DATA, VALID_PREDICTION_RESPONSE_DATA, VALID_STOP_RESPONSE_DATA  # Direct import
+
+
+@pytest.fixture
+def mock_route():
+    route = MBTARoute(VALID_ROUTE_RESPONSE_DATA)
+    return route
+
+@pytest.fixture
+def mock_schedule():
+    schedule = MBTASchedule(VALID_SCHEDULE_RESPONSE_DATA)
+    return schedule
+
+@pytest.fixture
+def mock_prediction():
+    prediction = MBTAPrediction(VALID_PREDICTION_RESPONSE_DATA)
+    return prediction
+
+@pytest.fixture
+def mock_stop():
+    stop = MBTAStop(VALID_STOP_RESPONSE_DATA)
+    return stop
+
+@pytest.fixture
+def journey():
+    """Fixture to create a Journey instance."""
+    return Journey()
+
+
+def test_add_stop(journey, mock_schedule, mock_stop):
+    """Test the add_stop method."""
+    journey.add_stop("departure", mock_schedule, mock_stop, "On time")
+
+    assert journey.stops['departure'] is not None
+    assert journey.stops['departure'].stop.name == "South St @ Spalding St"
+    assert journey.stops['departure'].arrival_time == None
+    assert journey.stops['departure'].departure_time == datetime.fromisoformat("2025-01-07T05:15:00-05:00")
+    assert journey.stops['departure'].stop_sequence == 50
+
+
+def test_get_route_details(journey, mock_route):
+    """Test the get_route_details method."""
+    journey.route = mock_route
+    
+    assert journey.get_route_short_name() == ""
+    assert journey.get_route_long_name() == "Red Line"
+    assert journey.get_route_color() == "DA291C"
+    assert journey.get_route_type() == 1
+    assert journey.get_route_description() == "Subway"
+
+
+def test_get_stop_details(journey, mock_schedule, mock_stop):
+    """Test the get_stop_details method."""
+    journey.add_stop("departure", mock_schedule, mock_stop, "On time")
+    journey.add_stop("arrival", mock_schedule, mock_stop, "On time")
+
+    assert journey.get_stop_name("departure") == "South St @ Spalding St"
+    assert journey.get_platform_name("departure") == None
+    assert journey.get_stop_time("departure") == datetime.fromisoformat("2025-01-07T05:15:00-05:00")
+    assert journey.get_stop_delay("departure") is None
+    assert journey.get_stop_status("departure") == "On time"
+
+
+def test_get_stop_id(journey, mock_schedule, mock_stop):
+    """Test the get_stop_id method."""
+    journey.add_stop("departure", mock_schedule, mock_stop, "On time")
+    journey.add_stop("arrival", mock_schedule, mock_stop, "On time")
+
+    assert journey.get_stop_id("departure") == "1936"
+    assert journey.get_stop_id("arrival") == "1936"
+
+
+def test_find_journey_stop_by_id(journey, mock_schedule, mock_stop):
+    """Test the find_journey_stop_by_id method."""
+    journey.add_stop("departure", mock_schedule, mock_stop, "On time")
+    journey.add_stop("arrival", mock_schedule, mock_stop, "On time")
+
+    journey_stop = journey.find_journey_stop_by_id("1936")
+    assert journey_stop is not None
+    assert journey_stop.stop.id == "1936"
+
+    journey_stop = journey.find_journey_stop_by_id("non-existing-id")
+    assert journey_stop is None

{mbtaclient-0.2.8 → mbtaclient-0.2.9}/tests/test_journey_stop.py

@@ -1,7 +1,7 @@
 import pytest
 from datetime import datetime, timedelta
-from src.mbtaclient.mbta_stop import MBTAStop
-from src.mbtaclient.mbta_utils import MBTAUtils
+from src.mbtaclient.stop import MBTAStop
+from src.mbtaclient.utils import MBTAUtils
 from src.mbtaclient.journey_stop import JourneyStop
 
 

mbtaclient-0.2.9/tests/test_mbta_alert.py

@@ -0,0 +1,43 @@
+import pytest
+from src.mbtaclient.alert import MBTAAlert
+from tests.mock_data import VALID_ALERT_RESPONSE_DATA  # Direct import from mock data
+
+def test_mbta_alert_init():
+    """Test initialization of MBTAAlert object."""
+    alert = MBTAAlert(VALID_ALERT_RESPONSE_DATA)
+
+    assert alert.id == "382310"
+    assert alert.cause == "CONSTRUCTION"
+    assert alert.effect == "STATION_ISSUE"
+    assert alert.header_text == (
+        "The Quincy Adams parking garage has re-opened with most parking spaces available. "
+        "Customers can access the garage via the Route 3 off ramp exit as well as the Burgin Parkway entrance."
+    )
+    assert alert.severity == 1
+    assert len(alert.informed_entities) == 3
+    assert alert.informed_entities[0]["stop"] == "70103"
+    assert alert.informed_entities[0]["route"] == "Red"
+
+def test_mbta_alert_get_informed_stops():
+    """Test get_informed_stops method."""
+    alert = MBTAAlert(VALID_ALERT_RESPONSE_DATA)
+
+    # Test for informed stops
+    informed_stops = alert.get_informed_stops()
+    assert set(informed_stops) == {"70103", "70104", "place-qamnl"}
+
+def test_mbta_alert_get_informed_trips():
+    """Test get_informed_trips method."""
+    alert = MBTAAlert(VALID_ALERT_RESPONSE_DATA)
+
+    # Test for informed trips (should be empty)
+    informed_trips = alert.get_informed_trips()
+    assert informed_trips == []
+
+def test_mbta_alert_get_informed_routes():
+    """Test get_informed_routes method."""
+    alert = MBTAAlert(VALID_ALERT_RESPONSE_DATA)
+
+    # Test for informed routes
+    informed_routes = alert.get_informed_routes()
+    assert set(informed_routes) == {"Red"}