Use fixtures instead of helper functions for APCUPSD tests (home-assistant#151172)

Co-authored-by: Franck Nijhof <frenck@frenck.nl>

Author: yuxincs

homeassistant/components/apcupsd/__init__.py

@@ -9,7 +9,7 @@
 
 from .coordinator import APCUPSdConfigEntry, APCUPSdCoordinator
 
-PLATFORMS: Final = (Platform.BINARY_SENSOR, Platform.SENSOR)
+PLATFORMS: Final = [Platform.BINARY_SENSOR, Platform.SENSOR]
 
 
 async def async_setup_entry(

tests/components/apcupsd/__init__.py

@@ -4,15 +4,8 @@
 
 from collections import OrderedDict
 from typing import Final
-from unittest.mock import patch
 
-from homeassistant.components.apcupsd.const import DOMAIN
-from homeassistant.components.apcupsd.coordinator import APCUPSdData
-from homeassistant.config_entries import SOURCE_USER
 from homeassistant.const import CONF_HOST, CONF_PORT
-from homeassistant.core import HomeAssistant
-
-from tests.common import MockConfigEntry
 
 CONF_DATA: Final = {CONF_HOST: "test", CONF_PORT: 1234}
 
@@ -79,33 +72,3 @@
         ("END APC", "1970-01-01 00:00:00 0000"),
     ]
 )
-
-
-async def async_init_integration(
-    hass: HomeAssistant,
-    *,
-    host: str = "test",
-    status: dict[str, str] | None = None,
-    entry_id: str = "mocked-config-entry-id",
-) -> MockConfigEntry:
-    """Set up the APC UPS Daemon integration in HomeAssistant."""
-    if status is None:
-        status = MOCK_STATUS
-
-    entry = MockConfigEntry(
-        entry_id=entry_id,
-        version=1,
-        domain=DOMAIN,
-        title="APCUPSd",
-        data=CONF_DATA | {CONF_HOST: host},
-        unique_id=APCUPSdData(status).serial_no,
-        source=SOURCE_USER,
-    )
-
-    entry.add_to_hass(hass)
-
-    with patch("aioapcaccess.request_status", return_value=status):
-        assert await hass.config_entries.async_setup(entry.entry_id)
-        await hass.async_block_till_done()
-
-    return entry

tests/components/apcupsd/conftest.py

@@ -1,10 +1,21 @@
 """Common fixtures for the APC UPS Daemon (APCUPSD) tests."""
 
-from collections.abc import Generator
+from collections.abc import AsyncGenerator, Generator
 from unittest.mock import AsyncMock, patch
 
 import pytest
 
+from homeassistant.components.apcupsd import PLATFORMS
+from homeassistant.components.apcupsd.const import DOMAIN
+from homeassistant.components.apcupsd.coordinator import APCUPSdData
+from homeassistant.config_entries import SOURCE_USER
+from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant
+
+from . import CONF_DATA, MOCK_STATUS
+
+from tests.common import MockConfigEntry
+
 
 @pytest.fixture
 def mock_setup_entry() -> Generator[AsyncMock]:
@@ -13,3 +24,58 @@ def mock_setup_entry() -> Generator[AsyncMock]:
         "homeassistant.components.apcupsd.async_setup_entry", return_value=True
     ) as mock_setup_entry:
         yield mock_setup_entry
+
+
+@pytest.fixture
+async def mock_request_status(
+    request: pytest.FixtureRequest,
+) -> AsyncGenerator[AsyncMock]:
+    """Return a mocked aioapcaccess.request_status function."""
+    mocked_status = getattr(request, "param", None) or MOCK_STATUS
+
+    with patch("aioapcaccess.request_status") as mock_request_status:
+        mock_request_status.return_value = mocked_status
+        yield mock_request_status
+
+
+@pytest.fixture
+def mock_config_entry(
+    request: pytest.FixtureRequest,
+    mock_request_status: AsyncMock,
+) -> MockConfigEntry:
+    """Mock setting up a config entry."""
+    entry_id = getattr(request, "param", None)
+
+    return MockConfigEntry(
+        entry_id=entry_id,
+        version=1,
+        domain=DOMAIN,
+        title="APC UPS Daemon",
+        data=CONF_DATA,
+        unique_id=APCUPSdData(mock_request_status.return_value).serial_no,
+        source=SOURCE_USER,
+    )
+
+
+@pytest.fixture
+def platforms() -> list[Platform]:
+    """Fixture to specify platforms to test."""
+    return PLATFORMS
+
+
+@pytest.fixture
+async def init_integration(
+    request: pytest.FixtureRequest,
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+    mock_request_status: AsyncMock,
+    platforms: list[Platform],
+) -> MockConfigEntry:
+    """Set up APC UPS Daemon integration for testing."""
+    mock_config_entry.add_to_hass(hass)
+
+    with patch("homeassistant.components.apcupsd.PLATFORMS", platforms):
+        await hass.config_entries.async_setup(mock_config_entry.entry_id)
+        await hass.async_block_till_done()
+
+    return mock_config_entry

tests/components/apcupsd/snapshots/test_init.ambr

@@ -1,5 +1,5 @@
 # serializer version: 1
