add tests for track model

Author: jsurrea

antares-python/src/antares/cli.py

@@ -1,6 +1,7 @@
 import asyncio
 import json
 import logging
+from typing import NoReturn
 
 import typer
 from rich.console import Console
@@ -15,7 +16,7 @@
 console = Console(theme=Theme({"info": "green", "warn": "yellow", "error": "bold red"}))
 
 
-def handle_error(message: str, code: int, json_output: bool = False):
+def handle_error(message: str, code: int, json_output: bool = False) -> NoReturn:
     logger = logging.getLogger("antares.cli")
     if json_output:
         typer.echo(json.dumps({"error": message}), err=True)
@@ -50,7 +51,7 @@ def reset(
     config: str = typer.Option(None),
     verbose: bool = typer.Option(False, "--verbose", "-v"),
     json_output: bool = typer.Option(False, "--json", help="Output in JSON format"),
-):
+) -> None:
     client = build_client(config, verbose, json_output)
     try:
         client.reset_simulation()
@@ -67,7 +68,7 @@ def add_ship(
     config: str = typer.Option(None, help="Path to the configuration file"),
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose output"),
     json_output: bool = typer.Option(False, "--json", help="Output in JSON format"),
-):
+) -> None:
     client = build_client(config, verbose, json_output)
     try:
         ship = ShipConfig(initial_position=(x, y))
@@ -84,13 +85,13 @@ def subscribe(
     verbose: bool = typer.Option(False, "--verbose", "-v"),
     json_output: bool = typer.Option(False, "--json", help="Output in JSON format"),
     log_file: str = typer.Option("antares.log", help="Path to log file"),
-):
+) -> None:
     setup_logging(log_file=log_file, level=logging.DEBUG if verbose else logging.INFO)
     logger = logging.getLogger("antares.cli")
 
     client = build_client(config, verbose, json_output)
 
-    async def _sub():
+    async def _sub() -> None:
         try:
             async for event in client.subscribe():
                 if json_output:

antares-python/src/antares/client/__init__.py

@@ -1,36 +1,29 @@
 from collections.abc import AsyncIterator
+from typing import Any
 
 from antares.client.rest import RestClient
 from antares.client.tcp import TCPSubscriber
 from antares.config import AntaresSettings
 from antares.models.ship import ShipConfig
+from antares.models.track import Track
 
 
 class AntaresClient:
     def __init__(
         self,
-        base_url: str | None = None,
-        tcp_host: str | None = None,
-        tcp_port: int | None = None,
-        timeout: float | None = None,
-        auth_token: str | None = None,
+        **kwargs: Any,
     ) -> None:
         """
         Public interface for interacting with the Antares simulation engine.
         Accepts config overrides directly or falls back to environment-based configuration.
         """
 
-        overrides = {
-            "base_url": base_url,
-            "tcp_host": tcp_host,
-            "tcp_port": tcp_port,
-            "timeout": timeout,
-            "auth_token": auth_token,
-        }
-        clean_overrides = {k: v for k, v in overrides.items() if v is not None}
+        # Only include kwargs that match AntaresSettings fields
+        valid_fields = AntaresSettings.model_fields.keys()
+        filtered_kwargs = {k: v for k, v in kwargs.items() if k in valid_fields and v is not None}
 
         # Merge provided arguments with environment/.env via AntaresSettings
