jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-07-19 11:17:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

Move do_adhoc_statistics to recorder test helpers (#71544)

Browse Source
This commit is contained in:
J. Nick Koston 2022-05-08 14:45:57 -05:00 committed by GitHub
parent e46310ac0b
commit 7c9c0e911a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 79 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
tests/components/history/test_init.py
View File

@ -8,7 +8,7 @@ from unittest.mock import patch, sentinel
import pytest import pytest
from pytest import approx from pytest import approx
from homeassistant.components import history, recorder from homeassistant.components import history
from homeassistant.components.recorder.history import get_significant_states from homeassistant.components.recorder.history import get_significant_states
from homeassistant.components.recorder.models import process_timestamp from homeassistant.components.recorder.models import process_timestamp
import homeassistant.core as ha import homeassistant.core as ha
@ -20,6 +20,7 @@ from homeassistant.util.unit_system import IMPERIAL_SYSTEM, METRIC_SYSTEM
from tests.components.recorder.common import ( from tests.components.recorder.common import (
async_recorder_block_till_done, async_recorder_block_till_done,
async_wait_recording_done, async_wait_recording_done,
do_adhoc_statistics,
wait_recording_done, wait_recording_done,
) )
@ -879,7 +880,7 @@ async def test_statistics_during_period(
hass.states.async_set("sensor.test", state, attributes=attributes) hass.states.async_set("sensor.test", state, attributes=attributes)
await async_wait_recording_done(hass) await async_wait_recording_done(hass)
hass.data[recorder.DATA_INSTANCE].do_adhoc_statistics(start=now) do_adhoc_statistics(hass, start=now)
await async_wait_recording_done(hass) await async_wait_recording_done(hass)
client = await hass_ws_client() client = await hass_ws_client()
@ -1021,7 +1022,7 @@ async def test_list_statistic_ids(
} }
] ]
hass.data[recorder.DATA_INSTANCE].do_adhoc_statistics(start=now) do_adhoc_statistics(hass, start=now)
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
# Remove the state, statistics will now be fetched from the database # Remove the state, statistics will now be fetched from the database
hass.states.async_remove("sensor.test") hass.states.async_remove("sensor.test")

11
tests/components/recorder/common.py
View File

@ -2,14 +2,16 @@
from __future__ import annotations from __future__ import annotations
from datetime import datetime, timedelta from datetime import datetime, timedelta
from typing import cast from typing import Any, cast
from sqlalchemy import create_engine from sqlalchemy import create_engine
from sqlalchemy.orm.session import Session from sqlalchemy.orm.session import Session
from homeassistant import core as ha from homeassistant import core as ha
from homeassistant.components import recorder from homeassistant.components import recorder
from homeassistant.components.recorder import get_instance, statistics
from homeassistant.components.recorder.models import RecorderRuns from homeassistant.components.recorder.models import RecorderRuns
from homeassistant.components.recorder.tasks import StatisticsTask
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.util import dt as dt_util from homeassistant.util import dt as dt_util
@ -19,6 +21,13 @@ from tests.components.recorder import models_schema_0
DEFAULT_PURGE_TASKS = 3 DEFAULT_PURGE_TASKS = 3
def do_adhoc_statistics(hass: HomeAssistant, **kwargs: Any) -> None:
"""Trigger an adhoc statistics run."""
if not (start := kwargs.get("start")):
start = statistics.get_start_time()
get_instance(hass).queue_task(StatisticsTask(start))
def wait_recording_done(hass: HomeAssistant) -> None: def wait_recording_done(hass: HomeAssistant) -> None:
"""Block till recording is done.""" """Block till recording is done."""
hass.block_till_done() hass.block_till_done()

19
tests/components/recorder/test_statistics.py
View File

