Fix/add more tests (#145)

* rename _Websocket to _WebsocketService to match convention, remove previous websocket tests

* unreviewed codex written tests for websocket service

* have codex make tests easier to read across the board

* remove usless core test

* unreviewed codex written tests for core

* unreviewed codex written tests for bus and predicates

* never use from future import annotations

* fix core tests

* add post_to_loop method

* fix tests by using post_to_loop method

* update changelog

Author: NodeJSmith

CHANGELOG.md

@@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Add validation for filename extension in AppManifest - add `.py` if no suffix, raise error if not `.py`
 - Bus handlers can now accept args and kwargs to be passed to the callback when the event is fired
 - `tasks.py` renamed to `task_bucket.py` to follow naming conventions
+- `post_to_loop` method added to `TaskBucket` to allow posting callables to the event loop from other threads
 
 ### Changed
 - **Breaking:** - Renamed `async_utils.py` to `func_utils.py`, added `callable_name` and `callable_short_name` utility functions

src/hassette/core/core.py

@@ -23,7 +23,7 @@
 from .services.health_service import _HealthService
 from .services.scheduler_service import _SchedulerService
 from .services.service_watcher import _ServiceWatcher
-from .services.websocket_service import _Websocket
+from .services.websocket_service import _WebsocketService
 
 if typing.TYPE_CHECKING:
     from hassette.events import Event
@@ -71,7 +71,7 @@ def __init__(self, config: HassetteConfig) -> None:
         self._bus_service = self.add_child(_BusService, stream=self._receive_stream.clone())
 
         self._service_watcher = self.add_child(_ServiceWatcher)
-        self._websocket = self.add_child(_Websocket)
+        self._websocket = self.add_child(_WebsocketService)
         self._health_service = self.add_child(_HealthService)
         self._file_watcher = self.add_child(_FileWatcher)
         self._app_handler = self.add_child(_AppHandler)

src/hassette/core/resources/task_bucket.py

@@ -126,6 +126,10 @@ def _call() -> R:
 
         return asyncio.to_thread(_call)
 
+    def post_to_loop(self, fn, *args, **kwargs) -> None:
+        """Schedule a callable on the event loop from any thread."""
+        self.hassette.loop.call_soon_threadsafe(fn, *args, **kwargs)
+
     @overload
     def make_async_adapter(self, fn: Callable[P, Awaitable[R]]) -> Callable[P, Awaitable[R]]: ...
     @overload

src/hassette/core/services/websocket_service.py

@@ -52,7 +52,7 @@
 )
 
 
-class _Websocket(Service):  # pyright: ignore[reportUnusedClass]
+class _WebsocketService(Service):  # pyright: ignore[reportUnusedClass]
     url: str
     """WebSocket URL to connect to."""
 

src/hassette/test_utils/harness.py

@@ -24,7 +24,7 @@
 from hassette.core.services.bus_service import _BusService
 from hassette.core.services.file_watcher import _FileWatcher
 from hassette.core.services.scheduler_service import _SchedulerService
-from hassette.core.services.websocket_service import _Websocket
+from hassette.core.services.websocket_service import _WebsocketService
 from hassette.enums import ResourceStatus
 from hassette.events import Event
 from hassette.test_utils.test_server import SimpleTestServer
@@ -85,7 +85,7 @@ def __init__(self, *, config: HassetteConfig) -> None:
         self._scheduler: Scheduler | None = None
         self._file_watcher: _FileWatcher | None = None
         self._app_handler: _AppHandler | None = None
-        self._websocket: _Websocket | None = None
+        self._websocket: _WebsocketService | None = None
 
     async def send_event(self, topic: str, event: Event[Any]) -> None:
         if not self._send_stream:
@@ -293,7 +293,7 @@ async def _start_api_mock(self) -> None:
         self._exit_stack.enter_context(rest_url_patch)
         self._exit_stack.enter_context(headers_patch)
 
-        self.hassette._websocket = Mock(spec=_Websocket)
+        self.hassette._websocket = Mock(spec=_WebsocketService)
         self.hassette._websocket.ready_event = asyncio.Event()
         self.hassette._websocket.ready_event.set()
 

tests/test_api.py

@@ -7,39 +7,43 @@
 
 
 async def test_api_rest_request_sets_body_and_headers(hassette_with_mock_api: tuple[Api, SimpleTestServer]):
-    api, mock = hassette_with_mock_api
+    """POST requests include JSON body and expected headers."""
+    api_client, mock_server = hassette_with_mock_api
 
