Introduce MockSmaEvCharger to tests (#25)

Author: alengwenus

custom_components/smaev/__init__.py

@@ -4,11 +4,8 @@
 import logging
 from typing import TYPE_CHECKING
 
-from pysmaev.core import SmaEvCharger
-from pysmaev.exceptions import (
-    SmaEvChargerAuthenticationError,
-    SmaEvChargerConnectionError,
-)
+import pysmaev.core
+import pysmaev.exceptions
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
@@ -57,16 +54,16 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     url = f"{protocol}://{entry.data[CONF_HOST]}"
 
     session = async_get_clientsession(hass, verify_ssl=entry.data[CONF_VERIFY_SSL])
-    evcharger = SmaEvCharger(
+    evcharger = pysmaev.core.SmaEvCharger(
         session, url, entry.data[CONF_USERNAME], entry.data[CONF_PASSWORD]
     )
 
     try:
         await evcharger.open()
         smaev_device_info = await evcharger.device_info()
-    except SmaEvChargerConnectionError as exc:
+    except pysmaev.exceptions.SmaEvChargerConnectionError as exc:
         raise ConfigEntryNotReady from exc
-    except SmaEvChargerAuthenticationError as exc:
+    except pysmaev.exceptions.SmaEvChargerAuthenticationError as exc:
         raise ConfigEntryAuthFailed from exc
 
     if TYPE_CHECKING:

custom_components/smaev/config_flow.py

@@ -5,11 +5,8 @@
 import logging
 from typing import Any
 
-from pysmaev.core import SmaEvCharger
-from pysmaev.exceptions import (
-    SmaEvChargerAuthenticationError,
-    SmaEvChargerConnectionError,
-)
+import pysmaev.core
+import pysmaev.exceptions
 
 import voluptuous as vol
 
@@ -49,15 +46,17 @@ async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> dict[str,
 
     protocol = "https" if data[CONF_SSL] else "http"
     url = f"{protocol}://{data[CONF_HOST]}"
-    evcharger = SmaEvCharger(session, url, data[CONF_USERNAME], data[CONF_PASSWORD])
+    evcharger = pysmaev.core.SmaEvCharger(
+        session, url, data[CONF_USERNAME], data[CONF_PASSWORD]
+    )
 
     errors: dict[str, str] = {}
     device_info: dict[str, str] = {}
     try:
         await evcharger.open()
-    except SmaEvChargerConnectionError:
+    except pysmaev.exceptions.SmaEvChargerConnectionError:
         errors[CONF_BASE] = "cannot_connect"
-    except SmaEvChargerAuthenticationError:
+    except pysmaev.exceptions.SmaEvChargerAuthenticationError:
         errors[CONF_BASE] = "invalid_auth"
     except Exception:  # pylint: disable=broad-except
         _LOGGER.exception("Unexpected exception")

tests/conftest.py

@@ -2,10 +2,14 @@
 import os
 import sys
 
+from unittest.mock import AsyncMock
+
 import pytest
 from homeassistant.const import CONF_HOST
 from custom_components import smaev
 
+from pysmaev.core import SmaEvCharger
+
 # Tests in the dev enviromentment use the pytest_homeassistant_custom_component instead of
 # a cloned HA core repo for a simple and clean structure. To still test against a HA core
 # clone (e.g. the dev branch for which no pytest_homeassistant_custom_component exists
@@ -33,6 +37,25 @@ def auto_enable_custom_integrations(enable_custom_integrations):
 }
 
 
+DEVICE_INFO = {
+    "name": "SMA EV Charger 22",
+    "serial": "1234567890",
+    "model": "EVC22-3AC-10",
+    "manufacturer": "SMA",
+    "sw_version": "1.2.23.R",
+}
+
+
+class MockSmaEvCharger(SmaEvCharger):
+    """Mocked SmaEvCharger."""
+
+    open = AsyncMock()
+    request_measurements = AsyncMock()
+    request_parameters = AsyncMock()
+
+    device_info = AsyncMock(return_value=DEVICE_INFO)
+
+
 @pytest.fixture(name="entry")
 def create_entry():
     """Return mock entry."""
@@ -44,15 +67,3 @@ def create_entry():
         options={},
     )
     return entry
-
-
-@pytest.fixture(name="device_info")
-def device_info():
-    """Return device info."""
-    return {
-        "name": "SMA EV Charger 22",
-        "serial": "1234567890",
-        "model": "EVC22-3AC-10",
-        "manufacturer": "SMA",
-        "sw_version": "1.2.23.R",
-    }

tests/test_config_flow.py

@@ -3,14 +3,17 @@
 
 import pytest
 
+import pysmaev.core
+import pysmaev.exceptions
+
 from homeassistant import config_entries, data_entry_flow
 from homeassistant.const import CONF_HOST, CONF_BASE
 from homeassistant.core import HomeAssistant
 
 from custom_components import smaev
 from custom_components.smaev.config_flow import SmaEvChargerConfigFlow, validate_input
 
-from .conftest import CONFIG_DATA
+from .conftest import CONFIG_DATA, MockSmaEvCharger, DEVICE_INFO
 
 
 async def test_show_form(hass: HomeAssistant) -> None:
@@ -24,44 +27,41 @@ async def test_show_form(hass: HomeAssistant) -> None:
     assert result["step_id"] == "user"
 
 
-async def test_step_user(hass, device_info):
+@patch.object(pysmaev.core, "SmaEvCharger", MockSmaEvCharger)
+async def test_step_user(hass):
     """Test for user step."""
-    with (
-        patch("pysmaev.core.SmaEvCharger.open"),
-        patch("pysmaev.core.SmaEvCharger.device_info", return_value=device_info),
-    ):
-        data = CONFIG_DATA.copy()
-        result = await hass.config_entries.flow.async_init(
-            smaev.DOMAIN, context={"source": config_entries.SOURCE_USER}, data=data
-        )
+    data = CONFIG_DATA.copy()
+    result = await hass.config_entries.flow.async_init(
+        smaev.DOMAIN, context={"source": config_entries.SOURCE_USER}, data=data
+    )
 
-        assert result["type"] == data_entry_flow.FlowResultType.CREATE_ENTRY
-        assert result["title"] == CONFIG_DATA[CONF_HOST]
-        assert result["data"] == CONFIG_DATA
+    assert result["type"] == data_entry_flow.FlowResultType.CREATE_ENTRY
+    assert result["title"] == CONFIG_DATA[CONF_HOST]
+    assert result["data"] == CONFIG_DATA
 
 
-async def test_step_user_existing_host(hass, entry, device_info):
+@patch.object(pysmaev.core, "SmaEvCharger", MockSmaEvCharger)
+async def test_step_user_existing_host(hass, entry):
     """Test for user defined host already exists."""
     entry.add_to_hass(hass)
 
-    with (
-        patch("pysmaev.core.SmaEvCharger.open"),
-        patch("pysmaev.core.SmaEvCharger.device_info", return_value=device_info),
-    ):
-        data = entry.data.copy()
-        result = await hass.config_entries.flow.async_init(
-            smaev.DOMAIN, context={"source": config_entries.SOURCE_USER}, data=data
-        )
+    data = entry.data.copy()
+    result = await hass.config_entries.flow.async_init(
+        smaev.DOMAIN, context={"source": config_entries.SOURCE_USER}, data=data
+    )
 
-        assert result["type"] == data_entry_flow.FlowResultType.ABORT
-        assert result["reason"] == "already_configured"
+    assert result["type"] == data_entry_flow.FlowResultType.ABORT
+    assert result["reason"] == "already_configured"
 
 
 @pytest.mark.parametrize(
     ("error", "errors"),
     [
-        (smaev.SmaEvChargerConnectionError, {CONF_BASE: "cannot_connect"}),
-        (smaev.SmaEvChargerAuthenticationError, {CONF_BASE: "invalid_auth"}),
+        (pysmaev.exceptions.SmaEvChargerConnectionError, {CONF_BASE: "cannot_connect"}),
+        (
+            pysmaev.exceptions.SmaEvChargerAuthenticationError,
+            {CONF_BASE: "invalid_auth"},
+        ),
         (Exception, {CONF_BASE: "unknown"}),
     ],
 )
@@ -77,7 +77,8 @@ async def test_step_user_error(hass, error, errors):
         assert result["errors"] == errors
 
 
-async def test_options_flow(hass, entry, device_info):
+@patch.object(pysmaev.core, "SmaEvCharger", MockSmaEvCharger)
+async def test_options_flow(hass, entry):
     """Test config flow options."""
     entry.add_to_hass(hass)
     result = await hass.config_entries.options.async_init(entry.entry_id)
@@ -87,13 +88,9 @@ async def test_options_flow(hass, entry, device_info):
 
     user_input = CONFIG_DATA.copy()
 
-    with (
-        patch("pysmaev.core.SmaEvCharger.open"),
-        patch("pysmaev.core.SmaEvCharger.device_info", return_value=device_info),
-    ):
-        result = await hass.config_entries.options.async_configure(
-            result["flow_id"], user_input=user_input
-        )
+    result = await hass.config_entries.options.async_configure(
+        result["flow_id"], user_input=user_input
+    )
 
     assert result["type"] == data_entry_flow.FlowResultType.CREATE_ENTRY
     assert all(value == entry.data[key] for key, value in user_input.items())
@@ -102,8 +99,11 @@ async def test_options_flow(hass, entry, device_info):
 @pytest.mark.parametrize(
     ("error", "errors"),
     [
-        (smaev.SmaEvChargerConnectionError, {CONF_BASE: "cannot_connect"}),
-        (smaev.SmaEvChargerAuthenticationError, {CONF_BASE: "invalid_auth"}),
+        (pysmaev.exceptions.SmaEvChargerConnectionError, {CONF_BASE: "cannot_connect"}),
+        (
+            pysmaev.exceptions.SmaEvChargerAuthenticationError,
+            {CONF_BASE: "invalid_auth"},
+        ),
         (Exception, {CONF_BASE: "unknown"}),
     ],
 )
@@ -126,28 +126,26 @@ async def test_options_flow_errors(hass, entry, error, errors):
     assert result["errors"] == errors
 
 
-async def test_validate_connection(hass: HomeAssistant, device_info):
+async def test_validate_connection(hass: HomeAssistant):
     """Test the connection validation."""
     data = CONFIG_DATA.copy()
 
-    with (
-        patch("pysmaev.core.SmaEvCharger.open") as mock_open,
-        patch(
-            "pysmaev.core.SmaEvCharger.device_info", return_value=device_info
-        ) as mock_device_info,
-    ):
+    with patch("pysmaev.core.SmaEvCharger", MockSmaEvCharger) as mock:
         result = await validate_input(hass, data=data)
 
-    assert mock_open.is_called
-    assert mock_device_info.is_called
-    assert result == (device_info, {})
+    assert mock.open.is_called
+    assert mock.device_info.is_called
+    assert result == (DEVICE_INFO, {})
 
 
 @pytest.mark.parametrize(
     ("error", "errors"),
     [
-        (smaev.SmaEvChargerConnectionError, {CONF_BASE: "cannot_connect"}),
-        (smaev.SmaEvChargerAuthenticationError, {CONF_BASE: "invalid_auth"}),
+        (pysmaev.exceptions.SmaEvChargerConnectionError, {CONF_BASE: "cannot_connect"}),
+        (
+            pysmaev.exceptions.SmaEvChargerAuthenticationError,
+            {CONF_BASE: "invalid_auth"},
+        ),
         (Exception, {CONF_BASE: "unknown"}),
     ],
 )

tests/test_datetime.py

@@ -1,22 +1,23 @@
 """Test for the SMA EV Charger datetime platform."""
 from unittest.mock import patch
 
+import pysmaev.core
+
 from homeassistant.const import STATE_UNKNOWN
 from homeassistant.core import HomeAssistant
 
 from custom_components.smaev import generate_smaev_entity_id
 from custom_components.smaev.datetime import DATETIME_DESCRIPTIONS, ENTITY_ID_FORMAT
 
+from .conftest import MockSmaEvCharger
+
 
-async def test_setup_smaev_datetime(hass: HomeAssistant, entry, device_info):
+@patch.object(pysmaev.core, "SmaEvCharger", MockSmaEvCharger)
+async def test_setup_smaev_datetime(hass: HomeAssistant, entry):
     """Test the setup of datetime."""
     entry.add_to_hass(hass)
-    with (
-        patch("pysmaev.core.SmaEvCharger.open"),
-        patch("pysmaev.core.SmaEvCharger.device_info", return_value=device_info),
-    ):
-        assert await hass.config_entries.async_setup(entry.entry_id)
-        await hass.async_block_till_done()
+    assert await hass.config_entries.async_setup(entry.entry_id)
+    await hass.async_block_till_done()
 
     for description in DATETIME_DESCRIPTIONS:
         if not description.entity_registry_enabled_default: