Convert test fixtures to async (#142052)

Author: emontnemery

tests/auth/providers/test_homeassistant.py

@@ -19,18 +19,18 @@
 
 
 @pytest.fixture
-def data(hass: HomeAssistant) -> hass_auth.Data:
+async def data(hass: HomeAssistant) -> hass_auth.Data:
     """Create a loaded data class."""
     data = hass_auth.Data(hass)
-    hass.loop.run_until_complete(data.async_load())
+    await data.async_load()
     return data
 
 
 @pytest.fixture
-def legacy_data(hass: HomeAssistant) -> hass_auth.Data:
+async def legacy_data(hass: HomeAssistant) -> hass_auth.Data:
     """Create a loaded legacy data class."""
     data = hass_auth.Data(hass)
-    hass.loop.run_until_complete(data.async_load())
+    await data.async_load()
     data.is_legacy = True
     return data
 

tests/components/api/test_init.py

@@ -22,12 +22,12 @@
 
 
 @pytest.fixture
-def mock_api_client(
+async def mock_api_client(
     hass: HomeAssistant, hass_client: ClientSessionGenerator
 ) -> TestClient:
     """Start the Home Assistant HTTP component and return admin API client."""
-    hass.loop.run_until_complete(async_setup_component(hass, "api", {}))
-    return hass.loop.run_until_complete(hass_client())
+    await async_setup_component(hass, "api", {})
+    return await hass_client()
 
 
 async def test_api_list_state_entities(

tests/components/cloud/conftest.py

@@ -218,9 +218,9 @@ def mock_user_data() -> Generator[MagicMock]:
 
 
 @pytest.fixture
-def mock_cloud_fixture(hass: HomeAssistant) -> CloudPreferences:
+async def mock_cloud_fixture(hass: HomeAssistant) -> CloudPreferences:
     """Fixture for cloud component."""
-    hass.loop.run_until_complete(mock_cloud(hass))
+    await mock_cloud(hass)
     return mock_cloud_prefs(hass, {})
 
 

tests/components/device_tracker/test_device_trigger.py

@@ -33,21 +33,19 @@ def stub_blueprint_populate_autouse(stub_blueprint_populate: None) -> None:
 
 
 @pytest.fixture(autouse=True)
-def setup_zone(hass: HomeAssistant) -> None:
+async def setup_zone(hass: HomeAssistant) -> None:
     """Create test zone."""
-    hass.loop.run_until_complete(
-        async_setup_component(
-            hass,
-            zone.DOMAIN,
-            {
-                "zone": {
-                    "name": "test",
-                    "latitude": HOME_LATITUDE,
-                    "longitude": HOME_LONGITUDE,
-                    "radius": 250,
-                }
-            },
-        )
+    await async_setup_component(
+        hass,
+        zone.DOMAIN,
+        {
+            "zone": {
+                "name": "test",
+                "latitude": HOME_LATITUDE,
+                "longitude": HOME_LONGITUDE,
+                "radius": 250,
+            }
+        },
     )
 
 

tests/components/duckdns/test_init.py

@@ -31,16 +31,16 @@ async def async_set_txt(hass: HomeAssistant, txt: str | None) -> None:
 
 
 @pytest.fixture
-def setup_duckdns(hass: HomeAssistant, aioclient_mock: AiohttpClientMocker) -> None:
+async def setup_duckdns(
+    hass: HomeAssistant, aioclient_mock: AiohttpClientMocker
+) -> None:
     """Fixture that sets up DuckDNS."""
     aioclient_mock.get(
         duckdns.UPDATE_URL, params={"domains": DOMAIN, "token": TOKEN}, text="OK"
     )
 
-    hass.loop.run_until_complete(
-        async_setup_component(
-            hass, duckdns.DOMAIN, {"duckdns": {"domain": DOMAIN, "access_token": TOKEN}}
-        )
+    await async_setup_component(
+        hass, duckdns.DOMAIN, {"duckdns": {"domain": DOMAIN, "access_token": TOKEN}}
     )
 
 

tests/components/freedns/test_init.py

@@ -16,25 +16,25 @@
 
 
 @pytest.fixture
-def setup_freedns(hass: HomeAssistant, aioclient_mock: AiohttpClientMocker) -> None:
+async def setup_freedns(
+    hass: HomeAssistant, aioclient_mock: AiohttpClientMocker
+) -> None:
     """Fixture that sets up FreeDNS."""
     params = {}
     params[ACCESS_TOKEN] = ""
     aioclient_mock.get(
         UPDATE_URL, params=params, text="Successfully updated 1 domains."
     )
 
-    hass.loop.run_until_complete(
-        async_setup_component(
-            hass,
-            freedns.DOMAIN,
-            {
-                freedns.DOMAIN: {
-                    "access_token": ACCESS_TOKEN,
-                    "scan_interval": UPDATE_INTERVAL,
-                }
-            },
-        )
+    await async_setup_component(
+        hass,
+        freedns.DOMAIN,
+        {
+            freedns.DOMAIN: {
+                "access_token": ACCESS_TOKEN,
+                "scan_interval": UPDATE_INTERVAL,
+            }
+        },
     )
 
 

tests/components/frontend/test_storage.py

@@ -13,9 +13,9 @@
 
 
 @pytest.fixture(autouse=True)
-def setup_frontend(hass: HomeAssistant) -> None:
+async def setup_frontend(hass: HomeAssistant) -> None:
     """Fixture to setup the frontend."""
-    hass.loop.run_until_complete(async_setup_component(hass, "frontend", {}))
+    await async_setup_component(hass, "frontend", {})
 
 
 async def test_get_user_data_empty(

tests/components/geo_location/test_trigger.py

@@ -29,22 +29,20 @@ def calls(hass: HomeAssistant) -> list[ServiceCall]:
 
 
 @pytest.fixture(autouse=True)
-def setup_comp(hass: HomeAssistant) -> None:
+async def setup_comp(hass: HomeAssistant) -> None:
     """Initialize components."""
     mock_component(hass, "group")
-    hass.loop.run_until_complete(
-        async_setup_component(
-            hass,
-            zone.DOMAIN,
-            {
-                "zone": {
-                    "name": "test",
-                    "latitude": 32.880837,
-                    "longitude": -117.237561,
-                    "radius": 250,
-                }
-            },
-        )
+    await async_setup_component(
+        hass,
+        zone.DOMAIN,
+        {
+            "zone": {
+                "name": "test",
+                "latitude": 32.880837,
+                "longitude": -117.237561,
+                "radius": 250,
+            }
+        },
     )
 
 

tests/components/google_assistant/test_google_assistant.py

@@ -1,6 +1,5 @@
 """The tests for the Google Assistant component."""
 
-from asyncio import AbstractEventLoop
 from http import HTTPStatus
 import json
 from unittest.mock import patch
@@ -38,32 +37,28 @@ def auth_header(hass_access_token: str) -> dict[str, str]:
 
 
 @pytest.fixture
-def assistant_client(
-    event_loop: AbstractEventLoop,
+async def assistant_client(
     hass: core.HomeAssistant,
     hass_client_no_auth: ClientSessionGenerator,
 ) -> TestClient:
     """Create web client for the Google Assistant API."""
-    loop = event_loop
-    loop.run_until_complete(
-        setup.async_setup_component(
-            hass,
-            "google_assistant",
-            {
-                "google_assistant": {
-                    "project_id": PROJECT_ID,
-                    "entity_config": {
-                        "light.ceiling_lights": {
-                            "aliases": ["top lights", "ceiling lights"],
-                            "name": "Roof Lights",
-                        }
-                    },
-                }
-            },
-        )
+    await setup.async_setup_component(
+        hass,
+        "google_assistant",
+        {
+            "google_assistant": {
+                "project_id": PROJECT_ID,
+                "entity_config": {
+                    "light.ceiling_lights": {
+                        "aliases": ["top lights", "ceiling lights"],
+                        "name": "Roof Lights",
+                    }
+                },
+            }
+        },
     )
 
-    return loop.run_until_complete(hass_client_no_auth())
+    return await hass_client_no_auth()
 
 
 @pytest.fixture(autouse=True)
@@ -87,16 +82,12 @@ async def wanted_platforms_only() -> None:
 
 
 @pytest.fixture
-def hass_fixture(
-    event_loop: AbstractEventLoop, hass: core.HomeAssistant
-) -> core.HomeAssistant:
+async def hass_fixture(hass: core.HomeAssistant) -> core.HomeAssistant:
     """Set up a Home Assistant instance for these tests."""
-    loop = event_loop
-
     # We need to do this to get access to homeassistant/turn_(on,off)
-    loop.run_until_complete(setup.async_setup_component(hass, core.DOMAIN, {}))
+    await setup.async_setup_component(hass, core.DOMAIN, {})
 
-    loop.run_until_complete(setup.async_setup_component(hass, "demo", {}))
+    await setup.async_setup_component(hass, "demo", {})
 
     return hass
 

tests/components/hassio/conftest.py

@@ -46,7 +46,7 @@ def hassio_env(supervisor_is_connected: AsyncMock) -> Generator[None]:
 
 
 @pytest.fixture
-def hassio_stubs(
+async def hassio_stubs(
     hassio_env: None,
     hass: HomeAssistant,
     hass_client: ClientSessionGenerator,
@@ -75,27 +75,27 @@ def hassio_stubs(
             "homeassistant.components.hassio.issues.SupervisorIssues.setup",
         ),
     ):
-        hass.loop.run_until_complete(async_setup_component(hass, "hassio", {}))
+        await async_setup_component(hass, "hassio", {})
 
     return hass_api.call_args[0][1]
 
 
 @pytest.fixture
-def hassio_client(
+async def hassio_client(
     hassio_stubs: RefreshToken, hass: HomeAssistant, hass_client: ClientSessionGenerator
 ) -> TestClient:
     """Return a Hass.io HTTP client."""
-    return hass.loop.run_until_complete(hass_client())
+    return await hass_client()
 
 
 @pytest.fixture
-def hassio_noauth_client(
+async def hassio_noauth_client(
     hassio_stubs: RefreshToken,
     hass: HomeAssistant,
     aiohttp_client: ClientSessionGenerator,
 ) -> TestClient:
     """Return a Hass.io HTTP client without auth."""
-    return hass.loop.run_until_complete(aiohttp_client(hass.http.app))
+    return await aiohttp_client(hass.http.app)
 
 
 @pytest.fixture

tests/components/http/test_cors.py

@@ -1,6 +1,5 @@
 """Test cors for the HTTP component."""
 
-from asyncio import AbstractEventLoop
 from http import HTTPStatus
 from pathlib import Path
 from unittest.mock import patch
@@ -55,14 +54,12 @@ async def mock_handler(request):
 
 
 @pytest.fixture
-def client(
-    event_loop: AbstractEventLoop, aiohttp_client: ClientSessionGenerator
-) -> TestClient:
+async def client(aiohttp_client: ClientSessionGenerator) -> TestClient:
     """Fixture to set up a web.Application."""
     app = web.Application()
     setup_cors(app, [TRUSTED_ORIGIN])
     app[KEY_ALLOW_CONFIGURED_CORS](app.router.add_get("/", mock_handler))
-    return event_loop.run_until_complete(aiohttp_client(app))
+    return await aiohttp_client(app)
 
 
 async def test_cors_requests(client) -> None:

tests/components/meraki/test_device_tracker.py

@@ -1,6 +1,5 @@
 """The tests the for Meraki device tracker."""
 
-from asyncio import AbstractEventLoop
 from http import HTTPStatus
 import json
 
@@ -22,31 +21,25 @@
 
 
 @pytest.fixture
-def meraki_client(
-    event_loop: AbstractEventLoop,
+async def meraki_client(
     hass: HomeAssistant,
     hass_client: ClientSessionGenerator,
 ) -> TestClient:
     """Meraki mock client."""
-    loop = event_loop
-
-    async def setup_and_wait():
-        result = await async_setup_component(
-            hass,
-            device_tracker.DOMAIN,
-            {
-                device_tracker.DOMAIN: {
-                    CONF_PLATFORM: "meraki",
-                    CONF_VALIDATOR: "validator",
-                    CONF_SECRET: "secret",
-                }
-            },
-        )
-        await hass.async_block_till_done()
-        return result
-
-    assert loop.run_until_complete(setup_and_wait())
-    return loop.run_until_complete(hass_client())
+    assert await async_setup_component(
+        hass,
+        device_tracker.DOMAIN,
+        {
+            device_tracker.DOMAIN: {
+                CONF_PLATFORM: "meraki",
+                CONF_VALIDATOR: "validator",
+                CONF_SECRET: "secret",
+            }
+        },
+    )
+    await hass.async_block_till_done()
+
+    return await hass_client()
 
 
 async def test_invalid_or_missing_data(