-    mock.expect("POST", "/api/thing", "", json={"a": 1}, status=200)
+    mock_server.expect("POST", "/api/thing", "", json={"a": 1}, status=200)
 
-    resp = await api.rest_request("POST", "/api/thing", data={"a": 1})
-    resp_data = await resp.json()
+    response = await api_client.rest_request("POST", "/api/thing", data={"a": 1})
+    payload = await response.json()
 
-    assert "application/json" in resp.headers.get("Content-Type", ""), "Expected JSON response"
-    assert resp_data == {"a": 1}, f"Expected echoed JSON, got {resp_data}"
+    assert "application/json" in response.headers.get("Content-Type", ""), "Expected JSON response"
+    assert payload == {"a": 1}, f"Expected echoed JSON, got {payload}"
 
 
 async def test_api_rest_request_cleans_params(hassette_with_mock_api: tuple[Api, SimpleTestServer]):
-    api, mock = hassette_with_mock_api
+    """Query parameters are cleaned before sending a GET request."""
+    api_client, mock_server = hassette_with_mock_api
 
-    params = {"keep": "x", "none": None, "empty": "  ", "flag": False}
+    request_params = {"keep": "x", "none": None, "empty": "  ", "flag": False}
 
-    mock.expect("GET", "/api/thing", "keep=x&flag=false", status=200)
+    mock_server.expect("GET", "/api/thing", "keep=x&flag=false", status=200)
 
-    resp = await api.rest_request("GET", "/api/thing", params=params)
+    response = await api_client.rest_request("GET", "/api/thing", params=request_params)
 
-    assert resp.status == 200, f"Expected 200 OK, got {resp.status}"
+    assert response.status == 200, f"Expected 200 OK, got {response.status}"
 
