add missing testing.

adamlogan73 · adamlogan73 · commit d5a73d4f49db · 2026-03-15T21:32:34.000-07:00
Some updates to dependencies and conftest were also required.
Updated ruff version did formatting slightly different in a few files.
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
@@ -10,7 +10,9 @@ repos:
     hooks:
       - id: trailing-whitespace
     rev: "v4.1.0"
-  - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: 'v0.0.209'
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: 'v0.15.6'
     hooks:
-      - id: ruff
+      - id: ruff-format
+      - id: ruff-check
+      - id: ruff-format
diff --git a/homeassistant_api/models/domains.py b/homeassistant_api/models/domains.py
@@ -383,9 +383,9 @@ class ServiceFieldSelectorObject(BaseModel):
 class ServiceFieldSelectorQRCode(BaseModel):
     data: str
     scale: Optional[Union[int, float]] = None
-    error_correction_level: Optional[
-        ServiceFieldSelectorQRCodeErrorCorrectionLevel
-    ] = None
+    error_correction_level: Optional[ServiceFieldSelectorQRCodeErrorCorrectionLevel] = (
+        None
+    )
     center_image: Optional[str] = None
 
 
diff --git a/homeassistant_api/rawasyncclient.py b/homeassistant_api/rawasyncclient.py
@@ -112,7 +112,7 @@ async def async_request(
             )
         except asyncio.exceptions.TimeoutError as err:
             raise RequestTimeoutError(
-                f'Home Assistant did not respond in time (timeout: {kwargs.get("timeout", 300)} sec)',
+                f"Home Assistant did not respond in time (timeout: {kwargs.get('timeout', 300)} sec)",
                 self.endpoint(path) + f"?{params}" * bool(params),
             ) from err
 
diff --git a/homeassistant_api/rawclient.py b/homeassistant_api/rawclient.py
@@ -113,7 +113,7 @@ def request(
             )
         except requests.exceptions.Timeout as err:
             raise RequestTimeoutError(
-                f'Home Assistant did not respond in time (timeout: {kwargs.get("timeout", 300)} sec)',
+                f"Home Assistant did not respond in time (timeout: {kwargs.get('timeout', 300)} sec)",
                 url=self.endpoint(path) + f"?{params}" * bool(params),
             ) from err
         return self.response_logic(response=resp, decode_bytes=decode_bytes)
