Add unit tests for client params, error classes, and models

Author: adamlogan73

tests/test_client.py

@@ -1,4 +1,5 @@
 import os
+from datetime import datetime
 
 import aiohttp_client_cache.session
 import requests_cache
@@ -7,6 +8,7 @@
 from homeassistant_api import AsyncWebsocketClient
 from homeassistant_api import Client
 from homeassistant_api import WebsocketClient
+from homeassistant_api.baseclient import BaseClient
 
 
 def test_custom_cached_session() -> None:
@@ -62,3 +64,47 @@ async def test_async_websocket_client_ping() -> None:
         os.environ["HOMEASSISTANTAPI_TOKEN"],
     ) as client:
         assert (await client.ping_latency()) > 0
+
+
+# --- BaseClient: prepare_get_entity_histories_params with naive timestamps ---
+
+
+def test_prepare_entity_histories_naive_timestamps() -> None:
+    """Tests that naive (tzinfo=None) timestamps are converted to local timezone."""
+    naive_start = datetime(2024, 1, 1, 12, 0, 0)  # noqa: DTZ001
+    naive_end = datetime(2024, 6, 1, 12, 0, 0)  # noqa: DTZ001
+    params, url = BaseClient.prepare_get_entity_histories_params(
+        start_timestamp=naive_start,
+        end_timestamp=naive_end,
+    )
+    # Naive timestamps should get a timezone attached
+    assert "+" in url or "-" in url.split("T")[-1], (
+        "start_timestamp should have timezone offset"
+    )
+    assert "+" in params["end_time"] or "-" in params["end_time"].split("T")[-1], (
+        "end_time should have timezone offset"
+    )
+
+
+# --- BaseClient: prepare_get_logbook_entry_params ---
+
+
+def test_prepare_logbook_entry_no_start_timestamp() -> None:
+    """Tests logbook params without a start_timestamp return base 'logbook' path."""
+    params, url = BaseClient.prepare_get_logbook_entry_params(
+        filter_entities=["light.kitchen", "light.bedroom"],
+        end_timestamp=datetime(2024, 6, 1, 12, 0, 0),  # noqa: DTZ001
+    )
+    assert url == "logbook"
+    assert "light.kitchen,light.bedroom" in params["entity"]
+    assert "end_time" in params
+
+
+def test_prepare_logbook_entry_string_timestamps() -> None:
+    """Tests logbook params with string timestamps pass through unchanged."""
+    params, url = BaseClient.prepare_get_logbook_entry_params(
+        start_timestamp="2024-01-01T00:00:00",
+        end_timestamp="2024-06-01T00:00:00",
+    )
+    assert "2024-01-01T00:00:00" in url
+    assert params["end_time"] == "2024-06-01T00:00:00"

tests/test_errors.py

@@ -6,10 +6,12 @@
 from http import HTTPMethod
 
 import aiohttp
+import aiohttp_client_cache.session
 import pytest
 import requests
 from multidict import CIMultiDict
 from multidict import CIMultiDictProxy
+from requests_cache import CachedSession
 
 from homeassistant_api import AsyncClient
 from homeassistant_api import AsyncWebsocketClient
@@ -28,6 +30,7 @@
 from homeassistant_api.errors import ResponseError
 from homeassistant_api.errors import UnauthorizedError
 from homeassistant_api.errors import UnexpectedStatusCodeError
+from homeassistant_api.models.states import State
 from homeassistant_api.models.websocket import Error
 from homeassistant_api.processing import async_process_response
 from homeassistant_api.processing import process_response
@@ -287,3 +290,114 @@ def test_error_model_without_optional_fields() -> None:
     assert error.translation_key is None
     assert error.translation_placeholders is None
     assert error.translation_domain is None