-# name: test_async_setup_entry[status0][device_MyUPS_XXXXXXXXXXXX]
+# name: test_async_setup_entry[mock_request_status0-mocked-config-entry-id][device_MyUPS_XXXXXXXXXXXX]
   DeviceRegistryEntrySnapshot({
     'area_id': None,
     'config_entries': <ANY>,
@@ -30,7 +30,7 @@
     'via_device_id': None,
   })
 # ---
-# name: test_async_setup_entry[status1][device_APC UPS_XXXX]
+# name: test_async_setup_entry[mock_request_status1-mocked-config-entry-id][device_APC UPS_XXXX]
   DeviceRegistryEntrySnapshot({
     'area_id': None,
     'config_entries': <ANY>,
@@ -61,7 +61,7 @@
     'via_device_id': None,
   })
 # ---
-# name: test_async_setup_entry[status2][device_APC UPS_<no serial>]
+# name: test_async_setup_entry[mock_request_status2-mocked-config-entry-id][device_APC UPS_<no serial>]
   DeviceRegistryEntrySnapshot({
     'area_id': None,
     'config_entries': <ANY>,
@@ -92,7 +92,7 @@
     'via_device_id': None,
   })
 # ---
-# name: test_async_setup_entry[status3][device_APC UPS_Blank]
+# name: test_async_setup_entry[mock_request_status3-mocked-config-entry-id][device_APC UPS_Blank]
   DeviceRegistryEntrySnapshot({
     'area_id': None,
     'config_entries': <ANY>,

tests/components/apcupsd/test_binary_sensor.py

@@ -1,6 +1,6 @@
 """Test binary sensors of APCUPSd integration."""
 
-from unittest.mock import patch
+from unittest.mock import AsyncMock
 
 import pytest
 from syrupy.assertion import SnapshotAssertion
@@ -10,47 +10,60 @@
 from homeassistant.helpers import entity_registry as er
 from homeassistant.util import slugify
 
-from . import MOCK_STATUS, async_init_integration
+from . import MOCK_STATUS
 
-from tests.common import snapshot_platform
+from tests.common import MockConfigEntry, snapshot_platform
+
+pytestmark = pytest.mark.usefixtures(
+    "entity_registry_enabled_by_default", "init_integration"
+)
+
+
+@pytest.fixture
+def platforms() -> list[Platform]:
+    """Overridden fixture to specify platforms to test."""
+    return [Platform.BINARY_SENSOR]
 
 
 async def test_binary_sensor(
     hass: HomeAssistant,
     entity_registry: er.EntityRegistry,
     snapshot: SnapshotAssertion,
+    mock_config_entry: MockConfigEntry,
 ) -> None:
-    """Test states of binary sensors."""
-    with patch("homeassistant.components.apcupsd.PLATFORMS", [Platform.BINARY_SENSOR]):
-        config_entry = await async_init_integration(hass, status=MOCK_STATUS)
-    await snapshot_platform(hass, entity_registry, snapshot, config_entry.entry_id)
+    """Test states of binary sensor entities."""
+    await snapshot_platform(hass, entity_registry, snapshot, mock_config_entry.entry_id)
 
 
-async def test_no_binary_sensor(hass: HomeAssistant) -> None:
+@pytest.mark.parametrize(
+    "mock_request_status",
+    [{k: v for k, v in MOCK_STATUS.items() if k != "STATFLAG"}],
+    indirect=True,
+)
+async def test_no_binary_sensor(
+    hass: HomeAssistant,
+    mock_request_status: AsyncMock,
+) -> None:
     """Test binary sensor when STATFLAG is not available."""
-    status = MOCK_STATUS.copy()
-    status.pop("STATFLAG")
-    await async_init_integration(hass, status=status)
-
-    device_slug = slugify(MOCK_STATUS["UPSNAME"])
+    device_slug = slugify(mock_request_status.return_value["UPSNAME"])
     state = hass.states.get(f"binary_sensor.{device_slug}_online_status")
     assert state is None
 
 
 @pytest.mark.parametrize(
-    ("override", "expected"),
+    ("mock_request_status", "expected"),
     [
-        ("0x008", "on"),
-        ("0x02040010 Status Flag", "off"),
+        (MOCK_STATUS | {"STATFLAG": "0x008"}, "on"),
+        (MOCK_STATUS | {"STATFLAG": "0x02040010 Status Flag"}, "off"),
     ],
+    indirect=["mock_request_status"],
 )
-async def test_statflag(hass: HomeAssistant, override: str, expected: str) -> None:
+async def test_statflag(
+    hass: HomeAssistant,
+    mock_request_status: AsyncMock,
+    expected: str,
+) -> None:
     """Test binary sensor for different STATFLAG values."""
-    status = MOCK_STATUS.copy()
-    status["STATFLAG"] = override
-    await async_init_integration(hass, status=status)
-
-    device_slug = slugify(MOCK_STATUS["UPSNAME"])
-    assert (
-        hass.states.get(f"binary_sensor.{device_slug}_online_status").state == expected
-    )
+    device_slug = slugify(mock_request_status.return_value["UPSNAME"])
+    state = hass.states.get(f"binary_sensor.{device_slug}_online_status")
+    assert state.state == expected