diff --git a/homeassistant_api/rawwebsocket.py b/homeassistant_api/rawwebsocket.py
@@ -41,12 +41,12 @@ def __init__(
         self._conn = None
 
         self._id_counter = 0
-        self._result_responses: dict[int, Optional[ResultResponse]] = (
-            {}
-        )  # id -> response
-        self._event_responses: dict[int, list[EventResponse]] = (
-            {}
-        )  # id -> [response, ...]
+        self._result_responses: dict[
+            int, Optional[ResultResponse]
+        ] = {}  # id -> response
+        self._event_responses: dict[
+            int, list[EventResponse]
+        ] = {}  # id -> [response, ...]
         self._ping_responses: dict[int, PingResponse] = {}  # id -> (sent, received)
 
     def __repr__(self) -> str:
diff --git a/homeassistant_api/utils.py b/homeassistant_api/utils.py
@@ -6,7 +6,8 @@
 
 if TYPE_CHECKING or os.getenv("DOCUMENTATION_MODE") != "true":
     JSONType = TypeAliasType(
-        "JSONType", "Optional[Union[int, float, str, bool, list[JSONType], dict[str, JSONType]]]"
+        "JSONType",
+        "Optional[Union[int, float, str, bool, list[JSONType], dict[str, JSONType]]]",
     )
 else:
     JSONType = type("JSONType", (object,), {})
diff --git a/poetry.lock b/poetry.lock
diff --git a/pyproject.toml b/pyproject.toml
@@ -43,19 +43,20 @@ types-requests = "^2.27.9"
 types-simplejson = "^3.17.3"
 types-toml = "^0.10.4"
 mypy = "^1.8.0"
-ruff = "^0.0.209"
+ruff = "^0.15"
 
 [tool.poetry.group.testing]
 optional = true
-
 [tool.poetry.group.testing.dependencies]
-pytest-asyncio = "^0.18.3"
-pytest-cov = "^3.0.0"
-pytest = "^6.2.5"
-aiosqlite = "^0.20.0"
+pytest-asyncio = "^1"
+pytest-cov = "^7"
+pytest = "^8"
+aiosqlite = "^0.22"
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "session"
+asyncio_default_test_loop_scope = "session"
 log_cli = true
 # log_cli_level = "DEBUG"
 log_cli_format = "%(asctime)s [%(levelname)8s] %(message)s (%(filename)s:%(lineno)s)"
@@ -72,7 +73,7 @@ exclude_lines = [
     "pragma: no cover"
 ]
 
-[tool.ruff]
+[tool.ruff.lint]
 exclude = [
     '.git',
     '__pycache__',
@@ -85,7 +86,7 @@ select = [
     'W',
 ]
 
-[tool.ruff.per-file-ignores]
+[tool.ruff.lint.per-file-ignores]
 "__init__.py" = ['F401']
 "conf.py" = ['E402']
 
diff --git a/tests/conftest.py b/tests/conftest.py
@@ -1,4 +1,3 @@
-import asyncio
 import logging
 import os
 from typing import AsyncGenerator, Generator, Literal, cast
@@ -35,14 +34,6 @@ def setup_cached_client(wait_for_server) -> Generator[Client, None, None]:
         yield cast(Client, client)
 
 
-@pytest.fixture(scope="session")
-def event_loop():
-    """Redefines the event loop with a broader scope."""
-    loop = asyncio.new_event_loop()
-    yield loop
-    loop.close()
-
-
 @pytest_asyncio.fixture(name="async_cached_client", scope="session")
 async def setup_async_cached_client(
     wait_for_server: Literal[None],
diff --git a/tests/test_endpoints.py b/tests/test_endpoints.py
@@ -3,6 +3,8 @@
 import logging
 from datetime import datetime
 
+import pytest
+
 from homeassistant_api import Client
 from homeassistant_api.errors import RequestError
 from homeassistant_api.models import ConfigEntryDisabler
@@ -154,6 +156,48 @@ async def test_async_get_entities(async_cached_client: Client) -> None:
     assert "sun" in entities
 
 
+def test_websocket_get_config(websocket_client: WebsocketClient) -> None:
+    """Tests the `"type": "get_config"` websocket command."""
+    config = websocket_client.get_config()
+    assert isinstance(config, dict)
+    assert config.get("state") in {"RUNNING", "NOT_RUNNING"}
+
+
+def test_websocket_get_state(websocket_client: WebsocketClient) -> None:
+    """Tests WebsocketClient.get_state with entity_id."""
+    state = websocket_client.get_state(entity_id="sun.sun")
+    assert state.entity_id == "sun.sun"
+    assert state.state in {"above_horizon", "below_horizon"}
+
+
+def test_websocket_get_entity_by_group_slug(websocket_client: WebsocketClient) -> None:
+    """Tests WebsocketClient.get_entity with group_id and slug."""
+    entity = websocket_client.get_entity(group_id="sun", slug="sun")
+    assert entity is not None
+    assert entity.entity_id == "sun.sun"
+
+
+def test_websocket_get_entity_by_entity_id(websocket_client: WebsocketClient) -> None:
+    """Tests WebsocketClient.get_entity with entity_id."""
+    entity = websocket_client.get_entity(entity_id="sun.sun")
+    assert entity is not None
+    assert entity.entity_id == "sun.sun"
+
+
+def test_websocket_get_entity_no_args(websocket_client: WebsocketClient) -> None:
+    """Tests WebsocketClient.get_entity raises ValueError with no arguments."""
+    with pytest.raises(
+        ValueError, match="Neither group_id and slug or entity_id provided"
+    ):
+        websocket_client.get_entity()
+
+
+def test_websocket_get_state_not_found(websocket_client: WebsocketClient) -> None:
+    """Tests WebsocketClient.get_state raises ValueError for nonexistent entity."""
+    with pytest.raises(ValueError, match="not found"):
+        websocket_client.get_state(entity_id="fake.nonexistent_entity_12345")
+
+
 def test_websocket_get_entities(websocket_client: WebsocketClient) -> None:
     """Tests the `"type": "get_entities"` websocket command."""
     entities = websocket_client.get_entities()
@@ -325,6 +369,22 @@ def test_websocket_trigger_service(websocket_client: WebsocketClient) -> None:
     assert resp is None
 
 
+def test_websocket_trigger_service_with_entity_id(
+    websocket_client: WebsocketClient,
+) -> None:
+    """Tests websocket trigger_service with an entity_id target."""
+    state_before = websocket_client.get_state(entity_id="sun.sun")
+    websocket_client.trigger_service(
+        "homeassistant",
+        "update_entity",
+        entity_id="sun.sun",
+    )
+    state_after = websocket_client.get_state(entity_id="sun.sun")
+    # update_entity refreshes the entity; state should remain valid
+    assert state_after.entity_id == state_before.entity_id
+    assert state_after.state in {"above_horizon", "below_horizon"}
+
+
 def test_trigger_service_with_response(cached_client: Client) -> None:
     """Tests the `POST /api/services/<domain>/<service>?return_response` endpoint."""
     weather = cached_client.get_domain("weather")
diff --git a/tests/test_errors.py b/tests/test_errors.py
@@ -19,6 +19,8 @@
     MalformedDataError,
     MethodNotAllowedError,
     ProcessorNotFoundError,
+    RequestError,
+    RequestTimeoutError,
     ResponseError,
     UnauthorizedError,
     UnexpectedStatusCodeError,
@@ -223,6 +225,37 @@ def test_unkown_scheme() -> None:
         Client("ftp://example.com", "token")
 
 
+def test_request_error_with_message_and_data() -> None:
+    """Tests RequestError when both message and data are provided."""
+    err = RequestError(
+        "some_data", url="http://localhost/api", message="Custom message"
+    )
+    assert "Custom message" in str(err)
+    assert "'http://localhost/api'" in str(err)
+    assert "'some_data'" in str(err)
+
+
+def test_request_error_no_data() -> None:
+    """Tests RequestError when data is None and no message."""
+    err = RequestError(None, url="http://localhost/api")
+    assert "'http://localhost/api'" in str(err)
+    assert "data" not in str(err)
+
+
+def test_request_timeout_error() -> None:
+    """Tests RequestTimeoutError constructor."""
+    err = RequestTimeoutError("Connection timed out", url="http://localhost/api")
+    assert "Connection timed out" in str(err)
+    assert "'http://localhost/api'" in str(err)
+    assert isinstance(err, RequestError)
+
+
+def test_websocket_invalid_scheme() -> None:
+    """Tests that WebsocketClient raises ValueError for non-ws schemes."""
+    with pytest.raises(ValueError, match="Unknown scheme"):
+        WebsocketClient("http://localhost", "token")
+
+
 def test_error_model_without_optional_fields() -> None:
     """Tests that Error model accepts responses missing optional translation fields."""
     error = Error(code="invalid_format", message="required key not provided")
diff --git a/tests/test_models.py b/tests/test_models.py
@@ -5,7 +5,8 @@
 
 import pytest
 
-from homeassistant_api import Client
+from homeassistant_api import Client, Domain
+from homeassistant_api.models.events import Event
 from homeassistant_api.models.states import State
 
 
@@ -119,6 +120,18 @@ def test_entity_get_history_none(cached_client: Client) -> None:
     assert history is None
 
 
+def test_event_from_json_raises() -> None:
+    """Tests that Event.from_json raises ValueError directing to from_json_with_client."""
+    with pytest.raises(ValueError, match="does not support `from_json\\(\\)`"):
+        Event.from_json({})
+
+
+def test_domain_from_json_with_client_missing_keys(cached_client: Client) -> None:
+    """Tests that Domain.from_json_with_client raises ValueError when keys are missing."""
+    with pytest.raises(ValueError, match="Missing services or domain"):
+        Domain.from_json_with_client({"foo": "bar"}, cached_client)
+
+
 async def test_async_entity_get_history_none(async_cached_client: Client) -> None:
     entity = await async_cached_client.async_get_entity(group_id="sun", slug="red_sun")
     assert entity is not None
diff --git a/tests/test_websocket.py b/tests/test_websocket.py
@@ -0,0 +1,100 @@
+"""Unit tests for RawWebsocketClient and WebsocketClient error paths."""
+
+import pytest
+
+from homeassistant_api.errors import ReceivingError, RequestError, ResponseError
+from homeassistant_api.rawwebsocket import RawWebsocketClient
+from homeassistant_api.models import websocket as ws_models
+
+
+def make_raw_client() -> RawWebsocketClient:
+    """Create a RawWebsocketClient without connecting."""
+    return RawWebsocketClient("ws://localhost:8123/api/websocket", "fake_token")
+
+
+def test_exit_without_connection() -> None:
+    """Tests __exit__ raises ReceivingError when connection is not open."""
+    client = make_raw_client()
+    with pytest.raises(ReceivingError, match="Connection is not open"):
+        client.__exit__(None, None, None)
+
+
+def test_send_without_connection() -> None:
+    """Tests _send raises ReceivingError when connection is not open."""
+    client = make_raw_client()
+    with pytest.raises(ReceivingError, match="Connection is not open"):
+        client._send({"type": "test"})
+
+
+def test_recv_without_connection() -> None:
+    """Tests _recv raises ReceivingError when connection is not open."""
+    client = make_raw_client()
+    with pytest.raises(ReceivingError, match="Connection is not open"):
+        client._recv()
+
+
+def test_handle_recv_message_without_id() -> None:
+    """Tests handle_recv raises ReceivingError for messages missing an id."""
+    client = make_raw_client()
+    with pytest.raises(ReceivingError, match="without an id"):
+        client.handle_recv({"type": "result", "success": True})
+
+
+def test_parse_response_error_result() -> None:
+    """Tests parse_response raises RequestError for failed result messages."""
+    client = make_raw_client()
+    client._result_responses[1] = None
+    with pytest.raises(RequestError):
+        client.parse_response(
+            {
+                "id": 1,
+                "type": "result",
+                "success": False,
+                "error": {"code": "not_found", "message": "Entity not found"},
+            }
+        )
+
+
+def test_parse_response_unexpected_type() -> None:
+    """Tests parse_response raises ReceivingError for unknown message types."""
+    client = make_raw_client()
+    with pytest.raises(ReceivingError, match="unexpected message type"):
+        client.parse_response({"id": 1, "type": "unknown_type"})
+
+
+def test_authentication_phase_invalid_welcome(monkeypatch) -> None:
+    """Tests authentication_phase raises ResponseError on invalid welcome message."""
+    client = make_raw_client()
+    monkeypatch.setattr(client, "_recv", lambda: {"type": "not_auth_required"})
+    with pytest.raises(
+        ResponseError, match="Unexpected response during authentication"
+    ):
+        client.authentication_phase()
+
+
+def test_authentication_phase_unexpected_auth_response(monkeypatch) -> None:
+    """Tests authentication_phase raises ResponseError when AuthOk.model_validate raises a non-ValidationError."""
+    call_count = 0
+
+    def fake_recv():
+        nonlocal call_count
+        call_count += 1
+        if call_count == 1:
+            return {"type": "auth_required", "ha_version": "2024.1.0"}
+        return {"type": "auth_ok", "ha_version": "2024.1.0", "message": "unexpected"}
+
+    client = make_raw_client()
+    monkeypatch.setattr(client, "_recv", fake_recv)
+    monkeypatch.setattr(client, "_send", lambda data: None)
+
+    # Patch AuthOk.model_validate to raise a non-ValidationError exception
+
+    def raise_runtime_error(*args, **kwargs):
+        raise RuntimeError("something went wrong")
+
+    monkeypatch.setattr(ws_models.AuthOk, "model_validate", raise_runtime_error)
+
+    with pytest.raises(
+        ResponseError, match="Unexpected response during authentication"
+    ):
+        client.authentication_phase()
diff --git a/volumes/config/.storage/core.restore_state b/volumes/config/.storage/core.restore_state

Original file line number	Diff line number	Diff line change
`@@ -112,7 +112,7 @@ async def async_request(`
`112`	`112`	`)`
`113`	`113`	`except asyncio.exceptions.TimeoutError as err:`
`114`	`114`	`raise RequestTimeoutError(`
`115`		`- f'Home Assistant did not respond in time (timeout: {kwargs.get("timeout", 300)} sec)',`
	`115`	`+ f"Home Assistant did not respond in time (timeout: {kwargs.get('timeout', 300)} sec)",`
`116`	`116`	`self.endpoint(path) + f"?{params}" * bool(params),`
`117`	`117`	`) from err`
`118`	`118`
Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,7 @@ def request(`
`113`	`113`	`)`
`114`	`114`	`except requests.exceptions.Timeout as err:`
`115`	`115`	`raise RequestTimeoutError(`
`116`		`- f'Home Assistant did not respond in time (timeout: {kwargs.get("timeout", 300)} sec)',`
	`116`	`+ f"Home Assistant did not respond in time (timeout: {kwargs.get('timeout', 300)} sec)",`
`117`	`117`	`url=self.endpoint(path) + f"?{params}" * bool(params),`
`118`	`118`	`) from err`
`119`	`119`	`return self.response_logic(response=resp, decode_bytes=decode_bytes)`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,8 @@`
`6`	`6`
`7`	`7`	`if TYPE_CHECKING or os.getenv("DOCUMENTATION_MODE") != "true":`
`8`	`8`	`JSONType = TypeAliasType(`
`9`		`- "JSONType", "Optional[Union[int, float, str, bool, list[JSONType], dict[str, JSONType]]]"`
	`9`	`+ "JSONType",`
	`10`	`+ "Optional[Union[int, float, str, bool, list[JSONType], dict[str, JSONType]]]",`
`10`	`11`	`)`
`11`	`12`	`else:`
`12`	`13`	`JSONType = type("JSONType", (object,), {})`