+
+
+# --- Processing: async processor not found ---
+
+
+async def test_async_exception_processor_not_found_error() -> None:
+    """Tests that async_process_response raises ProcessorNotFoundError for unknown MIME types."""
+    with pytest.raises(ProcessorNotFoundError, match="this_type/does-not-exist"):
+        await async_process_response(
+            make_async_response(200, "", {"Content-Type": "this_type/does-not-exist"}),
+        )
+
+
+async def test_async_exception_bad_request() -> None:
+    """Tests that async_process_response raises RequestError for 400 responses."""
+    with pytest.raises(RequestError):
+        await async_process_response(
+            make_async_response(400, "bad request data", {}),
+        )
+
+
+async def test_async_exception_internal_server_error() -> None:
+    """Tests that async_process_response raises InternalServerError for 500 responses."""
+    with pytest.raises(InternalServerError):
+        await async_process_response(make_async_response(500, "server broke", {}))
+
+
+async def test_async_exception_unexpected_status_code() -> None:
+    """Tests that async_process_response raises UnexpectedStatusCodeError for unknown status."""
+    with pytest.raises(UnexpectedStatusCodeError):
+        await async_process_response(make_async_response(0, "", {}))
+
+
+# --- WebSocket: NotImplementedError stubs ---
+
+
+def test_websocket_set_state_not_supported(websocket_client: WebsocketClient) -> None:
+    """Tests that WebsocketClient.set_state raises NotImplementedError."""
+    state = State(state="test", entity_id="sun.sun")
+    with pytest.raises(
+        NotImplementedError,
+        match="not supported over the WebSocket API",
+    ):
+        websocket_client.set_state(state)
+
+
+def test_websocket_get_entity_histories_not_supported(
+    websocket_client: WebsocketClient,
+) -> None:
+    """Tests that WebsocketClient.get_entity_histories raises NotImplementedError."""
+    with pytest.raises(
+        NotImplementedError,
+        match="not supported over the WebSocket API",
+    ):
+        list(websocket_client.get_entity_histories())
+
+
+async def test_async_websocket_set_state_not_supported(
+    async_websocket_client: AsyncWebsocketClient,
+) -> None:
+    """Tests that AsyncWebsocketClient.set_state raises NotImplementedError."""
+    state = State(state="test", entity_id="sun.sun")
+    with pytest.raises(
+        NotImplementedError,
+        match="not supported over the WebSocket API",
+    ):
+        await async_websocket_client.set_state(state)
+
+
+async def test_async_websocket_get_entity_histories_not_supported(
+    async_websocket_client: AsyncWebsocketClient,
+) -> None:
+    """Tests that AsyncWebsocketClient.get_entity_histories raises NotImplementedError."""
+    with pytest.raises(
+        NotImplementedError,
+        match="not supported over the WebSocket API",
+    ):
+        async for _ in async_websocket_client.get_entity_histories():
+            pass
+
+
+# --- Client: no-cache session ---
+
+
+def test_client_no_cache_session() -> None:
+    """Tests that Client can be created without a cache session."""
+    token = os.environ["HOMEASSISTANTAPI_TOKEN"]
+    client = Client(HA_URL, token, use_cache=False)
+    assert isinstance(client._session, requests.Session)
+    assert not isinstance(client._session, CachedSession)
+
+
+def test_client_default_cache_session() -> None:
+    """Tests that Client creates a CachedSession when use_cache=True."""
+    token = os.environ["HOMEASSISTANTAPI_TOKEN"]
+    client = Client(HA_URL, token, use_cache=True)
+    assert isinstance(client._session, CachedSession)
+
+
+async def test_async_client_no_cache_session() -> None:
+    """Tests that AsyncClient can be created without a cache session."""
+    token = os.environ["HOMEASSISTANTAPI_TOKEN"]
+    client = AsyncClient(HA_URL, token, use_cache=False)
+    assert isinstance(client._session, aiohttp.ClientSession)
+
+
+async def test_async_client_default_cache_session() -> None:
+    """Tests that AsyncClient creates a CachedSession when use_cache=True."""
+    token = os.environ["HOMEASSISTANTAPI_TOKEN"]
+    client = AsyncClient(HA_URL, token, use_cache=True)
+    assert isinstance(client._session, aiohttp_client_cache.session.CachedSession)

tests/test_models.py

@@ -9,7 +9,10 @@
 from homeassistant_api import AsyncClient
 from homeassistant_api import Client
 from homeassistant_api import Domain
+from homeassistant_api.models.domains import BaseDomain
+from homeassistant_api.models.entity import BaseGroup
 from homeassistant_api.models.events import Event
+from homeassistant_api.models.history import History
 from homeassistant_api.models.states import State
 
 
@@ -142,3 +145,76 @@ async def test_async_entity_get_history_none(async_cached_client: AsyncClient) -
         end_timestamp=datetime(2020, 1, 1, tzinfo=UTC),
     )
     assert history is None
+
+
+# --- BaseGroup: __getattr__ for nonexistent key ---
+
+
+def test_base_group_getattr_nonexistent() -> None:
+    """Tests that BaseGroup.__getattr__ raises AttributeError for unknown attributes."""
+    group = BaseGroup(group_id="test")
+    assert group.get_entity("nonexistent") is None
+    with pytest.raises(AttributeError):
+        _ = group.nonexistent_entity
+
+
+def test_base_group_add_entity_not_implemented() -> None:
+    """Tests that BaseGroup._add_entity raises NotImplementedError."""
+    group = BaseGroup(group_id="test")
+    with pytest.raises(NotImplementedError):
+        group._add_entity("slug", State(state="on", entity_id="test.slug"))
+
+
+# --- BaseDomain: _add_service not implemented ---
+
+
+def test_base_domain_add_service_not_implemented() -> None:
+    """Tests that BaseDomain._add_service raises NotImplementedError."""
+    domain = BaseDomain(domain_id="test")
+    with pytest.raises(NotImplementedError):
+        domain._add_service("svc")
+
+
+def test_base_domain_from_json_invalid_services_type(cached_client: Client) -> None:
+    """Tests that Domain.from_json_with_client raises TypeError when services is not a dict."""
+    with pytest.raises(TypeError, match="Expected dict for services"):
+        Domain.from_json_with_client(
+            {"domain": "test", "services": "not_a_dict"},
+            cached_client,
+        )
+
+
+# --- History: repr and entity_id ---
+
+
+def test_history_repr() -> None:
+    """Tests that History has a meaningful repr with entity_id."""
+    states = (
+        State(state="on", entity_id="light.kitchen"),
+        State(state="off", entity_id="light.kitchen"),
+    )
+    history = History(states=states)
+    assert history.entity_id == "light.kitchen"
+    assert "light.kitchen" in repr(history)
+
+
+def test_history_entity_id_from_states() -> None:
+    """Tests that History.entity_id is derived from the states' entity_ids."""
+    states = (
+        State(state="on", entity_id="light.kitchen"),
+        State(state="off", entity_id="light.kitchen"),
+    )
+    history = History(states=states)
+    assert history.entity_id == "light.kitchen"
+
+
+# --- Domain: service access via attribute ---
+
+
+def test_domain_service_attribute_access(cached_client: Client) -> None:
+    """Tests that Domain services are accessible as attributes."""
+    notify = cached_client.get_domain("notify")
+    assert notify is not None
+    svc = notify.get_service("persistent_notification")
+    assert svc is not None
+    assert notify.persistent_notification == svc