reach 100% coverage

Author: jsurrea

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

@@ -1,9 +1,12 @@
 import asyncio
 import json
+import logging
 from collections.abc import AsyncIterator
 
 from antares.errors import SubscriptionError
 
+logger = logging.getLogger(__name__)
+
 
 class TCPSubscriber:
     """
@@ -43,10 +46,13 @@ async def subscribe(self) -> AsyncIterator[dict]:
                 asyncio.IncompleteReadError,
                 json.JSONDecodeError,
             ) as e:
-                raise SubscriptionError(f"Failed to read from TCP stream: {e}") from e
+                logger.error("TCP stream error: %s", e)
+                if not self.reconnect:
+                    raise SubscriptionError(f"Failed to read from TCP stream: {e}") from e
 
+            # Stop if not reconnecting
             if not self.reconnect:
                 break
 
-            # Wait before attempting to reconnect
+            logger.info("Waiting 1 second before retrying TCP connection...")
             await asyncio.sleep(1)

antares-python/tests/client/test_rest.py

@@ -44,3 +44,41 @@ def test_add_ship_invalid_response(mocker):
     client = RestClient(base_url="http://localhost")
     with pytest.raises(SimulationError):
         client.add_ship(ship)
+
+
+def test_reset_simulation_http_error(mocker):
+    request = httpx.Request("POST", "http://localhost/simulation/reset")
+    response = httpx.Response(500, content=b"internal error", request=request)
+
+    mock_post = mocker.patch("httpx.post", return_value=response)
+
+    # .raise_for_status() triggers HTTPStatusError
+    def raise_error():
+        raise httpx.HTTPStatusError("error", request=request, response=response)
+
+    response.raise_for_status = raise_error
+
+    client = RestClient(base_url="http://localhost")
+
+    with pytest.raises(SimulationError) as exc:
+        client.reset_simulation()
+
+    assert "Reset failed" in str(exc.value)
+    mock_post.assert_called_once()
+
+
+def test_add_ship_request_error(mocker):
+    mocker.patch(
+        "httpx.post",
+        side_effect=httpx.RequestError(
+            "connection dropped", request=httpx.Request("POST", "http://localhost/simulation/ships")
+        ),
+    )
+
+    ship = ShipConfig(initial_position=(0, 0))
+    client = RestClient(base_url="http://localhost")
+
+    with pytest.raises(ConnectionError) as exc:
+        client.add_ship(ship)
+
+    assert "Could not reach Antares API" in str(exc.value)

antares-python/tests/client/test_tcp.py

@@ -38,3 +38,39 @@ async def test_subscribe_failure(monkeypatch):
     with pytest.raises(SubscriptionError):
         async for _ in subscriber.subscribe():
             pass
+
+
+@pytest.mark.asyncio
+async def test_subscribe_reconnects_on_failure(monkeypatch):
+    class OneMessageReader:
+        def __init__(self):
+            self.called = False
+
+        def at_eof(self):
+            return self.called
+
+        async def readline(self):
+            if not self.called:
+                self.called = True
+                return b'{"event": "recovered"}\n'
+            return b""
+
+    open_calls = []
+
+    async def fake_open_connection(host, port):
+        if not open_calls:
+            open_calls.append("fail")
+            raise ConnectionRefusedError("initial fail")
+        return OneMessageReader(), None
+
+    monkeypatch.setattr("asyncio.open_connection", fake_open_connection)
+    monkeypatch.setattr("asyncio.sleep", AsyncMock())
+
+    subscriber = TCPSubscriber("localhost", 1234, reconnect=True)
+
+    events = []
+    async for event in subscriber.subscribe():
+        events.append(event)
+        break  # Exit after one event
+
+    assert events == [{"event": "recovered"}]

antares-python/tests/test_cli.py

@@ -4,6 +4,7 @@
 from typer.testing import CliRunner
 
 from antares.cli import app
+from antares.errors import ConnectionError, SimulationError, SubscriptionError
 
 runner = CliRunner()
 
@@ -50,3 +51,86 @@ async def fake_sub(self):
     result = runner.invoke(app, ["subscribe", "--config", fake_config])
     assert result.exit_code == 0
     assert "test-event" in result.output
+
+
+def test_handle_error_json(monkeypatch):
+    result = runner.invoke(app, ["reset", "--json"], catch_exceptions=False)
+    assert result.exit_code in {1, 2}
+    assert "error" in result.output
+
+
+def test_build_client_fails(mocker):
+    mocker.patch("antares.config_loader.load_config", side_effect=Exception("broken config"))
+    result = runner.invoke(app, ["reset", "--config", "invalid.toml"])
+    assert result.exit_code == 1
+    assert "Failed to load configuration" in result.output
+
+
+def test_cli_reset_error_handling(mocker, fake_config):
+    mocker.patch(
+        "antares.client.rest.RestClient.reset_simulation",
+        side_effect=ConnectionError("cannot connect"),
+    )
+    result = runner.invoke(app, ["reset", "--config", fake_config])
+    expected_exit_code = 2
+    assert result.exit_code == expected_exit_code
+    assert "cannot connect" in result.output
+
+
+def test_cli_add_ship_error_handling(mocker, fake_config):
+    mocker.patch(
+        "antares.client.rest.RestClient.add_ship", side_effect=SimulationError("ship rejected")
+    )
+    result = runner.invoke(app, ["add-ship", "--x", "1", "--y", "2", "--config", fake_config])
+    expected_exit_code = 2
+    assert result.exit_code == expected_exit_code
+    assert "ship rejected" in result.output
+
+
+def test_cli_subscribe_error(monkeypatch, fake_config):
+    class FailingAsyncGenerator:
+        def __aiter__(self):
+            return self
+
+        async def __anext__(self):
+            raise SubscriptionError("stream failed")
+
+    monkeypatch.setattr(
+        "antares.client.tcp.TCPSubscriber.subscribe", lambda self: FailingAsyncGenerator()
+    )
+
+    result = runner.invoke(app, ["subscribe", "--config", fake_config])
+    expected_exit_code = 3
+    assert result.exit_code == expected_exit_code
+    assert "stream failed" in result.output
+
+
+def test_cli_verbose_prints_config(mocker, fake_config):
+    mocker.patch("antares.client.tcp.TCPSubscriber.subscribe", return_value=iter([]))
+    mocker.patch("antares.client.rest.RestClient.reset_simulation")
+
+    result = runner.invoke(app, ["reset", "--config", fake_config, "--verbose"])
+    assert result.exit_code == 0
+    assert "Using settings" in result.output
+
+
+def test_cli_subscribe_json(monkeypatch, fake_config):
+    class OneEventGen:
+        def __init__(self):
+            self.done = False
+
+        def __aiter__(self):
+            return self
+
+        async def __anext__(self):
+            if not self.done:
+                self.done = True
+                return {"event": "test"}
+            raise StopAsyncIteration
+
+    monkeypatch.setattr("antares.client.tcp.TCPSubscriber.subscribe", lambda self: OneEventGen())
+
+    result = runner.invoke(app, ["subscribe", "--config", fake_config, "--json"])
+
+    assert result.exit_code == 0
+    assert '{"event": "test"}' in result.output