-        self._settings = AntaresSettings(**clean_overrides)
+        self._settings = AntaresSettings(**filtered_kwargs)
 
         self._rest = RestClient(
             base_url=self._settings.base_url,
@@ -51,12 +44,12 @@ def add_ship(self, ship: ShipConfig) -> None:
         """
         return self._rest.add_ship(ship)
 
-    async def subscribe(self) -> AsyncIterator[dict]:
+    async def subscribe(self) -> AsyncIterator[Track]:
         """
         Subscribes to live simulation data over TCP.
 
         Yields:
-            Parsed simulation event data as dictionaries.
+            Parsed simulation event data as Track objects.
         """
         async for event in self._tcp.subscribe():
             yield event

antares-python/src/antares/client/tcp.py

@@ -4,6 +4,7 @@
 from collections.abc import AsyncIterator
 
 from antares.errors import SubscriptionError
+from antares.models.track import Track
 
 logger = logging.getLogger(__name__)
 
@@ -26,25 +27,27 @@ def __init__(self, host: str, port: int, reconnect: bool = True) -> None:
         self.port = port
         self.reconnect = reconnect
 
-    async def subscribe(self) -> AsyncIterator[dict]:
+    async def subscribe(self) -> AsyncIterator[Track]:
         """
-        Connects to the TCP server and yields simulation events as parsed dictionaries.
+        Connects to the TCP server and yields simulation events as Track objects.
         This is an infinite async generator until disconnected or cancelled.
 
         Yields:
-            Parsed simulation events.
+            Parsed simulation events as Track objects.
         """
         while True:
             try:
                 reader, _ = await asyncio.open_connection(self.host, self.port)
                 while not reader.at_eof():
                     line = await reader.readline()
                     if line:
-                        yield json.loads(line.decode())
+                        track = Track.from_csv_row(line.decode())
+                        yield track
             except (
                 ConnectionRefusedError,
                 asyncio.IncompleteReadError,
                 json.JSONDecodeError,
+                ValueError,
             ) as e:
                 logger.error("TCP stream error: %s", e)
                 if not self.reconnect:

antares-python/src/antares/config.py

@@ -7,14 +7,14 @@ class AntaresSettings(BaseSettings):
     Supports environment variables and `.env` file loading.
     """
 
-    base_url: str
+    base_url: str = "http://localhost:8000"
     tcp_host: str = "localhost"
     tcp_port: int = 9000
     timeout: float = 5.0
     auth_token: str | None = None
 
     model_config = SettingsConfigDict(
         env_file=".env",
-        env_prefix="ANTARES_",
+        env_prefix="antares_",
         case_sensitive=False,
     )

antares-python/src/antares/models/track.py

@@ -0,0 +1,84 @@
+from typing import ClassVar
+
+from pydantic import BaseModel, Field
+
+
+class Track(BaseModel):
+    id: int
+    year: int
+    month: int
+    day: int
+    hour: int
+    minute: int
+    second: int
+    millisecond: int
+    stat: str
+    type_: str = Field(alias="type")  # maps from "type" input
+    name: str
+    linemask: int
+    size: int
+    range: float
+    azimuth: float
+    lat: float
+    long: float
+    speed: float
+    course: float
+    quality: int
+    l16quality: int
+    lacks: int
+    winrgw: int
+    winazw: float
+    stderr: float
+
+    # expected order of fields from TCP stream
+    __field_order__: ClassVar[list[str]] = [
+        "id",
+        "year",
+        "month",
+        "day",
+        "hour",
+        "minute",
+        "second",
+        "millisecond",
+        "stat",
+        "type_",
+        "name",
+        "linemask",
+        "size",
+        "range",
+        "azimuth",
+        "lat",
+        "long",
+        "speed",
+        "course",
+        "quality",
+        "l16quality",
+        "lacks",
+        "winrgw",
+        "winazw",
+        "stderr",
+    ]
+
+    @classmethod
+    def from_csv_row(cls, line: str) -> "Track":
+        parts = line.strip().split(",")
+        if len(parts) != len(cls.__field_order__):
+            raise ValueError(f"Expected {len(cls.__field_order__)} fields, got {len(parts)}")
+
+        converted = {}
+        for field_name, value in zip(cls.__field_order__, parts, strict=True):
+            field_info = cls.model_fields[field_name]
+            field_type = field_info.annotation
+
+            if field_type is None:
+                raise ValueError(f"Field '{field_name}' has no type annotation")
+
+            # Use alias if defined
+            key = field_info.alias or field_name
+            try:
+                # We trust simple coercion here; Pydantic will do final validation
+                converted[key] = field_type(value)
+            except Exception as e:
+                raise ValueError(f"Invalid value for field '{field_name}': {value} ({e})") from e
+
+        return cls(**converted)

antares-python/template.env

@@ -0,0 +1 @@
+ANTARES_BASE_URL = "http://localhost:8080"

antares-python/tests/client/test_tcp.py

@@ -4,18 +4,19 @@
 
 from antares.client.tcp import TCPSubscriber
 from antares.errors import SubscriptionError
+from antares.models.track import Track
 
 
 @pytest.mark.asyncio
-async def test_subscribe_success(monkeypatch):
-    # Simulated lines returned from the TCP stream
-    lines = [b'{"event": "ok"}\n', b'{"event": "done"}\n', b""]
+async def test_subscribe_success(monkeypatch, sample_track_line):
+    # Simulated CSV lines returned from the TCP stream
+    encoded_lines = [sample_track_line.encode() + b"\n", b""]
 
     async def fake_readline():
-        return lines.pop(0)
+        return encoded_lines.pop(0)
 
     # Simulate EOF after all lines are read
-    eof_flags = [False, False, True]
+    eof_flags = [False, True]
 
     fake_reader = AsyncMock()
     fake_reader.readline = AsyncMock(side_effect=fake_readline)
@@ -27,7 +28,11 @@ async def fake_readline():
     subscriber = TCPSubscriber("localhost", 1234, reconnect=False)
 
     events = [event async for event in subscriber.subscribe()]
-    assert events == [{"event": "ok"}, {"event": "done"}]
+    expected_lat = -33.45
+    assert len(events) == 1
+    assert isinstance(events[0], Track)
+    assert events[0].name == "Eagle-1"
+    assert events[0].lat == expected_lat
 
 
 @pytest.mark.asyncio
@@ -41,7 +46,7 @@ async def test_subscribe_failure(monkeypatch):
 
 
 @pytest.mark.asyncio
-async def test_subscribe_reconnects_on_failure(monkeypatch):
+async def test_subscribe_reconnects_on_failure(monkeypatch, sample_track_line):
     class OneMessageReader:
         def __init__(self):
             self.called = False
@@ -52,7 +57,7 @@ def at_eof(self):
         async def readline(self):
             if not self.called:
                 self.called = True
-                return b'{"event": "recovered"}\n'
+                return sample_track_line.encode() + b"\n"
             return b""
 
     open_calls = []
@@ -71,6 +76,65 @@ async def fake_open_connection(host, port):
     events = []
     async for event in subscriber.subscribe():
         events.append(event)
-        break  # Exit after one event
+        break  # exit after first track
 
-    assert events == [{"event": "recovered"}]
+    assert len(events) == 1
+    assert isinstance(events[0], Track)
+    assert events[0].name == "Eagle-1"
+
+
+@pytest.mark.asyncio
+async def test_subscribe_invalid_field_count(monkeypatch):
+    invalid_line = "1,2025,4,11"
+
+    async def fake_readline():
+        return invalid_line.encode() + b"\n"
+
+    fake_reader = AsyncMock()
+    fake_reader.readline = AsyncMock(side_effect=fake_readline)
+    fake_reader.at_eof = MagicMock(side_effect=[False, True])
+
+    monkeypatch.setattr("asyncio.open_connection", AsyncMock(return_value=(fake_reader, None)))
+
+    subscriber = TCPSubscriber("localhost", 1234, reconnect=False)
+
+    with pytest.raises(SubscriptionError) as excinfo:
+        async for _ in subscriber.subscribe():
+            pass
+
+    assert "Expected 25 fields" in str(excinfo.value)
+
+
+@pytest.mark.asyncio
+async def test_subscribe_invalid_value(monkeypatch, sample_track_line):
+    bad_line = sample_track_line.replace("1,", "bad_id,", 1)
+
+    async def fake_readline():
+        return bad_line.encode() + b"\n"
+
+    fake_reader = AsyncMock()
+    fake_reader.readline = AsyncMock(side_effect=fake_readline)
+    fake_reader.at_eof = MagicMock(side_effect=[False, True])
+
+    monkeypatch.setattr("asyncio.open_connection", AsyncMock(return_value=(fake_reader, None)))
+
+    subscriber = TCPSubscriber("localhost", 1234, reconnect=False)
+
+    with pytest.raises(SubscriptionError) as excinfo:
+        async for _ in subscriber.subscribe():
+            pass
+
+    assert "Invalid value for field 'id'" in str(excinfo.value)
+
+
+def test_from_csv_field_type_none(monkeypatch):
+    class FakeTrack(Track):
+        __field_order__ = ["id"]
+        id: int
+
+    FakeTrack.model_fields["id"].annotation = None
+
+    with pytest.raises(ValueError) as excinfo:
+        FakeTrack.from_csv_row("123")
+
+    assert "has no type annotation" in str(excinfo.value)