pytest-homeassistant-custom-component 0.13.163__py3-none-any.whl → 0.13.298__py3-none-any.whl

pytest_homeassistant_custom_component/components/__init__.py

@@ -3,3 +3,354 @@ The tests for components.
 
 This file is originally from homeassistant/core and modified by pytest-homeassistant-custom-component.
 """
+
+from enum import StrEnum
+import itertools
+from typing import TypedDict
+
+from homeassistant.const import (
+    ATTR_AREA_ID,
+    ATTR_DEVICE_ID,
+    ATTR_FLOOR_ID,
+    ATTR_LABEL_ID,
+    CONF_ENTITY_ID,
+    CONF_OPTIONS,
+    CONF_PLATFORM,
+    CONF_TARGET,
+    STATE_UNAVAILABLE,
+    STATE_UNKNOWN,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import (
+    area_registry as ar,
+    device_registry as dr,
+    entity_registry as er,
+    floor_registry as fr,
+    label_registry as lr,
+)
+from homeassistant.setup import async_setup_component
+
+from ..common import MockConfigEntry, mock_device_registry
+
+
+async def target_entities(
+    hass: HomeAssistant, domain: str
+) -> tuple[list[str], list[str]]:
+    """Create multiple entities associated with different targets.
+
+    Returns a dict with the following keys:
+    - included: List of entity_ids meant to be targeted.
+    - excluded: List of entity_ids not meant to be targeted.
+    """
+    await async_setup_component(hass, domain, {})
+
+    config_entry = MockConfigEntry(domain="test")
+    config_entry.add_to_hass(hass)
+
+    floor_reg = fr.async_get(hass)
+    floor = floor_reg.async_get_floor_by_name("Test Floor") or floor_reg.async_create(
+        "Test Floor"
+    )
+
+    area_reg = ar.async_get(hass)
+    area = area_reg.async_get_area_by_name("Test Area") or area_reg.async_create(
+        "Test Area", floor_id=floor.floor_id
+    )
+
+    label_reg = lr.async_get(hass)
+    label = label_reg.async_get_label_by_name("Test Label") or label_reg.async_create(
+        "Test Label"
+    )
+
+    device = dr.DeviceEntry(id="test_device", area_id=area.id, labels={label.label_id})
+    mock_device_registry(hass, {device.id: device})
+
+    entity_reg = er.async_get(hass)
+    # Entities associated with area
+    entity_area = entity_reg.async_get_or_create(
+        domain=domain,
+        platform="test",
+        unique_id=f"{domain}_area",
+        suggested_object_id=f"area_{domain}",
+    )
+    entity_reg.async_update_entity(entity_area.entity_id, area_id=area.id)
+    entity_area_excluded = entity_reg.async_get_or_create(
+        domain=domain,
+        platform="test",
+        unique_id=f"{domain}_area_excluded",
+        suggested_object_id=f"area_{domain}_excluded",
+    )
+    entity_reg.async_update_entity(entity_area_excluded.entity_id, area_id=area.id)
+
+    # Entities associated with device
+    entity_reg.async_get_or_create(
+        domain=domain,
+        platform="test",
+        unique_id=f"{domain}_device",
+        suggested_object_id=f"device_{domain}",
+        device_id=device.id,
+    )
+    entity_reg.async_get_or_create(
+        domain=domain,
+        platform="test",
+        unique_id=f"{domain}_device_excluded",
+        suggested_object_id=f"device_{domain}_excluded",
+        device_id=device.id,
+    )
+
+    # Entities associated with label
+    entity_label = entity_reg.async_get_or_create(
+        domain=domain,
+        platform="test",
+        unique_id=f"{domain}_label",
+        suggested_object_id=f"label_{domain}",
+    )
+    entity_reg.async_update_entity(entity_label.entity_id, labels={label.label_id})
+    entity_label_excluded = entity_reg.async_get_or_create(
+        domain=domain,
+        platform="test",
+        unique_id=f"{domain}_label_excluded",
+        suggested_object_id=f"label_{domain}_excluded",
+    )
+    entity_reg.async_update_entity(
+        entity_label_excluded.entity_id, labels={label.label_id}
+    )
+
+    # Return all available entities
+    return {
+        "included": [
+            f"{domain}.standalone_{domain}",
+            f"{domain}.label_{domain}",
+            f"{domain}.area_{domain}",
+            f"{domain}.device_{domain}",
+        ],
+        "excluded": [
+            f"{domain}.standalone_{domain}_excluded",
+            f"{domain}.label_{domain}_excluded",
+            f"{domain}.area_{domain}_excluded",
+            f"{domain}.device_{domain}_excluded",
+        ],
+    }
+
+
+def parametrize_target_entities(domain: str) -> list[tuple[dict, str, int]]:
+    """Parametrize target entities for different target types.
+
+    Meant to be used with target_entities.
+    """
+    return [
+        (
+            {CONF_ENTITY_ID: f"{domain}.standalone_{domain}"},
+            f"{domain}.standalone_{domain}",
+            1,
+        ),
+        ({ATTR_LABEL_ID: "test_label"}, f"{domain}.label_{domain}", 2),
+        ({ATTR_AREA_ID: "test_area"}, f"{domain}.area_{domain}", 2),
+        ({ATTR_FLOOR_ID: "test_floor"}, f"{domain}.area_{domain}", 2),
+        ({ATTR_LABEL_ID: "test_label"}, f"{domain}.device_{domain}", 2),
+        ({ATTR_AREA_ID: "test_area"}, f"{domain}.device_{domain}", 2),
+        ({ATTR_FLOOR_ID: "test_floor"}, f"{domain}.device_{domain}", 2),
+        ({ATTR_DEVICE_ID: "test_device"}, f"{domain}.device_{domain}", 1),
+    ]
+
+
+class _StateDescription(TypedDict):
+    """Test state and expected service call count."""
+
+    state: str | None
+    attributes: dict
+
+
+class StateDescription(TypedDict):
+    """Test state and expected service call count."""
+
+    included: _StateDescription
+    excluded: _StateDescription
+    count: int
+
+
+def parametrize_trigger_states(
+    *,
+    trigger: str,
+    target_states: list[str | None | tuple[str | None, dict]],
+    other_states: list[str | None | tuple[str | None, dict]],
+    additional_attributes: dict | None = None,
+    trigger_from_none: bool = True,
+) -> list[tuple[str, list[StateDescription]]]:
+    """Parametrize states and expected service call counts.
+
+    The target_states and other_states iterables are either iterables of
+    states or iterables of (state, attributes) tuples.
+
+    Set `trigger_from_none` to False if the trigger is not expected to fire
+    when the initial state is None.
+
+    Returns a list of tuples with (trigger, list of states),
+    where states is a list of StateDescription dicts.
+    """
+
+    additional_attributes = additional_attributes or {}
+
+    def state_with_attributes(
+        state: str | None | tuple[str | None, dict], count: int
+    ) -> dict:
+        """Return (state, attributes) dict."""
+        if isinstance(state, str) or state is None:
+            return {
+                "included": {
+                    "state": state,
+                    "attributes": additional_attributes,
+                },
+                "excluded": {
+                    "state": state,
+                    "attributes": {},
+                },
+                "count": count,
+            }
+        return {
+            "included": {
+                "state": state[0],
+                "attributes": state[1] | additional_attributes,
+            },
+            "excluded": {
+                "state": state[0],
+                "attributes": state[1],
+            },
+            "count": count,
+        }
+
+    return [
+        # Initial state None
+        (
+            trigger,
+            list(
+                itertools.chain.from_iterable(
+                    (
+                        state_with_attributes(None, 0),
+                        state_with_attributes(target_state, 0),
+                        state_with_attributes(other_state, 0),
+                        state_with_attributes(
+                            target_state, 1 if trigger_from_none else 0
+                        ),
+                    )
+                    for target_state in target_states
+                    for other_state in other_states
+                )
+            ),
+        ),
+        # Initial state different from target state
+        (
+            trigger,
+            # other_state,
+            list(
+                itertools.chain.from_iterable(
+                    (
+                        state_with_attributes(other_state, 0),
+                        state_with_attributes(target_state, 1),
+                        state_with_attributes(other_state, 0),
+                        state_with_attributes(target_state, 1),
+                    )
+                    for target_state in target_states
+                    for other_state in other_states
+                )
+            ),
+        ),
+        # Initial state same as target state
+        (
+            trigger,
+            list(
+                itertools.chain.from_iterable(
+                    (
+                        state_with_attributes(target_state, 0),
+                        state_with_attributes(target_state, 0),
+                        state_with_attributes(other_state, 0),
+                        state_with_attributes(target_state, 1),
+                    )
+                    for target_state in target_states
+                    for other_state in other_states
+                )
+            ),
+        ),
+        # Initial state unavailable / unknown
+        (
+            trigger,
+            list(
+                itertools.chain.from_iterable(
+                    (
+                        state_with_attributes(STATE_UNAVAILABLE, 0),
+                        state_with_attributes(target_state, 0),
+                        state_with_attributes(other_state, 0),
+                        state_with_attributes(target_state, 1),
+                    )
+                    for target_state in target_states
+                    for other_state in other_states
+                )
+            ),
+        ),
+        (
+            trigger,
+            list(
+                itertools.chain.from_iterable(
+                    (
+                        state_with_attributes(STATE_UNKNOWN, 0),
+                        state_with_attributes(target_state, 0),
+                        state_with_attributes(other_state, 0),
+                        state_with_attributes(target_state, 1),
+                    )
+                    for target_state in target_states
+                    for other_state in other_states
+                )
+            ),
+        ),
+    ]
+
+
+async def arm_trigger(
+    hass: HomeAssistant,
+    trigger: str,
+    trigger_options: dict | None,
+    trigger_target: dict,
+) -> None:
+    """Arm the specified trigger, call service test.automation when it triggers."""
+
+    # Local include to avoid importing the automation component unnecessarily
+    from homeassistant.components import automation  # noqa: PLC0415
+
+    options = {CONF_OPTIONS: {**trigger_options}} if trigger_options is not None else {}
+
+    await async_setup_component(
+        hass,
+        automation.DOMAIN,
+        {
+            automation.DOMAIN: {
+                "trigger": {
+                    CONF_PLATFORM: trigger,
+                    CONF_TARGET: {**trigger_target},
+                }
+                | options,
+                "action": {
+                    "service": "test.automation",
+                    "data_template": {CONF_ENTITY_ID: "{{ trigger.entity_id }}"},
+                },
+            }
+        },
+    )
+
+
+def set_or_remove_state(
+    hass: HomeAssistant,
+    entity_id: str,
+    state: StateDescription,
+) -> None:
+    """Set or remove the state of an entity."""
+    if state["state"] is None:
+        hass.states.async_remove(entity_id)
+    else:
+        hass.states.async_set(
+            entity_id, state["state"], state["attributes"], force_update=True
+        )
+
+
+def other_states(state: StrEnum) -> list[str]:
+    """Return a sorted list with all states except the specified one."""
+    return sorted({s.value for s in state.__class__} - {state.value})

pytest_homeassistant_custom_component/components/diagnostics/__init__.py

@@ -0,0 +1,71 @@
+"""
+Tests for the Diagnostics integration.
+
+This file is originally from homeassistant/core and modified by pytest-homeassistant-custom-component.
+"""
+
+from http import HTTPStatus
+from typing import cast
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.device_registry import DeviceEntry
+from homeassistant.setup import async_setup_component
+from homeassistant.util.json import JsonObjectType
+
+from pytest_homeassistant_custom_component.typing import ClientSessionGenerator
+
+
+async def _get_diagnostics_for_config_entry(
+    hass: HomeAssistant,
+    hass_client: ClientSessionGenerator,
+    config_entry: ConfigEntry,
+) -> JsonObjectType:
+    """Return the diagnostics config entry for the specified domain."""
+    assert await async_setup_component(hass, "diagnostics", {})
+    await hass.async_block_till_done()
+
+    client = await hass_client()
+    response = await client.get(
+        f"/api/diagnostics/config_entry/{config_entry.entry_id}"
+    )
+    assert response.status == HTTPStatus.OK
+    return cast(JsonObjectType, await response.json())
+
+
+async def get_diagnostics_for_config_entry(
+    hass: HomeAssistant,
+    hass_client: ClientSessionGenerator,
+    config_entry: ConfigEntry,
+) -> JsonObjectType:
+    """Return the diagnostics config entry for the specified domain."""
+    data = await _get_diagnostics_for_config_entry(hass, hass_client, config_entry)
+    return cast(JsonObjectType, data["data"])
+
+
+async def _get_diagnostics_for_device(
+    hass: HomeAssistant,
+    hass_client: ClientSessionGenerator,
+    config_entry: ConfigEntry,
+    device: DeviceEntry,
+) -> JsonObjectType:
+    """Return the diagnostics for the specified device."""
+    assert await async_setup_component(hass, "diagnostics", {})
+
+    client = await hass_client()
+    response = await client.get(
+        f"/api/diagnostics/config_entry/{config_entry.entry_id}/device/{device.id}"
+    )
+    assert response.status == HTTPStatus.OK
+    return cast(JsonObjectType, await response.json())
+
+
+async def get_diagnostics_for_device(
+    hass: HomeAssistant,
+    hass_client: ClientSessionGenerator,
+    config_entry: ConfigEntry,
+    device: DeviceEntry,
+) -> JsonObjectType:
+    """Return the diagnostics for the specified device."""
+    data = await _get_diagnostics_for_device(hass, hass_client, config_entry, device)
+    return cast(JsonObjectType, data["data"])

pytest_homeassistant_custom_component/components/recorder/common.py

@@ -15,11 +15,13 @@ from functools import partial
 import importlib
 import sys
 import time
+from types import ModuleType
 from typing import Any, Literal, cast
 from unittest.mock import MagicMock, patch, sentinel
 
 from freezegun import freeze_time
-from sqlalchemy import create_engine
+import pytest
+from sqlalchemy import create_engine, event as sqlalchemy_event
 from sqlalchemy.orm.session import Session
 
 from homeassistant import core as ha
@@ -32,16 +34,25 @@ from homeassistant.components.recorder import (
     statistics,
 )
 from homeassistant.components.recorder.db_schema import (
+    EventData,
     Events,
     EventTypes,
     RecorderRuns,
+    StateAttributes,
     States,
     StatesMeta,
 )
+from homeassistant.components.recorder.models import (
+    bytes_to_ulid_or_none,
+    bytes_to_uuid_hex_or_none,
+)
 from homeassistant.components.recorder.tasks import RecorderTask, StatisticsTask
-from homeassistant.const import UnitOfTemperature
+from homeassistant.components.sensor import SensorDeviceClass, SensorStateClass
+from homeassistant.const import DEGREE, UnitOfTemperature
 from homeassistant.core import Event, HomeAssistant, State
-import homeassistant.util.dt as dt_util
+from homeassistant.helpers import recorder as recorder_helper
+from homeassistant.util import dt as dt_util
+from homeassistant.util.json import json_loads, json_loads_object
 
 from . import db_schema_0
 
@@ -83,6 +94,11 @@ async def async_block_recorder(hass: HomeAssistant, seconds: float) -> None:
     await event.wait()
 
 
+async def async_wait_recorder(hass: HomeAssistant) -> bool:
+    """Wait for recorder to initialize and return connection status."""
+    return await hass.data[recorder_helper.DATA_RECORDER].db_connected
+
+
 def get_start_time(start: datetime) -> datetime:
     """Calculate a valid start time for statistics."""
     start_minutes = start.minute - start.minute % 5
@@ -288,6 +304,7 @@ def record_states(
     sns2 = "sensor.test2"
     sns3 = "sensor.test3"
     sns4 = "sensor.test4"
+    sns5 = "sensor.wind_direction"
     sns1_attr = {
         "device_class": "temperature",
         "state_class": "measurement",
@@ -300,6 +317,11 @@ def record_states(
     }
     sns3_attr = {"device_class": "temperature"}
     sns4_attr = {}
+    sns5_attr = {
+        "device_class": SensorDeviceClass.WIND_DIRECTION,
+        "state_class": SensorStateClass.MEASUREMENT_ANGLE,
+        "unit_of_measurement": DEGREE,
+    }
 
     def set_state(entity_id, state, **kwargs):
         """Set the state."""
@@ -313,7 +335,7 @@ def record_states(
     three = two + timedelta(seconds=30 * 5)
     four = three + timedelta(seconds=14 * 5)
 
-    states = {mp: [], sns1: [], sns2: [], sns3: [], sns4: []}
+    states = {mp: [], sns1: [], sns2: [], sns3: [], sns4: [], sns5: []}
     with freeze_time(one) as freezer:
         states[mp].append(
             set_state(mp, "idle", attributes={"media_title": str(sentinel.mt1)})
@@ -322,6 +344,7 @@ def record_states(
         states[sns2].append(set_state(sns2, "10", attributes=sns2_attr))
         states[sns3].append(set_state(sns3, "10", attributes=sns3_attr))
         states[sns4].append(set_state(sns4, "10", attributes=sns4_attr))
+        states[sns5].append(set_state(sns5, "10", attributes=sns5_attr))
 
         freezer.move_to(one + timedelta(microseconds=1))
         states[mp].append(
@@ -333,12 +356,14 @@ def record_states(
         states[sns2].append(set_state(sns2, "15", attributes=sns2_attr))
         states[sns3].append(set_state(sns3, "15", attributes=sns3_attr))
         states[sns4].append(set_state(sns4, "15", attributes=sns4_attr))
+        states[sns5].append(set_state(sns5, "350", attributes=sns5_attr))
 
         freezer.move_to(three)
         states[sns1].append(set_state(sns1, "20", attributes=sns1_attr))
         states[sns2].append(set_state(sns2, "20", attributes=sns2_attr))
         states[sns3].append(set_state(sns3, "20", attributes=sns3_attr))
         states[sns4].append(set_state(sns4, "20", attributes=sns4_attr))
+        states[sns5].append(set_state(sns5, "5", attributes=sns5_attr))
 
     return zero, four, states
 
@@ -412,7 +437,15 @@ def create_engine_test_for_schema_version_postfix(
     schema_module = get_schema_module_path(schema_version_postfix)
     importlib.import_module(schema_module)
     old_db_schema = sys.modules[schema_module]
+    instance: Recorder | None = None
+    if "hass" in kwargs:
+        hass: HomeAssistant = kwargs.pop("hass")
+        instance = recorder.get_instance(hass)
     engine = create_engine(*args, **kwargs)
+    if instance is not None:
+        instance = recorder.get_instance(hass)
+        instance.engine = engine
+        sqlalchemy_event.listen(engine, "connect", instance._setup_recorder_connection)
     old_db_schema.Base.metadata.create_all(engine)
     with Session(engine) as session:
         session.add(
@@ -432,16 +465,15 @@ def get_schema_module_path(schema_version_postfix: str) -> str:
     return f"...components.recorder.db_schema_{schema_version_postfix}"
 
 
-@dataclass(slots=True)
-class MockMigrationTask(migration.MigrationTask):
-    """Mock migration task which does nothing."""
-
-    def run(self, instance: Recorder) -> None:
-        """Run migration task."""
+def get_patched_live_version(old_db_schema: ModuleType) -> int:
+    """Return the patched live migration version."""
+    return min(
+        migration.LIVE_MIGRATION_MIN_SCHEMA_VERSION, old_db_schema.SCHEMA_VERSION
+    )
 
 
 @contextmanager
-def old_db_schema(schema_version_postfix: str) -> Iterator[None]:
+def old_db_schema(hass: HomeAssistant, schema_version_postfix: str) -> Iterator[None]:
     """Fixture to initialize the db with the old schema."""
     schema_module = get_schema_module_path(schema_version_postfix)
     importlib.import_module(schema_module)
@@ -449,20 +481,24 @@ def old_db_schema(schema_version_postfix: str) -> Iterator[None]:
 
     with (
         patch.object(recorder, "db_schema", old_db_schema),
+        patch.object(migration, "SCHEMA_VERSION", old_db_schema.SCHEMA_VERSION),
         patch.object(
-            recorder.migration, "SCHEMA_VERSION", old_db_schema.SCHEMA_VERSION
+            migration,
+            "LIVE_MIGRATION_MIN_SCHEMA_VERSION",
+            get_patched_live_version(old_db_schema),
         ),
+        patch.object(migration, "non_live_data_migration_needed", return_value=False),
         patch.object(core, "StatesMeta", old_db_schema.StatesMeta),
         patch.object(core, "EventTypes", old_db_schema.EventTypes),
         patch.object(core, "EventData", old_db_schema.EventData),
         patch.object(core, "States", old_db_schema.States),
         patch.object(core, "Events", old_db_schema.Events),
         patch.object(core, "StateAttributes", old_db_schema.StateAttributes),
-        patch.object(migration.EntityIDMigration, "task", MockMigrationTask),
         patch(
             CREATE_ENGINE_TARGET,
             new=partial(
                 create_engine_test_for_schema_version_postfix,
+                hass=hass,
                 schema_version_postfix=schema_version_postfix,
             ),
         ),
@@ -481,3 +517,97 @@ async def async_attach_db_engine(hass: HomeAssistant) -> None:
             )
 
     await instance.async_add_executor_job(_mock_setup_recorder_connection)
+
+
+EVENT_ORIGIN_ORDER = [ha.EventOrigin.local, ha.EventOrigin.remote]
+
+
+def db_event_to_native(event: Events, validate_entity_id: bool = True) -> Event | None:
+    """Convert to a native HA Event."""
+    context = ha.Context(
+        id=bytes_to_ulid_or_none(event.context_id_bin),
+        user_id=bytes_to_uuid_hex_or_none(event.context_user_id_bin),
+        parent_id=bytes_to_ulid_or_none(event.context_parent_id_bin),
+    )
+    return Event(
+        event.event_type or "",
+        json_loads_object(event.event_data) if event.event_data else {},
+        ha.EventOrigin(event.origin)
+        if event.origin
+        else EVENT_ORIGIN_ORDER[event.origin_idx or 0],
+        event.time_fired_ts or 0,
+        context=context,
+    )
+
+
+def db_event_data_to_native(event_data: EventData) -> dict[str, Any]:
+    """Convert to an event data dictionary."""
+    shared_data = event_data.shared_data
+    if shared_data is None:
+        return {}
+    return cast(dict[str, Any], json_loads(shared_data))
+
+
+def db_state_to_native(state: States, validate_entity_id: bool = True) -> State | None:
+    """Convert to an HA state object."""
+    context = ha.Context(
+        id=bytes_to_ulid_or_none(state.context_id_bin),
+        user_id=bytes_to_uuid_hex_or_none(state.context_user_id_bin),
+        parent_id=bytes_to_ulid_or_none(state.context_parent_id_bin),
+    )
+    attrs = json_loads_object(state.attributes) if state.attributes else {}
+    last_updated = dt_util.utc_from_timestamp(state.last_updated_ts or 0)
+    if state.last_changed_ts is None or state.last_changed_ts == state.last_updated_ts:
+        last_changed = dt_util.utc_from_timestamp(state.last_updated_ts or 0)
+    else:
+        last_changed = dt_util.utc_from_timestamp(state.last_changed_ts or 0)
+    if (
+        state.last_reported_ts is None
+        or state.last_reported_ts == state.last_updated_ts
+    ):
+        last_reported = dt_util.utc_from_timestamp(state.last_updated_ts or 0)
+    else:
+        last_reported = dt_util.utc_from_timestamp(state.last_reported_ts or 0)
+    return State(
+        state.entity_id or "",
+        state.state,  # type: ignore[arg-type]
+        # Join the state_attributes table on attributes_id to get the attributes
+        # for newer states
+        attrs,
+        last_changed=last_changed,
+        last_reported=last_reported,
+        last_updated=last_updated,
+        context=context,
+        validate_entity_id=validate_entity_id,
+    )
+
+
+def db_state_attributes_to_native(state_attrs: StateAttributes) -> dict[str, Any]:
+    """Convert to a state attributes dictionary."""
+    shared_attrs = state_attrs.shared_attrs
+    if shared_attrs is None:
+        return {}
+    return cast(dict[str, Any], json_loads(shared_attrs))
+
+
+async def async_drop_index(
+    recorder: Recorder, table: str, index: str, caplog: pytest.LogCaptureFixture
+) -> None:
+    """Drop an index from the database.
+
+    migration._drop_index does not return or raise, so we verify the result
+    by checking the log for success or failure messages.
+    """
+
+    finish_msg = f"Finished dropping index `{index}` from table `{table}`"
+    fail_msg = f"Failed to drop index `{index}` from table `{table}`"
+
+    count_finish = caplog.text.count(finish_msg)
+    count_fail = caplog.text.count(fail_msg)
+
+    await recorder.async_add_executor_job(
+        migration._drop_index, recorder.get_session, table, index
+    )
+
+    assert caplog.text.count(finish_msg) == count_finish + 1
+    assert caplog.text.count(fail_msg) == count_fail

pytest_homeassistant_custom_component/components/recorder/db_schema_0.py

@@ -27,7 +27,7 @@ from sqlalchemy.orm.session import Session
 
 from homeassistant.core import Event, EventOrigin, State, split_entity_id
 from homeassistant.helpers.json import JSONEncoder
-import homeassistant.util.dt as dt_util
+from homeassistant.util import dt as dt_util
 
 # SQLAlchemy Schema
 Base = declarative_base()