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

Ensure recorder test fixture is setup before hass fixture (#80528)

Browse Source 
* Ensure recorder test fixture is setup before hass fixture

* Adjust more tests
This commit is contained in:
Erik Montnemery 2022-10-19 07:58:47 +02:00 committed by GitHub
parent c0be1d9fad
commit 31a787558f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
54 changed files with 293 additions and 284 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tests/components/analytics/test_analytics.py
View File

@ -451,7 +451,7 @@ async def test_send_with_no_energy(hass, aioclient_mock):
assert "energy" not in postdata assert "energy" not in postdata
async def test_send_with_no_energy_config(hass, aioclient_mock, recorder_mock): async def test_send_with_no_energy_config(recorder_mock, hass, aioclient_mock):
"""Test send base preferences are defined.""" """Test send base preferences are defined."""
aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=200) aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=200)
analytics = Analytics(hass) analytics = Analytics(hass)
@ -473,7 +473,7 @@ async def test_send_with_no_energy_config(hass, aioclient_mock, recorder_mock):
assert not postdata["energy"]["configured"] assert not postdata["energy"]["configured"]
async def test_send_with_energy_config(hass, aioclient_mock, recorder_mock): async def test_send_with_energy_config(recorder_mock, hass, aioclient_mock):
"""Test send base preferences are defined.""" """Test send base preferences are defined."""
aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=200) aioclient_mock.post(ANALYTICS_ENDPOINT_URL, status=200)
analytics = Analytics(hass) analytics = Analytics(hass)

2
tests/components/automation/test_recorder.py
View File

