Add testing

Author: mj23000

tests/conftest.py

@@ -66,3 +66,16 @@ def setup_websocket_client(
         os.environ["HOMEASSISTANTAPI_TOKEN"],
     ) as client:
         yield client
+
+
+@pytest.fixture(name="async_websocket_client", scope="session")
+async def setup_async_websocket_client(
+    wait_for_server: Literal[None],
+) -> AsyncGenerator[Client, None]:
+    """Initializes the Client and enters an async WebSocket session."""
+    async with WebsocketClient(
+        os.environ["HOMEASSISTANTAPI_WS_URL"],
+        os.environ["HOMEASSISTANTAPI_TOKEN"],
+        use_async=True
+    ) as client:
+        yield client

tests/test_client.py

@@ -55,3 +55,12 @@ def test_websocket_client_ping() -> None:
         os.environ["HOMEASSISTANTAPI_TOKEN"],
     ) as client:
         assert client.ping_latency() > 0
+
+
+async def test_async_websocket_client_ping() -> None:
+    async with WebsocketClient(
+        os.environ["HOMEASSISTANTAPI_WS_URL"],
+        os.environ["HOMEASSISTANTAPI_TOKEN"],
+        use_async=True
+    ) as client:
+        assert (await client.async_ping_latency()) > 0

tests/test_endpoints.py

@@ -130,6 +130,19 @@ def test_websocket_get_rendered_template(websocket_client: WebsocketClient) -> N
     }
 
 
+async def test_async_websocket_get_rendered_template(
+    async_websocket_client: WebsocketClient
+) -> None:
+    """Tests the `"type": "render_template"` websocket command."""
+    rendered_template = await async_websocket_client.async_get_rendered_template(
+        'The sun is {{ states("sun.sun").replace("_", " the ") }}.'
+    )
+    assert rendered_template in {
+        "The sun is above the horizon.",
+        "The sun is below the horizon.",
+    }
+
+
 def test_check_api_config(cached_client: Client) -> None:
     """Tests the `POST /api/config/core/check_config` endpoint."""
     assert cached_client.check_api_config()
@@ -158,6 +171,14 @@ def test_websocket_get_entities(websocket_client: WebsocketClient) -> None:
     assert "sun" in entities
 
 
+async def test_async_websocket_get_entities(
+    async_websocket_client: WebsocketClient
+) -> None:
+    """Tests the `"type": "get_entities"` websocket command."""
+    entities = await async_websocket_client.async_get_entities()
+    assert "sun" in entities
+
+
 def test_get_domains(cached_client: Client) -> None:
     """Tests the `GET /api/services` endpoint."""
     domains = cached_client.get_domains()
@@ -176,6 +197,14 @@ def test_websocket_get_domains(websocket_client: WebsocketClient) -> None:
     assert "homeassistant" in domains
 
 
+async def test_async_websocket_get_domains(
+    async_websocket_client: WebsocketClient
+) -> None:
+    """Tests the `"type": "get_domains"` websocket command."""
+    domains = await async_websocket_client.async_get_domains()
+    assert "homeassistant" in domains
+
+
 def test_get_domain(cached_client: Client) -> None:
     """Tests the `GET /api/services` endpoint."""
     domain = cached_client.get_domain("homeassistant")
@@ -197,6 +226,15 @@ def test_websocket_get_domain(websocket_client: WebsocketClient) -> None:
     assert domain.services
 
 
+async def test_async_websocket_get_domain(
+    async_websocket_client: WebsocketClient
+) -> None:
+    """Tests the `"type": "get_domain"` websocket command."""
+    domain = await async_websocket_client.async_get_domain("homeassistant")
+    assert domain is not None
+    assert domain.services
+
+
 def test_trigger_service(cached_client: Client) -> None:
     """Tests the `POST /api/services/<domain>/<service>` endpoint."""
     notify = cached_client.get_domain("notify")
@@ -231,6 +269,19 @@ def test_websocket_trigger_service(websocket_client: WebsocketClient) -> None:
     assert resp is None
 
 
