Add async config entry methods and improve test coverage to 99%

Add async counterparts for all config entry websocket methods in
RawAsyncWebsocketClient. Add async tests for websocket state, entity,
config entry, and error path coverage. Fix conftest return type
annotation, replace zip(range) with break, and use pytest.raises
instead of try/except in error tests.

Author: adamlogan73

homeassistant_api/rawasyncwebsocket.py

@@ -21,7 +21,16 @@
     ResponseError,
     UnauthorizedError,
 )
-from homeassistant_api.models import Domain, Entity, Group, State
+from homeassistant_api.models import (
+    ConfigEntry,
+    ConfigEntryEvent,
+    ConfigSubEntry,
+    Domain,
+    Entity,
+    Group,
+    State,
+)
+from homeassistant_api.models.config_entries import DisableEnableResult, FlowResult
 from homeassistant_api.models.states import Context
 from homeassistant_api.models.websocket import (
     AuthInvalid,
@@ -497,6 +506,145 @@ async def _async_unsubscribe(self, subcription_id: int) -> None:
         assert cast(ResultResponse, resp).result is None
         self._event_responses.pop(subcription_id)
 
+    async def async_get_config_entries(self) -> Tuple[ConfigEntry, ...]:
+        """
+        Get all config entries.
+
+        Sends command :code:`{"type": "config_entries/get", ...}`.
+        """
+        resp = await self.async_recv(await self.async_send("config_entries/get"))
+        return tuple(
+            ConfigEntry.from_json(entry)
+            for entry in cast(
+                list[dict[str, JSONType]],
+                cast(ResultResponse, resp).result,
+            )
+        )
+
+    async def async_disable_config_entry(self, entry_id: str) -> DisableEnableResult:
+        """
+        Disable a config entry.
+
+        Sends command :code:`{"type": "config_entries/disable", ...}`.
+        """
+        resp = await self.async_recv(
+            await self.async_send(
+                "config_entries/disable",
+                entry_id=entry_id,
+                disabled_by="user",
+            )
+        )
+        return DisableEnableResult.from_json(
+            cast(dict[str, JSONType], cast(ResultResponse, resp).result)
+        )
+
+    async def async_enable_config_entry(self, entry_id: str) -> DisableEnableResult:
+        """
+        Enable a config entry.
+
+        Sends command :code:`{"type": "config_entries/disable", ...}`.
+        """
+        resp = await self.async_recv(
+            await self.async_send(
+                "config_entries/disable",
+                entry_id=entry_id,
+                disabled_by=None,
+            )
+        )
+        return DisableEnableResult.from_json(
+            cast(dict[str, JSONType], cast(ResultResponse, resp).result)
+        )
+
+    async def async_ignore_config_flow(self, flow_id: str, title: str) -> None:
+        """
+        Ignore a config flow.
+
+        Sends command :code:`{"type": "config_entries/ignore_flow", ...}`.
+        """
+        await self.async_recv(
+            await self.async_send(
+                "config_entries/ignore_flow",
+                flow_id=flow_id,
+                title=title,
+            )
+        )
+
+    async def async_get_nonuser_flows_in_progress(self) -> Tuple[FlowResult, ...]:
+        """
+        Get non-user config flows in progress.
+
+        Sends command :code:`{"type": "config_entries/flow/progress", ...}`.
+        """
+        resp = await self.async_recv(
+            await self.async_send("config_entries/flow/progress")
+        )
+        return tuple(
+            FlowResult.from_json(flow)
+            for flow in cast(
+                list[dict[str, JSONType]],
+                cast(ResultResponse, resp).result,
+            )
+        )
+
+    async def async_get_entry_subentries(
+        self, entry_id: str
+    ) -> Tuple[ConfigSubEntry, ...]:
+        """
+        Get subentries for a config entry.
+
+        Sends command :code:`{"type": "config_entries/subentries/list", ...}`.
+        """
+        resp = await self.async_recv(
+            await self.async_send("config_entries/subentries/list", entry_id=entry_id)
+        )
+        return tuple(
+            ConfigSubEntry.from_json(subentry)
+            for subentry in cast(
+                list[dict[str, JSONType]],
+                cast(ResultResponse, resp).result,
+            )
+        )
+
+    async def async_delete_entry_subentry(
+        self, entry_id: str, subentry_id: str
+    ) -> None:
+        """
+        Delete a subentry from a config entry.
+
+        Sends command :code:`{"type": "config_entries/subentries/delete", ...}`.
+        """
+        await self.async_recv(
+            await self.async_send(
+                "config_entries/subentries/delete",
+                entry_id=entry_id,
+                subentry_id=subentry_id,
+            )
+        )
+
+    @contextlib.asynccontextmanager
+    async def async_listen_config_entries(
+        self,
+    ) -> AsyncGenerator[AsyncGenerator[list[ConfigEntryEvent], None], None]:
+        """
+        Listen for config entry changes.
+
+        Sends command :code:`{"type": "config_entries/subscribe", ...}`.
+        """
+        subscription = (
+            await self.async_recv(await self.async_send("config_entries/subscribe"))
+        ).id
+        yield self._async_wait_for_config_entries(subscription)
+        await self._async_unsubscribe(subscription)
+
+    async def _async_wait_for_config_entries(
+        self, subscription_id: int
+    ) -> AsyncGenerator[list[ConfigEntryEvent], None]:
+        """An async iterator that waits for config entry events."""
+        while True:
+            event_resp = cast(EventResponse, await self.async_recv(subscription_id))
+            entries = cast(list[dict[str, JSONType]], event_resp.event)
+            yield [ConfigEntryEvent.from_json(entry) for entry in entries]
+
     async def async_fire_event(self, event_type: str, **event_data) -> Context:
         """
         Fire an event.

tests/conftest.py

@@ -62,7 +62,7 @@ def setup_websocket_client(
 @pytest.fixture(name="async_websocket_client", scope="session")
 async def setup_async_websocket_client(
     wait_for_server: Literal[None],
-) -> AsyncGenerator[Client, None]:
+) -> AsyncGenerator[WebsocketClient, None]:
     """Initializes the Client and enters an async WebSocket session."""
     async with WebsocketClient(
         os.environ["HOMEASSISTANTAPI_WS_URL"],

tests/test_endpoints.py

@@ -171,6 +171,15 @@ def test_websocket_get_config(websocket_client: WebsocketClient) -> None:
     assert config.get("state") in {"RUNNING", "NOT_RUNNING"}
 
 
+async def test_async_websocket_get_config(
+    async_websocket_client: WebsocketClient,
+) -> None:
+    """Tests the `"type": "get_config"` websocket command."""
+    config = await async_websocket_client.async_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")
@@ -200,6 +209,53 @@ def test_websocket_get_entity_no_args(websocket_client: WebsocketClient) -> None
         websocket_client.get_entity()
 
 
+async def test_async_websocket_get_state(
+    async_websocket_client: WebsocketClient,
+) -> None:
+    """Tests async WebsocketClient.async_get_state with entity_id."""
+    state = await async_websocket_client.async_get_state(entity_id="sun.sun")
+    assert state.entity_id == "sun.sun"
+    assert state.state in {"above_horizon", "below_horizon"}
+
+
+async def test_async_websocket_get_entity_by_group_slug(
+    async_websocket_client: WebsocketClient,
+) -> None:
+    """Tests async WebsocketClient.async_get_entity with group_id and slug."""
+    entity = await async_websocket_client.async_get_entity(group_id="sun", slug="sun")
+    assert entity is not None
+    assert entity.entity_id == "sun.sun"
+
+
+async def test_async_websocket_get_entity_by_entity_id(
+    async_websocket_client: WebsocketClient,
+) -> None:
+    """Tests async WebsocketClient.async_get_entity with entity_id."""
+    entity = await async_websocket_client.async_get_entity(entity_id="sun.sun")
+    assert entity is not None
+    assert entity.entity_id == "sun.sun"
+
+
+async def test_async_websocket_get_entity_no_args(
+    async_websocket_client: WebsocketClient,
+) -> None:
+    """Tests async WebsocketClient.async_get_entity raises ValueError with no arguments."""
+    with pytest.raises(
+        ValueError, match="Neither group_id and slug or entity_id provided"
+    ):
+        await async_websocket_client.async_get_entity()
+
+
+async def test_async_websocket_get_state_not_found(
+    async_websocket_client: WebsocketClient,
+) -> None:
+    """Tests async WebsocketClient.async_get_state raises ValueError for nonexistent entity."""
+    with pytest.raises(ValueError, match="not found"):
+        await async_websocket_client.async_get_state(
+            entity_id="fake.nonexistent_entity_12345"
+        )
+
+
 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"):
@@ -283,6 +339,14 @@ def test_get_nonuser_flows_in_progress(websocket_client: WebsocketClient) -> Non
     assert not flows
 
 
+async def test_async_get_nonuser_flows_in_progress(
+    async_websocket_client: WebsocketClient,
+) -> None:
+    """Tests the `"type": "config_entries/flow/progress"` websocket command."""
+    flows = await async_websocket_client.async_get_nonuser_flows_in_progress()
+    assert not flows
+
+
 def test_disable_enable_config_entry(websocket_client: WebsocketClient) -> None:
     """Tests the `"type": "config_entries/disable"` websocket command."""
     # Get sun entry
@@ -299,21 +363,42 @@ def test_disable_enable_config_entry(websocket_client: WebsocketClient) -> None:
     # Re-enable
     websocket_client.enable_config_entry(entry.entry_id)
 
-    # Check that it was enable
+    # Check that it was enabled
     enabled_entry = websocket_client.get_config_entries()[0]
     assert enabled_entry.disabled_by is None
 
 
+async def test_async_disable_enable_config_entry(
+    async_websocket_client: WebsocketClient,
+) -> None:
+    """Tests the `"type": "config_entries/disable"` websocket command."""
+    entry = (await async_websocket_client.async_get_config_entries())[0]
+    assert entry.disabled_by is None
+
+    await async_websocket_client.async_disable_config_entry(entry.entry_id)
+
+    disabled_entry = (await async_websocket_client.async_get_config_entries())[0]
+    assert disabled_entry.disabled_by is ConfigEntryDisabler.USER
+
+    await async_websocket_client.async_enable_config_entry(entry.entry_id)
+
+    enabled_entry = (await async_websocket_client.async_get_config_entries())[0]
+    assert enabled_entry.disabled_by is None
+
+
 def test_ignore_config_flow(websocket_client: WebsocketClient) -> None:
     """Tests the `"type": "config_entries/ignore_flow"` websocket command."""
     # Currently not able to test as no flows are in progress. Send invalid parameters and handle that error
-    try:
+    with pytest.raises(RequestError, match="Config entry not found"):
         websocket_client.ignore_config_flow("", "")
-    except RequestError as error:
-        assert (
-            error.__str__()
-            == "An error occurred while making the request to 'Config entry not found' with data: 'not_found'"
-        )
+
+
+async def test_async_ignore_config_flow(
+    async_websocket_client: WebsocketClient,
+) -> None:
+    """Tests the `"type": "config_entries/ignore_flow"` websocket command."""
+    with pytest.raises(RequestError, match="Config entry not found"):
+        await async_websocket_client.async_ignore_config_flow("", "")
 
 
 def test_get_config_entries(websocket_client: WebsocketClient) -> None:
@@ -345,6 +430,20 @@ def test_get_config_entries(websocket_client: WebsocketClient) -> None:
     assert sun.num_subentries == 0
 
 
+async def test_async_get_config_entries(
+    async_websocket_client: WebsocketClient,
+) -> None:
+    """Tests the `"type": "config_entries/get"` websocket command."""
+    entries = await async_websocket_client.async_get_config_entries()
+    assert len(entries) == 4
+
+    sun = entries[0]
+    assert sun.entry_id == "5f8426fa502435857743f302651753c9"
+    assert sun.domain == "sun"
+    assert sun.title == "Sun"
+    assert sun.disabled_by is None
+
+
 def test_get_entry_subentries(websocket_client: WebsocketClient) -> None:
     """Tests the `"type": "config_entries/subentries/list"` websocket command."""
     # Currently not able to test as no entries with subentries available
@@ -356,16 +455,28 @@ def test_get_entry_subentries(websocket_client: WebsocketClient) -> None:
     assert not websocket_client.get_entry_subentries(sun.entry_id)
 
 
+async def test_async_get_entry_subentries(
+    async_websocket_client: WebsocketClient,
+) -> None:
+    """Tests the `"type": "config_entries/subentries/list"` websocket command."""
+    sun = (await async_websocket_client.async_get_config_entries())[0]
+    assert sun
+    assert not await async_websocket_client.async_get_entry_subentries(sun.entry_id)
+
+
 def test_delete_entry_subentry(websocket_client: WebsocketClient) -> None:
     """Tests the `"type": "config_entries/subentries/delete"` websocket command."""
     # Currently not able to test as no entries with subentries available. Send invalid parameters and handle that error
-    try:
+    with pytest.raises(RequestError, match="Config entry not found"):
         websocket_client.delete_entry_subentry("", "")
-    except RequestError as error:
-        assert (
-            error.__str__()
-            == "An error occurred while making the request to 'Config entry not found' with data: 'not_found'"
-        )
+
+
+async def test_async_delete_entry_subentry(
+    async_websocket_client: WebsocketClient,
+) -> None:
+    """Tests the `"type": "config_entries/subentries/delete"` websocket command."""
+    with pytest.raises(RequestError, match="Config entry not found"):
+        await async_websocket_client.async_delete_entry_subentry("", "")
 
 
 def test_trigger_service(cached_client: Client) -> None:
@@ -473,7 +584,7 @@ async def test_async_websocket_trigger_service_with_response(
     """Tests the `"type": "trigger_service_with_response"` websocket command."""
     weather = await async_websocket_client.async_get_domain("weather")
     assert weather is not None
-    data = weather.get_forecasts(
+    data = await weather.get_forecasts(
         entity_id="weather.forecast_home",
         type="hourly",
     )