@ -27,7 +27,7 @@ def calls(hass):
return async_mock_service(hass, "test", "automation") return async_mock_service(hass, "test", "automation")
async def test_exclude_attributes(hass, recorder_mock, calls): async def test_exclude_attributes(recorder_mock, hass, calls):
"""Test automation registered attributes to be excluded.""" """Test automation registered attributes to be excluded."""
assert await async_setup_component( assert await async_setup_component(
hass, hass,

2
tests/components/calendar/test_recorder.py
View File

@ -13,7 +13,7 @@ from tests.common import async_fire_time_changed
from tests.components.recorder.common import async_wait_recording_done from tests.components.recorder.common import async_wait_recording_done
async def test_events_http_api(hass, recorder_mock): async def test_events_http_api(recorder_mock, hass):
"""Test the calendar demo view.""" """Test the calendar demo view."""
await async_setup_component(hass, "calendar", {"calendar": {"platform": "demo"}}) await async_setup_component(hass, "calendar", {"calendar": {"platform": "demo"}})
await hass.async_block_till_done() await hass.async_block_till_done()

2
tests/components/camera/test_recorder.py
View File

@ -20,7 +20,7 @@ from tests.common import async_fire_time_changed
from tests.components.recorder.common import async_wait_recording_done from tests.components.recorder.common import async_wait_recording_done
async def test_exclude_attributes(hass, recorder_mock): async def test_exclude_attributes(recorder_mock, hass):
"""Test camera registered attributes to be excluded.""" """Test camera registered attributes to be excluded."""
await async_setup_component( await async_setup_component(
hass, camera.DOMAIN, {camera.DOMAIN: {"platform": "demo"}} hass, camera.DOMAIN, {camera.DOMAIN: {"platform": "demo"}}

2
tests/components/climate/test_recorder.py
View File

@ -26,7 +26,7 @@ from tests.common import async_fire_time_changed
from tests.components.recorder.common import async_wait_recording_done from tests.components.recorder.common import async_wait_recording_done
async def test_exclude_attributes(hass, recorder_mock): async def test_exclude_attributes(recorder_mock, hass):
"""Test climate registered attributes to be excluded.""" """Test climate registered attributes to be excluded."""
await async_setup_component( await async_setup_component(
hass, climate.DOMAIN, {climate.DOMAIN: {"platform": "demo"}} hass, climate.DOMAIN, {climate.DOMAIN: {"platform": "demo"}}

12
tests/components/demo/test_init.py
View File

@ -22,20 +22,20 @@ from homeassistant.util.unit_system import IMPERIAL_SYSTEM
from tests.components.recorder.common import async_wait_recording_done from tests.components.recorder.common import async_wait_recording_done
@pytest.fixture(autouse=True) @pytest.fixture
def mock_history(hass): def mock_history(hass):
"""Mock history component loaded.""" """Mock history component loaded."""
hass.config.components.add("history") hass.config.components.add("history")
@pytest.fixture(autouse=True) @pytest.fixture(autouse=True)
def mock_device_tracker_update_config(hass): def mock_device_tracker_update_config():
"""Prevent device tracker from creating known devices file.""" """Prevent device tracker from creating known devices file."""
with patch("homeassistant.components.device_tracker.legacy.update_config"): with patch("homeassistant.components.device_tracker.legacy.update_config"):
yield yield
async def test_setting_up_demo(hass): async def test_setting_up_demo(mock_history, hass):
"""Test if we can set up the demo and dump it to JSON.""" """Test if we can set up the demo and dump it to JSON."""
assert await async_setup_component(hass, DOMAIN, {DOMAIN: {}}) assert await async_setup_component(hass, DOMAIN, {DOMAIN: {}})
await hass.async_block_till_done() await hass.async_block_till_done()
@ -52,7 +52,7 @@ async def test_setting_up_demo(hass):
) )
async def test_demo_statistics(hass, recorder_mock): async def test_demo_statistics(recorder_mock, mock_history, hass):
"""Test that the demo components makes some statistics available.""" """Test that the demo components makes some statistics available."""
assert await async_setup_component(hass, DOMAIN, {DOMAIN: {}}) assert await async_setup_component(hass, DOMAIN, {DOMAIN: {}})
await hass.async_block_till_done() await hass.async_block_till_done()
@ -82,7 +82,7 @@ async def test_demo_statistics(hass, recorder_mock):
} in statistic_ids } in statistic_ids
async def test_demo_statistics_growth(hass, recorder_mock): async def test_demo_statistics_growth(recorder_mock, mock_history, hass):
"""Test that the demo sum statistics adds to the previous state.""" """Test that the demo sum statistics adds to the previous state."""
hass.config.units = IMPERIAL_SYSTEM hass.config.units = IMPERIAL_SYSTEM
@ -120,7 +120,7 @@ async def test_demo_statistics_growth(hass, recorder_mock):
assert statistics[statistic_id][0]["sum"] <= (2**20 + 24) assert statistics[statistic_id][0]["sum"] <= (2**20 + 24)
async def test_issues_created(hass, hass_client, hass_ws_client): async def test_issues_created(mock_history, hass, hass_client, hass_ws_client):
"""Test issues are created and can be fixed.""" """Test issues are created and can be fixed."""
assert await async_setup_component(hass, REPAIRS_DOMAIN, {REPAIRS_DOMAIN: {}}) assert await async_setup_component(hass, REPAIRS_DOMAIN, {REPAIRS_DOMAIN: {}})
assert await async_setup_component(hass, DOMAIN, {DOMAIN: {}}) assert await async_setup_component(hass, DOMAIN, {DOMAIN: {}})

24
tests/components/energy/test_sensor.py
View File

@ -49,7 +49,7 @@ def get_statistics_for_entity(statistics_results, entity_id):
return None return None
async def test_cost_sensor_no_states(hass, hass_storage, setup_integration) -> None: async def test_cost_sensor_no_states(setup_integration, hass, hass_storage) -> None:
"""Test sensors are created.""" """Test sensors are created."""
energy_data = data.EnergyManager.default_preferences() energy_data = data.EnergyManager.default_preferences()
energy_data["energy_sources"].append( energy_data["energy_sources"].append(
@ -75,7 +75,7 @@ async def test_cost_sensor_no_states(hass, hass_storage, setup_integration) -> N
# TODO: No states, should the cost entity refuse to setup? # TODO: No states, should the cost entity refuse to setup?
async def test_cost_sensor_attributes(hass, hass_storage, setup_integration) -> None: async def test_cost_sensor_attributes(setup_integration, hass, hass_storage) -> None:
"""Test sensor attributes.""" """Test sensor attributes."""
energy_data = data.EnergyManager.default_preferences() energy_data = data.EnergyManager.default_preferences()
energy_data["energy_sources"].append( energy_data["energy_sources"].append(
@ -124,10 +124,10 @@ async def test_cost_sensor_attributes(hass, hass_storage, setup_integration) ->
], ],
) )
async def test_cost_sensor_price_entity_total_increasing( async def test_cost_sensor_price_entity_total_increasing(
setup_integration,
hass, hass,
hass_storage, hass_storage,
hass_ws_client, hass_ws_client,
setup_integration,
initial_energy, initial_energy,
initial_cost, initial_cost,
price_entity, price_entity,
@ -327,10 +327,10 @@ async def test_cost_sensor_price_entity_total_increasing(
) )
@pytest.mark.parametrize("energy_state_class", ["total", "measurement"]) @pytest.mark.parametrize("energy_state_class", ["total", "measurement"])
async def test_cost_sensor_price_entity_total( async def test_cost_sensor_price_entity_total(
setup_integration,
hass, hass,
hass_storage, hass_storage,
hass_ws_client, hass_ws_client,
setup_integration,
initial_energy, initial_energy,
initial_cost, initial_cost,
price_entity, price_entity,
@ -533,10 +533,10 @@ async def test_cost_sensor_price_entity_total(
) )
@pytest.mark.parametrize("energy_state_class", ["total"]) @pytest.mark.parametrize("energy_state_class", ["total"])
async def test_cost_sensor_price_entity_total_no_reset( async def test_cost_sensor_price_entity_total_no_reset(
setup_integration,
hass, hass,
hass_storage, hass_storage,
hass_ws_client, hass_ws_client,
setup_integration,
initial_energy, initial_energy,
initial_cost, initial_cost,
price_entity, price_entity,
@ -706,7 +706,7 @@ async def test_cost_sensor_price_entity_total_no_reset(
], ],
) )
async def test_cost_sensor_handle_energy_units( async def test_cost_sensor_handle_energy_units(
hass, hass_storage, setup_integration, energy_unit, factor setup_integration, hass, hass_storage, energy_unit, factor
) -> None: ) -> None:
"""Test energy cost price from sensor entity.""" """Test energy cost price from sensor entity."""
energy_attributes = { energy_attributes = {
@ -771,7 +771,7 @@ async def test_cost_sensor_handle_energy_units(
], ],
) )
async def test_cost_sensor_handle_price_units( async def test_cost_sensor_handle_price_units(
hass, hass_storage, setup_integration, price_unit, factor setup_integration, hass, hass_storage, price_unit, factor
) -> None: ) -> None:
"""Test energy cost price from sensor entity.""" """Test energy cost price from sensor entity."""
energy_attributes = { energy_attributes = {
@ -834,7 +834,7 @@ async def test_cost_sensor_handle_price_units(
@pytest.mark.parametrize("unit", (VOLUME_CUBIC_FEET, VOLUME_CUBIC_METERS)) @pytest.mark.parametrize("unit", (VOLUME_CUBIC_FEET, VOLUME_CUBIC_METERS))
async def test_cost_sensor_handle_gas( async def test_cost_sensor_handle_gas(
hass, hass_storage, setup_integration, unit setup_integration, hass, hass_storage, unit
) -> None: ) -> None:
"""Test gas cost price from sensor entity.""" """Test gas cost price from sensor entity."""
energy_attributes = { energy_attributes = {
@ -884,7 +884,7 @@ async def test_cost_sensor_handle_gas(
async def test_cost_sensor_handle_gas_kwh( async def test_cost_sensor_handle_gas_kwh(
hass, hass_storage, setup_integration setup_integration, hass, hass_storage
) -> None: ) -> None:
"""Test gas cost price from sensor entity.""" """Test gas cost price from sensor entity."""
energy_attributes = { energy_attributes = {
@ -935,7 +935,7 @@ async def test_cost_sensor_handle_gas_kwh(
@pytest.mark.parametrize("state_class", [None]) @pytest.mark.parametrize("state_class", [None])
async def test_cost_sensor_wrong_state_class( async def test_cost_sensor_wrong_state_class(
hass, hass_storage, setup_integration, caplog, state_class setup_integration, hass, hass_storage, caplog, state_class
) -> None: ) -> None:
"""Test energy sensor rejects sensor with wrong state_class.""" """Test energy sensor rejects sensor with wrong state_class."""
energy_attributes = { energy_attributes = {
@ -996,7 +996,7 @@ async def test_cost_sensor_wrong_state_class(
@pytest.mark.parametrize("state_class", [SensorStateClass.MEASUREMENT]) @pytest.mark.parametrize("state_class", [SensorStateClass.MEASUREMENT])
async def test_cost_sensor_state_class_measurement_no_reset( async def test_cost_sensor_state_class_measurement_no_reset(
hass, hass_storage, setup_integration, caplog, state_class setup_integration, hass, hass_storage, caplog, state_class
) -> None: ) -> None:
"""Test energy sensor rejects state_class measurement with no last_reset.""" """Test energy sensor rejects state_class measurement with no last_reset."""
energy_attributes = { energy_attributes = {
@ -1051,7 +1051,7 @@ async def test_cost_sensor_state_class_measurement_no_reset(
assert state.state == STATE_UNKNOWN assert state.state == STATE_UNKNOWN
async def test_inherit_source_unique_id(hass, hass_storage, setup_integration): async def test_inherit_source_unique_id(setup_integration, hass, hass_storage):
"""Test sensor inherits unique ID from source.""" """Test sensor inherits unique ID from source."""
energy_data = data.EnergyManager.default_preferences() energy_data = data.EnergyManager.default_preferences()
energy_data["energy_sources"].append( energy_data["energy_sources"].append(

2
tests/components/energy/test_validate.py
View File

@ -48,7 +48,7 @@ def mock_get_metadata():
@pytest.fixture(autouse=True) @pytest.fixture(autouse=True)
async def mock_energy_manager(hass, recorder_mock): async def mock_energy_manager(recorder_mock, hass):
"""Set up energy.""" """Set up energy."""
assert await async_setup_component(hass, "energy", {"energy": {}}) assert await async_setup_component(hass, "energy", {"energy": {}})
manager = await async_get_manager(hass) manager = await async_get_manager(hass)

10
tests/components/energy/test_websocket_api.py
View File

@ -16,7 +16,7 @@ from tests.components.recorder.common import (
@pytest.fixture(autouse=True) @pytest.fixture(autouse=True)
async def setup_integration(hass, recorder_mock): async def setup_integration(recorder_mock, hass):
"""Set up the integration.""" """Set up the integration."""
assert await async_setup_component(hass, "energy", {}) assert await async_setup_component(hass, "energy", {})
@ -289,7 +289,7 @@ async def test_get_solar_forecast(hass, hass_ws_client, mock_energy_platform) ->
@pytest.mark.freeze_time("2021-08-01 00:00:00+00:00") @pytest.mark.freeze_time("2021-08-01 00:00:00+00:00")
async def test_fossil_energy_consumption_no_co2(hass, hass_ws_client, recorder_mock): async def test_fossil_energy_consumption_no_co2(recorder_mock, hass, hass_ws_client):
"""Test fossil_energy_consumption when co2 data is missing.""" """Test fossil_energy_consumption when co2 data is missing."""
now = dt_util.utcnow() now = dt_util.utcnow()
later = dt_util.as_utc(dt_util.parse_datetime("2022-09-01 00:00:00")) later = dt_util.as_utc(dt_util.parse_datetime("2022-09-01 00:00:00"))
@ -450,7 +450,7 @@ async def test_fossil_energy_consumption_no_co2(hass, hass_ws_client, recorder_m
@pytest.mark.freeze_time("2021-08-01 00:00:00+00:00") @pytest.mark.freeze_time("2021-08-01 00:00:00+00:00")
async def test_fossil_energy_consumption_hole(hass, hass_ws_client, recorder_mock): async def test_fossil_energy_consumption_hole(recorder_mock, hass, hass_ws_client):
"""Test fossil_energy_consumption when some data points lack sum.""" """Test fossil_energy_consumption when some data points lack sum."""
now = dt_util.utcnow() now = dt_util.utcnow()
later = dt_util.as_utc(dt_util.parse_datetime("2022-09-01 00:00:00")) later = dt_util.as_utc(dt_util.parse_datetime("2022-09-01 00:00:00"))
@ -611,7 +611,7 @@ async def test_fossil_energy_consumption_hole(hass, hass_ws_client, recorder_moc
@pytest.mark.freeze_time("2021-08-01 00:00:00+00:00") @pytest.mark.freeze_time("2021-08-01 00:00:00+00:00")
async def test_fossil_energy_consumption_no_data(hass, hass_ws_client, recorder_mock): async def test_fossil_energy_consumption_no_data(recorder_mock, hass, hass_ws_client):
"""Test fossil_energy_consumption when there is no data.""" """Test fossil_energy_consumption when there is no data."""
now = dt_util.utcnow() now = dt_util.utcnow()
later = dt_util.as_utc(dt_util.parse_datetime("2022-09-01 00:00:00")) later = dt_util.as_utc(dt_util.parse_datetime("2022-09-01 00:00:00"))
@ -759,7 +759,7 @@ async def test_fossil_energy_consumption_no_data(hass, hass_ws_client, recorder_
@pytest.mark.freeze_time("2021-08-01 00:00:00+00:00") @pytest.mark.freeze_time("2021-08-01 00:00:00+00:00")
async def test_fossil_energy_consumption(hass, hass_ws_client, recorder_mock): async def test_fossil_energy_consumption(recorder_mock, hass, hass_ws_client):
"""Test fossil_energy_consumption with co2 sensor data.""" """Test fossil_energy_consumption with co2 sensor data."""
now = dt_util.utcnow() now = dt_util.utcnow()
later = dt_util.as_utc(dt_util.parse_datetime("2022-09-01 00:00:00")) later = dt_util.as_utc(dt_util.parse_datetime("2022-09-01 00:00:00"))

2
tests/components/fan/test_recorder.py
View File

@ -16,7 +16,7 @@ from tests.common import async_fire_time_changed
from tests.components.recorder.common import async_wait_recording_done from tests.components.recorder.common import async_wait_recording_done
async def test_exclude_attributes(hass, recorder_mock): async def test_exclude_attributes(recorder_mock, hass):
"""Test fan registered attributes to be excluded.""" """Test fan registered attributes to be excluded."""
await async_setup_component(hass, fan.DOMAIN, {fan.DOMAIN: {"platform": "demo"}}) await async_setup_component(hass, fan.DOMAIN, {fan.DOMAIN: {"platform": "demo"}})
await hass.async_block_till_done() await hass.async_block_till_done()

16
tests/components/filter/test_sensor.py
View File

@ -59,7 +59,7 @@ async def test_setup_fail(hass):
await hass.async_block_till_done() await hass.async_block_till_done()
async def test_chain(hass, recorder_mock, values): async def test_chain(recorder_mock, hass, values):
"""Test if filter chaining works.""" """Test if filter chaining works."""
config = { config = {
"sensor": { "sensor": {
@ -87,7 +87,7 @@ async def test_chain(hass, recorder_mock, values):
@pytest.mark.parametrize("missing", (True, False)) @pytest.mark.parametrize("missing", (True, False))
async def test_chain_history(hass, recorder_mock, values, missing): async def test_chain_history(recorder_mock, hass, values, missing):
"""Test if filter chaining works, when a source is and isn't recorded.""" """Test if filter chaining works, when a source is and isn't recorded."""
config = { config = {
"sensor": { "sensor": {
@ -141,7 +141,7 @@ async def test_chain_history(hass, recorder_mock, values, missing):
assert state.state == "17.05" assert state.state == "17.05"
async def test_source_state_none(hass, recorder_mock, values): async def test_source_state_none(recorder_mock, hass, values):
"""Test is source sensor state is null and sets state to STATE_UNKNOWN.""" """Test is source sensor state is null and sets state to STATE_UNKNOWN."""
config = { config = {
@ -201,7 +201,7 @@ async def test_source_state_none(hass, recorder_mock, values):
assert state.state == STATE_UNKNOWN assert state.state == STATE_UNKNOWN
async def test_history_time(hass, recorder_mock): async def test_history_time(recorder_mock, hass):
"""Test loading from history based on a time window.""" """Test loading from history based on a time window."""
config = { config = {
"sensor": { "sensor": {
@ -239,7 +239,7 @@ async def test_history_time(hass, recorder_mock):
assert state.state == "18.0" assert state.state == "18.0"
async def test_setup(hass, recorder_mock): async def test_setup(recorder_mock, hass):
"""Test if filter attributes are inherited.""" """Test if filter attributes are inherited."""
config = { config = {
"sensor": { "sensor": {
@ -280,7 +280,7 @@ async def test_setup(hass, recorder_mock):
assert entity_id == "sensor.test" assert entity_id == "sensor.test"
async def test_invalid_state(hass, recorder_mock): async def test_invalid_state(recorder_mock, hass):
"""Test if filter attributes are inherited.""" """Test if filter attributes are inherited."""
config = { config = {
"sensor": { "sensor": {
@ -310,7 +310,7 @@ async def test_invalid_state(hass, recorder_mock):
assert state.state == STATE_UNAVAILABLE assert state.state == STATE_UNAVAILABLE
async def test_timestamp_state(hass, recorder_mock): async def test_timestamp_state(recorder_mock, hass):
"""Test if filter state is a datetime.""" """Test if filter state is a datetime."""
config = { config = {
"sensor": { "sensor": {
@ -469,7 +469,7 @@ def test_time_sma(values):
assert filtered.state == 21.5 assert filtered.state == 21.5
async def test_reload(hass, recorder_mock): async def test_reload(recorder_mock, hass):
"""Verify we can reload filter sensors.""" """Verify we can reload filter sensors."""
hass.states.async_set("sensor.test_monitored", 12345) hass.states.async_set("sensor.test_monitored", 12345)
await async_setup_component( await async_setup_component(

2
tests/components/group/test_recorder.py
View File

@ -16,7 +16,7 @@ from tests.common import async_fire_time_changed
from tests.components.recorder.common import async_wait_recording_done from tests.components.recorder.common import async_wait_recording_done
async def test_exclude_attributes(hass, recorder_mock): async def test_exclude_attributes(recorder_mock, hass):
"""Test number registered attributes to be excluded.""" """Test number registered attributes to be excluded."""
hass.states.async_set("light.bowl", STATE_ON) hass.states.async_set("light.bowl", STATE_ON)

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

@ -587,7 +587,7 @@ def record_states(hass):
return zero, four, states return zero, four, states
async def test_fetch_period_api(hass, hass_client, recorder_mock): async def test_fetch_period_api(recorder_mock, hass, hass_client):
"""Test the fetch period view for history.""" """Test the fetch period view for history."""
await async_setup_component(hass, "history", {}) await async_setup_component(hass, "history", {})
client = await hass_client() client = await hass_client()
@ -596,7 +596,7 @@ async def test_fetch_period_api(hass, hass_client, recorder_mock):
async def test_fetch_period_api_with_use_include_order( async def test_fetch_period_api_with_use_include_order(
hass, hass_client, recorder_mock recorder_mock, hass, hass_client
): ):
"""Test the fetch period view for history with include order.""" """Test the fetch period view for history with include order."""
await async_setup_component( await async_setup_component(
@ -607,7 +607,7 @@ async def test_fetch_period_api_with_use_include_order(
assert response.status == HTTPStatus.OK assert response.status == HTTPStatus.OK
async def test_fetch_period_api_with_minimal_response(hass, recorder_mock, hass_client): async def test_fetch_period_api_with_minimal_response(recorder_mock, hass, hass_client):
"""Test the fetch period view for history with minimal_response.""" """Test the fetch period view for history with minimal_response."""
now = dt_util.utcnow() now = dt_util.utcnow()
await async_setup_component(hass, "history", {}) await async_setup_component(hass, "history", {})
@ -647,7 +647,7 @@ async def test_fetch_period_api_with_minimal_response(hass, recorder_mock, hass_
).replace('"', "") ).replace('"', "")
async def test_fetch_period_api_with_no_timestamp(hass, hass_client, recorder_mock): async def test_fetch_period_api_with_no_timestamp(recorder_mock, hass, hass_client):
"""Test the fetch period view for history with no timestamp.""" """Test the fetch period view for history with no timestamp."""
await async_setup_component(hass, "history", {}) await async_setup_component(hass, "history", {})
client = await hass_client() client = await hass_client()
@ -655,7 +655,7 @@ async def test_fetch_period_api_with_no_timestamp(hass, hass_client, recorder_mo
assert response.status == HTTPStatus.OK assert response.status == HTTPStatus.OK
async def test_fetch_period_api_with_include_order(hass, hass_client, recorder_mock): async def test_fetch_period_api_with_include_order(recorder_mock, hass, hass_client):
"""Test the fetch period view for history.""" """Test the fetch period view for history."""
await async_setup_component( await async_setup_component(
hass, hass,
@ -676,7 +676,7 @@ async def test_fetch_period_api_with_include_order(hass, hass_client, recorder_m
async def test_fetch_period_api_with_entity_glob_include( async def test_fetch_period_api_with_entity_glob_include(
hass, hass_client, recorder_mock recorder_mock, hass, hass_client
): ):
"""Test the fetch period view for history.""" """Test the fetch period view for history."""
await async_setup_component( await async_setup_component(
@ -704,7 +704,7 @@ async def test_fetch_period_api_with_entity_glob_include(
async def test_fetch_period_api_with_entity_glob_exclude( async def test_fetch_period_api_with_entity_glob_exclude(
hass, hass_client, recorder_mock recorder_mock, hass, hass_client
): ):
"""Test the fetch period view for history.""" """Test the fetch period view for history."""
await async_setup_component( await async_setup_component(
@ -744,7 +744,7 @@ async def test_fetch_period_api_with_entity_glob_exclude(
async def test_fetch_period_api_with_entity_glob_include_and_exclude( async def test_fetch_period_api_with_entity_glob_include_and_exclude(
hass, hass_client, recorder_mock recorder_mock, hass, hass_client
): ):
"""Test the fetch period view for history.""" """Test the fetch period view for history."""
await async_setup_component( await async_setup_component(
@ -786,7 +786,7 @@ async def test_fetch_period_api_with_entity_glob_include_and_exclude(
assert response_json[3][0]["entity_id"] == "switch.match" assert response_json[3][0]["entity_id"] == "switch.match"
async def test_entity_ids_limit_via_api(hass, hass_client, recorder_mock): async def test_entity_ids_limit_via_api(recorder_mock, hass, hass_client):
"""Test limiting history to entity_ids.""" """Test limiting history to entity_ids."""
await async_setup_component( await async_setup_component(
hass, hass,
@ -811,7 +811,7 @@ async def test_entity_ids_limit_via_api(hass, hass_client, recorder_mock):
async def test_entity_ids_limit_via_api_with_skip_initial_state( async def test_entity_ids_limit_via_api_with_skip_initial_state(
hass, hass_client, recorder_mock recorder_mock, hass, hass_client
): ):
"""Test limiting history to entity_ids with skip_initial_state.""" """Test limiting history to entity_ids with skip_initial_state."""
await async_setup_component( await async_setup_component(
@ -844,7 +844,7 @@ async def test_entity_ids_limit_via_api_with_skip_initial_state(
assert response_json[1][0]["entity_id"] == "light.cow" assert response_json[1][0]["entity_id"] == "light.cow"
async def test_statistics_during_period(hass, hass_ws_client, recorder_mock, caplog): async def test_statistics_during_period(recorder_mock, hass, hass_ws_client, caplog):
"""Test history/statistics_during_period forwards to recorder.""" """Test history/statistics_during_period forwards to recorder."""
now = dt_util.utcnow() now = dt_util.utcnow()
await async_setup_component(hass, "history", {}) await async_setup_component(hass, "history", {})
@ -889,7 +889,7 @@ async def test_statistics_during_period(hass, hass_ws_client, recorder_mock, cap
ws_mock.assert_awaited_once() ws_mock.assert_awaited_once()
async def test_list_statistic_ids(hass, hass_ws_client, recorder_mock, caplog): async def test_list_statistic_ids(recorder_mock, hass, hass_ws_client, caplog):
"""Test history/list_statistic_ids forwards to recorder.""" """Test history/list_statistic_ids forwards to recorder."""
await async_setup_component(hass, "history", {}) await async_setup_component(hass, "history", {})
client = await hass_ws_client() client = await hass_ws_client()
@ -914,7 +914,7 @@ async def test_list_statistic_ids(hass, hass_ws_client, recorder_mock, caplog):
ws_mock.assert_called_once() ws_mock.assert_called_once()
async def test_history_during_period(hass, hass_ws_client, recorder_mock): async def test_history_during_period(recorder_mock, hass, hass_ws_client):
"""Test history_during_period.""" """Test history_during_period."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -1047,7 +1047,7 @@ async def test_history_during_period(hass, hass_ws_client, recorder_mock):
async def test_history_during_period_impossible_conditions( async def test_history_during_period_impossible_conditions(
hass, hass_ws_client, recorder_mock recorder_mock, hass, hass_ws_client
): ):
"""Test history_during_period returns when condition cannot be true.""" """Test history_during_period returns when condition cannot be true."""
await async_setup_component(hass, "history", {}) await async_setup_component(hass, "history", {})
@ -1109,7 +1109,7 @@ async def test_history_during_period_impossible_conditions(
"time_zone", ["UTC", "Europe/Berlin", "America/Chicago", "US/Hawaii"] "time_zone", ["UTC", "Europe/Berlin", "America/Chicago", "US/Hawaii"]
) )
async def test_history_during_period_significant_domain( async def test_history_during_period_significant_domain(
time_zone, hass, hass_ws_client, recorder_mock time_zone, recorder_mock, hass, hass_ws_client
): ):
"""Test history_during_period with climate domain.""" """Test history_during_period with climate domain."""
hass.config.set_time_zone(time_zone) hass.config.set_time_zone(time_zone)
@ -1274,7 +1274,7 @@ async def test_history_during_period_significant_domain(
async def test_history_during_period_bad_start_time( async def test_history_during_period_bad_start_time(
hass, hass_ws_client, recorder_mock recorder_mock, hass, hass_ws_client
): ):
"""Test history_during_period bad state time.""" """Test history_during_period bad state time."""
await async_setup_component( await async_setup_component(
@ -1296,7 +1296,7 @@ async def test_history_during_period_bad_start_time(
assert response["error"]["code"] == "invalid_start_time" assert response["error"]["code"] == "invalid_start_time"
async def test_history_during_period_bad_end_time(hass, hass_ws_client, recorder_mock): async def test_history_during_period_bad_end_time(recorder_mock, hass, hass_ws_client):
"""Test history_during_period bad end time.""" """Test history_during_period bad end time."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -1321,7 +1321,7 @@ async def test_history_during_period_bad_end_time(hass, hass_ws_client, recorder
async def test_history_during_period_with_use_include_order( async def test_history_during_period_with_use_include_order(
hass, hass_ws_client, recorder_mock recorder_mock, hass, hass_ws_client
): ):
"""Test history_during_period.""" """Test history_during_period."""
now = dt_util.utcnow() now = dt_util.utcnow()

38
tests/components/history_stats/test_sensor.py
View File

@ -136,7 +136,7 @@ class TestHistoryStatsSensor(unittest.TestCase):
self.hass.start() self.hass.start()
async def test_invalid_date_for_start(hass, recorder_mock): async def test_invalid_date_for_start(recorder_mock, hass):
"""Verify with an invalid date for start.""" """Verify with an invalid date for start."""
await async_setup_component( await async_setup_component(
hass, hass,
@ -161,7 +161,7 @@ async def test_invalid_date_for_start(hass, recorder_mock):
assert hass.states.get("sensor.test") is None assert hass.states.get("sensor.test") is None
async def test_invalid_date_for_end(hass, recorder_mock): async def test_invalid_date_for_end(recorder_mock, hass):
"""Verify with an invalid date for end.""" """Verify with an invalid date for end."""
await async_setup_component( await async_setup_component(
hass, hass,
@ -186,7 +186,7 @@ async def test_invalid_date_for_end(hass, recorder_mock):
assert hass.states.get("sensor.test") is None assert hass.states.get("sensor.test") is None
async def test_invalid_entity_in_template(hass, recorder_mock): async def test_invalid_entity_in_template(recorder_mock, hass):
"""Verify with an invalid entity in the template.""" """Verify with an invalid entity in the template."""
await async_setup_component( await async_setup_component(
hass, hass,
@ -211,7 +211,7 @@ async def test_invalid_entity_in_template(hass, recorder_mock):
assert hass.states.get("sensor.test") is None assert hass.states.get("sensor.test") is None
async def test_invalid_entity_returning_none_in_template(hass, recorder_mock): async def test_invalid_entity_returning_none_in_template(recorder_mock, hass):
"""Verify with an invalid entity returning none in the template.""" """Verify with an invalid entity returning none in the template."""
await async_setup_component( await async_setup_component(
hass, hass,
@ -236,7 +236,7 @@ async def test_invalid_entity_returning_none_in_template(hass, recorder_mock):
assert hass.states.get("sensor.test") is None assert hass.states.get("sensor.test") is None
async def test_reload(hass, recorder_mock): async def test_reload(recorder_mock, hass):
"""Verify we can reload history_stats sensors.""" """Verify we can reload history_stats sensors."""
hass.state = ha.CoreState.not_running hass.state = ha.CoreState.not_running
hass.states.async_set("binary_sensor.test_id", "on") hass.states.async_set("binary_sensor.test_id", "on")
@ -279,7 +279,7 @@ async def test_reload(hass, recorder_mock):
assert hass.states.get("sensor.second_test") assert hass.states.get("sensor.second_test")
async def test_measure_multiple(hass, recorder_mock): async def test_measure_multiple(recorder_mock, hass):
"""Test the history statistics sensor measure for multiple .""" """Test the history statistics sensor measure for multiple ."""
start_time = dt_util.utcnow() - timedelta(minutes=60) start_time = dt_util.utcnow() - timedelta(minutes=60)
t0 = start_time + timedelta(minutes=20) t0 = start_time + timedelta(minutes=20)
@ -361,7 +361,7 @@ async def test_measure_multiple(hass, recorder_mock):
assert hass.states.get("sensor.sensor4").state == "50.0" assert hass.states.get("sensor.sensor4").state == "50.0"
async def test_measure(hass, recorder_mock): async def test_measure(recorder_mock, hass):
"""Test the history statistics sensor measure.""" """Test the history statistics sensor measure."""
start_time = dt_util.utcnow() - timedelta(minutes=60) start_time = dt_util.utcnow() - timedelta(minutes=60)
t0 = start_time + timedelta(minutes=20) t0 = start_time + timedelta(minutes=20)
@ -440,7 +440,7 @@ async def test_measure(hass, recorder_mock):
assert hass.states.get("sensor.sensor4").state == "83.3" assert hass.states.get("sensor.sensor4").state == "83.3"
async def test_async_on_entire_period(hass, recorder_mock): async def test_async_on_entire_period(recorder_mock, hass):
"""Test the history statistics sensor measuring as on the entire period.""" """Test the history statistics sensor measuring as on the entire period."""
start_time = dt_util.utcnow() - timedelta(minutes=60) start_time = dt_util.utcnow() - timedelta(minutes=60)
t0 = start_time + timedelta(minutes=20) t0 = start_time + timedelta(minutes=20)
@ -520,7 +520,7 @@ async def test_async_on_entire_period(hass, recorder_mock):
assert hass.states.get("sensor.on_sensor4").state == "100.0" assert hass.states.get("sensor.on_sensor4").state == "100.0"
async def test_async_off_entire_period(hass, recorder_mock): async def test_async_off_entire_period(recorder_mock, hass):
"""Test the history statistics sensor measuring as off the entire period.""" """Test the history statistics sensor measuring as off the entire period."""
start_time = dt_util.utcnow() - timedelta(minutes=60) start_time = dt_util.utcnow() - timedelta(minutes=60)
t0 = start_time + timedelta(minutes=20) t0 = start_time + timedelta(minutes=20)
@ -602,8 +602,8 @@ async def test_async_off_entire_period(hass, recorder_mock):
async def test_async_start_from_history_and_switch_to_watching_state_changes_single( async def test_async_start_from_history_and_switch_to_watching_state_changes_single(
hass,
recorder_mock, recorder_mock,
hass,
): ):
"""Test we startup from history and switch to watching state changes.""" """Test we startup from history and switch to watching state changes."""
hass.config.set_time_zone("UTC") hass.config.set_time_zone("UTC")
@ -702,8 +702,8 @@ async def test_async_start_from_history_and_switch_to_watching_state_changes_sin
async def test_async_start_from_history_and_switch_to_watching_state_changes_single_expanding_window( async def test_async_start_from_history_and_switch_to_watching_state_changes_single_expanding_window(
hass,
recorder_mock, recorder_mock,
hass,
): ):
"""Test we startup from history and switch to watching state changes with an expanding end time.""" """Test we startup from history and switch to watching state changes with an expanding end time."""
hass.config.set_time_zone("UTC") hass.config.set_time_zone("UTC")
@ -801,8 +801,8 @@ async def test_async_start_from_history_and_switch_to_watching_state_changes_sin
async def test_async_start_from_history_and_switch_to_watching_state_changes_multiple( async def test_async_start_from_history_and_switch_to_watching_state_changes_multiple(
hass,
recorder_mock, recorder_mock,
hass,
): ):
"""Test we startup from history and switch to watching state changes.""" """Test we startup from history and switch to watching state changes."""
hass.config.set_time_zone("UTC") hass.config.set_time_zone("UTC")
@ -938,7 +938,7 @@ async def test_async_start_from_history_and_switch_to_watching_state_changes_mul
assert hass.states.get("sensor.sensor4").state == "87.5" assert hass.states.get("sensor.sensor4").state == "87.5"
async def test_does_not_work_into_the_future(hass, recorder_mock): async def test_does_not_work_into_the_future(recorder_mock, hass):
"""Test history cannot tell the future. """Test history cannot tell the future.
Verifies we do not regress https://github.com/home-assistant/core/pull/20589 Verifies we do not regress https://github.com/home-assistant/core/pull/20589
@ -1078,7 +1078,7 @@ async def test_does_not_work_into_the_future(hass, recorder_mock):
assert hass.states.get("sensor.sensor1").state == "0.0" assert hass.states.get("sensor.sensor1").state == "0.0"
async def test_reload_before_start_event(hass, recorder_mock): async def test_reload_before_start_event(recorder_mock, hass):
"""Verify we can reload history_stats sensors before the start event.""" """Verify we can reload history_stats sensors before the start event."""
hass.state = ha.CoreState.not_running hass.state = ha.CoreState.not_running
hass.states.async_set("binary_sensor.test_id", "on") hass.states.async_set("binary_sensor.test_id", "on")
@ -1119,7 +1119,7 @@ async def test_reload_before_start_event(hass, recorder_mock):
assert hass.states.get("sensor.second_test") assert hass.states.get("sensor.second_test")
async def test_measure_sliding_window(hass, recorder_mock): async def test_measure_sliding_window(recorder_mock, hass):
"""Test the history statistics sensor with a moving end and a moving start.""" """Test the history statistics sensor with a moving end and a moving start."""
start_time = dt_util.utcnow() - timedelta(minutes=60) start_time = dt_util.utcnow() - timedelta(minutes=60)
t0 = start_time + timedelta(minutes=20) t0 = start_time + timedelta(minutes=20)
@ -1212,7 +1212,7 @@ async def test_measure_sliding_window(hass, recorder_mock):
assert hass.states.get("sensor.sensor4").state == "41.7" assert hass.states.get("sensor.sensor4").state == "41.7"
async def test_measure_from_end_going_backwards(hass, recorder_mock): async def test_measure_from_end_going_backwards(recorder_mock, hass):
"""Test the history statistics sensor with a moving end and a duration to find the start.""" """Test the history statistics sensor with a moving end and a duration to find the start."""
start_time = dt_util.utcnow() - timedelta(minutes=60) start_time = dt_util.utcnow() - timedelta(minutes=60)
t0 = start_time + timedelta(minutes=20) t0 = start_time + timedelta(minutes=20)
@ -1304,7 +1304,7 @@ async def test_measure_from_end_going_backwards(hass, recorder_mock):
assert hass.states.get("sensor.sensor4").state == "83.3" assert hass.states.get("sensor.sensor4").state == "83.3"
async def test_measure_cet(hass, recorder_mock): async def test_measure_cet(recorder_mock, hass):
"""Test the history statistics sensor measure with a non-UTC timezone.""" """Test the history statistics sensor measure with a non-UTC timezone."""
hass.config.set_time_zone("Europe/Berlin") hass.config.set_time_zone("Europe/Berlin")
start_time = dt_util.utcnow() - timedelta(minutes=60) start_time = dt_util.utcnow() - timedelta(minutes=60)
@ -1385,7 +1385,7 @@ async def test_measure_cet(hass, recorder_mock):
@pytest.mark.parametrize("time_zone", ["Europe/Berlin", "America/Chicago", "US/Hawaii"]) @pytest.mark.parametrize("time_zone", ["Europe/Berlin", "America/Chicago", "US/Hawaii"])
async def test_end_time_with_microseconds_zeroed(time_zone, hass, recorder_mock): async def test_end_time_with_microseconds_zeroed(time_zone, recorder_mock, hass):
"""Test the history statistics sensor that has the end time microseconds zeroed out.""" """Test the history statistics sensor that has the end time microseconds zeroed out."""
hass.config.set_time_zone(time_zone) hass.config.set_time_zone(time_zone)
start_of_today = dt_util.now().replace(hour=0, minute=0, second=0, microsecond=0) start_of_today = dt_util.now().replace(hour=0, minute=0, second=0, microsecond=0)
@ -1498,7 +1498,7 @@ async def test_end_time_with_microseconds_zeroed(time_zone, hass, recorder_mock)
assert hass.states.get("sensor.heatpump_compressor_today").state == "16.0" assert hass.states.get("sensor.heatpump_compressor_today").state == "16.0"
async def test_device_classes(hass, recorder_mock): async def test_device_classes(recorder_mock, hass):
"""Test the device classes.""" """Test the device classes."""
await async_setup_component( await async_setup_component(
hass, hass,

2
tests/components/humidifier/test_recorder.py
View File

@ -20,7 +20,7 @@ from tests.common import async_fire_time_changed
from tests.components.recorder.common import async_wait_recording_done from tests.components.recorder.common import async_wait_recording_done
async def test_exclude_attributes(hass, recorder_mock): async def test_exclude_attributes(recorder_mock, hass):
"""Test humidifier registered attributes to be excluded.""" """Test humidifier registered attributes to be excluded."""
await async_setup_component( await async_setup_component(
hass, humidifier.DOMAIN, {humidifier.DOMAIN: {"platform": "demo"}} hass, humidifier.DOMAIN, {humidifier.DOMAIN: {"platform": "demo"}}

2
tests/components/input_boolean/test_recorder.py
View File

@ -16,7 +16,7 @@ from tests.components.recorder.common import async_wait_recording_done
async def test_exclude_attributes( async def test_exclude_attributes(
hass: HomeAssistant, recorder_mock, enable_custom_integrations: None recorder_mock, hass: HomeAssistant, enable_custom_integrations: None
): ):
"""Test attributes to be excluded.""" """Test attributes to be excluded."""
assert await async_setup_component(hass, DOMAIN, {DOMAIN: {"test": {}}}) assert await async_setup_component(hass, DOMAIN, {DOMAIN: {"test": {}}})

2
tests/components/input_button/test_recorder.py
View File

@ -16,7 +16,7 @@ from tests.components.recorder.common import async_wait_recording_done
async def test_exclude_attributes( async def test_exclude_attributes(
hass: HomeAssistant, recorder_mock, enable_custom_integrations: None recorder_mock, hass: HomeAssistant, enable_custom_integrations: None
): ):
"""Test attributes to be excluded.""" """Test attributes to be excluded."""
assert await async_setup_component(hass, DOMAIN, {DOMAIN: {"test": {}}}) assert await async_setup_component(hass, DOMAIN, {DOMAIN: {"test": {}}})

2
tests/components/input_datetime/test_recorder.py
View File

@ -16,7 +16,7 @@ from tests.components.recorder.common import async_wait_recording_done
async def test_exclude_attributes( async def test_exclude_attributes(
hass: HomeAssistant, recorder_mock, enable_custom_integrations: None recorder_mock, hass: HomeAssistant, enable_custom_integrations: None
): ):
"""Test attributes to be excluded.""" """Test attributes to be excluded."""
assert await async_setup_component( assert await async_setup_component(

2
tests/components/input_number/test_recorder.py
View File

@ -22,7 +22,7 @@ from tests.components.recorder.common import async_wait_recording_done
async def test_exclude_attributes( async def test_exclude_attributes(
hass: HomeAssistant, recorder_mock, enable_custom_integrations: None recorder_mock, hass: HomeAssistant, enable_custom_integrations: None
): ):
"""Test attributes to be excluded.""" """Test attributes to be excluded."""
assert await async_setup_component( assert await async_setup_component(

2
tests/components/input_select/test_recorder.py
View File

@ -16,7 +16,7 @@ from tests.components.recorder.common import async_wait_recording_done
async def test_exclude_attributes( async def test_exclude_attributes(
hass: HomeAssistant, recorder_mock, enable_custom_integrations: None recorder_mock, hass: HomeAssistant, enable_custom_integrations: None
): ):
"""Test attributes to be excluded.""" """Test attributes to be excluded."""
assert await async_setup_component( assert await async_setup_component(

2
tests/components/input_text/test_recorder.py
View File

@ -23,7 +23,7 @@ from tests.components.recorder.common import async_wait_recording_done
async def test_exclude_attributes( async def test_exclude_attributes(
hass: HomeAssistant, recorder_mock, enable_custom_integrations: None recorder_mock, hass: HomeAssistant, enable_custom_integrations: None
): ):
"""Test attributes to be excluded.""" """Test attributes to be excluded."""
assert await async_setup_component(hass, DOMAIN, {DOMAIN: {"test": {}}}) assert await async_setup_component(hass, DOMAIN, {DOMAIN: {"test": {}}})

2
tests/components/light/test_recorder.py
View File

@ -21,7 +21,7 @@ from tests.common import async_fire_time_changed
from tests.components.recorder.common import async_wait_recording_done from tests.components.recorder.common import async_wait_recording_done
async def test_exclude_attributes(hass, recorder_mock): async def test_exclude_attributes(recorder_mock, hass):
"""Test light registered attributes to be excluded.""" """Test light registered attributes to be excluded."""
await async_setup_component( await async_setup_component(
hass, light.DOMAIN, {light.DOMAIN: {"platform": "demo"}} hass, light.DOMAIN, {light.DOMAIN: {"platform": "demo"}}

92
tests/components/logbook/test_init.py
View File

@ -58,7 +58,7 @@ EMPTY_CONFIG = logbook.CONFIG_SCHEMA({logbook.DOMAIN: {}})
@pytest.fixture @pytest.fixture
async def hass_(hass, recorder_mock): async def hass_(recorder_mock, hass):
"""Set up things to be run when tests are started.""" """Set up things to be run when tests are started."""
assert await async_setup_component(hass, logbook.DOMAIN, EMPTY_CONFIG) assert await async_setup_component(hass, logbook.DOMAIN, EMPTY_CONFIG)
return hass return hass
@ -123,7 +123,7 @@ async def test_service_call_create_logbook_entry(hass_):
assert last_call.data.get(logbook.ATTR_DOMAIN) == "logbook" assert last_call.data.get(logbook.ATTR_DOMAIN) == "logbook"
async def test_service_call_create_logbook_entry_invalid_entity_id(hass, recorder_mock): async def test_service_call_create_logbook_entry_invalid_entity_id(recorder_mock, hass):
"""Test if service call create log book entry with an invalid entity id.""" """Test if service call create log book entry with an invalid entity id."""
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
await hass.async_block_till_done() await hass.async_block_till_done()
@ -352,7 +352,7 @@ def create_state_changed_event_from_old_new(
return LazyEventPartialState(row, {}) return LazyEventPartialState(row, {})
async def test_logbook_view(hass, hass_client, recorder_mock): async def test_logbook_view(recorder_mock, hass, hass_client):
"""Test the logbook view.""" """Test the logbook view."""
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
@ -361,7 +361,7 @@ async def test_logbook_view(hass, hass_client, recorder_mock):
assert response.status == HTTPStatus.OK assert response.status == HTTPStatus.OK
async def test_logbook_view_invalid_start_date_time(hass, hass_client, recorder_mock): async def test_logbook_view_invalid_start_date_time(recorder_mock, hass, hass_client):
"""Test the logbook view with an invalid date time.""" """Test the logbook view with an invalid date time."""
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
@ -370,7 +370,7 @@ async def test_logbook_view_invalid_start_date_time(hass, hass_client, recorder_
assert response.status == HTTPStatus.BAD_REQUEST assert response.status == HTTPStatus.BAD_REQUEST
async def test_logbook_view_invalid_end_date_time(hass, hass_client, recorder_mock): async def test_logbook_view_invalid_end_date_time(recorder_mock, hass, hass_client):
"""Test the logbook view.""" """Test the logbook view."""
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
@ -381,7 +381,7 @@ async def test_logbook_view_invalid_end_date_time(hass, hass_client, recorder_mo
assert response.status == HTTPStatus.BAD_REQUEST assert response.status == HTTPStatus.BAD_REQUEST
async def test_logbook_view_period_entity(hass, hass_client, recorder_mock, set_utc): async def test_logbook_view_period_entity(recorder_mock, hass, hass_client, set_utc):
"""Test the logbook view with period and entity.""" """Test the logbook view with period and entity."""
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
@ -462,7 +462,7 @@ async def test_logbook_view_period_entity(hass, hass_client, recorder_mock, set_
assert response_json[0]["entity_id"] == entity_id_test assert response_json[0]["entity_id"] == entity_id_test
async def test_logbook_describe_event(hass, hass_client, recorder_mock): async def test_logbook_describe_event(recorder_mock, hass, hass_client):
"""Test teaching logbook about a new event.""" """Test teaching logbook about a new event."""
def _describe(event): def _describe(event):
@ -498,7 +498,7 @@ async def test_logbook_describe_event(hass, hass_client, recorder_mock):
assert event["domain"] == "test_domain" assert event["domain"] == "test_domain"
async def test_exclude_described_event(hass, hass_client, recorder_mock): async def test_exclude_described_event(recorder_mock, hass, hass_client):
"""Test exclusions of events that are described by another integration.""" """Test exclusions of events that are described by another integration."""
name = "My Automation Rule" name = "My Automation Rule"
entity_id = "automation.excluded_rule" entity_id = "automation.excluded_rule"
@ -561,7 +561,7 @@ async def test_exclude_described_event(hass, hass_client, recorder_mock):
assert event["entity_id"] == "automation.included_rule" assert event["entity_id"] == "automation.included_rule"
async def test_logbook_view_end_time_entity(hass, hass_client, recorder_mock): async def test_logbook_view_end_time_entity(recorder_mock, hass, hass_client):
"""Test the logbook view with end_time and entity.""" """Test the logbook view with end_time and entity."""
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
@ -616,7 +616,7 @@ async def test_logbook_view_end_time_entity(hass, hass_client, recorder_mock):
assert response_json[0]["entity_id"] == entity_id_test assert response_json[0]["entity_id"] == entity_id_test
async def test_logbook_entity_filter_with_automations(hass, hass_client, recorder_mock): async def test_logbook_entity_filter_with_automations(recorder_mock, hass, hass_client):
"""Test the logbook view with end_time and entity with automations and scripts.""" """Test the logbook view with end_time and entity with automations and scripts."""
await asyncio.gather( await asyncio.gather(
*[ *[
@ -692,7 +692,7 @@ async def test_logbook_entity_filter_with_automations(hass, hass_client, recorde
async def test_logbook_entity_no_longer_in_state_machine( async def test_logbook_entity_no_longer_in_state_machine(
hass, hass_client, recorder_mock recorder_mock, hass, hass_client
): ):
"""Test the logbook view with an entity that hass been removed from the state machine.""" """Test the logbook view with an entity that hass been removed from the state machine."""
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
@ -730,7 +730,7 @@ async def test_logbook_entity_no_longer_in_state_machine(
async def test_filter_continuous_sensor_values( async def test_filter_continuous_sensor_values(
hass, hass_client, recorder_mock, set_utc recorder_mock, hass, hass_client, set_utc
): ):
"""Test remove continuous sensor events from logbook.""" """Test remove continuous sensor events from logbook."""
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
@ -770,7 +770,7 @@ async def test_filter_continuous_sensor_values(
assert response_json[1]["entity_id"] == entity_id_third assert response_json[1]["entity_id"] == entity_id_third
async def test_exclude_new_entities(hass, hass_client, recorder_mock, set_utc): async def test_exclude_new_entities(recorder_mock, hass, hass_client, set_utc):
"""Test if events are excluded on first update.""" """Test if events are excluded on first update."""
await asyncio.gather( await asyncio.gather(
*[ *[
@ -807,7 +807,7 @@ async def test_exclude_new_entities(hass, hass_client, recorder_mock, set_utc):
assert response_json[1]["message"] == "started" assert response_json[1]["message"] == "started"
async def test_exclude_removed_entities(hass, hass_client, recorder_mock, set_utc): async def test_exclude_removed_entities(recorder_mock, hass, hass_client, set_utc):
"""Test if events are excluded on last update.""" """Test if events are excluded on last update."""
await asyncio.gather( await asyncio.gather(
*[ *[
@ -851,7 +851,7 @@ async def test_exclude_removed_entities(hass, hass_client, recorder_mock, set_ut
assert response_json[2]["entity_id"] == entity_id2 assert response_json[2]["entity_id"] == entity_id2
async def test_exclude_attribute_changes(hass, hass_client, recorder_mock, set_utc): async def test_exclude_attribute_changes(recorder_mock, hass, hass_client, set_utc):
"""Test if events of attribute changes are filtered.""" """Test if events of attribute changes are filtered."""
await asyncio.gather( await asyncio.gather(
*[ *[
@ -891,7 +891,7 @@ async def test_exclude_attribute_changes(hass, hass_client, recorder_mock, set_u
assert response_json[2]["entity_id"] == "light.kitchen" assert response_json[2]["entity_id"] == "light.kitchen"
async def test_logbook_entity_context_id(hass, recorder_mock, hass_client): async def test_logbook_entity_context_id(recorder_mock, hass, hass_client):
"""Test the logbook view with end_time and entity with automations and scripts.""" """Test the logbook view with end_time and entity with automations and scripts."""
await asyncio.gather( await asyncio.gather(
*[ *[
@ -1042,7 +1042,7 @@ async def test_logbook_entity_context_id(hass, recorder_mock, hass_client):
async def test_logbook_context_id_automation_script_started_manually( async def test_logbook_context_id_automation_script_started_manually(
hass, recorder_mock, hass_client recorder_mock, hass, hass_client
): ):
"""Test the logbook populates context_ids for scripts and automations started manually.""" """Test the logbook populates context_ids for scripts and automations started manually."""
await asyncio.gather( await asyncio.gather(
@ -1132,7 +1132,7 @@ async def test_logbook_context_id_automation_script_started_manually(
assert json_dict[4]["context_domain"] == "script" assert json_dict[4]["context_domain"] == "script"
async def test_logbook_entity_context_parent_id(hass, hass_client, recorder_mock): async def test_logbook_entity_context_parent_id(recorder_mock, hass, hass_client):
"""Test the logbook view links events via context parent_id.""" """Test the logbook view links events via context parent_id."""
await asyncio.gather( await asyncio.gather(
*[ *[
@ -1311,7 +1311,7 @@ async def test_logbook_entity_context_parent_id(hass, hass_client, recorder_mock
assert json_dict[8]["context_user_id"] == "485cacf93ef84d25a99ced3126b921d2" assert json_dict[8]["context_user_id"] == "485cacf93ef84d25a99ced3126b921d2"
async def test_logbook_context_from_template(hass, hass_client, recorder_mock): async def test_logbook_context_from_template(recorder_mock, hass, hass_client):
"""Test the logbook view with end_time and entity with automations and scripts.""" """Test the logbook view with end_time and entity with automations and scripts."""
await asyncio.gather( await asyncio.gather(
*[ *[
@ -1398,7 +1398,7 @@ async def test_logbook_context_from_template(hass, hass_client, recorder_mock):
assert json_dict[5]["context_user_id"] == "9400facee45711eaa9308bfd3d19e474" assert json_dict[5]["context_user_id"] == "9400facee45711eaa9308bfd3d19e474"
async def test_logbook_(hass, hass_client, recorder_mock): async def test_logbook_(recorder_mock, hass, hass_client):
"""Test the logbook view with a single entity and .""" """Test the logbook view with a single entity and ."""
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
assert await async_setup_component( assert await async_setup_component(
@ -1467,7 +1467,7 @@ async def test_logbook_(hass, hass_client, recorder_mock):
assert json_dict[1]["context_user_id"] == "9400facee45711eaa9308bfd3d19e474" assert json_dict[1]["context_user_id"] == "9400facee45711eaa9308bfd3d19e474"
async def test_logbook_many_entities_multiple_calls(hass, hass_client, recorder_mock): async def test_logbook_many_entities_multiple_calls(recorder_mock, hass, hass_client):
"""Test the logbook view with a many entities called multiple times.""" """Test the logbook view with a many entities called multiple times."""
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
await async_setup_component(hass, "automation", {}) await async_setup_component(hass, "automation", {})
@ -1537,7 +1537,7 @@ async def test_logbook_many_entities_multiple_calls(hass, hass_client, recorder_
assert len(json_dict) == 0 assert len(json_dict) == 0
async def test_custom_log_entry_discoverable_via_(hass, hass_client, recorder_mock): async def test_custom_log_entry_discoverable_via_(recorder_mock, hass, hass_client):
"""Test if a custom log entry is later discoverable via .""" """Test if a custom log entry is later discoverable via ."""
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
@ -1572,7 +1572,7 @@ async def test_custom_log_entry_discoverable_via_(hass, hass_client, recorder_mo
assert json_dict[0]["entity_id"] == "switch.test_switch" assert json_dict[0]["entity_id"] == "switch.test_switch"
async def test_logbook_multiple_entities(hass, hass_client, recorder_mock): async def test_logbook_multiple_entities(recorder_mock, hass, hass_client):
"""Test the logbook view with a multiple entities.""" """Test the logbook view with a multiple entities."""
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
assert await async_setup_component( assert await async_setup_component(
@ -1696,7 +1696,7 @@ async def test_logbook_multiple_entities(hass, hass_client, recorder_mock):
assert json_dict[3]["context_user_id"] == "9400facee45711eaa9308bfd3d19e474" assert json_dict[3]["context_user_id"] == "9400facee45711eaa9308bfd3d19e474"
async def test_logbook_invalid_entity(hass, hass_client, recorder_mock): async def test_logbook_invalid_entity(recorder_mock, hass, hass_client):
"""Test the logbook view with requesting an invalid entity.""" """Test the logbook view with requesting an invalid entity."""
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
await hass.async_block_till_done() await hass.async_block_till_done()
@ -1714,7 +1714,7 @@ async def test_logbook_invalid_entity(hass, hass_client, recorder_mock):
assert response.status == HTTPStatus.INTERNAL_SERVER_ERROR assert response.status == HTTPStatus.INTERNAL_SERVER_ERROR
async def test_icon_and_state(hass, hass_client, recorder_mock): async def test_icon_and_state(recorder_mock, hass, hass_client):
"""Test to ensure state and custom icons are returned.""" """Test to ensure state and custom icons are returned."""
await asyncio.gather( await asyncio.gather(
*[ *[
@ -1757,7 +1757,7 @@ async def test_icon_and_state(hass, hass_client, recorder_mock):
assert response_json[2]["state"] == STATE_OFF assert response_json[2]["state"] == STATE_OFF
async def test_fire_logbook_entries(hass, hass_client, recorder_mock): async def test_fire_logbook_entries(recorder_mock, hass, hass_client):
"""Test many logbook entry calls.""" """Test many logbook entry calls."""
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
@ -1793,7 +1793,7 @@ async def test_fire_logbook_entries(hass, hass_client, recorder_mock):
assert len(response_json) == 11 assert len(response_json) == 11
async def test_exclude_events_domain(hass, hass_client, recorder_mock): async def test_exclude_events_domain(recorder_mock, hass, hass_client):
"""Test if events are filtered if domain is excluded in config.""" """Test if events are filtered if domain is excluded in config."""
entity_id = "switch.bla" entity_id = "switch.bla"
entity_id2 = "sensor.blu" entity_id2 = "sensor.blu"
@ -1827,7 +1827,7 @@ async def test_exclude_events_domain(hass, hass_client, recorder_mock):
_assert_entry(entries[1], name="blu", entity_id=entity_id2) _assert_entry(entries[1], name="blu", entity_id=entity_id2)
async def test_exclude_events_domain_glob(hass, hass_client, recorder_mock): async def test_exclude_events_domain_glob(recorder_mock, hass, hass_client):
"""Test if events are filtered if domain or glob is excluded in config.""" """Test if events are filtered if domain or glob is excluded in config."""
entity_id = "switch.bla" entity_id = "switch.bla"
entity_id2 = "sensor.blu" entity_id2 = "sensor.blu"
@ -1870,7 +1870,7 @@ async def test_exclude_events_domain_glob(hass, hass_client, recorder_mock):
_assert_entry(entries[1], name="blu", entity_id=entity_id2) _assert_entry(entries[1], name="blu", entity_id=entity_id2)
async def test_include_events_entity(hass, hass_client, recorder_mock): async def test_include_events_entity(recorder_mock, hass, hass_client):
"""Test if events are filtered if entity is included in config.""" """Test if events are filtered if entity is included in config."""
entity_id = "sensor.bla" entity_id = "sensor.bla"
entity_id2 = "sensor.blu" entity_id2 = "sensor.blu"
@ -1910,7 +1910,7 @@ async def test_include_events_entity(hass, hass_client, recorder_mock):
_assert_entry(entries[1], name="blu", entity_id=entity_id2) _assert_entry(entries[1], name="blu", entity_id=entity_id2)
async def test_exclude_events_entity(hass, hass_client, recorder_mock): async def test_exclude_events_entity(recorder_mock, hass, hass_client):
"""Test if events are filtered if entity is excluded in config.""" """Test if events are filtered if entity is excluded in config."""
entity_id = "sensor.bla" entity_id = "sensor.bla"
entity_id2 = "sensor.blu" entity_id2 = "sensor.blu"
@ -1944,7 +1944,7 @@ async def test_exclude_events_entity(hass, hass_client, recorder_mock):
_assert_entry(entries[1], name="blu", entity_id=entity_id2) _assert_entry(entries[1], name="blu", entity_id=entity_id2)
async def test_include_events_domain(hass, hass_client, recorder_mock): async def test_include_events_domain(recorder_mock, hass, hass_client):
"""Test if events are filtered if domain is included in config.""" """Test if events are filtered if domain is included in config."""
assert await async_setup_component(hass, "alexa", {}) assert await async_setup_component(hass, "alexa", {})
entity_id = "switch.bla" entity_id = "switch.bla"
@ -1986,7 +1986,7 @@ async def test_include_events_domain(hass, hass_client, recorder_mock):
_assert_entry(entries[2], name="blu", entity_id=entity_id2) _assert_entry(entries[2], name="blu", entity_id=entity_id2)
async def test_include_events_domain_glob(hass, hass_client, recorder_mock): async def test_include_events_domain_glob(recorder_mock, hass, hass_client):
"""Test if events are filtered if domain or glob is included in config.""" """Test if events are filtered if domain or glob is included in config."""
assert await async_setup_component(hass, "alexa", {}) assert await async_setup_component(hass, "alexa", {})
entity_id = "switch.bla" entity_id = "switch.bla"
@ -2043,7 +2043,7 @@ async def test_include_events_domain_glob(hass, hass_client, recorder_mock):
_assert_entry(entries[3], name="included", entity_id=entity_id3) _assert_entry(entries[3], name="included", entity_id=entity_id3)
async def test_include_exclude_events_no_globs(hass, hass_client, recorder_mock): async def test_include_exclude_events_no_globs(recorder_mock, hass, hass_client):
"""Test if events are filtered if include and exclude is configured.""" """Test if events are filtered if include and exclude is configured."""
entity_id = "switch.bla" entity_id = "switch.bla"
entity_id2 = "sensor.blu" entity_id2 = "sensor.blu"
@ -2100,7 +2100,7 @@ async def test_include_exclude_events_no_globs(hass, hass_client, recorder_mock)
async def test_include_exclude_events_with_glob_filters( async def test_include_exclude_events_with_glob_filters(
hass, hass_client, recorder_mock recorder_mock, hass, hass_client
): ):
"""Test if events are filtered if include and exclude is configured.""" """Test if events are filtered if include and exclude is configured."""
entity_id = "switch.bla" entity_id = "switch.bla"
@ -2165,7 +2165,7 @@ async def test_include_exclude_events_with_glob_filters(
_assert_entry(entries[6], name="included", entity_id=entity_id5, state="30") _assert_entry(entries[6], name="included", entity_id=entity_id5, state="30")
async def test_empty_config(hass, hass_client, recorder_mock): async def test_empty_config(recorder_mock, hass, hass_client):
"""Test we can handle an empty entity filter.""" """Test we can handle an empty entity filter."""
entity_id = "sensor.blu" entity_id = "sensor.blu"
@ -2197,7 +2197,7 @@ async def test_empty_config(hass, hass_client, recorder_mock):
_assert_entry(entries[1], name="blu", entity_id=entity_id) _assert_entry(entries[1], name="blu", entity_id=entity_id)
async def test_context_filter(hass, hass_client, recorder_mock): async def test_context_filter(recorder_mock, hass, hass_client):
"""Test we can filter by context.""" """Test we can filter by context."""
assert await async_setup_component(hass, "logbook", {}) assert await async_setup_component(hass, "logbook", {})
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
@ -2269,7 +2269,7 @@ def _assert_entry(
assert state == entry["state"] assert state == entry["state"]
async def test_get_events(hass, hass_ws_client, recorder_mock): async def test_get_events(recorder_mock, hass, hass_ws_client):
"""Test logbook get_events.""" """Test logbook get_events."""
now = dt_util.utcnow() now = dt_util.utcnow()
await asyncio.gather( await asyncio.gather(
@ -2387,7 +2387,7 @@ async def test_get_events(hass, hass_ws_client, recorder_mock):
assert isinstance(results[0]["when"], float) assert isinstance(results[0]["when"], float)
async def test_get_events_future_start_time(hass, hass_ws_client, recorder_mock): async def test_get_events_future_start_time(recorder_mock, hass, hass_ws_client):
"""Test get_events with a future start time.""" """Test get_events with a future start time."""
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
@ -2410,7 +2410,7 @@ async def test_get_events_future_start_time(hass, hass_ws_client, recorder_mock)
assert len(results) == 0 assert len(results) == 0
async def test_get_events_bad_start_time(hass, hass_ws_client, recorder_mock): async def test_get_events_bad_start_time(recorder_mock, hass, hass_ws_client):
"""Test get_events bad start time.""" """Test get_events bad start time."""
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
@ -2428,7 +2428,7 @@ async def test_get_events_bad_start_time(hass, hass_ws_client, recorder_mock):
assert response["error"]["code"] == "invalid_start_time" assert response["error"]["code"] == "invalid_start_time"
async def test_get_events_bad_end_time(hass, hass_ws_client, recorder_mock): async def test_get_events_bad_end_time(recorder_mock, hass, hass_ws_client):
"""Test get_events bad end time.""" """Test get_events bad end time."""
now = dt_util.utcnow() now = dt_util.utcnow()
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
@ -2448,7 +2448,7 @@ async def test_get_events_bad_end_time(hass, hass_ws_client, recorder_mock):
assert response["error"]["code"] == "invalid_end_time" assert response["error"]["code"] == "invalid_end_time"
async def test_get_events_invalid_filters(hass, hass_ws_client, recorder_mock): async def test_get_events_invalid_filters(recorder_mock, hass, hass_ws_client):
"""Test get_events invalid filters.""" """Test get_events invalid filters."""
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
@ -2476,7 +2476,7 @@ async def test_get_events_invalid_filters(hass, hass_ws_client, recorder_mock):
assert response["error"]["code"] == "invalid_format" assert response["error"]["code"] == "invalid_format"
async def test_get_events_with_device_ids(hass, hass_ws_client, recorder_mock): async def test_get_events_with_device_ids(recorder_mock, hass, hass_ws_client):
"""Test logbook get_events for device ids.""" """Test logbook get_events for device ids."""
now = dt_util.utcnow() now = dt_util.utcnow()
await asyncio.gather( await asyncio.gather(
@ -2613,7 +2613,7 @@ async def test_get_events_with_device_ids(hass, hass_ws_client, recorder_mock):
assert isinstance(results[3]["when"], float) assert isinstance(results[3]["when"], float)
async def test_logbook_select_entities_context_id(hass, recorder_mock, hass_client): async def test_logbook_select_entities_context_id(recorder_mock, hass, hass_client):
"""Test the logbook view with end_time and entity with automations and scripts.""" """Test the logbook view with end_time and entity with automations and scripts."""
await asyncio.gather( await asyncio.gather(
*[ *[
@ -2746,7 +2746,7 @@ async def test_logbook_select_entities_context_id(hass, recorder_mock, hass_clie
assert json_dict[3]["context_user_id"] == "9400facee45711eaa9308bfd3d19e474" assert json_dict[3]["context_user_id"] == "9400facee45711eaa9308bfd3d19e474"
async def test_get_events_with_context_state(hass, hass_ws_client, recorder_mock): async def test_get_events_with_context_state(recorder_mock, hass, hass_ws_client):
"""Test logbook get_events with a context state.""" """Test logbook get_events with a context state."""
now = dt_util.utcnow() now = dt_util.utcnow()
await asyncio.gather( await asyncio.gather(
@ -2809,7 +2809,7 @@ async def test_get_events_with_context_state(hass, hass_ws_client, recorder_mock
assert "context_event_type" not in results[3] assert "context_event_type" not in results[3]
async def test_logbook_with_empty_config(hass, recorder_mock): async def test_logbook_with_empty_config(recorder_mock, hass):
"""Test we handle a empty configuration.""" """Test we handle a empty configuration."""
assert await async_setup_component( assert await async_setup_component(
hass, hass,
@ -2822,7 +2822,7 @@ async def test_logbook_with_empty_config(hass, recorder_mock):
await hass.async_block_till_done() await hass.async_block_till_done()
async def test_logbook_with_non_iterable_entity_filter(hass, recorder_mock): async def test_logbook_with_non_iterable_entity_filter(recorder_mock, hass):
"""Test we handle a non-iterable entity filter.""" """Test we handle a non-iterable entity filter."""
assert await async_setup_component( assert await async_setup_component(
hass, hass,

56
tests/components/logbook/test_websocket_api.py
View File

@ -123,7 +123,7 @@ async def _async_mock_devices_with_logbook_platform(hass):
return [device, device2] return [device, device2]
async def test_get_events(hass, hass_ws_client, recorder_mock): async def test_get_events(recorder_mock, hass, hass_ws_client):
"""Test logbook get_events.""" """Test logbook get_events."""
now = dt_util.utcnow() now = dt_util.utcnow()
await asyncio.gather( await asyncio.gather(
@ -241,7 +241,7 @@ async def test_get_events(hass, hass_ws_client, recorder_mock):
assert isinstance(results[0]["when"], float) assert isinstance(results[0]["when"], float)
async def test_get_events_entities_filtered_away(hass, hass_ws_client, recorder_mock): async def test_get_events_entities_filtered_away(recorder_mock, hass, hass_ws_client):
"""Test logbook get_events all entities filtered away.""" """Test logbook get_events all entities filtered away."""
now = dt_util.utcnow() now = dt_util.utcnow()
await asyncio.gather( await asyncio.gather(
@ -303,7 +303,7 @@ async def test_get_events_entities_filtered_away(hass, hass_ws_client, recorder_
assert len(results) == 0 assert len(results) == 0
async def test_get_events_future_start_time(hass, hass_ws_client, recorder_mock): async def test_get_events_future_start_time(recorder_mock, hass, hass_ws_client):
"""Test get_events with a future start time.""" """Test get_events with a future start time."""
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
@ -326,7 +326,7 @@ async def test_get_events_future_start_time(hass, hass_ws_client, recorder_mock)
assert len(results) == 0 assert len(results) == 0
async def test_get_events_bad_start_time(hass, hass_ws_client, recorder_mock): async def test_get_events_bad_start_time(recorder_mock, hass, hass_ws_client):
"""Test get_events bad start time.""" """Test get_events bad start time."""
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
@ -344,7 +344,7 @@ async def test_get_events_bad_start_time(hass, hass_ws_client, recorder_mock):
assert response["error"]["code"] == "invalid_start_time" assert response["error"]["code"] == "invalid_start_time"
async def test_get_events_bad_end_time(hass, hass_ws_client, recorder_mock): async def test_get_events_bad_end_time(recorder_mock, hass, hass_ws_client):
"""Test get_events bad end time.""" """Test get_events bad end time."""
now = dt_util.utcnow() now = dt_util.utcnow()
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
@ -364,7 +364,7 @@ async def test_get_events_bad_end_time(hass, hass_ws_client, recorder_mock):
assert response["error"]["code"] == "invalid_end_time" assert response["error"]["code"] == "invalid_end_time"
async def test_get_events_invalid_filters(hass, hass_ws_client, recorder_mock): async def test_get_events_invalid_filters(recorder_mock, hass, hass_ws_client):
"""Test get_events invalid filters.""" """Test get_events invalid filters."""
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
@ -392,7 +392,7 @@ async def test_get_events_invalid_filters(hass, hass_ws_client, recorder_mock):
assert response["error"]["code"] == "invalid_format" assert response["error"]["code"] == "invalid_format"
async def test_get_events_with_device_ids(hass, hass_ws_client, recorder_mock): async def test_get_events_with_device_ids(recorder_mock, hass, hass_ws_client):
"""Test logbook get_events for device ids.""" """Test logbook get_events for device ids."""
now = dt_util.utcnow() now = dt_util.utcnow()
await asyncio.gather( await asyncio.gather(
@ -504,7 +504,7 @@ async def test_get_events_with_device_ids(hass, hass_ws_client, recorder_mock):
@patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0) @patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0)
async def test_subscribe_unsubscribe_logbook_stream_excluded_entities( async def test_subscribe_unsubscribe_logbook_stream_excluded_entities(
hass, recorder_mock, hass_ws_client recorder_mock, hass, hass_ws_client
): ):
"""Test subscribe/unsubscribe logbook stream with excluded entities.""" """Test subscribe/unsubscribe logbook stream with excluded entities."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -689,7 +689,7 @@ async def test_subscribe_unsubscribe_logbook_stream_excluded_entities(
@patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0) @patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0)
async def test_subscribe_unsubscribe_logbook_stream_included_entities( async def test_subscribe_unsubscribe_logbook_stream_included_entities(
hass, recorder_mock, hass_ws_client recorder_mock, hass, hass_ws_client
): ):
"""Test subscribe/unsubscribe logbook stream with included entities.""" """Test subscribe/unsubscribe logbook stream with included entities."""
test_entities = ( test_entities = (
@ -897,7 +897,7 @@ async def test_subscribe_unsubscribe_logbook_stream_included_entities(
@patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0) @patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0)
async def test_logbook_stream_excluded_entities_inherits_filters_from_recorder( async def test_logbook_stream_excluded_entities_inherits_filters_from_recorder(
hass, recorder_mock, hass_ws_client recorder_mock, hass, hass_ws_client
): ):
"""Test subscribe/unsubscribe logbook stream inherts filters from recorder.""" """Test subscribe/unsubscribe logbook stream inherts filters from recorder."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -1088,7 +1088,7 @@ async def test_logbook_stream_excluded_entities_inherits_filters_from_recorder(
@patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0) @patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0)
async def test_subscribe_unsubscribe_logbook_stream( async def test_subscribe_unsubscribe_logbook_stream(
hass, recorder_mock, hass_ws_client recorder_mock, hass, hass_ws_client
): ):
"""Test subscribe/unsubscribe logbook stream.""" """Test subscribe/unsubscribe logbook stream."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -1391,7 +1391,7 @@ async def test_subscribe_unsubscribe_logbook_stream(
@patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0) @patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0)
async def test_subscribe_unsubscribe_logbook_stream_entities( async def test_subscribe_unsubscribe_logbook_stream_entities(
hass, recorder_mock, hass_ws_client recorder_mock, hass, hass_ws_client
): ):
"""Test subscribe/unsubscribe logbook stream with specific entities.""" """Test subscribe/unsubscribe logbook stream with specific entities."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -1489,7 +1489,7 @@ async def test_subscribe_unsubscribe_logbook_stream_entities(
@patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0) @patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0)
async def test_subscribe_unsubscribe_logbook_stream_entities_with_end_time( async def test_subscribe_unsubscribe_logbook_stream_entities_with_end_time(
hass, recorder_mock, hass_ws_client recorder_mock, hass, hass_ws_client
): ):
"""Test subscribe/unsubscribe logbook stream with specific entities and an end_time.""" """Test subscribe/unsubscribe logbook stream with specific entities and an end_time."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -1596,7 +1596,7 @@ async def test_subscribe_unsubscribe_logbook_stream_entities_with_end_time(
@patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0) @patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0)
async def test_subscribe_unsubscribe_logbook_stream_entities_past_only( async def test_subscribe_unsubscribe_logbook_stream_entities_past_only(
hass, recorder_mock, hass_ws_client recorder_mock, hass, hass_ws_client
): ):
"""Test subscribe/unsubscribe logbook stream with specific entities in the past.""" """Test subscribe/unsubscribe logbook stream with specific entities in the past."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -1664,7 +1664,7 @@ async def test_subscribe_unsubscribe_logbook_stream_entities_past_only(
@patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0) @patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0)
async def test_subscribe_unsubscribe_logbook_stream_big_query( async def test_subscribe_unsubscribe_logbook_stream_big_query(
hass, recorder_mock, hass_ws_client recorder_mock, hass, hass_ws_client
): ):
"""Test subscribe/unsubscribe logbook stream and ask for a large time frame. """Test subscribe/unsubscribe logbook stream and ask for a large time frame.
@ -1764,7 +1764,7 @@ async def test_subscribe_unsubscribe_logbook_stream_big_query(
@patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0) @patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0)
async def test_subscribe_unsubscribe_logbook_stream_device( async def test_subscribe_unsubscribe_logbook_stream_device(
hass, recorder_mock, hass_ws_client recorder_mock, hass, hass_ws_client
): ):
"""Test subscribe/unsubscribe logbook stream with a device.""" """Test subscribe/unsubscribe logbook stream with a device."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -1856,7 +1856,7 @@ async def test_subscribe_unsubscribe_logbook_stream_device(
assert hass.bus.async_listeners() == init_listeners assert hass.bus.async_listeners() == init_listeners
async def test_event_stream_bad_start_time(hass, hass_ws_client, recorder_mock): async def test_event_stream_bad_start_time(recorder_mock, hass, hass_ws_client):
"""Test event_stream bad start time.""" """Test event_stream bad start time."""
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
@ -1876,7 +1876,7 @@ async def test_event_stream_bad_start_time(hass, hass_ws_client, recorder_mock):
@patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0) @patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0)
async def test_logbook_stream_match_multiple_entities( async def test_logbook_stream_match_multiple_entities(
hass, recorder_mock, hass_ws_client recorder_mock, hass, hass_ws_client
): ):
"""Test logbook stream with a described integration that uses multiple entities.""" """Test logbook stream with a described integration that uses multiple entities."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -1971,7 +1971,7 @@ async def test_logbook_stream_match_multiple_entities(
assert hass.bus.async_listeners() == init_listeners assert hass.bus.async_listeners() == init_listeners
async def test_event_stream_bad_end_time(hass, hass_ws_client, recorder_mock): async def test_event_stream_bad_end_time(recorder_mock, hass, hass_ws_client):
"""Test event_stream bad end time.""" """Test event_stream bad end time."""
await async_setup_component(hass, "logbook", {}) await async_setup_component(hass, "logbook", {})
await async_recorder_block_till_done(hass) await async_recorder_block_till_done(hass)
@ -2004,8 +2004,8 @@ async def test_event_stream_bad_end_time(hass, hass_ws_client, recorder_mock):
async def test_live_stream_with_one_second_commit_interval( async def test_live_stream_with_one_second_commit_interval(
hass: HomeAssistant,
async_setup_recorder_instance: SetupRecorderInstanceT, async_setup_recorder_instance: SetupRecorderInstanceT,
hass: HomeAssistant,
hass_ws_client, hass_ws_client,
): ):
"""Test the recorder with a 1s commit interval.""" """Test the recorder with a 1s commit interval."""
@ -2095,7 +2095,7 @@ async def test_live_stream_with_one_second_commit_interval(
@patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0) @patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0)
async def test_subscribe_disconnected(hass, recorder_mock, hass_ws_client): async def test_subscribe_disconnected(recorder_mock, hass, hass_ws_client):
"""Test subscribe/unsubscribe logbook stream gets disconnected.""" """Test subscribe/unsubscribe logbook stream gets disconnected."""
now = dt_util.utcnow() now = dt_util.utcnow()
await asyncio.gather( await asyncio.gather(
@ -2150,7 +2150,7 @@ async def test_subscribe_disconnected(hass, recorder_mock, hass_ws_client):
@patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0) @patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0)
async def test_stream_consumer_stop_processing(hass, recorder_mock, hass_ws_client): async def test_stream_consumer_stop_processing(recorder_mock, hass, hass_ws_client):
"""Test we unsubscribe if the stream consumer fails or is canceled.""" """Test we unsubscribe if the stream consumer fails or is canceled."""
now = dt_util.utcnow() now = dt_util.utcnow()
await asyncio.gather( await asyncio.gather(
@ -2203,7 +2203,7 @@ async def test_stream_consumer_stop_processing(hass, recorder_mock, hass_ws_clie
@patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0) @patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0)
async def test_recorder_is_far_behind(hass, recorder_mock, hass_ws_client, caplog): async def test_recorder_is_far_behind(recorder_mock, hass, hass_ws_client, caplog):
"""Test we still start live streaming if the recorder is far behind.""" """Test we still start live streaming if the recorder is far behind."""
now = dt_util.utcnow() now = dt_util.utcnow()
await asyncio.gather( await asyncio.gather(
@ -2279,7 +2279,7 @@ async def test_recorder_is_far_behind(hass, recorder_mock, hass_ws_client, caplo
@patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0) @patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0)
async def test_subscribe_all_entities_are_continuous( async def test_subscribe_all_entities_are_continuous(
hass, recorder_mock, hass_ws_client recorder_mock, hass, hass_ws_client
): ):
"""Test subscribe/unsubscribe logbook stream with entities that are always filtered.""" """Test subscribe/unsubscribe logbook stream with entities that are always filtered."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -2337,7 +2337,7 @@ async def test_subscribe_all_entities_are_continuous(
@patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0) @patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0)
async def test_subscribe_all_entities_have_uom_multiple( async def test_subscribe_all_entities_have_uom_multiple(
hass, recorder_mock, hass_ws_client recorder_mock, hass, hass_ws_client
): ):
"""Test logbook stream with specific request for multiple entities that are always filtered.""" """Test logbook stream with specific request for multiple entities that are always filtered."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -2394,7 +2394,7 @@ async def test_subscribe_all_entities_have_uom_multiple(
@patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0) @patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0)
async def test_subscribe_entities_some_have_uom_multiple( async def test_subscribe_entities_some_have_uom_multiple(
hass, recorder_mock, hass_ws_client recorder_mock, hass, hass_ws_client
): ):
"""Test logbook stream with uom filtered entities and non-filtered entities.""" """Test logbook stream with uom filtered entities and non-filtered entities."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -2499,7 +2499,7 @@ async def test_subscribe_entities_some_have_uom_multiple(
@patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0) @patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0)
async def test_logbook_stream_ignores_forced_updates( async def test_logbook_stream_ignores_forced_updates(
hass, recorder_mock, hass_ws_client recorder_mock, hass, hass_ws_client
): ):
"""Test logbook live stream ignores forced updates.""" """Test logbook live stream ignores forced updates."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -2613,7 +2613,7 @@ async def test_logbook_stream_ignores_forced_updates(
@patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0) @patch("homeassistant.components.logbook.websocket_api.EVENT_COALESCE_TIME", 0)
async def test_subscribe_all_entities_are_continuous_with_device( async def test_subscribe_all_entities_are_continuous_with_device(
hass, recorder_mock, hass_ws_client recorder_mock, hass, hass_ws_client
): ):
"""Test subscribe/unsubscribe logbook stream with entities that are always filtered and a device.""" """Test subscribe/unsubscribe logbook stream with entities that are always filtered and a device."""
now = dt_util.utcnow() now = dt_util.utcnow()

2
tests/components/media_player/test_recorder.py
View File

@ -22,7 +22,7 @@ from tests.common import async_fire_time_changed
from tests.components.recorder.common import async_wait_recording_done from tests.components.recorder.common import async_wait_recording_done
async def test_exclude_attributes(hass, recorder_mock): async def test_exclude_attributes(recorder_mock, hass):
"""Test media_player registered attributes to be excluded.""" """Test media_player registered attributes to be excluded."""
await async_setup_component( await async_setup_component(
hass, media_player.DOMAIN, {media_player.DOMAIN: {"platform": "demo"}} hass, media_player.DOMAIN, {media_player.DOMAIN: {"platform": "demo"}}

2
tests/components/number/test_recorder.py
View File

@ -16,7 +16,7 @@ from tests.common import async_fire_time_changed
from tests.components.recorder.common import async_wait_recording_done from tests.components.recorder.common import async_wait_recording_done
async def test_exclude_attributes(hass, recorder_mock): async def test_exclude_attributes(recorder_mock, hass):
"""Test number registered attributes to be excluded.""" """Test number registered attributes to be excluded."""
await async_setup_component( await async_setup_component(
hass, number.DOMAIN, {number.DOMAIN: {"platform": "demo"}} hass, number.DOMAIN, {number.DOMAIN: {"platform": "demo"}}

2
tests/components/plant/test_init.py
View File

@ -144,7 +144,7 @@ async def test_state_problem_if_unavailable(hass):
assert state.attributes[plant.READING_MOISTURE] == STATE_UNAVAILABLE assert state.attributes[plant.READING_MOISTURE] == STATE_UNAVAILABLE
async def test_load_from_db(hass, recorder_mock): async def test_load_from_db(recorder_mock, hass):
"""Test bootstrapping the brightness history from the database. """Test bootstrapping the brightness history from the database.
This test can should only be executed if the loading of the history This test can should only be executed if the loading of the history

10
tests/components/recorder/test_backup.py
View File

@ -10,7 +10,7 @@ from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError from homeassistant.exceptions import HomeAssistantError
async def test_async_pre_backup(hass: HomeAssistant, recorder_mock) -> None: async def test_async_pre_backup(recorder_mock, hass: HomeAssistant) -> None:
"""Test pre backup.""" """Test pre backup."""
with patch( with patch(
"homeassistant.components.recorder.core.Recorder.lock_database" "homeassistant.components.recorder.core.Recorder.lock_database"
@ -20,7 +20,7 @@ async def test_async_pre_backup(hass: HomeAssistant, recorder_mock) -> None:
async def test_async_pre_backup_with_timeout( async def test_async_pre_backup_with_timeout(
hass: HomeAssistant, recorder_mock recorder_mock, hass: HomeAssistant
) -> None: ) -> None:
"""Test pre backup with timeout.""" """Test pre backup with timeout."""
with patch( with patch(
@ -32,7 +32,7 @@ async def test_async_pre_backup_with_timeout(
async def test_async_pre_backup_with_migration( async def test_async_pre_backup_with_migration(
hass: HomeAssistant, recorder_mock recorder_mock, hass: HomeAssistant
) -> None: ) -> None:
"""Test pre backup with migration.""" """Test pre backup with migration."""
with patch( with patch(
@ -42,7 +42,7 @@ async def test_async_pre_backup_with_migration(
await async_pre_backup(hass) await async_pre_backup(hass)
async def test_async_post_backup(hass: HomeAssistant, recorder_mock) -> None: async def test_async_post_backup(recorder_mock, hass: HomeAssistant) -> None:
"""Test post backup.""" """Test post backup."""
with patch( with patch(
"homeassistant.components.recorder.core.Recorder.unlock_database" "homeassistant.components.recorder.core.Recorder.unlock_database"
@ -51,7 +51,7 @@ async def test_async_post_backup(hass: HomeAssistant, recorder_mock) -> None:
assert unlock_mock.called assert unlock_mock.called
async def test_async_post_backup_failure(hass: HomeAssistant, recorder_mock) -> None: async def test_async_post_backup_failure(recorder_mock, hass: HomeAssistant) -> None:
"""Test post backup failure.""" """Test post backup failure."""
with patch( with patch(
"homeassistant.components.recorder.core.Recorder.unlock_database", "homeassistant.components.recorder.core.Recorder.unlock_database",

22
tests/components/recorder/test_filters_with_entityfilter.py
View File

@ -71,7 +71,7 @@ async def _async_get_states_and_events_with_filter(
return filtered_states_entity_ids, filtered_events_entity_ids return filtered_states_entity_ids, filtered_events_entity_ids
async def test_included_and_excluded_simple_case_no_domains(hass, recorder_mock): async def test_included_and_excluded_simple_case_no_domains(recorder_mock, hass):
"""Test filters with included and excluded without domains.""" """Test filters with included and excluded without domains."""
filter_accept = {"sensor.kitchen4", "switch.kitchen"} filter_accept = {"sensor.kitchen4", "switch.kitchen"}
filter_reject = { filter_reject = {
@ -127,7 +127,7 @@ async def test_included_and_excluded_simple_case_no_domains(hass, recorder_mock)
assert not filtered_events_entity_ids.intersection(filter_reject) assert not filtered_events_entity_ids.intersection(filter_reject)
async def test_included_and_excluded_simple_case_no_globs(hass, recorder_mock): async def test_included_and_excluded_simple_case_no_globs(recorder_mock, hass):
"""Test filters with included and excluded without globs.""" """Test filters with included and excluded without globs."""
filter_accept = {"switch.bla", "sensor.blu", "sensor.keep"} filter_accept = {"switch.bla", "sensor.blu", "sensor.keep"}
filter_reject = {"sensor.bli"} filter_reject = {"sensor.bli"}
@ -168,7 +168,7 @@ async def test_included_and_excluded_simple_case_no_globs(hass, recorder_mock):
async def test_included_and_excluded_simple_case_without_underscores( async def test_included_and_excluded_simple_case_without_underscores(
hass, recorder_mock recorder_mock, hass
): ):
"""Test filters with included and excluded without underscores.""" """Test filters with included and excluded without underscores."""
filter_accept = {"light.any", "sensor.kitchen4", "switch.kitchen"} filter_accept = {"light.any", "sensor.kitchen4", "switch.kitchen"}
@ -221,7 +221,7 @@ async def test_included_and_excluded_simple_case_without_underscores(
assert not filtered_events_entity_ids.intersection(filter_reject) assert not filtered_events_entity_ids.intersection(filter_reject)
async def test_included_and_excluded_simple_case_with_underscores(hass, recorder_mock): async def test_included_and_excluded_simple_case_with_underscores(recorder_mock, hass):
"""Test filters with included and excluded with underscores.""" """Test filters with included and excluded with underscores."""
filter_accept = {"light.any", "sensor.kitchen_4", "switch.kitchen"} filter_accept = {"light.any", "sensor.kitchen_4", "switch.kitchen"}
filter_reject = {"switch.other", "cover.any", "sensor.weather_5", "light.kitchen"} filter_reject = {"switch.other", "cover.any", "sensor.weather_5", "light.kitchen"}
@ -273,7 +273,7 @@ async def test_included_and_excluded_simple_case_with_underscores(hass, recorder
assert not filtered_events_entity_ids.intersection(filter_reject) assert not filtered_events_entity_ids.intersection(filter_reject)
async def test_included_and_excluded_complex_case(hass, recorder_mock): async def test_included_and_excluded_complex_case(recorder_mock, hass):
"""Test filters with included and excluded with a complex filter.""" """Test filters with included and excluded with a complex filter."""
filter_accept = {"light.any", "sensor.kitchen_4", "switch.kitchen"} filter_accept = {"light.any", "sensor.kitchen_4", "switch.kitchen"}
filter_reject = { filter_reject = {
@ -330,7 +330,7 @@ async def test_included_and_excluded_complex_case(hass, recorder_mock):
assert not filtered_events_entity_ids.intersection(filter_reject) assert not filtered_events_entity_ids.intersection(filter_reject)
async def test_included_entities_and_excluded_domain(hass, recorder_mock): async def test_included_entities_and_excluded_domain(recorder_mock, hass):
"""Test filters with included entities and excluded domain.""" """Test filters with included entities and excluded domain."""
filter_accept = { filter_accept = {
"media_player.test", "media_player.test",
@ -376,7 +376,7 @@ async def test_included_entities_and_excluded_domain(hass, recorder_mock):
assert not filtered_events_entity_ids.intersection(filter_reject) assert not filtered_events_entity_ids.intersection(filter_reject)
async def test_same_domain_included_excluded(hass, recorder_mock): async def test_same_domain_included_excluded(recorder_mock, hass):
"""Test filters with the same domain included and excluded.""" """Test filters with the same domain included and excluded."""
filter_accept = { filter_accept = {
"media_player.test", "media_player.test",
@ -422,7 +422,7 @@ async def test_same_domain_included_excluded(hass, recorder_mock):
assert not filtered_events_entity_ids.intersection(filter_reject) assert not filtered_events_entity_ids.intersection(filter_reject)
async def test_same_entity_included_excluded(hass, recorder_mock): async def test_same_entity_included_excluded(recorder_mock, hass):
"""Test filters with the same entity included and excluded.""" """Test filters with the same entity included and excluded."""
filter_accept = { filter_accept = {
"media_player.test", "media_player.test",
@ -468,7 +468,7 @@ async def test_same_entity_included_excluded(hass, recorder_mock):
assert not filtered_events_entity_ids.intersection(filter_reject) assert not filtered_events_entity_ids.intersection(filter_reject)
async def test_same_entity_included_excluded_include_domain_wins(hass, recorder_mock): async def test_same_entity_included_excluded_include_domain_wins(recorder_mock, hass):
"""Test filters with domain and entities and the include domain wins.""" """Test filters with domain and entities and the include domain wins."""
filter_accept = { filter_accept = {
"media_player.test2", "media_player.test2",
@ -516,7 +516,7 @@ async def test_same_entity_included_excluded_include_domain_wins(hass, recorder_
assert not filtered_events_entity_ids.intersection(filter_reject) assert not filtered_events_entity_ids.intersection(filter_reject)
async def test_specificly_included_entity_always_wins(hass, recorder_mock): async def test_specificly_included_entity_always_wins(recorder_mock, hass):
"""Test specificlly included entity always wins.""" """Test specificlly included entity always wins."""
filter_accept = { filter_accept = {
"media_player.test2", "media_player.test2",
@ -564,7 +564,7 @@ async def test_specificly_included_entity_always_wins(hass, recorder_mock):
assert not filtered_events_entity_ids.intersection(filter_reject) assert not filtered_events_entity_ids.intersection(filter_reject)
async def test_specificly_included_entity_always_wins_over_glob(hass, recorder_mock): async def test_specificly_included_entity_always_wins_over_glob(recorder_mock, hass):
"""Test specificlly included entity always wins over a glob.""" """Test specificlly included entity always wins over a glob."""
filter_accept = { filter_accept = {
"sensor.apc900va_status", "sensor.apc900va_status",

8
tests/components/recorder/test_history.py
View File

@ -650,8 +650,8 @@ def record_states(hass) -> tuple[datetime, datetime, dict[str, list[State]]]:
async def test_state_changes_during_period_query_during_migration_to_schema_25( async def test_state_changes_during_period_query_during_migration_to_schema_25(
hass: ha.HomeAssistant,
async_setup_recorder_instance: SetupRecorderInstanceT, async_setup_recorder_instance: SetupRecorderInstanceT,
hass: ha.HomeAssistant,
): ):
"""Test we can query data prior to schema 25 and during migration to schema 25.""" """Test we can query data prior to schema 25 and during migration to schema 25."""
instance = await async_setup_recorder_instance(hass, {}) instance = await async_setup_recorder_instance(hass, {})
@ -700,8 +700,8 @@ async def test_state_changes_during_period_query_during_migration_to_schema_25(
async def test_get_states_query_during_migration_to_schema_25( async def test_get_states_query_during_migration_to_schema_25(
hass: ha.HomeAssistant,
async_setup_recorder_instance: SetupRecorderInstanceT, async_setup_recorder_instance: SetupRecorderInstanceT,
hass: ha.HomeAssistant,
): ):
"""Test we can query data prior to schema 25 and during migration to schema 25.""" """Test we can query data prior to schema 25 and during migration to schema 25."""
instance = await async_setup_recorder_instance(hass, {}) instance = await async_setup_recorder_instance(hass, {})
@ -746,8 +746,8 @@ async def test_get_states_query_during_migration_to_schema_25(
async def test_get_states_query_during_migration_to_schema_25_multiple_entities( async def test_get_states_query_during_migration_to_schema_25_multiple_entities(
hass: ha.HomeAssistant,
async_setup_recorder_instance: SetupRecorderInstanceT, async_setup_recorder_instance: SetupRecorderInstanceT,
hass: ha.HomeAssistant,
): ):
"""Test we can query data prior to schema 25 and during migration to schema 25.""" """Test we can query data prior to schema 25 and during migration to schema 25."""
instance = await async_setup_recorder_instance(hass, {}) instance = await async_setup_recorder_instance(hass, {})
@ -795,8 +795,8 @@ async def test_get_states_query_during_migration_to_schema_25_multiple_entities(
async def test_get_full_significant_states_handles_empty_last_changed( async def test_get_full_significant_states_handles_empty_last_changed(
hass: ha.HomeAssistant,
async_setup_recorder_instance: SetupRecorderInstanceT, async_setup_recorder_instance: SetupRecorderInstanceT,
hass: ha.HomeAssistant,
): ):
"""Test getting states when last_changed is null.""" """Test getting states when last_changed is null."""
await async_setup_recorder_instance(hass, {}) await async_setup_recorder_instance(hass, {})

30
tests/components/recorder/test_init.py
View File

@ -92,7 +92,7 @@ def _default_recorder(hass):
async def test_shutdown_before_startup_finishes( async def test_shutdown_before_startup_finishes(
hass: HomeAssistant, async_setup_recorder_instance: SetupRecorderInstanceT, tmp_path async_setup_recorder_instance: SetupRecorderInstanceT, hass: HomeAssistant, tmp_path
): ):
"""Test shutdown before recorder starts is clean.""" """Test shutdown before recorder starts is clean."""
@ -124,8 +124,8 @@ async def test_shutdown_before_startup_finishes(
async def test_canceled_before_startup_finishes( async def test_canceled_before_startup_finishes(
hass: HomeAssistant,
async_setup_recorder_instance: SetupRecorderInstanceT, async_setup_recorder_instance: SetupRecorderInstanceT,
hass: HomeAssistant,
caplog: pytest.LogCaptureFixture, caplog: pytest.LogCaptureFixture,
): ):
"""Test recorder shuts down when its startup future is canceled out from under it.""" """Test recorder shuts down when its startup future is canceled out from under it."""
@ -145,7 +145,7 @@ async def test_canceled_before_startup_finishes(
) )
async def test_shutdown_closes_connections(hass, recorder_mock): async def test_shutdown_closes_connections(recorder_mock, hass):
"""Test shutdown closes connections.""" """Test shutdown closes connections."""
hass.state = CoreState.not_running hass.state = CoreState.not_running
@ -171,7 +171,7 @@ async def test_shutdown_closes_connections(hass, recorder_mock):
async def test_state_gets_saved_when_set_before_start_event( async def test_state_gets_saved_when_set_before_start_event(
hass: HomeAssistant, async_setup_recorder_instance: SetupRecorderInstanceT async_setup_recorder_instance: SetupRecorderInstanceT, hass: HomeAssistant
): ):
"""Test we can record an event when starting with not running.""" """Test we can record an event when starting with not running."""
@ -197,7 +197,7 @@ async def test_state_gets_saved_when_set_before_start_event(
assert db_states[0].event_id is None assert db_states[0].event_id is None
async def test_saving_state(hass: HomeAssistant, recorder_mock): async def test_saving_state(recorder_mock, hass: HomeAssistant):
"""Test saving and restoring a state.""" """Test saving and restoring a state."""
entity_id = "test.recorder" entity_id = "test.recorder"
state = "restoring_from_db" state = "restoring_from_db"
@ -220,7 +220,7 @@ async def test_saving_state(hass: HomeAssistant, recorder_mock):
async def test_saving_many_states( async def test_saving_many_states(
hass: HomeAssistant, async_setup_recorder_instance: SetupRecorderInstanceT async_setup_recorder_instance: SetupRecorderInstanceT, hass: HomeAssistant
): ):
"""Test we expire after many commits.""" """Test we expire after many commits."""
instance = await async_setup_recorder_instance( instance = await async_setup_recorder_instance(
@ -248,7 +248,7 @@ async def test_saving_many_states(
async def test_saving_state_with_intermixed_time_changes( async def test_saving_state_with_intermixed_time_changes(
hass: HomeAssistant, recorder_mock recorder_mock, hass: HomeAssistant
): ):
"""Test saving states with intermixed time changes.""" """Test saving states with intermixed time changes."""
entity_id = "test.recorder" entity_id = "test.recorder"
@ -348,7 +348,7 @@ def test_saving_state_with_sqlalchemy_exception(hass, hass_recorder, caplog):
async def test_force_shutdown_with_queue_of_writes_that_generate_exceptions( async def test_force_shutdown_with_queue_of_writes_that_generate_exceptions(
hass, async_setup_recorder_instance, caplog async_setup_recorder_instance, hass, caplog
): ):
"""Test forcing shutdown.""" """Test forcing shutdown."""
instance = await async_setup_recorder_instance(hass) instance = await async_setup_recorder_instance(hass)
@ -1370,8 +1370,8 @@ def test_entity_id_filter(hass_recorder):
async def test_database_lock_and_unlock( async def test_database_lock_and_unlock(
hass: HomeAssistant,
async_setup_recorder_instance: SetupRecorderInstanceT, async_setup_recorder_instance: SetupRecorderInstanceT,
hass: HomeAssistant,
tmp_path, tmp_path,
): ):
"""Test writing events during lock getting written after unlocking.""" """Test writing events during lock getting written after unlocking."""
@ -1412,8 +1412,8 @@ async def test_database_lock_and_unlock(
async def test_database_lock_and_overflow( async def test_database_lock_and_overflow(
hass: HomeAssistant,
async_setup_recorder_instance: SetupRecorderInstanceT, async_setup_recorder_instance: SetupRecorderInstanceT,
hass: HomeAssistant,
tmp_path, tmp_path,
): ):
"""Test writing events during lock leading to overflow the queue causes the database to unlock.""" """Test writing events during lock leading to overflow the queue causes the database to unlock."""
@ -1450,7 +1450,7 @@ async def test_database_lock_and_overflow(
assert not instance.unlock_database() assert not instance.unlock_database()
async def test_database_lock_timeout(hass, recorder_mock): async def test_database_lock_timeout(recorder_mock, hass):
"""Test locking database timeout when recorder stopped.""" """Test locking database timeout when recorder stopped."""
hass.bus.async_fire(EVENT_HOMEASSISTANT_STOP) hass.bus.async_fire(EVENT_HOMEASSISTANT_STOP)
@ -1473,7 +1473,7 @@ async def test_database_lock_timeout(hass, recorder_mock):
block_task.event.set() block_task.event.set()
async def test_database_lock_without_instance(hass, recorder_mock): async def test_database_lock_without_instance(recorder_mock, hass):
"""Test database lock doesn't fail if instance is not initialized.""" """Test database lock doesn't fail if instance is not initialized."""
hass.bus.async_fire(EVENT_HOMEASSISTANT_STOP) hass.bus.async_fire(EVENT_HOMEASSISTANT_STOP)
@ -1494,8 +1494,8 @@ async def test_in_memory_database(hass, caplog):
async def test_database_connection_keep_alive( async def test_database_connection_keep_alive(
hass: HomeAssistant,
async_setup_recorder_instance: SetupRecorderInstanceT, async_setup_recorder_instance: SetupRecorderInstanceT,
hass: HomeAssistant,
caplog: pytest.LogCaptureFixture, caplog: pytest.LogCaptureFixture,
): ):
"""Test we keep alive socket based dialects.""" """Test we keep alive socket based dialects."""
@ -1514,8 +1514,8 @@ async def test_database_connection_keep_alive(
async def test_database_connection_keep_alive_disabled_on_sqlite( async def test_database_connection_keep_alive_disabled_on_sqlite(
hass: HomeAssistant,
async_setup_recorder_instance: SetupRecorderInstanceT, async_setup_recorder_instance: SetupRecorderInstanceT,
hass: HomeAssistant,
caplog: pytest.LogCaptureFixture, caplog: pytest.LogCaptureFixture,
): ):
"""Test we do not do keep alive for sqlite.""" """Test we do not do keep alive for sqlite."""
@ -1590,7 +1590,7 @@ def test_deduplication_state_attributes_inside_commit_interval(hass_recorder, ca
assert first_attributes_id == last_attributes_id assert first_attributes_id == last_attributes_id
async def test_async_block_till_done(hass, async_setup_recorder_instance): async def test_async_block_till_done(async_setup_recorder_instance, hass):
"""Test we can block until recordering is done.""" """Test we can block until recordering is done."""
instance = await async_setup_recorder_instance(hass) instance = await async_setup_recorder_instance(hass)
await async_wait_recording_done(hass) await async_wait_recording_done(hass)

36
tests/components/recorder/test_purge.py
View File

@ -53,7 +53,7 @@ def mock_use_sqlite(request):
async def test_purge_old_states( async def test_purge_old_states(
hass: HomeAssistant, async_setup_recorder_instance: SetupRecorderInstanceT async_setup_recorder_instance: SetupRecorderInstanceT, hass: HomeAssistant
): ):
"""Test deleting old states.""" """Test deleting old states."""
instance = await async_setup_recorder_instance(hass) instance = await async_setup_recorder_instance(hass)
@ -135,7 +135,7 @@ async def test_purge_old_states(
async def test_purge_old_states_encouters_database_corruption( async def test_purge_old_states_encouters_database_corruption(
hass: HomeAssistant, async_setup_recorder_instance: SetupRecorderInstanceT async_setup_recorder_instance: SetupRecorderInstanceT, hass: HomeAssistant
): ):
"""Test database image image is malformed while deleting old states.""" """Test database image image is malformed while deleting old states."""
await async_setup_recorder_instance(hass) await async_setup_recorder_instance(hass)
@ -165,8 +165,8 @@ async def test_purge_old_states_encouters_database_corruption(
async def test_purge_old_states_encounters_temporary_mysql_error( async def test_purge_old_states_encounters_temporary_mysql_error(
hass: HomeAssistant,
async_setup_recorder_instance: SetupRecorderInstanceT, async_setup_recorder_instance: SetupRecorderInstanceT,
hass: HomeAssistant,
caplog, caplog,
): ):
"""Test retry on specific mysql operational errors.""" """Test retry on specific mysql operational errors."""
@ -196,8 +196,8 @@ async def test_purge_old_states_encounters_temporary_mysql_error(
async def test_purge_old_states_encounters_operational_error( async def test_purge_old_states_encounters_operational_error(
hass: HomeAssistant,
async_setup_recorder_instance: SetupRecorderInstanceT, async_setup_recorder_instance: SetupRecorderInstanceT,
hass: HomeAssistant,
caplog, caplog,
): ):
"""Test error on operational errors that are not mysql does not retry.""" """Test error on operational errors that are not mysql does not retry."""
@ -222,7 +222,7 @@ async def test_purge_old_states_encounters_operational_error(
async def test_purge_old_events( async def test_purge_old_events(
hass: HomeAssistant, async_setup_recorder_instance: SetupRecorderInstanceT async_setup_recorder_instance: SetupRecorderInstanceT, hass: HomeAssistant
): ):
"""Test deleting old events.""" """Test deleting old events."""
instance = await async_setup_recorder_instance(hass) instance = await async_setup_recorder_instance(hass)
@ -259,7 +259,7 @@ async def test_purge_old_events(
async def test_purge_old_recorder_runs( async def test_purge_old_recorder_runs(
hass: HomeAssistant, async_setup_recorder_instance: SetupRecorderInstanceT async_setup_recorder_instance: SetupRecorderInstanceT, hass: HomeAssistant
): ):
"""Test deleting old recorder runs keeps current run.""" """Test deleting old recorder runs keeps current run."""
instance = await async_setup_recorder_instance(hass) instance = await async_setup_recorder_instance(hass)
@ -295,7 +295,7 @@ async def test_purge_old_recorder_runs(
async def test_purge_old_statistics_runs( async def test_purge_old_statistics_runs(
hass: HomeAssistant, async_setup_recorder_instance: SetupRecorderInstanceT async_setup_recorder_instance: SetupRecorderInstanceT, hass: HomeAssistant
): ):
"""Test deleting old statistics runs keeps the latest run.""" """Test deleting old statistics runs keeps the latest run."""
instance = await async_setup_recorder_instance(hass) instance = await async_setup_recorder_instance(hass)
@ -320,8 +320,8 @@ async def test_purge_old_statistics_runs(
@pytest.mark.parametrize("use_sqlite", (True, False), indirect=True) @pytest.mark.parametrize("use_sqlite", (True, False), indirect=True)
async def test_purge_method( async def test_purge_method(
hass: HomeAssistant,
async_setup_recorder_instance: SetupRecorderInstanceT, async_setup_recorder_instance: SetupRecorderInstanceT,
hass: HomeAssistant,
caplog: pytest.LogCaptureFixture, caplog: pytest.LogCaptureFixture,
use_sqlite: bool, use_sqlite: bool,
): ):
@ -436,8 +436,8 @@ async def test_purge_method(
@pytest.mark.parametrize("use_sqlite", (True, False), indirect=True) @pytest.mark.parametrize("use_sqlite", (True, False), indirect=True)
async def test_purge_edge_case( async def test_purge_edge_case(
hass: HomeAssistant,
async_setup_recorder_instance: SetupRecorderInstanceT, async_setup_recorder_instance: SetupRecorderInstanceT,
hass: HomeAssistant,
use_sqlite: bool, use_sqlite: bool,
): ):
"""Test states and events are purged even if they occurred shortly before purge_before.""" """Test states and events are purged even if they occurred shortly before purge_before."""
@ -503,8 +503,8 @@ async def test_purge_edge_case(
async def test_purge_cutoff_date( async def test_purge_cutoff_date(
hass: HomeAssistant,
async_setup_recorder_instance: SetupRecorderInstanceT, async_setup_recorder_instance: SetupRecorderInstanceT,
hass: HomeAssistant,
): ):
"""Test states and events are purged only if they occurred before "now() - keep_days".""" """Test states and events are purged only if they occurred before "now() - keep_days"."""
@ -651,8 +651,8 @@ async def test_purge_cutoff_date(
@pytest.mark.parametrize("use_sqlite", (True, False), indirect=True) @pytest.mark.parametrize("use_sqlite", (True, False), indirect=True)
async def test_purge_filtered_states( async def test_purge_filtered_states(
hass: HomeAssistant,
async_setup_recorder_instance: SetupRecorderInstanceT, async_setup_recorder_instance: SetupRecorderInstanceT,
hass: HomeAssistant,
use_sqlite: bool, use_sqlite: bool,
): ):
"""Test filtered states are purged.""" """Test filtered states are purged."""
@ -837,8 +837,8 @@ async def test_purge_filtered_states(
@pytest.mark.parametrize("use_sqlite", (True, False), indirect=True) @pytest.mark.parametrize("use_sqlite", (True, False), indirect=True)
async def test_purge_filtered_states_to_empty( async def test_purge_filtered_states_to_empty(
hass: HomeAssistant,
async_setup_recorder_instance: SetupRecorderInstanceT, async_setup_recorder_instance: SetupRecorderInstanceT,
hass: HomeAssistant,
use_sqlite: bool, use_sqlite: bool,
): ):
"""Test filtered states are purged all the way to an empty db.""" """Test filtered states are purged all the way to an empty db."""
@ -890,8 +890,8 @@ async def test_purge_filtered_states_to_empty(
@pytest.mark.parametrize("use_sqlite", (True, False), indirect=True) @pytest.mark.parametrize("use_sqlite", (True, False), indirect=True)
async def test_purge_without_state_attributes_filtered_states_to_empty( async def test_purge_without_state_attributes_filtered_states_to_empty(
hass: HomeAssistant,
async_setup_recorder_instance: SetupRecorderInstanceT, async_setup_recorder_instance: SetupRecorderInstanceT,
hass: HomeAssistant,
use_sqlite: bool, use_sqlite: bool,
): ):
"""Test filtered legacy states without state attributes are purged all the way to an empty db.""" """Test filtered legacy states without state attributes are purged all the way to an empty db."""
@ -964,8 +964,8 @@ async def test_purge_without_state_attributes_filtered_states_to_empty(
async def test_purge_filtered_events( async def test_purge_filtered_events(
hass: HomeAssistant,
async_setup_recorder_instance: SetupRecorderInstanceT, async_setup_recorder_instance: SetupRecorderInstanceT,
hass: HomeAssistant,
): ):
"""Test filtered events are purged.""" """Test filtered events are purged."""
config: ConfigType = {"exclude": {"event_types": ["EVENT_PURGE"]}} config: ConfigType = {"exclude": {"event_types": ["EVENT_PURGE"]}}
@ -1052,8 +1052,8 @@ async def test_purge_filtered_events(
async def test_purge_filtered_events_state_changed( async def test_purge_filtered_events_state_changed(
hass: HomeAssistant,
async_setup_recorder_instance: SetupRecorderInstanceT, async_setup_recorder_instance: SetupRecorderInstanceT,
hass: HomeAssistant,
): ):
"""Test filtered state_changed events are purged. This should also remove all states.""" """Test filtered state_changed events are purged. This should also remove all states."""
config: ConfigType = {"exclude": {"event_types": [EVENT_STATE_CHANGED]}} config: ConfigType = {"exclude": {"event_types": [EVENT_STATE_CHANGED]}}
@ -1155,7 +1155,7 @@ async def test_purge_filtered_events_state_changed(
async def test_purge_entities( async def test_purge_entities(
hass: HomeAssistant, async_setup_recorder_instance: SetupRecorderInstanceT async_setup_recorder_instance: SetupRecorderInstanceT, hass: HomeAssistant
): ):
"""Test purging of specific entities.""" """Test purging of specific entities."""
await async_setup_recorder_instance(hass) await async_setup_recorder_instance(hass)
@ -1527,7 +1527,7 @@ def _add_state_and_state_changed_event(
async def test_purge_many_old_events( async def test_purge_many_old_events(
hass: HomeAssistant, async_setup_recorder_instance: SetupRecorderInstanceT async_setup_recorder_instance: SetupRecorderInstanceT, hass: HomeAssistant
): ):
"""Test deleting old events.""" """Test deleting old events."""
instance = await async_setup_recorder_instance(hass) instance = await async_setup_recorder_instance(hass)
@ -1580,7 +1580,7 @@ async def test_purge_many_old_events(
async def test_purge_can_mix_legacy_and_new_format( async def test_purge_can_mix_legacy_and_new_format(
hass: HomeAssistant, async_setup_recorder_instance: SetupRecorderInstanceT async_setup_recorder_instance: SetupRecorderInstanceT, hass: HomeAssistant
): ):
"""Test purging with legacy a new events.""" """Test purging with legacy a new events."""
instance = await async_setup_recorder_instance(hass) instance = await async_setup_recorder_instance(hass)

2
tests/components/recorder/test_run_history.py
View File

@ -8,7 +8,7 @@ from homeassistant.components.recorder.models import process_timestamp
from homeassistant.util import dt as dt_util from homeassistant.util import dt as dt_util
async def test_run_history(hass, recorder_mock): async def test_run_history(recorder_mock, hass):
"""Test the run history gives the correct run.""" """Test the run history gives the correct run."""
instance = recorder.get_instance(hass) instance = recorder.get_instance(hass)
now = dt_util.utcnow() now = dt_util.utcnow()

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

@ -448,9 +448,9 @@ def test_statistics_duplicated(hass_recorder, caplog):
), ),
) )
async def test_import_statistics( async def test_import_statistics(
recorder_mock,
hass, hass,
hass_ws_client, hass_ws_client,
recorder_mock,
caplog, caplog,
source, source,
statistic_id, statistic_id,

8
tests/components/recorder/test_system_health.py
View File

@ -14,7 +14,7 @@ from .common import async_wait_recording_done
from tests.common import SetupRecorderInstanceT, get_system_health_info from tests.common import SetupRecorderInstanceT, get_system_health_info
async def test_recorder_system_health(hass, recorder_mock): async def test_recorder_system_health(recorder_mock, hass):
"""Test recorder system health.""" """Test recorder system health."""
assert await async_setup_component(hass, "system_health", {}) assert await async_setup_component(hass, "system_health", {})
await async_wait_recording_done(hass) await async_wait_recording_done(hass)
@ -32,7 +32,7 @@ async def test_recorder_system_health(hass, recorder_mock):
@pytest.mark.parametrize( @pytest.mark.parametrize(
"dialect_name", [SupportedDialect.MYSQL, SupportedDialect.POSTGRESQL] "dialect_name", [SupportedDialect.MYSQL, SupportedDialect.POSTGRESQL]
) )
async def test_recorder_system_health_alternate_dbms(hass, recorder_mock, dialect_name): async def test_recorder_system_health_alternate_dbms(recorder_mock, hass, dialect_name):
"""Test recorder system health.""" """Test recorder system health."""
assert await async_setup_component(hass, "system_health", {}) assert await async_setup_component(hass, "system_health", {})
await async_wait_recording_done(hass) await async_wait_recording_done(hass)
@ -57,7 +57,7 @@ async def test_recorder_system_health_alternate_dbms(hass, recorder_mock, dialec
"dialect_name", [SupportedDialect.MYSQL, SupportedDialect.POSTGRESQL] "dialect_name", [SupportedDialect.MYSQL, SupportedDialect.POSTGRESQL]
) )
async def test_recorder_system_health_db_url_missing_host( async def test_recorder_system_health_db_url_missing_host(
hass, recorder_mock, dialect_name recorder_mock, hass, dialect_name
): ):
"""Test recorder system health with a db_url without a hostname.""" """Test recorder system health with a db_url without a hostname."""
assert await async_setup_component(hass, "system_health", {}) assert await async_setup_component(hass, "system_health", {})
@ -85,7 +85,7 @@ async def test_recorder_system_health_db_url_missing_host(
async def test_recorder_system_health_crashed_recorder_runs_table( async def test_recorder_system_health_crashed_recorder_runs_table(
hass: HomeAssistant, async_setup_recorder_instance: SetupRecorderInstanceT async_setup_recorder_instance: SetupRecorderInstanceT, hass: HomeAssistant
): ):
"""Test recorder system health with crashed recorder runs table.""" """Test recorder system health with crashed recorder runs table."""
with patch("homeassistant.components.recorder.run_history.RunHistory.load_from_db"): with patch("homeassistant.components.recorder.run_history.RunHistory.load_from_db"):

2
tests/components/recorder/test_util.py
View File

@ -651,8 +651,8 @@ def test_periodic_db_cleanups(hass_recorder):
@patch("homeassistant.components.recorder.pool.check_loop") @patch("homeassistant.components.recorder.pool.check_loop")
async def test_write_lock_db( async def test_write_lock_db(
skip_check_loop, skip_check_loop,
hass: HomeAssistant,
async_setup_recorder_instance: SetupRecorderInstanceT, async_setup_recorder_instance: SetupRecorderInstanceT,
hass: HomeAssistant,
tmp_path, tmp_path,
): ):
"""Test database write lock.""" """Test database write lock."""

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

@ -122,7 +122,7 @@ VOLUME_SENSOR_M3_ATTRIBUTES_TOTAL = {
} }
async def test_statistics_during_period(hass, hass_ws_client, recorder_mock): async def test_statistics_during_period(recorder_mock, hass, hass_ws_client):
"""Test statistics_during_period.""" """Test statistics_during_period."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -200,9 +200,9 @@ async def test_statistics_during_period(hass, hass_ws_client, recorder_mock):
], ],
) )
async def test_statistics_during_period_unit_conversion( async def test_statistics_during_period_unit_conversion(
recorder_mock,
hass, hass,
hass_ws_client, hass_ws_client,
recorder_mock,
attributes, attributes,
state, state,
value, value,
@ -293,9 +293,9 @@ async def test_statistics_during_period_unit_conversion(
], ],
) )
async def test_sum_statistics_during_period_unit_conversion( async def test_sum_statistics_during_period_unit_conversion(
recorder_mock,
hass, hass,
hass_ws_client, hass_ws_client,
recorder_mock,
attributes, attributes,
state, state,
value, value,
@ -386,7 +386,7 @@ async def test_sum_statistics_during_period_unit_conversion(
], ],
) )
async def test_statistics_during_period_invalid_unit_conversion( async def test_statistics_during_period_invalid_unit_conversion(
hass, hass_ws_client, recorder_mock, custom_units recorder_mock, hass, hass_ws_client, custom_units
): ):
"""Test statistics_during_period.""" """Test statistics_during_period."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -425,7 +425,7 @@ async def test_statistics_during_period_invalid_unit_conversion(
async def test_statistics_during_period_in_the_past( async def test_statistics_during_period_in_the_past(
hass, hass_ws_client, recorder_mock recorder_mock, hass, hass_ws_client
): ):
"""Test statistics_during_period in the past.""" """Test statistics_during_period in the past."""
hass.config.set_time_zone("UTC") hass.config.set_time_zone("UTC")
@ -548,7 +548,7 @@ async def test_statistics_during_period_in_the_past(
async def test_statistics_during_period_bad_start_time( async def test_statistics_during_period_bad_start_time(
hass, hass_ws_client, recorder_mock recorder_mock, hass, hass_ws_client
): ):
"""Test statistics_during_period.""" """Test statistics_during_period."""
client = await hass_ws_client() client = await hass_ws_client()
@ -566,7 +566,7 @@ async def test_statistics_during_period_bad_start_time(
async def test_statistics_during_period_bad_end_time( async def test_statistics_during_period_bad_end_time(
hass, hass_ws_client, recorder_mock recorder_mock, hass, hass_ws_client
): ):
"""Test statistics_during_period.""" """Test statistics_during_period."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -614,9 +614,9 @@ async def test_statistics_during_period_bad_end_time(
], ],
) )
async def test_list_statistic_ids( async def test_list_statistic_ids(
recorder_mock,
hass, hass,
hass_ws_client, hass_ws_client,
recorder_mock,
units, units,
attributes, attributes,
display_unit, display_unit,
@ -724,7 +724,7 @@ async def test_list_statistic_ids(
assert response["result"] == [] assert response["result"] == []
async def test_validate_statistics(hass, hass_ws_client, recorder_mock): async def test_validate_statistics(recorder_mock, hass, hass_ws_client):
"""Test validate_statistics can be called.""" """Test validate_statistics can be called."""
id = 1 id = 1
@ -746,7 +746,7 @@ async def test_validate_statistics(hass, hass_ws_client, recorder_mock):
await assert_validation_result(client, {}) await assert_validation_result(client, {})
async def test_clear_statistics(hass, hass_ws_client, recorder_mock): async def test_clear_statistics(recorder_mock, hass, hass_ws_client):
"""Test removing statistics.""" """Test removing statistics."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -873,7 +873,7 @@ async def test_clear_statistics(hass, hass_ws_client, recorder_mock):
"new_unit, new_unit_class", [("dogs", None), (None, None), ("W", "power")] "new_unit, new_unit_class", [("dogs", None), (None, None), ("W", "power")]
) )
async def test_update_statistics_metadata( async def test_update_statistics_metadata(
hass, hass_ws_client, recorder_mock, new_unit, new_unit_class recorder_mock, hass, hass_ws_client, new_unit, new_unit_class
): ):
"""Test removing statistics.""" """Test removing statistics."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -964,7 +964,7 @@ async def test_update_statistics_metadata(
} }
async def test_change_statistics_unit(hass, hass_ws_client, recorder_mock): async def test_change_statistics_unit(recorder_mock, hass, hass_ws_client):
"""Test change unit of recorded statistics.""" """Test change unit of recorded statistics."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -1083,7 +1083,7 @@ async def test_change_statistics_unit(hass, hass_ws_client, recorder_mock):
async def test_change_statistics_unit_errors( async def test_change_statistics_unit_errors(
hass, hass_ws_client, recorder_mock, caplog recorder_mock, hass, hass_ws_client, caplog
): ):
"""Test change unit of recorded statistics.""" """Test change unit of recorded statistics."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -1200,7 +1200,7 @@ async def test_change_statistics_unit_errors(
await assert_statistics(expected_statistics) await assert_statistics(expected_statistics)
async def test_recorder_info(hass, hass_ws_client, recorder_mock): async def test_recorder_info(recorder_mock, hass, hass_ws_client):
"""Test getting recorder status.""" """Test getting recorder status."""
client = await hass_ws_client() client = await hass_ws_client()
@ -1329,7 +1329,7 @@ async def test_backup_start_no_recorder(
async def test_backup_start_timeout( async def test_backup_start_timeout(
hass, hass_ws_client, hass_supervisor_access_token, recorder_mock recorder_mock, hass, hass_ws_client, hass_supervisor_access_token
): ):
"""Test getting backup start when recorder is not present.""" """Test getting backup start when recorder is not present."""
client = await hass_ws_client(hass, hass_supervisor_access_token) client = await hass_ws_client(hass, hass_supervisor_access_token)
@ -1348,7 +1348,7 @@ async def test_backup_start_timeout(
async def test_backup_end( async def test_backup_end(
hass, hass_ws_client, hass_supervisor_access_token, recorder_mock recorder_mock, hass, hass_ws_client, hass_supervisor_access_token
): ):
"""Test backup start.""" """Test backup start."""
client = await hass_ws_client(hass, hass_supervisor_access_token) client = await hass_ws_client(hass, hass_supervisor_access_token)
@ -1366,7 +1366,7 @@ async def test_backup_end(
async def test_backup_end_without_start( async def test_backup_end_without_start(
hass, hass_ws_client, hass_supervisor_access_token, recorder_mock recorder_mock, hass, hass_ws_client, hass_supervisor_access_token
): ):
"""Test backup start.""" """Test backup start."""
client = await hass_ws_client(hass, hass_supervisor_access_token) client = await hass_ws_client(hass, hass_supervisor_access_token)
@ -1400,7 +1400,7 @@ async def test_backup_end_without_start(
], ],
) )
async def test_get_statistics_metadata( async def test_get_statistics_metadata(
hass, hass_ws_client, recorder_mock, units, attributes, unit, unit_class recorder_mock, hass, hass_ws_client, units, attributes, unit, unit_class
): ):
"""Test get_statistics_metadata.""" """Test get_statistics_metadata."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -1545,7 +1545,7 @@ async def test_get_statistics_metadata(
), ),
) )
async def test_import_statistics( async def test_import_statistics(
hass, hass_ws_client, recorder_mock, caplog, source, statistic_id recorder_mock, hass, hass_ws_client, caplog, source, statistic_id
): ):
"""Test importing statistics.""" """Test importing statistics."""
client = await hass_ws_client() client = await hass_ws_client()
@ -1772,7 +1772,7 @@ async def test_import_statistics(
), ),
) )
async def test_adjust_sum_statistics_energy( async def test_adjust_sum_statistics_energy(
hass, hass_ws_client, recorder_mock, caplog, source, statistic_id recorder_mock, hass, hass_ws_client, caplog, source, statistic_id
): ):
"""Test adjusting statistics.""" """Test adjusting statistics."""
client = await hass_ws_client() client = await hass_ws_client()
@ -1968,7 +1968,7 @@ async def test_adjust_sum_statistics_energy(
), ),
) )
async def test_adjust_sum_statistics_gas( async def test_adjust_sum_statistics_gas(
hass, hass_ws_client, recorder_mock, caplog, source, statistic_id recorder_mock, hass, hass_ws_client, caplog, source, statistic_id
): ):
"""Test adjusting statistics.""" """Test adjusting statistics."""
client = await hass_ws_client() client = await hass_ws_client()
@ -2168,9 +2168,9 @@ async def test_adjust_sum_statistics_gas(
), ),
) )
async def test_adjust_sum_statistics_errors( async def test_adjust_sum_statistics_errors(
recorder_mock,
hass, hass,
hass_ws_client, hass_ws_client,
recorder_mock,
caplog, caplog,
state_unit, state_unit,
statistic_unit, statistic_unit,

2
tests/components/schedule/test_recorder.py
View File

@ -16,8 +16,8 @@ from tests.components.recorder.common import async_wait_recording_done
async def test_exclude_attributes( async def test_exclude_attributes(
hass: HomeAssistant,
recorder_mock: None, recorder_mock: None,
hass: HomeAssistant,
enable_custom_integrations: None, enable_custom_integrations: None,
) -> None: ) -> None:
"""Test attributes to be excluded.""" """Test attributes to be excluded."""

2
tests/components/script/test_recorder.py
View File

@ -27,7 +27,7 @@ def calls(hass):
return async_mock_service(hass, "test", "automation") return async_mock_service(hass, "test", "automation")
async def test_exclude_attributes(hass, recorder_mock, calls): async def test_exclude_attributes(recorder_mock, hass, calls):
"""Test automation registered attributes to be excluded.""" """Test automation registered attributes to be excluded."""
await hass.async_block_till_done() await hass.async_block_till_done()
calls = [] calls = []

2
tests/components/select/test_recorder.py
View File

@ -16,7 +16,7 @@ from tests.common import async_fire_time_changed
from tests.components.recorder.common import async_wait_recording_done from tests.components.recorder.common import async_wait_recording_done
async def test_exclude_attributes(hass, recorder_mock): async def test_exclude_attributes(recorder_mock, hass):
"""Test select registered attributes to be excluded.""" """Test select registered attributes to be excluded."""
await async_setup_component( await async_setup_component(
hass, select.DOMAIN, {select.DOMAIN: {"platform": "demo"}} hass, select.DOMAIN, {select.DOMAIN: {"platform": "demo"}}

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

@ -430,9 +430,9 @@ def test_compile_hourly_statistics_wrong_unit(hass_recorder, caplog, attributes)
], ],
) )
async def test_compile_hourly_sum_statistics_amount( async def test_compile_hourly_sum_statistics_amount(
recorder_mock,
hass, hass,
hass_ws_client, hass_ws_client,
recorder_mock,
caplog, caplog,
units, units,
state_class, state_class,
@ -3328,7 +3328,7 @@ def record_states(hass, zero, entity_id, attributes, seq=None):
], ],
) )
async def test_validate_unit_change_convertible( async def test_validate_unit_change_convertible(
hass, hass_ws_client, recorder_mock, units, attributes, unit, unit2, supported_unit recorder_mock, hass, hass_ws_client, units, attributes, unit, unit2, supported_unit
): ):
"""Test validate_statistics. """Test validate_statistics.
@ -3443,7 +3443,7 @@ async def test_validate_unit_change_convertible(
], ],
) )
async def test_validate_statistics_unit_ignore_device_class( async def test_validate_statistics_unit_ignore_device_class(
hass, hass_ws_client, recorder_mock, units, attributes recorder_mock, hass, hass_ws_client, units, attributes
): ):
"""Test validate_statistics. """Test validate_statistics.
@ -3514,7 +3514,7 @@ async def test_validate_statistics_unit_ignore_device_class(
], ],
) )
async def test_validate_statistics_unit_change_no_device_class( async def test_validate_statistics_unit_change_no_device_class(
hass, hass_ws_client, recorder_mock, units, attributes, unit, unit2, supported_unit recorder_mock, hass, hass_ws_client, units, attributes, unit, unit2, supported_unit
): ):
"""Test validate_statistics. """Test validate_statistics.
@ -3629,7 +3629,7 @@ async def test_validate_statistics_unit_change_no_device_class(
], ],
) )
async def test_validate_statistics_unsupported_state_class( async def test_validate_statistics_unsupported_state_class(
hass, hass_ws_client, recorder_mock, units, attributes, unit recorder_mock, hass, hass_ws_client, units, attributes, unit
): ):
"""Test validate_statistics.""" """Test validate_statistics."""
id = 1 id = 1
@ -3693,7 +3693,7 @@ async def test_validate_statistics_unsupported_state_class(
], ],
) )
async def test_validate_statistics_sensor_no_longer_recorded( async def test_validate_statistics_sensor_no_longer_recorded(
hass, hass_ws_client, recorder_mock, units, attributes, unit recorder_mock, hass, hass_ws_client, units, attributes, unit
): ):
"""Test validate_statistics.""" """Test validate_statistics."""
id = 1 id = 1
@ -3754,7 +3754,7 @@ async def test_validate_statistics_sensor_no_longer_recorded(
], ],
) )
async def test_validate_statistics_sensor_not_recorded( async def test_validate_statistics_sensor_not_recorded(
hass, hass_ws_client, recorder_mock, units, attributes, unit recorder_mock, hass, hass_ws_client, units, attributes, unit
): ):
"""Test validate_statistics.""" """Test validate_statistics."""
id = 1 id = 1
@ -3812,7 +3812,7 @@ async def test_validate_statistics_sensor_not_recorded(
], ],
) )
async def test_validate_statistics_sensor_removed( async def test_validate_statistics_sensor_removed(
hass, hass_ws_client, recorder_mock, units, attributes, unit recorder_mock, hass, hass_ws_client, units, attributes, unit
): ):
"""Test validate_statistics.""" """Test validate_statistics."""
id = 1 id = 1
@ -3871,7 +3871,7 @@ async def test_validate_statistics_sensor_removed(
], ],
) )
async def test_validate_statistics_unit_change_no_conversion( async def test_validate_statistics_unit_change_no_conversion(
hass, recorder_mock, hass_ws_client, attributes, unit1, unit2 recorder_mock, hass, hass_ws_client, attributes, unit1, unit2
): ):
"""Test validate_statistics.""" """Test validate_statistics."""
id = 1 id = 1
@ -3988,7 +3988,7 @@ async def test_validate_statistics_unit_change_no_conversion(
await assert_validation_result(client, expected) await assert_validation_result(client, expected)
async def test_validate_statistics_other_domain(hass, hass_ws_client, recorder_mock): async def test_validate_statistics_other_domain(recorder_mock, hass, hass_ws_client):
"""Test sensor does not raise issues for statistics for other domains.""" """Test sensor does not raise issues for statistics for other domains."""
id = 1 id = 1

2
tests/components/siren/test_recorder.py
View File

@ -16,7 +16,7 @@ from tests.common import async_fire_time_changed
from tests.components.recorder.common import async_wait_recording_done from tests.components.recorder.common import async_wait_recording_done
async def test_exclude_attributes(hass, recorder_mock): async def test_exclude_attributes(recorder_mock, hass):
"""Test siren registered attributes to be excluded.""" """Test siren registered attributes to be excluded."""
await async_setup_component( await async_setup_component(
hass, siren.DOMAIN, {siren.DOMAIN: {"platform": "demo"}} hass, siren.DOMAIN, {siren.DOMAIN: {"platform": "demo"}}

20
tests/components/sql/test_config_flow.py
View File

@ -21,7 +21,7 @@ from . import (
from tests.common import MockConfigEntry from tests.common import MockConfigEntry
async def test_form(hass: HomeAssistant, recorder_mock) -> None: async def test_form(recorder_mock, hass: HomeAssistant) -> None:
"""Test we get the form.""" """Test we get the form."""
result = await hass.config_entries.flow.async_init( result = await hass.config_entries.flow.async_init(
@ -53,7 +53,7 @@ async def test_form(hass: HomeAssistant, recorder_mock) -> None:
assert len(mock_setup_entry.mock_calls) == 1 assert len(mock_setup_entry.mock_calls) == 1
async def test_import_flow_success(hass: HomeAssistant, recorder_mock) -> None: async def test_import_flow_success(recorder_mock, hass: HomeAssistant) -> None:
"""Test a successful import of yaml.""" """Test a successful import of yaml."""
with patch( with patch(
@ -80,7 +80,7 @@ async def test_import_flow_success(hass: HomeAssistant, recorder_mock) -> None:
assert len(mock_setup_entry.mock_calls) == 1 assert len(mock_setup_entry.mock_calls) == 1
async def test_import_flow_already_exist(hass: HomeAssistant, recorder_mock) -> None: async def test_import_flow_already_exist(recorder_mock, hass: HomeAssistant) -> None:
"""Test import of yaml already exist.""" """Test import of yaml already exist."""
MockConfigEntry( MockConfigEntry(
@ -103,7 +103,7 @@ async def test_import_flow_already_exist(hass: HomeAssistant, recorder_mock) ->
assert result3["reason"] == "already_configured" assert result3["reason"] == "already_configured"
async def test_flow_fails_db_url(hass: HomeAssistant, recorder_mock) -> None: async def test_flow_fails_db_url(recorder_mock, hass: HomeAssistant) -> None:
"""Test config flow fails incorrect db url.""" """Test config flow fails incorrect db url."""
result4 = await hass.config_entries.flow.async_init( result4 = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER} DOMAIN, context={"source": config_entries.SOURCE_USER}
@ -124,7 +124,7 @@ async def test_flow_fails_db_url(hass: HomeAssistant, recorder_mock) -> None:
assert result4["errors"] == {"db_url": "db_url_invalid"} assert result4["errors"] == {"db_url": "db_url_invalid"}
async def test_flow_fails_invalid_query(hass: HomeAssistant, recorder_mock) -> None: async def test_flow_fails_invalid_query(recorder_mock, hass: HomeAssistant) -> None:
"""Test config flow fails incorrect db url.""" """Test config flow fails incorrect db url."""
result4 = await hass.config_entries.flow.async_init( result4 = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER} DOMAIN, context={"source": config_entries.SOURCE_USER}
@ -170,7 +170,7 @@ async def test_flow_fails_invalid_query(hass: HomeAssistant, recorder_mock) -> N
} }
async def test_options_flow(hass: HomeAssistant, recorder_mock) -> None: async def test_options_flow(recorder_mock, hass: HomeAssistant) -> None:
"""Test options config flow.""" """Test options config flow."""
entry = MockConfigEntry( entry = MockConfigEntry(
domain=DOMAIN, domain=DOMAIN,
@ -219,7 +219,7 @@ async def test_options_flow(hass: HomeAssistant, recorder_mock) -> None:
async def test_options_flow_name_previously_removed( async def test_options_flow_name_previously_removed(
hass: HomeAssistant, recorder_mock recorder_mock, hass: HomeAssistant
) -> None: ) -> None:
"""Test options config flow where the name was missing.""" """Test options config flow where the name was missing."""
entry = MockConfigEntry( entry = MockConfigEntry(
@ -270,7 +270,7 @@ async def test_options_flow_name_previously_removed(
} }
async def test_options_flow_fails_db_url(hass: HomeAssistant, recorder_mock) -> None: async def test_options_flow_fails_db_url(recorder_mock, hass: HomeAssistant) -> None:
"""Test options flow fails incorrect db url.""" """Test options flow fails incorrect db url."""
entry = MockConfigEntry( entry = MockConfigEntry(
domain=DOMAIN, domain=DOMAIN,
@ -313,7 +313,7 @@ async def test_options_flow_fails_db_url(hass: HomeAssistant, recorder_mock) ->
async def test_options_flow_fails_invalid_query( async def test_options_flow_fails_invalid_query(
hass: HomeAssistant, recorder_mock recorder_mock, hass: HomeAssistant
) -> None: ) -> None:
"""Test options flow fails incorrect query and template.""" """Test options flow fails incorrect query and template."""
entry = MockConfigEntry( entry = MockConfigEntry(
@ -369,7 +369,7 @@ async def test_options_flow_fails_invalid_query(
} }
async def test_options_flow_db_url_empty(hass: HomeAssistant, recorder_mock) -> None: async def test_options_flow_db_url_empty(recorder_mock, hass: HomeAssistant) -> None:
"""Test options config flow with leaving db_url empty.""" """Test options config flow with leaving db_url empty."""
entry = MockConfigEntry( entry = MockConfigEntry(
domain=DOMAIN, domain=DOMAIN,

6
tests/components/statistics/test_sensor.py
View File

@ -1010,7 +1010,7 @@ async def test_invalid_state_characteristic(hass: HomeAssistant):
assert state is None assert state is None
async def test_initialize_from_database(hass: HomeAssistant, recorder_mock): async def test_initialize_from_database(recorder_mock, hass: HomeAssistant):
"""Test initializing the statistics from the recorder database.""" """Test initializing the statistics from the recorder database."""
# enable and pre-fill the recorder # enable and pre-fill the recorder
await hass.async_block_till_done() await hass.async_block_till_done()
@ -1049,7 +1049,7 @@ async def test_initialize_from_database(hass: HomeAssistant, recorder_mock):
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == TEMP_CELSIUS assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == TEMP_CELSIUS
async def test_initialize_from_database_with_maxage(hass: HomeAssistant, recorder_mock): async def test_initialize_from_database_with_maxage(recorder_mock, hass: HomeAssistant):
"""Test initializing the statistics from the database.""" """Test initializing the statistics from the database."""
now = dt_util.utcnow() now = dt_util.utcnow()
mock_data = { mock_data = {
@ -1109,7 +1109,7 @@ async def test_initialize_from_database_with_maxage(hass: HomeAssistant, recorde
) + timedelta(hours=1) ) + timedelta(hours=1)
async def test_reload(hass: HomeAssistant, recorder_mock): async def test_reload(recorder_mock, hass: HomeAssistant):
"""Verify we can reload statistics sensors.""" """Verify we can reload statistics sensors."""
await async_setup_component( await async_setup_component(

2
tests/components/sun/test_recorder.py
View File

@ -26,7 +26,7 @@ from tests.common import async_fire_time_changed
from tests.components.recorder.common import async_wait_recording_done from tests.components.recorder.common import async_wait_recording_done
async def test_exclude_attributes(hass, recorder_mock): async def test_exclude_attributes(recorder_mock, hass):
"""Test sun attributes to be excluded.""" """Test sun attributes to be excluded."""
await async_setup_component(hass, DOMAIN, {}) await async_setup_component(hass, DOMAIN, {})
await hass.async_block_till_done() await hass.async_block_till_done()

6
tests/components/tibber/test_config_flow.py
View File

@ -15,7 +15,7 @@ def tibber_setup_fixture():
yield yield
async def test_show_config_form(hass, recorder_mock): async def test_show_config_form(recorder_mock, hass):
"""Test show configuration form.""" """Test show configuration form."""
result = await hass.config_entries.flow.async_init( result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER} DOMAIN, context={"source": config_entries.SOURCE_USER}
@ -25,7 +25,7 @@ async def test_show_config_form(hass, recorder_mock):
assert result["step_id"] == "user" assert result["step_id"] == "user"
async def test_create_entry(hass, recorder_mock): async def test_create_entry(recorder_mock, hass):
"""Test create entry from user input.""" """Test create entry from user input."""
test_data = { test_data = {
CONF_ACCESS_TOKEN: "valid", CONF_ACCESS_TOKEN: "valid",
@ -49,7 +49,7 @@ async def test_create_entry(hass, recorder_mock):
assert result["data"] == test_data assert result["data"] == test_data
async def test_flow_entry_already_exists(hass, recorder_mock, config_entry): async def test_flow_entry_already_exists(recorder_mock, hass, config_entry):
"""Test user input for config_entry that already exists.""" """Test user input for config_entry that already exists."""
test_data = { test_data = {
CONF_ACCESS_TOKEN: "valid", CONF_ACCESS_TOKEN: "valid",

2
tests/components/tibber/test_diagnostics.py
View File

@ -8,7 +8,7 @@ from .test_common import mock_get_homes
from tests.components.diagnostics import get_diagnostics_for_config_entry from tests.components.diagnostics import get_diagnostics_for_config_entry
async def test_entry_diagnostics(hass, hass_client, recorder_mock, config_entry): async def test_entry_diagnostics(recorder_mock, hass, hass_client, config_entry):
"""Test config entry diagnostics.""" """Test config entry diagnostics."""
with patch( with patch(
"tibber.Tibber.update_info", "tibber.Tibber.update_info",

2
tests/components/tibber/test_statistics.py
View File

@ -10,7 +10,7 @@ from .test_common import CONSUMPTION_DATA_1, PRODUCTION_DATA_1, mock_get_homes
from tests.components.recorder.common import async_wait_recording_done from tests.components.recorder.common import async_wait_recording_done
async def test_async_setup_entry(hass, recorder_mock): async def test_async_setup_entry(recorder_mock, hass):
"""Test setup Tibber.""" """Test setup Tibber."""
tibber_connection = AsyncMock() tibber_connection = AsyncMock()
tibber_connection.name = "tibber" tibber_connection.name = "tibber"

2
tests/components/update/test_recorder.py
View File

@ -21,7 +21,7 @@ from tests.components.recorder.common import async_wait_recording_done
async def test_exclude_attributes( async def test_exclude_attributes(
hass: HomeAssistant, recorder_mock, enable_custom_integrations: None recorder_mock, hass: HomeAssistant, enable_custom_integrations: None
): ):
"""Test update attributes to be excluded.""" """Test update attributes to be excluded."""
platform = getattr(hass.components, f"test.{DOMAIN}") platform = getattr(hass.components, f"test.{DOMAIN}")

2
tests/components/vacuum/test_recorder.py
View File

@ -16,7 +16,7 @@ from tests.common import async_fire_time_changed
from tests.components.recorder.common import async_wait_recording_done from tests.components.recorder.common import async_wait_recording_done
async def test_exclude_attributes(hass, recorder_mock): async def test_exclude_attributes(recorder_mock, hass):
"""Test vacuum registered attributes to be excluded.""" """Test vacuum registered attributes to be excluded."""
await async_setup_component( await async_setup_component(
hass, vacuum.DOMAIN, {vacuum.DOMAIN: {"platform": "demo"}} hass, vacuum.DOMAIN, {vacuum.DOMAIN: {"platform": "demo"}}

2
tests/components/water_heater/test_recorder.py
View File

@ -20,7 +20,7 @@ from tests.common import async_fire_time_changed
from tests.components.recorder.common import async_wait_recording_done from tests.components.recorder.common import async_wait_recording_done
async def test_exclude_attributes(hass, recorder_mock): async def test_exclude_attributes(recorder_mock, hass):
"""Test water_heater registered attributes to be excluded.""" """Test water_heater registered attributes to be excluded."""
await async_setup_component( await async_setup_component(
hass, water_heater.DOMAIN, {water_heater.DOMAIN: {"platform": "demo"}} hass, water_heater.DOMAIN, {water_heater.DOMAIN: {"platform": "demo"}}

2
tests/components/weather/test_recorder.py
View File

@ -15,7 +15,7 @@ from tests.common import async_fire_time_changed
from tests.components.recorder.common import async_wait_recording_done from tests.components.recorder.common import async_wait_recording_done
async def test_exclude_attributes(hass: HomeAssistant, recorder_mock) -> None: async def test_exclude_attributes(recorder_mock, hass: HomeAssistant) -> None:
"""Test weather attributes to be excluded.""" """Test weather attributes to be excluded."""
await async_setup_component(hass, DOMAIN, {DOMAIN: {"platform": "demo"}}) await async_setup_component(hass, DOMAIN, {DOMAIN: {"platform": "demo"}})
hass.config.units = METRIC_SYSTEM hass.config.units = METRIC_SYSTEM

13
tests/conftest.py
View File

@ -312,9 +312,17 @@ def aiohttp_client(
@pytest.fixture @pytest.fixture
def hass(loop, load_registries, hass_storage, request): def hass_fixture_setup():
"""Fixture whichis truthy if the hass fixture has been setup."""
return []
@pytest.fixture
def hass(hass_fixture_setup, loop, load_registries, hass_storage, request):
"""Fixture to provide a test instance of Home Assistant.""" """Fixture to provide a test instance of Home Assistant."""
hass_fixture_setup.append(True)
orig_tz = dt_util.DEFAULT_TIME_ZONE orig_tz = dt_util.DEFAULT_TIME_ZONE
def exc_handle(loop, context): def exc_handle(loop, context):
@ -912,9 +920,10 @@ async def _async_init_recorder_component(hass, add_config=None):
@pytest.fixture @pytest.fixture
async def async_setup_recorder_instance( async def async_setup_recorder_instance(
enable_nightly_purge, enable_statistics hass_fixture_setup, enable_nightly_purge, enable_statistics
) -> AsyncGenerator[SetupRecorderInstanceT, None]: ) -> AsyncGenerator[SetupRecorderInstanceT, None]:
"""Yield callable to setup recorder instance.""" """Yield callable to setup recorder instance."""
assert not hass_fixture_setup
nightly = recorder.Recorder.async_nightly_tasks if enable_nightly_purge else None nightly = recorder.Recorder.async_nightly_tasks if enable_nightly_purge else None
stats = recorder.Recorder.async_periodic_statistics if enable_statistics else None stats = recorder.Recorder.async_periodic_statistics if enable_statistics else None

2
tests/helpers/test_recorder.py
View File

@ -9,7 +9,7 @@ from tests.common import SetupRecorderInstanceT
async def test_async_migration_in_progress( async def test_async_migration_in_progress(
hass: HomeAssistant, async_setup_recorder_instance: SetupRecorderInstanceT async_setup_recorder_instance: SetupRecorderInstanceT, hass: HomeAssistant
): ):
"""Test async_migration_in_progress wraps the recorder.""" """Test async_migration_in_progress wraps the recorder."""
with patch( with patch(