+async def test_async_websocket_trigger_service(
+    async_websocket_client: WebsocketClient
+) -> None:
+    """Tests the `"type": "trigger_service"` websocket command."""
+    notify = await async_websocket_client.async_get_domain("notify")
+    assert notify is not None
+    resp = await notify.persistent_notification(
+        message="Your API Test Suite just said hello!", title="Test Suite Notifcation"
+    )
+    # Websocket API doesnt return changed states so we check for None
+    assert resp is None
+
+
 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")
@@ -267,6 +318,20 @@ def test_websocket_trigger_service_with_response(
     assert data is not None
 
 
+async def test_async_websocket_trigger_service_with_response(
+    async_websocket_client: WebsocketClient
+) -> None:
+    """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(
+        entity_id="weather.forecast_home",
+        type="hourly",
+    )
+    # Websocket API doesnt return changed states so we check data is not None because we expect a response
+    assert data is not None
+
+
 def test_get_states(cached_client: Client) -> None:
     """Tests the `GET /api/states` endpoint."""
     states = cached_client.get_states()
@@ -288,6 +353,15 @@ def test_websocket_get_states(websocket_client: WebsocketClient) -> None:
         assert isinstance(state, State)
 
 
+async def test_async_websocket_get_states(
+    async_websocket_client: WebsocketClient
+) -> None:
+    """Tests the `"type": "get_states"` websocket command."""
+    states = await async_websocket_client.async_get_states()
+    for state in states:
+        assert isinstance(state, State)
+
+
 def test_get_state(cached_client: Client) -> None:
     """Tests the `GET /api/states/<entity_id>` endpoint."""
     state = cached_client.get_state(entity_id="sun.sun")

tests/test_errors.py

@@ -42,6 +42,16 @@ def test_websocket_unauthorized() -> None:
             pass
 
 
+async def test_async_websocket_unauthorized() -> None:
+    with pytest.raises(UnauthorizedError):
+        async with WebsocketClient(
+            os.environ["HOMEASSISTANTAPI_WS_URL"],
+            "lolthisisawrongtokenforsure",
+            use_async=True,
+        ):
+            pass
+
+
 async def test_async_unauthorized() -> None:
     with pytest.raises(UnauthorizedError):
         async with Client(

tests/test_events.py

@@ -16,6 +16,17 @@ def test_listen_events(websocket_client: WebsocketClient) -> None:
             assert event.data["message"] == "Triggered by websocket client"
 
 
+async def test_async_listen_events(async_websocket_client: WebsocketClient) -> None:
+    async with async_websocket_client.async_listen_events("async_test_event") as events:
+        await async_websocket_client.async_fire_event(
+            "async_test_event", message="Triggered by async websocket client"
+        )
+        async for _, event in zip(range(1), events):
+            assert event.origin == "LOCAL"
+            assert event.event_type == "async_test_event"
+            assert event.data["message"] == "Triggered by async websocket client"
+
+
 def test_listen_trigger(websocket_client: WebsocketClient) -> None:
     future = datetime.fromisoformat(
         websocket_client.get_rendered_template("{{ (now() + timedelta(seconds=1)) }}")
@@ -28,3 +39,19 @@ def test_listen_trigger(websocket_client: WebsocketClient) -> None:
             assert datetime.fromisoformat(
                 trigger["trigger"]["now"]
             ).timestamp() == pytest.approx(future.timestamp(), abs=1)
+
+
+async def test_async_listen_trigger(async_websocket_client: WebsocketClient) -> None:
+    future = datetime.fromisoformat(
+        await async_websocket_client.async_get_rendered_template(
+            "{{ (now() + timedelta(seconds=1)) }}"
+        )
+    )
+    async with async_websocket_client.async_listen_trigger(
+        "time", at=future.strftime("%H:%M:%S")
+    ) as triggers:
+        async for _, trigger in zip(range(1), triggers):
+            assert trigger["trigger"]["platform"] == "time"
+            assert datetime.fromisoformat(
+                trigger["trigger"]["now"]
+            ).timestamp() == pytest.approx(future.timestamp(), abs=1)