-    assert dict(resp.request_info.url.query) == {"keep": "x", "flag": "false"}, (
-        f"Unexpected query params: {resp.request_info.url.query}"
+    assert dict(response.request_info.url.query) == {"keep": "x", "flag": "false"}, (
+        f"Unexpected query params: {response.request_info.url.query}"
     )
 
 
 def test_clean_kwargs_basic():
-    out = clean_kwargs(a=None, b=False, c="  ", d="x", e=5)
-    assert out == {"b": "false", "d": "x", "e": 5}, f"Unexpected cleaned kwargs: {out}"
+    """clean_kwargs drops empty values and normalises booleans."""
+    cleaned_kwargs = clean_kwargs(a=None, b=False, c="  ", d="x", e=5)
+    assert cleaned_kwargs == {"b": "false", "d": "x", "e": 5}, f"Unexpected cleaned kwargs: {cleaned_kwargs}"
 
 
 def test_sync_parity():
+    """Sync facade exposes the same public methods as the async API."""
     api_methods = inspect.getmembers(Api, predicate=inspect.isfunction)
     api_sync_methods = inspect.getmembers(ApiSyncFacade, predicate=inspect.isfunction)
 

tests/test_apps.py

@@ -63,7 +63,7 @@ async def test_handle_changes_disables_app(self) -> None:
         event = asyncio.Event()
 
         async def handler(*args, **kwargs):  # noqa
-            event.set()
+            self.hassette.task_bucket.post_to_loop(event.set)
 
         self.hassette._bus_service.add_listener(
             Listener(
@@ -103,7 +103,7 @@ async def test_handle_changes_enables_app(self) -> None:
         event = asyncio.Event()
 
         async def handler(*args, **kwargs):  # noqa
-            event.set()
+            self.hassette.task_bucket.post_to_loop(event.set)
 
         self.hassette._bus_service.add_listener(
             Listener(

tests/test_bus.py

@@ -1,48 +1,176 @@
 # pyright: reportInvalidTypeArguments=none, reportArgumentType=none
 
+
 import asyncio
+import typing
 from types import SimpleNamespace
+from unittest.mock import AsyncMock, Mock
+
+import pytest
 
+from hassette.core.resources.bus.listeners import Subscription
+from hassette.core.resources.bus.predicates import AllOf, AttrChanged, EntityMatches, Guard, StateChanged
+from hassette.core.resources.bus.predicates.event import CallServiceEventWrapper, KeyValueMatches
 from hassette.events.base import Event
 
+if typing.TYPE_CHECKING:
+    from hassette.core.core import Hassette
+    from hassette.core.resources.bus.bus import Bus
+
+
+@pytest.fixture
+def bus_instance(hassette_with_bus: "Hassette") -> "Bus":
+    """Return the Bus resource for the running Hassette harness."""
+    return hassette_with_bus._bus
+
+
+async def test_on_registers_listener_and_supports_unsubscribe(bus_instance: "Bus") -> None:
+    """Bus.on wraps handlers, normalises predicates, and wires subscription cleanup."""
+
+    async def handler(event):  # noqa
+        await asyncio.sleep(0)
+
+    add_listener_mock = Mock()
+    remove_listener_mock = Mock()
+    original_service = bus_instance.bus_service
+    original_remove = bus_instance.remove_listener
+    bus_instance.bus_service = Mock(add_listener=add_listener_mock)  # type: ignore[assignment]
+    bus_instance.remove_listener = remove_listener_mock  # type: ignore[assignment]
+
+    try:
+        subscription = bus_instance.on(
+            topic="demo.topic",
+            handler=handler,
+            where=[lambda _: True],
+            args=("prefix",),
+            kwargs={"suffix": "!"},
+            once=True,
+            debounce=0.1,
+            throttle=0.2,
+        )
+
+        assert isinstance(subscription, Subscription)
+        add_listener_mock.assert_called_once()
+        listener = add_listener_mock.call_args.args[0]
+
+        assert listener.topic == "demo.topic"
+        assert listener.orig_handler is handler
+        assert asyncio.iscoroutinefunction(listener.handler)
+        assert listener.args == ("prefix",)
+        assert listener.kwargs == {"suffix": "!"}
+        assert listener.once is True
+        assert listener.debounce == 0.1
+        assert listener.throttle == 0.2
+        assert isinstance(listener.predicate, AllOf)
+
+        subscription.unsubscribe()
+        remove_listener_mock.assert_called_once_with(listener)
+    finally:
+        bus_instance.bus_service = original_service  # type: ignore[assignment]
+        bus_instance.remove_listener = original_remove  # type: ignore[assignment]
+
+
+async def test_on_state_change_builds_predicates(bus_instance: "Bus") -> None:
+    """on_state_change composes entity, state, and extra predicates."""
+    extra_guard = Guard(lambda event: event.payload.topic == "any")
+
+    subscription = bus_instance.on_state_change(
+        "sensor.kitchen",
+        handler=AsyncMock(),
+        changed_from="off",
+        changed_to="on",
+        where=extra_guard,
+        args=(),
+        kwargs=None,
+    )
+
+    listener = subscription.listener
+    assert isinstance(listener.predicate, AllOf)
+    predicate_types = {type(pred) for pred in listener.predicate.predicates}
+    assert EntityMatches in predicate_types
+    assert StateChanged in predicate_types
+    assert extra_guard in listener.predicate.predicates
+
+
+async def test_on_attribute_change_targets_attribute(bus_instance: "Bus") -> None:
+    """on_attribute_change adds AttrChanged predicate for the supplied attribute."""
+    subscription = bus_instance.on_attribute_change(
+        "light.office",
+        "brightness",
+        handler=AsyncMock(),
+        changed_from=100,
+        changed_to=200,
+    )
+
+    listener = subscription.listener
+    assert isinstance(listener.predicate, AllOf)
+    attr_predicates = [pred for pred in listener.predicate.predicates if isinstance(pred, AttrChanged)]
+    assert attr_predicates, "Expected AttrChanged predicate to be included"
+    attr_pred = attr_predicates[0]
+    assert attr_pred.name == "brightness"
+    assert attr_pred.from_ == 100
+    assert attr_pred.to == 200
+
+
+async def test_on_call_service_handles_mapping_predicates(bus_instance: "Bus") -> None:
+    """on_call_service wraps mapping filters as KeyValueMatches within a CallServiceEventWrapper."""
+    subscription = bus_instance.on_call_service(
+        domain="light",
+        service="turn_on",
+        handler=AsyncMock(),
+        where=[{"entity_id": "light.kitchen"}, lambda data: data.get("brightness", 0) > 150],
+    )
+
+    listener = subscription.listener
+    assert isinstance(listener.predicate, AllOf)
+
+    predicate_types = {type(pred) for pred in listener.predicate.predicates}
+    assert Guard in predicate_types, "Expected domain/service guards"
+    assert CallServiceEventWrapper in predicate_types, "Expected wrapper for mapping predicates"
+
+    wrapper = next(pred for pred in listener.predicate.predicates if isinstance(pred, CallServiceEventWrapper))
+    assert any(isinstance(pred, KeyValueMatches) for pred in wrapper.predicates)
+
 
 async def test_once_listener_removed(hassette_with_bus) -> None:
+    """Listeners registered with once=True are removed after the first invocation."""
     hassette = hassette_with_bus
 
-    payloads: list[int] = []
-    first_fired = asyncio.Event()
+    received_payloads: list[int] = []
+    first_invocation = asyncio.Event()
 
     async def handler(event: Event[SimpleNamespace]) -> None:
-        payloads.append(event.payload.value)
-        first_fired.set()
+        received_payloads.append(event.payload.value)
+        hassette_with_bus.task_bucket.post_to_loop(first_invocation.set)
 
     hassette._bus.on(topic="custom.once", handler=handler, once=True)
 
     await hassette.send_event("custom.once", Event(topic="custom.once", payload=SimpleNamespace(value=1)))
 
-    await asyncio.wait_for(first_fired.wait(), timeout=1)
+    await asyncio.wait_for(first_invocation.wait(), timeout=1)
     await asyncio.sleep(0.05)
 
     await hassette.send_event("custom.once", Event(topic="custom.once", payload=SimpleNamespace(value=2)))
 
     await asyncio.sleep(0.1)
 
-    assert payloads == [1], f"Expected handler to fire once with payload 1, got {payloads}"
+    assert received_payloads == [1], f"Expected handler to fire once with payload 1, got {received_payloads}"
 
 
 async def test_bus_background_tasks_cleanup(hassette_with_bus) -> None:
+    """Bus cleans up background tasks after a once handler completes."""
     hassette = hassette_with_bus
 
-    fired = asyncio.Event()
+    event_received = asyncio.Event()
 
     async def handler(event: Event[SimpleNamespace]) -> None:  # noqa
-        fired.set()
+        hassette_with_bus.task_bucket.post_to_loop(event_received.set)
 
     hassette._bus.on(topic="custom.cleanup", handler=handler, once=True)
 
     await hassette.send_event("custom.cleanup", Event(topic="custom.cleanup", payload=SimpleNamespace(value=9)))
 
-    await asyncio.wait_for(fired.wait(), timeout=1)
+    await asyncio.wait_for(event_received.wait(), timeout=1)
     await asyncio.sleep(0.1)
 
     assert len(hassette._bus.task_bucket) == 0, (
@@ -51,19 +179,22 @@ async def handler(event: Event[SimpleNamespace]) -> None:  # noqa
 
 
 async def test_bus_uses_args_kwargs(hassette_with_bus) -> None:
+    """Handlers receive configured args and kwargs when invoked."""
     hassette = hassette_with_bus
 
-    received: list[str] = []
-    fired = asyncio.Event()
+    formatted_messages: list[str] = []
+    event_processed = asyncio.Event()
 
     def handler(event: Event[SimpleNamespace], prefix: str, suffix: str) -> None:
-        received.append(f"{prefix}{event.payload.value}{suffix}")
-        fired.set()
+        formatted_messages.append(f"{prefix}{event.payload.value}{suffix}")
+        hassette_with_bus.task_bucket.post_to_loop(event_processed.set)
 
     hassette._bus.on(topic="custom.args", handler=handler, args=("Value: ",), kwargs={"suffix": "!"})
 
     await hassette.send_event("custom.args", Event(topic="custom.args", payload=SimpleNamespace(value="Test")))
 
-    await asyncio.wait_for(fired.wait(), timeout=1)
+    await asyncio.wait_for(event_processed.wait(), timeout=1)
 
-    assert received == ["Value: Test!"], f"Expected handler to receive formatted value, got {received}"
+    assert formatted_messages == ["Value: Test!"], (
+        f"Expected handler to receive formatted value, got {formatted_messages}"
+    )

tests/test_config.py

@@ -6,9 +6,7 @@
 
 
 def test_overrides_are_used(env_file_path: Path, test_config: HassetteConfig) -> None:
-    """
-    Test that the overrides in the HassetteConfig are used correctly.
-    """
+    """Configuration values honour overrides from the test TOML and .env."""
 
     expected_token = dotenv.get_key(env_file_path, "hassette__token")
 
@@ -21,9 +19,9 @@ def test_overrides_are_used(env_file_path: Path, test_config: HassetteConfig) ->
 
 
 def test_env_overrides_are_used(test_config_class, monkeypatch):
-    """
-    Test that environment variable overrides are used correctly.
-    """
+    """Environment overrides win when constructing a HassetteConfig."""
     monkeypatch.setenv("hassette__app_dir", "/custom/apps")
-    config = test_config_class()
-    assert config.app_dir == Path("/custom/apps"), f"Expected /custom/apps, got {config.app_dir}"
+    config_with_env_override = test_config_class()
+    assert config_with_env_override.app_dir == Path("/custom/apps"), (
+        f"Expected /custom/apps, got {config_with_env_override.app_dir}"
+    )