@ -30,7 +30,7 @@ from homeassistant.exceptions import HomeAssistantError
from homeassistant.setup import setup_component from homeassistant.setup import setup_component
import homeassistant.util.dt as dt_util import homeassistant.util.dt as dt_util
from .common import async_wait_recording_done from .common import async_wait_recording_done, do_adhoc_statistics
from tests.common import mock_registry from tests.common import mock_registry
from tests.components.recorder.common import wait_recording_done from tests.components.recorder.common import wait_recording_done
@ -57,8 +57,8 @@ def test_compile_hourly_statistics(hass_recorder):
stats = get_last_short_term_statistics(hass, 0, "sensor.test1", True) stats = get_last_short_term_statistics(hass, 0, "sensor.test1", True)
assert stats == {} assert stats == {}
recorder.do_adhoc_statistics(start=zero) do_adhoc_statistics(hass, start=zero)
recorder.do_adhoc_statistics(start=four) do_adhoc_statistics(hass, start=four)
wait_recording_done(hass) wait_recording_done(hass)
expected_1 = { expected_1 = {
"statistic_id": "sensor.test1", "statistic_id": "sensor.test1",
@ -197,12 +197,11 @@ def test_compile_periodic_statistics_exception(
"""Test exception handling when compiling periodic statistics.""" """Test exception handling when compiling periodic statistics."""
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
now = dt_util.utcnow() now = dt_util.utcnow()
recorder.do_adhoc_statistics(start=now) do_adhoc_statistics(hass, start=now)
recorder.do_adhoc_statistics(start=now + timedelta(minutes=5)) do_adhoc_statistics(hass, start=now + timedelta(minutes=5))
wait_recording_done(hass) wait_recording_done(hass)
expected_1 = { expected_1 = {
"statistic_id": "sensor.test1", "statistic_id": "sensor.test1",
@ -249,7 +248,6 @@ def test_compile_periodic_statistics_exception(
def test_rename_entity(hass_recorder): def test_rename_entity(hass_recorder):
"""Test statistics is migrated when entity_id is changed.""" """Test statistics is migrated when entity_id is changed."""
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
entity_reg = mock_registry(hass) entity_reg = mock_registry(hass)
@ -277,7 +275,7 @@ def test_rename_entity(hass_recorder):
stats = get_last_short_term_statistics(hass, 0, "sensor.test1", True) stats = get_last_short_term_statistics(hass, 0, "sensor.test1", True)
assert stats == {} assert stats == {}
recorder.do_adhoc_statistics(start=zero) do_adhoc_statistics(hass, start=zero)
wait_recording_done(hass) wait_recording_done(hass)
expected_1 = { expected_1 = {
"statistic_id": "sensor.test1", "statistic_id": "sensor.test1",
@ -317,7 +315,6 @@ def test_rename_entity(hass_recorder):
def test_statistics_duplicated(hass_recorder, caplog): def test_statistics_duplicated(hass_recorder, caplog):
"""Test statistics with same start time is not compiled.""" """Test statistics with same start time is not compiled."""
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
zero, four, states = record_states(hass) zero, four, states = record_states(hass)
hist = history.get_significant_states(hass, zero, four) hist = history.get_significant_states(hass, zero, four)
@ -331,7 +328,7 @@ def test_statistics_duplicated(hass_recorder, caplog):
"homeassistant.components.sensor.recorder.compile_statistics", "homeassistant.components.sensor.recorder.compile_statistics",
return_value=statistics.PlatformCompiledStatistics([], {}), return_value=statistics.PlatformCompiledStatistics([], {}),
) as compile_statistics: ) as compile_statistics:
recorder.do_adhoc_statistics(start=zero) do_adhoc_statistics(hass, start=zero)
wait_recording_done(hass) wait_recording_done(hass)
assert compile_statistics.called assert compile_statistics.called
compile_statistics.reset_mock() compile_statistics.reset_mock()
@ -339,7 +336,7 @@ def test_statistics_duplicated(hass_recorder, caplog):
assert "Statistics already compiled" not in caplog.text assert "Statistics already compiled" not in caplog.text
caplog.clear() caplog.clear()
recorder.do_adhoc_statistics(start=zero) do_adhoc_statistics(hass, start=zero)
wait_recording_done(hass) wait_recording_done(hass)
assert not compile_statistics.called assert not compile_statistics.called
compile_statistics.reset_mock() compile_statistics.reset_mock()

7
tests/components/recorder/test_websocket_api.py
View File

@ -18,6 +18,7 @@ from .common import (
async_recorder_block_till_done, async_recorder_block_till_done,
async_wait_recording_done, async_wait_recording_done,
create_engine_test, create_engine_test,
do_adhoc_statistics,
) )
from tests.common import async_fire_time_changed from tests.common import async_fire_time_changed
@ -84,7 +85,7 @@ async def test_clear_statistics(hass, hass_ws_client, recorder_mock):
hass.states.async_set("sensor.test3", state * 3, attributes=attributes) hass.states.async_set("sensor.test3", state * 3, attributes=attributes)
await async_wait_recording_done(hass) await async_wait_recording_done(hass)
hass.data[DATA_INSTANCE].do_adhoc_statistics(start=now) do_adhoc_statistics(hass, start=now)
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
client = await hass_ws_client() client = await hass_ws_client()
@ -208,7 +209,7 @@ async def test_update_statistics_metadata(
hass.states.async_set("sensor.test", state, attributes=attributes) hass.states.async_set("sensor.test", state, attributes=attributes)
await async_wait_recording_done(hass) await async_wait_recording_done(hass)
hass.data[DATA_INSTANCE].do_adhoc_statistics(period="hourly", start=now) do_adhoc_statistics(hass, period="hourly", start=now)
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
client = await hass_ws_client() client = await hass_ws_client()
@ -521,7 +522,7 @@ async def test_get_statistics_metadata(
} }
] ]
hass.data[recorder.DATA_INSTANCE].do_adhoc_statistics(start=now) do_adhoc_statistics(hass, start=now)
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
# Remove the state, statistics will now be fetched from the database # Remove the state, statistics will now be fetched from the database
hass.states.async_remove("sensor.test") hass.states.async_remove("sensor.test")

136
tests/components/sensor/test_recorder.py
View File

@ -1,7 +1,6 @@
"""The tests for sensor recorder platform.""" """The tests for sensor recorder platform."""
# pylint: disable=protected-access,invalid-name # pylint: disable=protected-access,invalid-name
from datetime import timedelta from datetime import timedelta
from functools import partial
import math import math
from statistics import mean from statistics import mean
from unittest.mock import patch from unittest.mock import patch
@ -30,6 +29,7 @@ from homeassistant.util.unit_system import IMPERIAL_SYSTEM, METRIC_SYSTEM
from tests.components.recorder.common import ( from tests.components.recorder.common import (
async_recorder_block_till_done, async_recorder_block_till_done,
async_wait_recording_done, async_wait_recording_done,
do_adhoc_statistics,
wait_recording_done, wait_recording_done,
) )
@ -101,7 +101,6 @@ def test_compile_hourly_statistics(
"""Test compiling hourly statistics.""" """Test compiling hourly statistics."""
zero = dt_util.utcnow() zero = dt_util.utcnow()
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
wait_recording_done(hass) # Wait for the sensor recorder platform to be added wait_recording_done(hass) # Wait for the sensor recorder platform to be added
attributes = { attributes = {
@ -113,7 +112,7 @@ def test_compile_hourly_statistics(
hist = history.get_significant_states(hass, zero, four) hist = history.get_significant_states(hass, zero, four)
assert dict(states) == dict(hist) assert dict(states) == dict(hist)
recorder.do_adhoc_statistics(start=zero) do_adhoc_statistics(hass, start=zero)
wait_recording_done(hass) wait_recording_done(hass)
statistic_ids = list_statistic_ids(hass) statistic_ids = list_statistic_ids(hass)
assert statistic_ids == [ assert statistic_ids == [
@ -157,7 +156,6 @@ def test_compile_hourly_statistics_purged_state_changes(
"""Test compiling hourly statistics.""" """Test compiling hourly statistics."""
zero = dt_util.utcnow() zero = dt_util.utcnow()
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
wait_recording_done(hass) # Wait for the sensor recorder platform to be added wait_recording_done(hass) # Wait for the sensor recorder platform to be added
attributes = { attributes = {
@ -181,7 +179,7 @@ def test_compile_hourly_statistics_purged_state_changes(
hist = history.get_significant_states(hass, zero, four) hist = history.get_significant_states(hass, zero, four)
assert not hist assert not hist
recorder.do_adhoc_statistics(start=zero) do_adhoc_statistics(hass, start=zero)
wait_recording_done(hass) wait_recording_done(hass)
statistic_ids = list_statistic_ids(hass) statistic_ids = list_statistic_ids(hass)
assert statistic_ids == [ assert statistic_ids == [
@ -218,7 +216,6 @@ def test_compile_hourly_statistics_unsupported(hass_recorder, caplog, attributes
"""Test compiling hourly statistics for unsupported sensor.""" """Test compiling hourly statistics for unsupported sensor."""
zero = dt_util.utcnow() zero = dt_util.utcnow()
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
wait_recording_done(hass) # Wait for the sensor recorder platform to be added wait_recording_done(hass) # Wait for the sensor recorder platform to be added
four, states = record_states(hass, zero, "sensor.test1", attributes) four, states = record_states(hass, zero, "sensor.test1", attributes)
@ -250,7 +247,7 @@ def test_compile_hourly_statistics_unsupported(hass_recorder, caplog, attributes
hist = history.get_significant_states(hass, zero, four) hist = history.get_significant_states(hass, zero, four)
assert dict(states) == dict(hist) assert dict(states) == dict(hist)
recorder.do_adhoc_statistics(start=zero) do_adhoc_statistics(hass, start=zero)
wait_recording_done(hass) wait_recording_done(hass)
statistic_ids = list_statistic_ids(hass) statistic_ids = list_statistic_ids(hass)
assert statistic_ids == [ assert statistic_ids == [
@ -361,7 +358,6 @@ async def test_compile_hourly_sum_statistics_amount(
period2_end = period0 + timedelta(minutes=15) period2_end = period0 + timedelta(minutes=15)
client = await hass_ws_client() client = await hass_ws_client()
hass.config.units = units hass.config.units = units
recorder = hass.data[DATA_INSTANCE]
await async_setup_component(hass, "sensor", {}) await async_setup_component(hass, "sensor", {})
# Wait for the sensor recorder platform to be added # Wait for the sensor recorder platform to be added
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
@ -382,17 +378,11 @@ async def test_compile_hourly_sum_statistics_amount(
) )
assert dict(states)["sensor.test1"] == dict(hist)["sensor.test1"] assert dict(states)["sensor.test1"] == dict(hist)["sensor.test1"]
await hass.async_add_executor_job( do_adhoc_statistics(hass, start=period0)
partial(recorder.do_adhoc_statistics, start=period0)
)
await async_wait_recording_done(hass) await async_wait_recording_done(hass)
await hass.async_add_executor_job( do_adhoc_statistics(hass, start=period1)
partial(recorder.do_adhoc_statistics, start=period1)
)
await async_wait_recording_done(hass) await async_wait_recording_done(hass)
await hass.async_add_executor_job( do_adhoc_statistics(hass, start=period2)
partial(recorder.do_adhoc_statistics, start=period2)
)
await async_wait_recording_done(hass) await async_wait_recording_done(hass)
statistic_ids = await hass.async_add_executor_job(list_statistic_ids, hass) statistic_ids = await hass.async_add_executor_job(list_statistic_ids, hass)
assert statistic_ids == [ assert statistic_ids == [
@ -525,7 +515,6 @@ def test_compile_hourly_sum_statistics_amount_reset_every_state_change(
"""Test compiling hourly statistics.""" """Test compiling hourly statistics."""
zero = dt_util.utcnow() zero = dt_util.utcnow()
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
wait_recording_done(hass) # Wait for the sensor recorder platform to be added wait_recording_done(hass) # Wait for the sensor recorder platform to be added
attributes = { attributes = {
@ -573,8 +562,8 @@ def test_compile_hourly_sum_statistics_amount_reset_every_state_change(
) )
assert dict(states)["sensor.test1"] == dict(hist)["sensor.test1"] assert dict(states)["sensor.test1"] == dict(hist)["sensor.test1"]
recorder.do_adhoc_statistics(start=zero) do_adhoc_statistics(hass, start=zero)
recorder.do_adhoc_statistics(start=zero + timedelta(minutes=5)) do_adhoc_statistics(hass, start=zero + timedelta(minutes=5))
wait_recording_done(hass) wait_recording_done(hass)
statistic_ids = list_statistic_ids(hass) statistic_ids = list_statistic_ids(hass)
assert statistic_ids == [ assert statistic_ids == [
@ -632,7 +621,6 @@ def test_compile_hourly_sum_statistics_amount_invalid_last_reset(
"""Test compiling hourly statistics.""" """Test compiling hourly statistics."""
zero = dt_util.utcnow() zero = dt_util.utcnow()
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
wait_recording_done(hass) # Wait for the sensor recorder platform to be added wait_recording_done(hass) # Wait for the sensor recorder platform to be added
attributes = { attributes = {
@ -666,7 +654,7 @@ def test_compile_hourly_sum_statistics_amount_invalid_last_reset(
) )
assert dict(states)["sensor.test1"] == dict(hist)["sensor.test1"] assert dict(states)["sensor.test1"] == dict(hist)["sensor.test1"]
recorder.do_adhoc_statistics(start=zero) do_adhoc_statistics(hass, start=zero)
wait_recording_done(hass) wait_recording_done(hass)
statistic_ids = list_statistic_ids(hass) statistic_ids = list_statistic_ids(hass)
assert statistic_ids == [ assert statistic_ids == [
@ -712,7 +700,6 @@ def test_compile_hourly_sum_statistics_nan_inf_state(
"""Test compiling hourly statistics with nan and inf states.""" """Test compiling hourly statistics with nan and inf states."""
zero = dt_util.utcnow() zero = dt_util.utcnow()
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
wait_recording_done(hass) # Wait for the sensor recorder platform to be added wait_recording_done(hass) # Wait for the sensor recorder platform to be added
attributes = { attributes = {
@ -742,7 +729,7 @@ def test_compile_hourly_sum_statistics_nan_inf_state(
) )
assert dict(states)["sensor.test1"] == dict(hist)["sensor.test1"] assert dict(states)["sensor.test1"] == dict(hist)["sensor.test1"]
recorder.do_adhoc_statistics(start=zero) do_adhoc_statistics(hass, start=zero)
wait_recording_done(hass) wait_recording_done(hass)
statistic_ids = list_statistic_ids(hass) statistic_ids = list_statistic_ids(hass)
assert statistic_ids == [ assert statistic_ids == [
@ -817,7 +804,6 @@ def test_compile_hourly_sum_statistics_negative_state(
zero = dt_util.utcnow() zero = dt_util.utcnow()
hass = hass_recorder() hass = hass_recorder()
hass.data.pop(loader.DATA_CUSTOM_COMPONENTS) hass.data.pop(loader.DATA_CUSTOM_COMPONENTS)
recorder = hass.data[DATA_INSTANCE]
platform = getattr(hass.components, "test.sensor") platform = getattr(hass.components, "test.sensor")
platform.init(empty=True) platform.init(empty=True)
@ -855,7 +841,7 @@ def test_compile_hourly_sum_statistics_negative_state(
) )
assert dict(states)[entity_id] == dict(hist)[entity_id] assert dict(states)[entity_id] == dict(hist)[entity_id]
recorder.do_adhoc_statistics(start=zero) do_adhoc_statistics(hass, start=zero)
wait_recording_done(hass) wait_recording_done(hass)
statistic_ids = list_statistic_ids(hass) statistic_ids = list_statistic_ids(hass)
assert { assert {
@ -911,7 +897,6 @@ def test_compile_hourly_sum_statistics_total_no_reset(
period1_end = period2 = period0 + timedelta(minutes=10) period1_end = period2 = period0 + timedelta(minutes=10)
period2_end = period0 + timedelta(minutes=15) period2_end = period0 + timedelta(minutes=15)
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
wait_recording_done(hass) # Wait for the sensor recorder platform to be added wait_recording_done(hass) # Wait for the sensor recorder platform to be added
attributes = { attributes = {
@ -930,11 +915,11 @@ def test_compile_hourly_sum_statistics_total_no_reset(
) )
assert dict(states)["sensor.test1"] == dict(hist)["sensor.test1"] assert dict(states)["sensor.test1"] == dict(hist)["sensor.test1"]
recorder.do_adhoc_statistics(start=period0) do_adhoc_statistics(hass, start=period0)
wait_recording_done(hass) wait_recording_done(hass)
recorder.do_adhoc_statistics(start=period1) do_adhoc_statistics(hass, start=period1)
wait_recording_done(hass) wait_recording_done(hass)
recorder.do_adhoc_statistics(start=period2) do_adhoc_statistics(hass, start=period2)
wait_recording_done(hass) wait_recording_done(hass)
statistic_ids = list_statistic_ids(hass) statistic_ids = list_statistic_ids(hass)
assert statistic_ids == [ assert statistic_ids == [
@ -1006,7 +991,6 @@ def test_compile_hourly_sum_statistics_total_increasing(
period1_end = period2 = period0 + timedelta(minutes=10) period1_end = period2 = period0 + timedelta(minutes=10)
period2_end = period0 + timedelta(minutes=15) period2_end = period0 + timedelta(minutes=15)
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
wait_recording_done(hass) # Wait for the sensor recorder platform to be added wait_recording_done(hass) # Wait for the sensor recorder platform to be added
attributes = { attributes = {
@ -1025,11 +1009,11 @@ def test_compile_hourly_sum_statistics_total_increasing(
) )
assert dict(states)["sensor.test1"] == dict(hist)["sensor.test1"] assert dict(states)["sensor.test1"] == dict(hist)["sensor.test1"]
recorder.do_adhoc_statistics(start=period0) do_adhoc_statistics(hass, start=period0)
wait_recording_done(hass) wait_recording_done(hass)
recorder.do_adhoc_statistics(start=period1) do_adhoc_statistics(hass, start=period1)
wait_recording_done(hass) wait_recording_done(hass)
recorder.do_adhoc_statistics(start=period2) do_adhoc_statistics(hass, start=period2)
wait_recording_done(hass) wait_recording_done(hass)
statistic_ids = list_statistic_ids(hass) statistic_ids = list_statistic_ids(hass)
assert statistic_ids == [ assert statistic_ids == [
@ -1099,7 +1083,6 @@ def test_compile_hourly_sum_statistics_total_increasing_small_dip(
period1_end = period2 = period0 + timedelta(minutes=10) period1_end = period2 = period0 + timedelta(minutes=10)
period2_end = period0 + timedelta(minutes=15) period2_end = period0 + timedelta(minutes=15)
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
wait_recording_done(hass) # Wait for the sensor recorder platform to be added wait_recording_done(hass) # Wait for the sensor recorder platform to be added
attributes = { attributes = {
@ -1118,15 +1101,15 @@ def test_compile_hourly_sum_statistics_total_increasing_small_dip(
) )
assert dict(states)["sensor.test1"] == dict(hist)["sensor.test1"] assert dict(states)["sensor.test1"] == dict(hist)["sensor.test1"]
recorder.do_adhoc_statistics(start=period0) do_adhoc_statistics(hass, start=period0)
wait_recording_done(hass) wait_recording_done(hass)
recorder.do_adhoc_statistics(start=period1) do_adhoc_statistics(hass, start=period1)
wait_recording_done(hass) wait_recording_done(hass)
assert ( assert (
"Entity sensor.test1 has state class total_increasing, but its state is not " "Entity sensor.test1 has state class total_increasing, but its state is not "
"strictly increasing." "strictly increasing."
) not in caplog.text ) not in caplog.text
recorder.do_adhoc_statistics(start=period2) do_adhoc_statistics(hass, start=period2)
wait_recording_done(hass) wait_recording_done(hass)
state = states["sensor.test1"][6].state state = states["sensor.test1"][6].state
previous_state = float(states["sensor.test1"][5].state) previous_state = float(states["sensor.test1"][5].state)
@ -1196,7 +1179,6 @@ def test_compile_hourly_energy_statistics_unsupported(hass_recorder, caplog):
period1_end = period2 = period0 + timedelta(minutes=10) period1_end = period2 = period0 + timedelta(minutes=10)
period2_end = period0 + timedelta(minutes=15) period2_end = period0 + timedelta(minutes=15)
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
wait_recording_done(hass) # Wait for the sensor recorder platform to be added wait_recording_done(hass) # Wait for the sensor recorder platform to be added
sns1_attr = { sns1_attr = {
@ -1225,11 +1207,11 @@ def test_compile_hourly_energy_statistics_unsupported(hass_recorder, caplog):
) )
assert dict(states)["sensor.test1"] == dict(hist)["sensor.test1"] assert dict(states)["sensor.test1"] == dict(hist)["sensor.test1"]
recorder.do_adhoc_statistics(start=period0) do_adhoc_statistics(hass, start=period0)
wait_recording_done(hass) wait_recording_done(hass)
recorder.do_adhoc_statistics(start=period1) do_adhoc_statistics(hass, start=period1)
wait_recording_done(hass) wait_recording_done(hass)
recorder.do_adhoc_statistics(start=period2) do_adhoc_statistics(hass, start=period2)
wait_recording_done(hass) wait_recording_done(hass)
statistic_ids = list_statistic_ids(hass) statistic_ids = list_statistic_ids(hass)
assert statistic_ids == [ assert statistic_ids == [
@ -1290,7 +1272,6 @@ def test_compile_hourly_energy_statistics_multiple(hass_recorder, caplog):
period1_end = period2 = period0 + timedelta(minutes=10) period1_end = period2 = period0 + timedelta(minutes=10)
period2_end = period0 + timedelta(minutes=15) period2_end = period0 + timedelta(minutes=15)
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
wait_recording_done(hass) # Wait for the sensor recorder platform to be added wait_recording_done(hass) # Wait for the sensor recorder platform to be added
sns1_attr = {**ENERGY_SENSOR_ATTRIBUTES, "last_reset": None} sns1_attr = {**ENERGY_SENSOR_ATTRIBUTES, "last_reset": None}
@ -1317,11 +1298,11 @@ def test_compile_hourly_energy_statistics_multiple(hass_recorder, caplog):
) )
assert dict(states)["sensor.test1"] == dict(hist)["sensor.test1"] assert dict(states)["sensor.test1"] == dict(hist)["sensor.test1"]
recorder.do_adhoc_statistics(start=period0) do_adhoc_statistics(hass, start=period0)
wait_recording_done(hass) wait_recording_done(hass)
recorder.do_adhoc_statistics(start=period1) do_adhoc_statistics(hass, start=period1)
wait_recording_done(hass) wait_recording_done(hass)
recorder.do_adhoc_statistics(start=period2) do_adhoc_statistics(hass, start=period2)
wait_recording_done(hass) wait_recording_done(hass)
statistic_ids = list_statistic_ids(hass) statistic_ids = list_statistic_ids(hass)
assert statistic_ids == [ assert statistic_ids == [
@ -1483,7 +1464,6 @@ def test_compile_hourly_statistics_unchanged(
"""Test compiling hourly statistics, with no changes during the hour.""" """Test compiling hourly statistics, with no changes during the hour."""
zero = dt_util.utcnow() zero = dt_util.utcnow()
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
wait_recording_done(hass) # Wait for the sensor recorder platform to be added wait_recording_done(hass) # Wait for the sensor recorder platform to be added
attributes = { attributes = {
@ -1495,7 +1475,7 @@ def test_compile_hourly_statistics_unchanged(
hist = history.get_significant_states(hass, zero, four) hist = history.get_significant_states(hass, zero, four)
assert dict(states) == dict(hist) assert dict(states) == dict(hist)
recorder.do_adhoc_statistics(start=four) do_adhoc_statistics(hass, start=four)
wait_recording_done(hass) wait_recording_done(hass)
stats = statistics_during_period(hass, four, period="5minute") stats = statistics_during_period(hass, four, period="5minute")
assert stats == { assert stats == {
@ -1520,7 +1500,6 @@ def test_compile_hourly_statistics_partially_unavailable(hass_recorder, caplog):
"""Test compiling hourly statistics, with the sensor being partially unavailable.""" """Test compiling hourly statistics, with the sensor being partially unavailable."""
zero = dt_util.utcnow() zero = dt_util.utcnow()
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
wait_recording_done(hass) # Wait for the sensor recorder platform to be added wait_recording_done(hass) # Wait for the sensor recorder platform to be added
four, states = record_states_partially_unavailable( four, states = record_states_partially_unavailable(
@ -1529,7 +1508,7 @@ def test_compile_hourly_statistics_partially_unavailable(hass_recorder, caplog):
hist = history.get_significant_states(hass, zero, four) hist = history.get_significant_states(hass, zero, four)
assert dict(states) == dict(hist) assert dict(states) == dict(hist)
recorder.do_adhoc_statistics(start=zero) do_adhoc_statistics(hass, start=zero)
wait_recording_done(hass) wait_recording_done(hass)
stats = statistics_during_period(hass, zero, period="5minute") stats = statistics_during_period(hass, zero, period="5minute")
assert stats == { assert stats == {
@ -1572,7 +1551,6 @@ def test_compile_hourly_statistics_unavailable(
"""Test compiling hourly statistics, with the sensor being unavailable.""" """Test compiling hourly statistics, with the sensor being unavailable."""
zero = dt_util.utcnow() zero = dt_util.utcnow()
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
wait_recording_done(hass) # Wait for the sensor recorder platform to be added wait_recording_done(hass) # Wait for the sensor recorder platform to be added
attributes = { attributes = {
@ -1588,7 +1566,7 @@ def test_compile_hourly_statistics_unavailable(
hist = history.get_significant_states(hass, zero, four) hist = history.get_significant_states(hass, zero, four)
assert dict(states) == dict(hist) assert dict(states) == dict(hist)
recorder.do_adhoc_statistics(start=four) do_adhoc_statistics(hass, start=four)
wait_recording_done(hass) wait_recording_done(hass)
stats = statistics_during_period(hass, four, period="5minute") stats = statistics_during_period(hass, four, period="5minute")
assert stats == { assert stats == {
@ -1613,14 +1591,13 @@ def test_compile_hourly_statistics_fails(hass_recorder, caplog):
"""Test compiling hourly statistics throws.""" """Test compiling hourly statistics throws."""
zero = dt_util.utcnow() zero = dt_util.utcnow()
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
wait_recording_done(hass) # Wait for the sensor recorder platform to be added wait_recording_done(hass) # Wait for the sensor recorder platform to be added
with patch( with patch(
"homeassistant.components.sensor.recorder.compile_statistics", "homeassistant.components.sensor.recorder.compile_statistics",
side_effect=Exception, side_effect=Exception,
): ):
recorder.do_adhoc_statistics(start=zero) do_adhoc_statistics(hass, start=zero)
wait_recording_done(hass) wait_recording_done(hass)
assert "Error while processing event StatisticsTask" in caplog.text assert "Error while processing event StatisticsTask" in caplog.text
@ -1737,7 +1714,6 @@ def test_compile_hourly_statistics_changing_units_1(
"""Test compiling hourly statistics where units change from one hour to the next.""" """Test compiling hourly statistics where units change from one hour to the next."""
zero = dt_util.utcnow() zero = dt_util.utcnow()
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
wait_recording_done(hass) # Wait for the sensor recorder platform to be added wait_recording_done(hass) # Wait for the sensor recorder platform to be added
attributes = { attributes = {
@ -1758,7 +1734,7 @@ def test_compile_hourly_statistics_changing_units_1(
hist = history.get_significant_states(hass, zero, four) hist = history.get_significant_states(hass, zero, four)
assert dict(states) == dict(hist) assert dict(states) == dict(hist)
recorder.do_adhoc_statistics(start=zero) do_adhoc_statistics(hass, start=zero)
wait_recording_done(hass) wait_recording_done(hass)
assert "does not match the unit of already compiled" not in caplog.text assert "does not match the unit of already compiled" not in caplog.text
statistic_ids = list_statistic_ids(hass) statistic_ids = list_statistic_ids(hass)
@ -1789,7 +1765,7 @@ def test_compile_hourly_statistics_changing_units_1(
] ]
} }
recorder.do_adhoc_statistics(start=zero + timedelta(minutes=10)) do_adhoc_statistics(hass, start=zero + timedelta(minutes=10))
wait_recording_done(hass) wait_recording_done(hass)
assert ( assert (
"The unit of sensor.test1 (cats) does not match the unit of already compiled " "The unit of sensor.test1 (cats) does not match the unit of already compiled "
@ -1840,7 +1816,6 @@ def test_compile_hourly_statistics_changing_units_2(
"""Test compiling hourly statistics where units change during an hour.""" """Test compiling hourly statistics where units change during an hour."""
zero = dt_util.utcnow() zero = dt_util.utcnow()
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
wait_recording_done(hass) # Wait for the sensor recorder platform to be added wait_recording_done(hass) # Wait for the sensor recorder platform to be added
attributes = { attributes = {
@ -1857,7 +1832,7 @@ def test_compile_hourly_statistics_changing_units_2(
hist = history.get_significant_states(hass, zero, four) hist = history.get_significant_states(hass, zero, four)
assert dict(states) == dict(hist) assert dict(states) == dict(hist)
recorder.do_adhoc_statistics(start=zero + timedelta(seconds=30 * 5)) do_adhoc_statistics(hass, start=zero + timedelta(seconds=30 * 5))
wait_recording_done(hass) wait_recording_done(hass)
assert "The unit of sensor.test1 is changing" in caplog.text assert "The unit of sensor.test1 is changing" in caplog.text
assert "and matches the unit of already compiled statistics" not in caplog.text assert "and matches the unit of already compiled statistics" not in caplog.text
@ -1893,7 +1868,6 @@ def test_compile_hourly_statistics_changing_units_3(
"""Test compiling hourly statistics where units change from one hour to the next.""" """Test compiling hourly statistics where units change from one hour to the next."""
zero = dt_util.utcnow() zero = dt_util.utcnow()
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
wait_recording_done(hass) # Wait for the sensor recorder platform to be added wait_recording_done(hass) # Wait for the sensor recorder platform to be added
attributes = { attributes = {
@ -1914,7 +1888,7 @@ def test_compile_hourly_statistics_changing_units_3(
hist = history.get_significant_states(hass, zero, four) hist = history.get_significant_states(hass, zero, four)
assert dict(states) == dict(hist) assert dict(states) == dict(hist)
recorder.do_adhoc_statistics(start=zero) do_adhoc_statistics(hass, start=zero)
wait_recording_done(hass) wait_recording_done(hass)
assert "does not match the unit of already compiled" not in caplog.text assert "does not match the unit of already compiled" not in caplog.text
statistic_ids = list_statistic_ids(hass) statistic_ids = list_statistic_ids(hass)
@ -1945,7 +1919,7 @@ def test_compile_hourly_statistics_changing_units_3(
] ]
} }
recorder.do_adhoc_statistics(start=zero + timedelta(minutes=10)) do_adhoc_statistics(hass, start=zero + timedelta(minutes=10))
wait_recording_done(hass) wait_recording_done(hass)
assert "The unit of sensor.test1 is changing" in caplog.text assert "The unit of sensor.test1 is changing" in caplog.text
assert f"matches the unit of already compiled statistics ({unit})" in caplog.text assert f"matches the unit of already compiled statistics ({unit})" in caplog.text
@ -1991,7 +1965,6 @@ def test_compile_hourly_statistics_changing_device_class_1(
"""Test compiling hourly statistics where device class changes from one hour to the next.""" """Test compiling hourly statistics where device class changes from one hour to the next."""
zero = dt_util.utcnow() zero = dt_util.utcnow()
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
wait_recording_done(hass) # Wait for the sensor recorder platform to be added wait_recording_done(hass) # Wait for the sensor recorder platform to be added
@ -2002,7 +1975,7 @@ def test_compile_hourly_statistics_changing_device_class_1(
} }
four, states = record_states(hass, zero, "sensor.test1", attributes) four, states = record_states(hass, zero, "sensor.test1", attributes)
recorder.do_adhoc_statistics(start=zero) do_adhoc_statistics(hass, start=zero)
wait_recording_done(hass) wait_recording_done(hass)
assert "does not match the unit of already compiled" not in caplog.text assert "does not match the unit of already compiled" not in caplog.text
statistic_ids = list_statistic_ids(hass) statistic_ids = list_statistic_ids(hass)
@ -2047,7 +2020,7 @@ def test_compile_hourly_statistics_changing_device_class_1(
assert dict(states) == dict(hist) assert dict(states) == dict(hist)
# Run statistics again, we get a warning, and no additional statistics is generated # Run statistics again, we get a warning, and no additional statistics is generated
recorder.do_adhoc_statistics(start=zero + timedelta(minutes=10)) do_adhoc_statistics(hass, start=zero + timedelta(minutes=10))
wait_recording_done(hass) wait_recording_done(hass)
assert ( assert (
f"The normalized unit of sensor.test1 ({statistic_unit}) does not match the " f"The normalized unit of sensor.test1 ({statistic_unit}) does not match the "
@ -2095,7 +2068,6 @@ def test_compile_hourly_statistics_changing_device_class_2(
"""Test compiling hourly statistics where device class changes from one hour to the next.""" """Test compiling hourly statistics where device class changes from one hour to the next."""
zero = dt_util.utcnow() zero = dt_util.utcnow()
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
wait_recording_done(hass) # Wait for the sensor recorder platform to be added wait_recording_done(hass) # Wait for the sensor recorder platform to be added
@ -2107,7 +2079,7 @@ def test_compile_hourly_statistics_changing_device_class_2(
} }
four, states = record_states(hass, zero, "sensor.test1", attributes) four, states = record_states(hass, zero, "sensor.test1", attributes)
recorder.do_adhoc_statistics(start=zero) do_adhoc_statistics(hass, start=zero)
wait_recording_done(hass) wait_recording_done(hass)
assert "does not match the unit of already compiled" not in caplog.text assert "does not match the unit of already compiled" not in caplog.text
statistic_ids = list_statistic_ids(hass) statistic_ids = list_statistic_ids(hass)
@ -2152,7 +2124,7 @@ def test_compile_hourly_statistics_changing_device_class_2(
assert dict(states) == dict(hist) assert dict(states) == dict(hist)
# Run statistics again, we get a warning, and no additional statistics is generated # Run statistics again, we get a warning, and no additional statistics is generated
recorder.do_adhoc_statistics(start=zero + timedelta(minutes=10)) do_adhoc_statistics(hass, start=zero + timedelta(minutes=10))
wait_recording_done(hass) wait_recording_done(hass)
assert ( assert (
f"The unit of sensor.test1 ({state_unit}) does not match the " f"The unit of sensor.test1 ({state_unit}) does not match the "
@ -2202,7 +2174,6 @@ def test_compile_hourly_statistics_changing_statistics(
period0_end = period1 = period0 + timedelta(minutes=5) period0_end = period1 = period0 + timedelta(minutes=5)
period1_end = period0 + timedelta(minutes=10) period1_end = period0 + timedelta(minutes=10)
hass = hass_recorder() hass = hass_recorder()
recorder = hass.data[DATA_INSTANCE]
setup_component(hass, "sensor", {}) setup_component(hass, "sensor", {})
wait_recording_done(hass) # Wait for the sensor recorder platform to be added wait_recording_done(hass) # Wait for the sensor recorder platform to be added
attributes_1 = { attributes_1 = {
@ -2216,7 +2187,7 @@ def test_compile_hourly_statistics_changing_statistics(
"unit_of_measurement": unit, "unit_of_measurement": unit,
} }
four, states = record_states(hass, period0, "sensor.test1", attributes_1) four, states = record_states(hass, period0, "sensor.test1", attributes_1)
recorder.do_adhoc_statistics(start=period0) do_adhoc_statistics(hass, start=period0)
wait_recording_done(hass) wait_recording_done(hass)
statistic_ids = list_statistic_ids(hass) statistic_ids = list_statistic_ids(hass)
assert statistic_ids == [ assert statistic_ids == [
@ -2250,7 +2221,7 @@ def test_compile_hourly_statistics_changing_statistics(
hist = history.get_significant_states(hass, period0, four) hist = history.get_significant_states(hass, period0, four)
assert dict(states) == dict(hist) assert dict(states) == dict(hist)
recorder.do_adhoc_statistics(start=period1) do_adhoc_statistics(hass, start=period1)
wait_recording_done(hass) wait_recording_done(hass)
statistic_ids = list_statistic_ids(hass) statistic_ids = list_statistic_ids(hass)
assert statistic_ids == [ assert statistic_ids == [
@ -2447,7 +2418,7 @@ def test_compile_statistics_hourly_daily_monthly_summary(
# Generate 5-minute statistics for two hours # Generate 5-minute statistics for two hours
start = zero start = zero
for i in range(24): for i in range(24):
recorder.do_adhoc_statistics(start=start) do_adhoc_statistics(hass, start=start)
wait_recording_done(hass) wait_recording_done(hass)
start += timedelta(minutes=5) start += timedelta(minutes=5)
@ -2841,7 +2812,7 @@ async def test_validate_statistics_supported_device_class(
# Statistics has run, invalid state - expect error # Statistics has run, invalid state - expect error
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
hass.data[DATA_INSTANCE].do_adhoc_statistics(start=now) do_adhoc_statistics(hass, start=now)
hass.states.async_set( hass.states.async_set(
"sensor.test", 12, attributes={**attributes, **{"unit_of_measurement": "dogs"}} "sensor.test", 12, attributes={**attributes, **{"unit_of_measurement": "dogs"}}
) )
@ -2856,7 +2827,7 @@ async def test_validate_statistics_supported_device_class(
await assert_validation_result(client, {}) await assert_validation_result(client, {})
# Valid state, statistic runs again - empty response # Valid state, statistic runs again - empty response
hass.data[DATA_INSTANCE].do_adhoc_statistics(start=now) do_adhoc_statistics(hass, start=now)
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
await assert_validation_result(client, {}) await assert_validation_result(client, {})
@ -2915,7 +2886,7 @@ async def test_validate_statistics_supported_device_class_2(
await assert_validation_result(client, {}) await assert_validation_result(client, {})
# Statistics has run, device class set - expect error # Statistics has run, device class set - expect error
hass.data[DATA_INSTANCE].do_adhoc_statistics(start=now) do_adhoc_statistics(hass, start=now)
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
hass.states.async_set("sensor.test", 12, attributes=attributes) hass.states.async_set("sensor.test", 12, attributes=attributes)
await hass.async_block_till_done() await hass.async_block_till_done()
@ -3004,7 +2975,7 @@ async def test_validate_statistics_unsupported_state_class(
await assert_validation_result(client, {}) await assert_validation_result(client, {})
# Statistics has run, empty response # Statistics has run, empty response
hass.data[DATA_INSTANCE].do_adhoc_statistics(start=now) do_adhoc_statistics(hass, start=now)
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
await assert_validation_result(client, {}) await assert_validation_result(client, {})
@ -3068,7 +3039,7 @@ async def test_validate_statistics_sensor_no_longer_recorded(
await assert_validation_result(client, {}) await assert_validation_result(client, {})
# Statistics has run, empty response # Statistics has run, empty response
hass.data[DATA_INSTANCE].do_adhoc_statistics(start=now) do_adhoc_statistics(hass, start=now)
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
await assert_validation_result(client, {}) await assert_validation_result(client, {})
@ -3141,7 +3112,7 @@ async def test_validate_statistics_sensor_not_recorded(
await assert_validation_result(client, expected) await assert_validation_result(client, expected)
# Statistics has run, expect same error # Statistics has run, expect same error
hass.data[DATA_INSTANCE].do_adhoc_statistics(start=now) do_adhoc_statistics(hass, start=now)
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
await assert_validation_result(client, expected) await assert_validation_result(client, expected)
@ -3187,7 +3158,7 @@ async def test_validate_statistics_sensor_removed(
await assert_validation_result(client, {}) await assert_validation_result(client, {})
# Statistics has run, empty response # Statistics has run, empty response
hass.data[DATA_INSTANCE].do_adhoc_statistics(start=now) do_adhoc_statistics(hass, start=now)
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
await assert_validation_result(client, {}) await assert_validation_result(client, {})
@ -3243,7 +3214,6 @@ async def test_validate_statistics_unsupported_device_class(
await async_setup_component(hass, "sensor", {}) await async_setup_component(hass, "sensor", {})
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
client = await hass_ws_client() client = await hass_ws_client()
rec = hass.data[DATA_INSTANCE]
# No statistics, no state - empty response # No statistics, no state - empty response
await assert_validation_result(client, {}) await assert_validation_result(client, {})
@ -3260,7 +3230,7 @@ async def test_validate_statistics_unsupported_device_class(
# Run statistics, no statistics will be generated because of conflicting units # Run statistics, no statistics will be generated because of conflicting units
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
rec.do_adhoc_statistics(start=now) do_adhoc_statistics(hass, start=now)
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
await assert_statistic_ids([]) await assert_statistic_ids([])
@ -3272,7 +3242,7 @@ async def test_validate_statistics_unsupported_device_class(
# Run statistics one hour later, only the "dogs" state will be considered # Run statistics one hour later, only the "dogs" state will be considered
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
rec.do_adhoc_statistics(start=now + timedelta(hours=1)) do_adhoc_statistics(hass, start=now + timedelta(hours=1))
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
await assert_statistic_ids( await assert_statistic_ids(
[{"statistic_id": "sensor.test", "unit_of_measurement": "dogs"}] [{"statistic_id": "sensor.test", "unit_of_measurement": "dogs"}]
@ -3305,7 +3275,7 @@ async def test_validate_statistics_unsupported_device_class(
# Valid state, statistic runs again - empty response # Valid state, statistic runs again - empty response
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
hass.data[DATA_INSTANCE].do_adhoc_statistics(start=now) do_adhoc_statistics(hass, start=now)
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
await assert_validation_result(client, {}) await assert_validation_result(client, {})