evlli/hass-core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add type hints to integration tests (part 22) (#88234)

Browse source
This commit is contained in:
epenet 2023-02-16 14:08:03 +01:00 • committed by GitHub
parent 567c7f4f99
commit 88cfbf6a34
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
50 changed files with 1269 additions and 559 deletions
Download patch file Download diff file Expand all files Collapse all files

71
tests/components/tasmota/test_binary_sensor.py
View file

@ -10,6 +10,7 @@ from hatasmota.utils import (
get_topic_tele_sensor, get_topic_tele_sensor,
get_topic_tele_will, get_topic_tele_will,
) )
import pytest
from homeassistant.components.tasmota.const import DEFAULT_PREFIX from homeassistant.components.tasmota.const import DEFAULT_PREFIX
from homeassistant.const import ( from homeassistant.const import (
@ -21,6 +22,7 @@ from homeassistant.const import (
Platform, Platform,
) )
import homeassistant.core as ha import homeassistant.core as ha
from homeassistant.core import HomeAssistant
import homeassistant.util.dt as dt_util import homeassistant.util.dt as dt_util
from .test_common import ( from .test_common import (
@ -37,9 +39,12 @@ from .test_common import (
) )
from tests.common import async_fire_mqtt_message, async_fire_time_changed from tests.common import async_fire_mqtt_message, async_fire_time_changed
from tests.typing import MqttMockHAClient, MqttMockPahoClient
async def test_controlling_state_via_mqtt(hass, mqtt_mock, setup_tasmota): async def test_controlling_state_via_mqtt(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["swc"][0] = 1 config["swc"][0] = 1
@ -104,7 +109,9 @@ async def test_controlling_state_via_mqtt(hass, mqtt_mock, setup_tasmota):
assert entity.force_update assert entity.force_update
async def test_controlling_state_via_mqtt_switchname(hass, mqtt_mock, setup_tasmota): async def test_controlling_state_via_mqtt_switchname(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["swc"][0] = 1 config["swc"][0] = 1
@ -164,7 +171,9 @@ async def test_controlling_state_via_mqtt_switchname(hass, mqtt_mock, setup_tasm
assert state.state == STATE_OFF assert state.state == STATE_OFF
async def test_pushon_controlling_state_via_mqtt(hass, mqtt_mock, setup_tasmota): async def test_pushon_controlling_state_via_mqtt(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["swc"][0] = 13 config["swc"][0] = 13
@ -213,7 +222,9 @@ async def test_pushon_controlling_state_via_mqtt(hass, mqtt_mock, setup_tasmota)
assert state.state == STATE_OFF assert state.state == STATE_OFF
async def test_friendly_names(hass, mqtt_mock, setup_tasmota): async def test_friendly_names(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["swc"][0] = 1 config["swc"][0] = 1
@ -237,7 +248,9 @@ async def test_friendly_names(hass, mqtt_mock, setup_tasmota):
assert state.attributes.get("friendly_name") == "Beer" assert state.attributes.get("friendly_name") == "Beer"
async def test_off_delay(hass, mqtt_mock, setup_tasmota): async def test_off_delay(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test off_delay option.""" """Test off_delay option."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["swc"][0] = 13 # PUSHON: 1s off_delay config["swc"][0] = 13 # PUSHON: 1s off_delay
@ -286,8 +299,11 @@ async def test_off_delay(hass, mqtt_mock, setup_tasmota):
async def test_availability_when_connection_lost( async def test_availability_when_connection_lost(
hass, mqtt_client_mock, mqtt_mock, setup_tasmota hass: HomeAssistant,
): mqtt_client_mock: MqttMockPahoClient,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test availability after MQTT disconnection.""" """Test availability after MQTT disconnection."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["swc"][0] = 1 config["swc"][0] = 1
@ -297,7 +313,9 @@ async def test_availability_when_connection_lost(
) )
async def test_availability(hass, mqtt_mock, setup_tasmota): async def test_availability(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test availability.""" """Test availability."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["swc"][0] = 1 config["swc"][0] = 1
@ -305,7 +323,9 @@ async def test_availability(hass, mqtt_mock, setup_tasmota):
await help_test_availability(hass, mqtt_mock, Platform.BINARY_SENSOR, config) await help_test_availability(hass, mqtt_mock, Platform.BINARY_SENSOR, config)
async def test_availability_discovery_update(hass, mqtt_mock, setup_tasmota): async def test_availability_discovery_update(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test availability discovery update.""" """Test availability discovery update."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["swc"][0] = 1 config["swc"][0] = 1
@ -316,8 +336,11 @@ async def test_availability_discovery_update(hass, mqtt_mock, setup_tasmota):
async def test_availability_poll_state( async def test_availability_poll_state(
hass, mqtt_client_mock, mqtt_mock, setup_tasmota hass: HomeAssistant,
): mqtt_client_mock: MqttMockPahoClient,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test polling after MQTT connection (re)established.""" """Test polling after MQTT connection (re)established."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["swc"][0] = 1 config["swc"][0] = 1
@ -334,7 +357,12 @@ async def test_availability_poll_state(
) )
async def test_discovery_removal_binary_sensor(hass, mqtt_mock, caplog, setup_tasmota): async def test_discovery_removal_binary_sensor(
hass: HomeAssistant,
mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
setup_tasmota,
) -> None:
"""Test removal of discovered binary_sensor.""" """Test removal of discovered binary_sensor."""
config1 = copy.deepcopy(DEFAULT_CONFIG) config1 = copy.deepcopy(DEFAULT_CONFIG)
config2 = copy.deepcopy(DEFAULT_CONFIG) config2 = copy.deepcopy(DEFAULT_CONFIG)
@ -349,8 +377,11 @@ async def test_discovery_removal_binary_sensor(hass, mqtt_mock, caplog, setup_ta
async def test_discovery_update_unchanged_binary_sensor( async def test_discovery_update_unchanged_binary_sensor(
hass, mqtt_mock, caplog, setup_tasmota hass: HomeAssistant,
): mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
setup_tasmota,
) -> None:
"""Test update of discovered binary_sensor.""" """Test update of discovered binary_sensor."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["swc"][0] = 1 config["swc"][0] = 1
@ -363,7 +394,9 @@ async def test_discovery_update_unchanged_binary_sensor(
) )
async def test_discovery_device_remove(hass, mqtt_mock, setup_tasmota): async def test_discovery_device_remove(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test device registry remove.""" """Test device registry remove."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["swc"][0] = 1 config["swc"][0] = 1
@ -373,7 +406,9 @@ async def test_discovery_device_remove(hass, mqtt_mock, setup_tasmota):
) )
async def test_entity_id_update_subscriptions(hass, mqtt_mock, setup_tasmota): async def test_entity_id_update_subscriptions(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test MQTT subscriptions are managed when entity_id is updated.""" """Test MQTT subscriptions are managed when entity_id is updated."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["swc"][0] = 1 config["swc"][0] = 1
@ -389,7 +424,9 @@ async def test_entity_id_update_subscriptions(hass, mqtt_mock, setup_tasmota):
) )
async def test_entity_id_update_discovery_update(hass, mqtt_mock, setup_tasmota): async def test_entity_id_update_discovery_update(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test MQTT discovery update when entity_id is updated.""" """Test MQTT discovery update when entity_id is updated."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["swc"][0] = 1 config["swc"][0] = 1

30
tests/components/tasmota/test_config_flow.py
View file

@ -1,11 +1,15 @@
"""Test config flow.""" """Test config flow."""
from homeassistant import config_entries from homeassistant import config_entries
from homeassistant.core import HomeAssistant
from homeassistant.helpers.service_info.mqtt import MqttServiceInfo from homeassistant.helpers.service_info.mqtt import MqttServiceInfo
from tests.common import MockConfigEntry from tests.common import MockConfigEntry
from tests.typing import MqttMockHAClient
async def test_mqtt_abort_if_existing_entry(hass, mqtt_mock): async def test_mqtt_abort_if_existing_entry(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient
) -> None:
"""Check MQTT flow aborts when an entry already exist.""" """Check MQTT flow aborts when an entry already exist."""
MockConfigEntry(domain="tasmota").add_to_hass(hass) MockConfigEntry(domain="tasmota").add_to_hass(hass)
@ -17,7 +21,9 @@ async def test_mqtt_abort_if_existing_entry(hass, mqtt_mock):
assert result["reason"] == "single_instance_allowed" assert result["reason"] == "single_instance_allowed"
async def test_mqtt_abort_invalid_topic(hass, mqtt_mock): async def test_mqtt_abort_invalid_topic(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient
) -> None:
"""Check MQTT flow aborts if discovery topic is invalid.""" """Check MQTT flow aborts if discovery topic is invalid."""
discovery_info = MqttServiceInfo( discovery_info = MqttServiceInfo(
topic="tasmota/discovery/DC4F220848A2/bla", topic="tasmota/discovery/DC4F220848A2/bla",
@ -79,7 +85,7 @@ async def test_mqtt_abort_invalid_topic(hass, mqtt_mock):
assert result["type"] == "form" assert result["type"] == "form"
async def test_mqtt_setup(hass, mqtt_mock) -> None: async def test_mqtt_setup(hass: HomeAssistant, mqtt_mock: MqttMockHAClient) -> None:
"""Test we can finish a config flow through MQTT with custom prefix.""" """Test we can finish a config flow through MQTT with custom prefix."""
discovery_info = MqttServiceInfo( discovery_info = MqttServiceInfo(
topic="tasmota/discovery/DC4F220848A2/config", topic="tasmota/discovery/DC4F220848A2/config",
@ -109,7 +115,7 @@ async def test_mqtt_setup(hass, mqtt_mock) -> None:
assert result["result"].data == {"discovery_prefix": "tasmota/discovery"} assert result["result"].data == {"discovery_prefix": "tasmota/discovery"}
async def test_user_setup(hass, mqtt_mock): async def test_user_setup(hass: HomeAssistant, mqtt_mock: MqttMockHAClient) -> None:
"""Test we can finish a config flow.""" """Test we can finish a config flow."""
result = await hass.config_entries.flow.async_init( result = await hass.config_entries.flow.async_init(
"tasmota", context={"source": config_entries.SOURCE_USER} "tasmota", context={"source": config_entries.SOURCE_USER}
@ -124,7 +130,9 @@ async def test_user_setup(hass, mqtt_mock):
} }
async def test_user_setup_advanced(hass, mqtt_mock): async def test_user_setup_advanced(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient
) -> None:
"""Test we can finish a config flow.""" """Test we can finish a config flow."""
result = await hass.config_entries.flow.async_init( result = await hass.config_entries.flow.async_init(
"tasmota", "tasmota",
@ -142,7 +150,9 @@ async def test_user_setup_advanced(hass, mqtt_mock):
} }
async def test_user_setup_advanced_strip_wildcard(hass, mqtt_mock): async def test_user_setup_advanced_strip_wildcard(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient
) -> None:
"""Test we can finish a config flow.""" """Test we can finish a config flow."""
result = await hass.config_entries.flow.async_init( result = await hass.config_entries.flow.async_init(
"tasmota", "tasmota",
@ -160,7 +170,9 @@ async def test_user_setup_advanced_strip_wildcard(hass, mqtt_mock):
} }
async def test_user_setup_invalid_topic_prefix(hass, mqtt_mock): async def test_user_setup_invalid_topic_prefix(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient
) -> None:
"""Test abort on invalid discovery topic.""" """Test abort on invalid discovery topic."""
result = await hass.config_entries.flow.async_init( result = await hass.config_entries.flow.async_init(
"tasmota", "tasmota",
@ -176,7 +188,9 @@ async def test_user_setup_invalid_topic_prefix(hass, mqtt_mock):
assert result["errors"]["base"] == "invalid_discovery_topic" assert result["errors"]["base"] == "invalid_discovery_topic"
async def test_user_single_instance(hass, mqtt_mock): async def test_user_single_instance(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient
) -> None:
"""Test we only allow a single config flow.""" """Test we only allow a single config flow."""
MockConfigEntry(domain="tasmota").add_to_hass(hass) MockConfigEntry(domain="tasmota").add_to_hass(hass)

82
tests/components/tasmota/test_cover.py
View file

@ -14,6 +14,7 @@ import pytest
from homeassistant.components import cover from homeassistant.components import cover
from homeassistant.components.tasmota.const import DEFAULT_PREFIX from homeassistant.components.tasmota.const import DEFAULT_PREFIX
from homeassistant.const import ATTR_ASSUMED_STATE, STATE_UNKNOWN, Platform from homeassistant.const import ATTR_ASSUMED_STATE, STATE_UNKNOWN, Platform
from homeassistant.core import HomeAssistant
from .test_common import ( from .test_common import (
DEFAULT_CONFIG, DEFAULT_CONFIG,
@ -29,6 +30,7 @@ from .test_common import (
) )
from tests.common import async_fire_mqtt_message from tests.common import async_fire_mqtt_message
from tests.typing import MqttMockHAClient, MqttMockPahoClient
COVER_SUPPORT = ( COVER_SUPPORT = (
cover.SUPPORT_OPEN cover.SUPPORT_OPEN
@ -44,7 +46,9 @@ TILT_SUPPORT = (
) )
async def test_missing_relay(hass, mqtt_mock, setup_tasmota): async def test_missing_relay(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test no cover is discovered if relays are missing.""" """Test no cover is discovered if relays are missing."""
@ -58,8 +62,12 @@ async def test_missing_relay(hass, mqtt_mock, setup_tasmota):
], ],
) )
async def test_multiple_covers( async def test_multiple_covers(
hass, mqtt_mock, setup_tasmota, relay_config, num_covers hass: HomeAssistant,
): mqtt_mock: MqttMockHAClient,
setup_tasmota,
relay_config,
num_covers,
) -> None:
"""Test discovery of multiple covers.""" """Test discovery of multiple covers."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"] = relay_config config["rl"] = relay_config
@ -77,7 +85,9 @@ async def test_multiple_covers(
assert len(hass.states.async_all("cover")) == num_covers assert len(hass.states.async_all("cover")) == num_covers
async def test_tilt_support(hass, mqtt_mock, setup_tasmota): async def test_tilt_support(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test tilt support detection.""" """Test tilt support detection."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"] = [3, 3, 3, 3, 3, 3, 3, 3] config["rl"] = [3, 3, 3, 3, 3, 3, 3, 3]
@ -111,7 +121,9 @@ async def test_tilt_support(hass, mqtt_mock, setup_tasmota):
assert state.attributes["supported_features"] == COVER_SUPPORT assert state.attributes["supported_features"] == COVER_SUPPORT
async def test_controlling_state_via_mqtt_tilt(hass, mqtt_mock, setup_tasmota): async def test_controlling_state_via_mqtt_tilt(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 3 config["rl"][0] = 3
@ -283,8 +295,8 @@ async def test_controlling_state_via_mqtt_tilt(hass, mqtt_mock, setup_tasmota):
@pytest.mark.parametrize("tilt", ("", ',"Tilt":0')) @pytest.mark.parametrize("tilt", ("", ',"Tilt":0'))
async def test_controlling_state_via_mqtt_inverted( async def test_controlling_state_via_mqtt_inverted(
hass, mqtt_mock, setup_tasmota, tilt hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota, tilt
): ) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 3 config["rl"][0] = 3
@ -458,7 +470,9 @@ async def call_service(hass, entity_id, service, **kwargs):
) )
async def test_sending_mqtt_commands(hass, mqtt_mock, setup_tasmota): async def test_sending_mqtt_commands(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test the sending MQTT commands.""" """Test the sending MQTT commands."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["dn"] = "Test" config["dn"] = "Test"
@ -561,7 +575,9 @@ async def test_sending_mqtt_commands(hass, mqtt_mock, setup_tasmota):
mqtt_mock.async_publish.reset_mock() mqtt_mock.async_publish.reset_mock()
async def test_sending_mqtt_commands_inverted(hass, mqtt_mock, setup_tasmota): async def test_sending_mqtt_commands_inverted(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test the sending MQTT commands.""" """Test the sending MQTT commands."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["dn"] = "Test" config["dn"] = "Test"
@ -626,8 +642,11 @@ async def test_sending_mqtt_commands_inverted(hass, mqtt_mock, setup_tasmota):
async def test_availability_when_connection_lost( async def test_availability_when_connection_lost(
hass, mqtt_client_mock, mqtt_mock, setup_tasmota hass: HomeAssistant,
): mqtt_client_mock: MqttMockPahoClient,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test availability after MQTT disconnection.""" """Test availability after MQTT disconnection."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["dn"] = "Test" config["dn"] = "Test"
@ -643,7 +662,9 @@ async def test_availability_when_connection_lost(
) )
async def test_availability(hass, mqtt_mock, setup_tasmota): async def test_availability(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test availability.""" """Test availability."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["dn"] = "Test" config["dn"] = "Test"
@ -654,7 +675,9 @@ async def test_availability(hass, mqtt_mock, setup_tasmota):
) )
async def test_availability_discovery_update(hass, mqtt_mock, setup_tasmota): async def test_availability_discovery_update(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test availability discovery update.""" """Test availability discovery update."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["dn"] = "Test" config["dn"] = "Test"
@ -666,8 +689,11 @@ async def test_availability_discovery_update(hass, mqtt_mock, setup_tasmota):
async def test_availability_poll_state( async def test_availability_poll_state(
hass, mqtt_client_mock, mqtt_mock, setup_tasmota hass: HomeAssistant,
): mqtt_client_mock: MqttMockPahoClient,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test polling after MQTT connection (re)established.""" """Test polling after MQTT connection (re)established."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 3 config["rl"][0] = 3
@ -678,7 +704,12 @@ async def test_availability_poll_state(
) )
async def test_discovery_removal_cover(hass, mqtt_mock, caplog, setup_tasmota): async def test_discovery_removal_cover(
hass: HomeAssistant,
mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
setup_tasmota,
) -> None:
"""Test removal of discovered cover.""" """Test removal of discovered cover."""
config1 = copy.deepcopy(DEFAULT_CONFIG) config1 = copy.deepcopy(DEFAULT_CONFIG)
config1["dn"] = "Test" config1["dn"] = "Test"
@ -701,7 +732,12 @@ async def test_discovery_removal_cover(hass, mqtt_mock, caplog, setup_tasmota):
) )
async def test_discovery_update_unchanged_cover(hass, mqtt_mock, caplog, setup_tasmota): async def test_discovery_update_unchanged_cover(
hass: HomeAssistant,
mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
setup_tasmota,
) -> None:
"""Test update of discovered cover.""" """Test update of discovered cover."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["dn"] = "Test" config["dn"] = "Test"
@ -722,7 +758,9 @@ async def test_discovery_update_unchanged_cover(hass, mqtt_mock, caplog, setup_t
) )
async def test_discovery_device_remove(hass, mqtt_mock, setup_tasmota): async def test_discovery_device_remove(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test device registry remove.""" """Test device registry remove."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["dn"] = "Test" config["dn"] = "Test"
@ -734,7 +772,9 @@ async def test_discovery_device_remove(hass, mqtt_mock, setup_tasmota):
) )
async def test_entity_id_update_subscriptions(hass, mqtt_mock, setup_tasmota): async def test_entity_id_update_subscriptions(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test MQTT subscriptions are managed when entity_id is updated.""" """Test MQTT subscriptions are managed when entity_id is updated."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["dn"] = "Test" config["dn"] = "Test"
@ -751,7 +791,9 @@ async def test_entity_id_update_subscriptions(hass, mqtt_mock, setup_tasmota):
) )
async def test_entity_id_update_discovery_update(hass, mqtt_mock, setup_tasmota): async def test_entity_id_update_discovery_update(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test MQTT discovery update when entity_id is updated.""" """Test MQTT discovery update when entity_id is updated."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["dn"] = "Test" config["dn"] = "Test"

111
tests/components/tasmota/test_device_trigger.py
View file

@ -10,6 +10,7 @@ import homeassistant.components.automation as automation
from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.device_automation import DeviceAutomationType
from homeassistant.components.tasmota import _LOGGER from homeassistant.components.tasmota import _LOGGER
from homeassistant.components.tasmota.const import DEFAULT_PREFIX, DOMAIN from homeassistant.components.tasmota.const import DEFAULT_PREFIX, DOMAIN
from homeassistant.core import HomeAssistant
from homeassistant.helpers import device_registry as dr from homeassistant.helpers import device_registry as dr
from homeassistant.helpers.trigger import async_initialize_triggers from homeassistant.helpers.trigger import async_initialize_triggers
from homeassistant.setup import async_setup_component from homeassistant.setup import async_setup_component
@ -22,9 +23,16 @@ from tests.common import (
async_get_device_automations, async_get_device_automations,
) )
from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401
from tests.typing import MqttMockHAClient, WebSocketGenerator
async def test_get_triggers_btn(hass, device_reg, entity_reg, mqtt_mock, setup_tasmota): async def test_get_triggers_btn(
hass: HomeAssistant,
device_reg,
entity_reg,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test we get the expected triggers from a discovered mqtt device.""" """Test we get the expected triggers from a discovered mqtt device."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["btn"][0] = 1 config["btn"][0] = 1
@ -65,7 +73,13 @@ async def test_get_triggers_btn(hass, device_reg, entity_reg, mqtt_mock, setup_t
assert_lists_same(triggers, expected_triggers) assert_lists_same(triggers, expected_triggers)
async def test_get_triggers_swc(hass, device_reg, entity_reg, mqtt_mock, setup_tasmota): async def test_get_triggers_swc(
hass: HomeAssistant,
device_reg,
entity_reg,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test we get the expected triggers from a discovered mqtt device.""" """Test we get the expected triggers from a discovered mqtt device."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["swc"][0] = 0 config["swc"][0] = 0
@ -95,8 +109,12 @@ async def test_get_triggers_swc(hass, device_reg, entity_reg, mqtt_mock, setup_t
async def test_get_unknown_triggers( async def test_get_unknown_triggers(
hass, device_reg, entity_reg, mqtt_mock, setup_tasmota hass: HomeAssistant,
): device_reg,
entity_reg,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test we don't get unknown triggers.""" """Test we don't get unknown triggers."""
# Discover a device without device triggers # Discover a device without device triggers
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
@ -140,8 +158,12 @@ async def test_get_unknown_triggers(
async def test_get_non_existing_triggers( async def test_get_non_existing_triggers(
hass, device_reg, entity_reg, mqtt_mock, setup_tasmota hass: HomeAssistant,
): device_reg,
entity_reg,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test getting non existing triggers.""" """Test getting non existing triggers."""
# Discover a device without device triggers # Discover a device without device triggers
config1 = copy.deepcopy(DEFAULT_CONFIG) config1 = copy.deepcopy(DEFAULT_CONFIG)
@ -162,8 +184,12 @@ async def test_get_non_existing_triggers(
@pytest.mark.no_fail_on_log_exception @pytest.mark.no_fail_on_log_exception
async def test_discover_bad_triggers( async def test_discover_bad_triggers(
hass, device_reg, entity_reg, mqtt_mock, setup_tasmota hass: HomeAssistant,
): device_reg,
entity_reg,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test exception handling when discovering trigger.""" """Test exception handling when discovering trigger."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["swc"][0] = 0 config["swc"][0] = 0
@ -245,8 +271,12 @@ async def test_discover_bad_triggers(
async def test_update_remove_triggers( async def test_update_remove_triggers(
hass, device_reg, entity_reg, mqtt_mock, setup_tasmota hass: HomeAssistant,
): device_reg,
entity_reg,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test triggers can be updated and removed.""" """Test triggers can be updated and removed."""
# Discover a device with toggle + hold trigger # Discover a device with toggle + hold trigger
config1 = copy.deepcopy(DEFAULT_CONFIG) config1 = copy.deepcopy(DEFAULT_CONFIG)
@ -318,8 +348,8 @@ async def test_update_remove_triggers(
async def test_if_fires_on_mqtt_message_btn( async def test_if_fires_on_mqtt_message_btn(
hass, device_reg, calls, mqtt_mock, setup_tasmota hass: HomeAssistant, device_reg, calls, mqtt_mock: MqttMockHAClient, setup_tasmota
): ) -> None:
"""Test button triggers firing.""" """Test button triggers firing."""
# Discover a device with 2 device triggers # Discover a device with 2 device triggers
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
@ -389,8 +419,8 @@ async def test_if_fires_on_mqtt_message_btn(
async def test_if_fires_on_mqtt_message_swc( async def test_if_fires_on_mqtt_message_swc(
hass, device_reg, calls, mqtt_mock, setup_tasmota hass: HomeAssistant, device_reg, calls, mqtt_mock: MqttMockHAClient, setup_tasmota
): ) -> None:
"""Test switch triggers firing.""" """Test switch triggers firing."""
# Discover a device with 2 device triggers # Discover a device with 2 device triggers
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
@ -483,8 +513,8 @@ async def test_if_fires_on_mqtt_message_swc(
async def test_if_fires_on_mqtt_message_late_discover( async def test_if_fires_on_mqtt_message_late_discover(
hass, device_reg, calls, mqtt_mock, setup_tasmota hass: HomeAssistant, device_reg, calls, mqtt_mock: MqttMockHAClient, setup_tasmota
): ) -> None:
"""Test triggers firing of MQTT device triggers discovered after setup.""" """Test triggers firing of MQTT device triggers discovered after setup."""
# Discover a device without device triggers # Discover a device without device triggers
config1 = copy.deepcopy(DEFAULT_CONFIG) config1 = copy.deepcopy(DEFAULT_CONFIG)
@ -562,8 +592,8 @@ async def test_if_fires_on_mqtt_message_late_discover(
async def test_if_fires_on_mqtt_message_after_update( async def test_if_fires_on_mqtt_message_after_update(
hass, device_reg, calls, mqtt_mock, setup_tasmota hass: HomeAssistant, device_reg, calls, mqtt_mock: MqttMockHAClient, setup_tasmota
): ) -> None:
"""Test triggers firing after update.""" """Test triggers firing after update."""
# Discover a device with device trigger # Discover a device with device trigger
config1 = copy.deepcopy(DEFAULT_CONFIG) config1 = copy.deepcopy(DEFAULT_CONFIG)
@ -643,7 +673,9 @@ async def test_if_fires_on_mqtt_message_after_update(
assert len(calls) == 3 assert len(calls) == 3
async def test_no_resubscribe_same_topic(hass, device_reg, mqtt_mock, setup_tasmota): async def test_no_resubscribe_same_topic(
hass: HomeAssistant, device_reg, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test subscription to topics without change.""" """Test subscription to topics without change."""
# Discover a device with device trigger # Discover a device with device trigger
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
@ -690,8 +722,8 @@ async def test_no_resubscribe_same_topic(hass, device_reg, mqtt_mock, setup_tasm
async def test_not_fires_on_mqtt_message_after_remove_by_mqtt( async def test_not_fires_on_mqtt_message_after_remove_by_mqtt(
hass, device_reg, calls, mqtt_mock, setup_tasmota hass: HomeAssistant, device_reg, calls, mqtt_mock: MqttMockHAClient, setup_tasmota
): ) -> None:
"""Test triggers not firing after removal.""" """Test triggers not firing after removal."""
# Discover a device with device trigger # Discover a device with device trigger
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
@ -761,8 +793,13 @@ async def test_not_fires_on_mqtt_message_after_remove_by_mqtt(
async def test_not_fires_on_mqtt_message_after_remove_from_registry( async def test_not_fires_on_mqtt_message_after_remove_from_registry(
hass, hass_ws_client, device_reg, calls, mqtt_mock, setup_tasmota hass: HomeAssistant,
): hass_ws_client: WebSocketGenerator,
device_reg,
calls,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test triggers not firing after removal.""" """Test triggers not firing after removal."""
assert await async_setup_component(hass, "config", {}) assert await async_setup_component(hass, "config", {})
# Discover a device with device trigger # Discover a device with device trigger
@ -820,7 +857,9 @@ async def test_not_fires_on_mqtt_message_after_remove_from_registry(
assert len(calls) == 1 assert len(calls) == 1
async def test_attach_remove(hass, device_reg, mqtt_mock, setup_tasmota): async def test_attach_remove(
hass: HomeAssistant, device_reg, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test attach and removal of trigger.""" """Test attach and removal of trigger."""
# Discover a device with device trigger # Discover a device with device trigger
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
@ -879,7 +918,9 @@ async def test_attach_remove(hass, device_reg, mqtt_mock, setup_tasmota):
assert len(calls) == 1 assert len(calls) == 1
async def test_attach_remove_late(hass, device_reg, mqtt_mock, setup_tasmota): async def test_attach_remove_late(
hass: HomeAssistant, device_reg, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test attach and removal of trigger.""" """Test attach and removal of trigger."""
# Discover a device without device triggers # Discover a device without device triggers
config1 = copy.deepcopy(DEFAULT_CONFIG) config1 = copy.deepcopy(DEFAULT_CONFIG)
@ -950,7 +991,9 @@ async def test_attach_remove_late(hass, device_reg, mqtt_mock, setup_tasmota):
assert len(calls) == 1 assert len(calls) == 1
async def test_attach_remove_late2(hass, device_reg, mqtt_mock, setup_tasmota): async def test_attach_remove_late2(
hass: HomeAssistant, device_reg, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test attach and removal of trigger.""" """Test attach and removal of trigger."""
# Discover a device without device triggers # Discover a device without device triggers
config1 = copy.deepcopy(DEFAULT_CONFIG) config1 = copy.deepcopy(DEFAULT_CONFIG)
@ -1006,7 +1049,9 @@ async def test_attach_remove_late2(hass, device_reg, mqtt_mock, setup_tasmota):
assert len(calls) == 0 assert len(calls) == 0
async def test_attach_remove_unknown1(hass, device_reg, mqtt_mock, setup_tasmota): async def test_attach_remove_unknown1(
hass: HomeAssistant, device_reg, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test attach and removal of unknown trigger.""" """Test attach and removal of unknown trigger."""
# Discover a device without device triggers # Discover a device without device triggers
config1 = copy.deepcopy(DEFAULT_CONFIG) config1 = copy.deepcopy(DEFAULT_CONFIG)
@ -1044,8 +1089,12 @@ async def test_attach_remove_unknown1(hass, device_reg, mqtt_mock, setup_tasmota
async def test_attach_unknown_remove_device_from_registry( async def test_attach_unknown_remove_device_from_registry(
hass, hass_ws_client, device_reg, mqtt_mock, setup_tasmota hass: HomeAssistant,
): hass_ws_client: WebSocketGenerator,
device_reg,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test attach and removal of device with unknown trigger.""" """Test attach and removal of device with unknown trigger."""
assert await async_setup_component(hass, "config", {}) assert await async_setup_component(hass, "config", {})
# Discover a device without device triggers # Discover a device without device triggers
@ -1092,7 +1141,9 @@ async def test_attach_unknown_remove_device_from_registry(
await hass.async_block_till_done() await hass.async_block_till_done()
async def test_attach_remove_config_entry(hass, device_reg, mqtt_mock, setup_tasmota): async def test_attach_remove_config_entry(
hass: HomeAssistant, device_reg, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test trigger cleanup when removing a Tasmota config entry.""" """Test trigger cleanup when removing a Tasmota config entry."""
# Discover a device with device trigger # Discover a device with device trigger
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)

139
tests/components/tasmota/test_discovery.py
View file

@ -3,8 +3,11 @@ import copy
import json import json
from unittest.mock import ANY, patch from unittest.mock import ANY, patch
import pytest
from homeassistant.components.tasmota.const import DEFAULT_PREFIX from homeassistant.components.tasmota.const import DEFAULT_PREFIX
from homeassistant.components.tasmota.discovery import ALREADY_DISCOVERED from homeassistant.components.tasmota.discovery import ALREADY_DISCOVERED
from homeassistant.core import HomeAssistant
from homeassistant.helpers import ( from homeassistant.helpers import (
device_registry as dr, device_registry as dr,
entity_registry as er, entity_registry as er,
@ -16,9 +19,12 @@ from .conftest import setup_tasmota_helper
from .test_common import DEFAULT_CONFIG, DEFAULT_CONFIG_9_0_0_3, remove_device from .test_common import DEFAULT_CONFIG, DEFAULT_CONFIG_9_0_0_3, remove_device
from tests.common import MockConfigEntry, async_fire_mqtt_message from tests.common import MockConfigEntry, async_fire_mqtt_message
from tests.typing import MqttMockHAClient, WebSocketGenerator
async def test_subscribing_config_topic(hass, mqtt_mock, setup_tasmota): async def test_subscribing_config_topic(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test setting up discovery.""" """Test setting up discovery."""
discovery_topic = DEFAULT_PREFIX discovery_topic = DEFAULT_PREFIX
@ -26,7 +32,9 @@ async def test_subscribing_config_topic(hass, mqtt_mock, setup_tasmota):
mqtt_mock.async_subscribe.assert_any_call(discovery_topic + "/#", ANY, 0, "utf-8") mqtt_mock.async_subscribe.assert_any_call(discovery_topic + "/#", ANY, 0, "utf-8")
async def test_future_discovery_message(hass, mqtt_mock, caplog): async def test_future_discovery_message(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, caplog: pytest.LogCaptureFixture
) -> None:
"""Test we handle backwards compatible discovery messages.""" """Test we handle backwards compatible discovery messages."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["future_option"] = "BEST_SINCE_SLICED_BREAD" config["future_option"] = "BEST_SINCE_SLICED_BREAD"
@ -45,7 +53,9 @@ async def test_future_discovery_message(hass, mqtt_mock, caplog):
assert mock_tasmota_get_device_config.called assert mock_tasmota_get_device_config.called
async def test_valid_discovery_message(hass, mqtt_mock, caplog): async def test_valid_discovery_message(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, caplog: pytest.LogCaptureFixture
) -> None:
"""Test discovery callback called.""" """Test discovery callback called."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
@ -62,7 +72,7 @@ async def test_valid_discovery_message(hass, mqtt_mock, caplog):
assert mock_tasmota_get_device_config.called assert mock_tasmota_get_device_config.called
async def test_invalid_topic(hass, mqtt_mock): async def test_invalid_topic(hass: HomeAssistant, mqtt_mock: MqttMockHAClient) -> None:
"""Test receiving discovery message on wrong topic.""" """Test receiving discovery message on wrong topic."""
with patch( with patch(
"homeassistant.components.tasmota.discovery.tasmota_get_device_config" "homeassistant.components.tasmota.discovery.tasmota_get_device_config"
@ -74,7 +84,9 @@ async def test_invalid_topic(hass, mqtt_mock):
assert not mock_tasmota_get_device_config.called assert not mock_tasmota_get_device_config.called
async def test_invalid_message(hass, mqtt_mock, caplog): async def test_invalid_message(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, caplog: pytest.LogCaptureFixture
) -> None:
"""Test receiving an invalid message.""" """Test receiving an invalid message."""
with patch( with patch(
"homeassistant.components.tasmota.discovery.tasmota_get_device_config" "homeassistant.components.tasmota.discovery.tasmota_get_device_config"
@ -87,7 +99,9 @@ async def test_invalid_message(hass, mqtt_mock, caplog):
assert not mock_tasmota_get_device_config.called assert not mock_tasmota_get_device_config.called
async def test_invalid_mac(hass, mqtt_mock, caplog): async def test_invalid_mac(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, caplog: pytest.LogCaptureFixture
) -> None:
"""Test topic is not matching device MAC.""" """Test topic is not matching device MAC."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
@ -105,8 +119,13 @@ async def test_invalid_mac(hass, mqtt_mock, caplog):
async def test_correct_config_discovery( async def test_correct_config_discovery(
hass, mqtt_mock, caplog, device_reg, entity_reg, setup_tasmota hass: HomeAssistant,
): mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
device_reg,
entity_reg,
setup_tasmota,
) -> None:
"""Test receiving valid discovery message.""" """Test receiving valid discovery message."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 1 config["rl"][0] = 1
@ -135,8 +154,13 @@ async def test_correct_config_discovery(
async def test_device_discover( async def test_device_discover(
hass, mqtt_mock, caplog, device_reg, entity_reg, setup_tasmota hass: HomeAssistant,
): mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
device_reg,
entity_reg,
setup_tasmota,
) -> None:
"""Test setting up a device.""" """Test setting up a device."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
mac = config["mac"] mac = config["mac"]
@ -161,8 +185,13 @@ async def test_device_discover(
async def test_device_discover_deprecated( async def test_device_discover_deprecated(
hass, mqtt_mock, caplog, device_reg, entity_reg, setup_tasmota hass: HomeAssistant,
): mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
device_reg,
entity_reg,
setup_tasmota,
) -> None:
"""Test setting up a device with deprecated discovery message.""" """Test setting up a device with deprecated discovery message."""
config = copy.deepcopy(DEFAULT_CONFIG_9_0_0_3) config = copy.deepcopy(DEFAULT_CONFIG_9_0_0_3)
mac = config["mac"] mac = config["mac"]
@ -186,8 +215,13 @@ async def test_device_discover_deprecated(
async def test_device_update( async def test_device_update(
hass, mqtt_mock, caplog, device_reg, entity_reg, setup_tasmota hass: HomeAssistant,
): mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
device_reg,
entity_reg,
setup_tasmota,
) -> None:
"""Test updating a device.""" """Test updating a device."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["md"] = "Model 1" config["md"] = "Model 1"
@ -231,8 +265,13 @@ async def test_device_update(
async def test_device_remove( async def test_device_remove(
hass, mqtt_mock, caplog, device_reg, entity_reg, setup_tasmota hass: HomeAssistant,
): mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
device_reg,
entity_reg,
setup_tasmota,
) -> None:
"""Test removing a discovered device.""" """Test removing a discovered device."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
mac = config["mac"] mac = config["mac"]
@ -265,8 +304,13 @@ async def test_device_remove(
async def test_device_remove_multiple_config_entries_1( async def test_device_remove_multiple_config_entries_1(
hass, mqtt_mock, caplog, device_reg, entity_reg, setup_tasmota hass: HomeAssistant,
): mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
device_reg,
entity_reg,
setup_tasmota,
) -> None:
"""Test removing a discovered device.""" """Test removing a discovered device."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
mac = config["mac"] mac = config["mac"]
@ -311,8 +355,13 @@ async def test_device_remove_multiple_config_entries_1(
async def test_device_remove_multiple_config_entries_2( async def test_device_remove_multiple_config_entries_2(
hass, mqtt_mock, caplog, device_reg, entity_reg, setup_tasmota hass: HomeAssistant,
): mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
device_reg,
entity_reg,
setup_tasmota,
) -> None:
"""Test removing a discovered device.""" """Test removing a discovered device."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
mac = config["mac"] mac = config["mac"]
@ -370,8 +419,13 @@ async def test_device_remove_multiple_config_entries_2(
async def test_device_remove_stale( async def test_device_remove_stale(
hass, hass_ws_client, mqtt_mock, caplog, device_reg, setup_tasmota hass: HomeAssistant,
): hass_ws_client: WebSocketGenerator,
mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
device_reg,
setup_tasmota,
) -> None:
"""Test removing a stale (undiscovered) device does not throw.""" """Test removing a stale (undiscovered) device does not throw."""
assert await async_setup_component(hass, "config", {}) assert await async_setup_component(hass, "config", {})
mac = "00000049A3BC" mac = "00000049A3BC"
@ -401,8 +455,13 @@ async def test_device_remove_stale(
async def test_device_rediscover( async def test_device_rediscover(
hass, mqtt_mock, caplog, device_reg, entity_reg, setup_tasmota hass: HomeAssistant,
): mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
device_reg,
entity_reg,
setup_tasmota,
) -> None:
"""Test removing a device.""" """Test removing a device."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
mac = config["mac"] mac = config["mac"]
@ -448,7 +507,12 @@ async def test_device_rediscover(
assert device_entry1.id == device_entry.id assert device_entry1.id == device_entry.id
async def test_entity_duplicate_discovery(hass, mqtt_mock, caplog, setup_tasmota): async def test_entity_duplicate_discovery(
hass: HomeAssistant,
mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
setup_tasmota,
) -> None:
"""Test entities are not duplicated.""" """Test entities are not duplicated."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 1 config["rl"][0] = 1
@ -478,7 +542,12 @@ async def test_entity_duplicate_discovery(hass, mqtt_mock, caplog, setup_tasmota
) )
async def test_entity_duplicate_removal(hass, mqtt_mock, caplog, setup_tasmota): async def test_entity_duplicate_removal(
hass: HomeAssistant,
mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
setup_tasmota,
) -> None:
"""Test removing entity twice.""" """Test removing entity twice."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 1 config["rl"][0] = 1
@ -502,8 +571,13 @@ async def test_entity_duplicate_removal(hass, mqtt_mock, caplog, setup_tasmota):
async def test_same_topic( async def test_same_topic(
hass, mqtt_mock, caplog, device_reg, entity_reg, setup_tasmota hass: HomeAssistant,
): mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
device_reg,
entity_reg,
setup_tasmota,
) -> None:
"""Test detecting devices with same topic.""" """Test detecting devices with same topic."""
configs = [ configs = [
copy.deepcopy(DEFAULT_CONFIG), copy.deepcopy(DEFAULT_CONFIG),
@ -621,8 +695,13 @@ async def test_same_topic(
async def test_topic_no_prefix( async def test_topic_no_prefix(
hass, mqtt_mock, caplog, device_reg, entity_reg, setup_tasmota hass: HomeAssistant,
): mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
device_reg,
entity_reg,
setup_tasmota,
) -> None:
"""Test detecting devices with same topic.""" """Test detecting devices with same topic."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 1 config["rl"][0] = 1

62
tests/components/tasmota/test_fan.py
View file

@ -14,6 +14,7 @@ from voluptuous import MultipleInvalid
from homeassistant.components import fan from homeassistant.components import fan
from homeassistant.components.tasmota.const import DEFAULT_PREFIX from homeassistant.components.tasmota.const import DEFAULT_PREFIX
from homeassistant.const import ATTR_ASSUMED_STATE, STATE_OFF, STATE_ON, Platform from homeassistant.const import ATTR_ASSUMED_STATE, STATE_OFF, STATE_ON, Platform
from homeassistant.core import HomeAssistant
from .test_common import ( from .test_common import (
DEFAULT_CONFIG, DEFAULT_CONFIG,
@ -30,9 +31,12 @@ from .test_common import (
from tests.common import async_fire_mqtt_message from tests.common import async_fire_mqtt_message
from tests.components.fan import common from tests.components.fan import common
from tests.typing import MqttMockHAClient, MqttMockPahoClient
async def test_controlling_state_via_mqtt(hass, mqtt_mock, setup_tasmota): async def test_controlling_state_via_mqtt(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["if"] = 1 config["if"] = 1
@ -88,7 +92,9 @@ async def test_controlling_state_via_mqtt(hass, mqtt_mock, setup_tasmota):
assert state.attributes["percentage"] == 0 assert state.attributes["percentage"] == 0
async def test_sending_mqtt_commands(hass, mqtt_mock, setup_tasmota): async def test_sending_mqtt_commands(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test the sending MQTT commands.""" """Test the sending MQTT commands."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["if"] = 1 config["if"] = 1
@ -182,7 +188,9 @@ async def test_sending_mqtt_commands(hass, mqtt_mock, setup_tasmota):
mqtt_mock.async_publish.reset_mock() mqtt_mock.async_publish.reset_mock()
async def test_invalid_fan_speed_percentage(hass, mqtt_mock, setup_tasmota): async def test_invalid_fan_speed_percentage(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test the sending MQTT commands.""" """Test the sending MQTT commands."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["if"] = 1 config["if"] = 1
@ -211,8 +219,11 @@ async def test_invalid_fan_speed_percentage(hass, mqtt_mock, setup_tasmota):
async def test_availability_when_connection_lost( async def test_availability_when_connection_lost(
hass, mqtt_client_mock, mqtt_mock, setup_tasmota hass: HomeAssistant,
): mqtt_client_mock: MqttMockPahoClient,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test availability after MQTT disconnection.""" """Test availability after MQTT disconnection."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["dn"] = "Test" config["dn"] = "Test"
@ -222,7 +233,9 @@ async def test_availability_when_connection_lost(
) )
async def test_availability(hass, mqtt_mock, setup_tasmota): async def test_availability(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test availability.""" """Test availability."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["dn"] = "Test" config["dn"] = "Test"
@ -230,7 +243,9 @@ async def test_availability(hass, mqtt_mock, setup_tasmota):
await help_test_availability(hass, mqtt_mock, Platform.FAN, config) await help_test_availability(hass, mqtt_mock, Platform.FAN, config)
async def test_availability_discovery_update(hass, mqtt_mock, setup_tasmota): async def test_availability_discovery_update(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test availability discovery update.""" """Test availability discovery update."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["dn"] = "Test" config["dn"] = "Test"
@ -239,8 +254,11 @@ async def test_availability_discovery_update(hass, mqtt_mock, setup_tasmota):
async def test_availability_poll_state( async def test_availability_poll_state(
hass, mqtt_client_mock, mqtt_mock, setup_tasmota hass: HomeAssistant,
): mqtt_client_mock: MqttMockPahoClient,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test polling after MQTT connection (re)established.""" """Test polling after MQTT connection (re)established."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["if"] = 1 config["if"] = 1
@ -250,7 +268,12 @@ async def test_availability_poll_state(
) )
async def test_discovery_removal_fan(hass, mqtt_mock, caplog, setup_tasmota): async def test_discovery_removal_fan(
hass: HomeAssistant,
mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
setup_tasmota,
) -> None:
"""Test removal of discovered fan.""" """Test removal of discovered fan."""
config1 = copy.deepcopy(DEFAULT_CONFIG) config1 = copy.deepcopy(DEFAULT_CONFIG)
config1["dn"] = "Test" config1["dn"] = "Test"
@ -264,7 +287,12 @@ async def test_discovery_removal_fan(hass, mqtt_mock, caplog, setup_tasmota):
) )
async def test_discovery_update_unchanged_fan(hass, mqtt_mock, caplog, setup_tasmota): async def test_discovery_update_unchanged_fan(
hass: HomeAssistant,
mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
setup_tasmota,
) -> None:
"""Test update of discovered fan.""" """Test update of discovered fan."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["dn"] = "Test" config["dn"] = "Test"
@ -277,7 +305,9 @@ async def test_discovery_update_unchanged_fan(hass, mqtt_mock, caplog, setup_tas
) )
async def test_discovery_device_remove(hass, mqtt_mock, setup_tasmota): async def test_discovery_device_remove(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test device registry remove.""" """Test device registry remove."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["dn"] = "Test" config["dn"] = "Test"
@ -288,7 +318,9 @@ async def test_discovery_device_remove(hass, mqtt_mock, setup_tasmota):
) )
async def test_entity_id_update_subscriptions(hass, mqtt_mock, setup_tasmota): async def test_entity_id_update_subscriptions(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test MQTT subscriptions are managed when entity_id is updated.""" """Test MQTT subscriptions are managed when entity_id is updated."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["dn"] = "Test" config["dn"] = "Test"
@ -303,7 +335,9 @@ async def test_entity_id_update_subscriptions(hass, mqtt_mock, setup_tasmota):
) )
async def test_entity_id_update_discovery_update(hass, mqtt_mock, setup_tasmota): async def test_entity_id_update_discovery_update(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test MQTT discovery update when entity_id is updated.""" """Test MQTT discovery update when entity_id is updated."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["dn"] = "Test" config["dn"] = "Test"

39
tests/components/tasmota/test_init.py
View file

@ -3,7 +3,10 @@ import copy
import json import json
from unittest.mock import call from unittest.mock import call
import pytest
from homeassistant.components.tasmota.const import DEFAULT_PREFIX, DOMAIN from homeassistant.components.tasmota.const import DEFAULT_PREFIX, DOMAIN
from homeassistant.core import HomeAssistant
from homeassistant.helpers import device_registry as dr from homeassistant.helpers import device_registry as dr
from homeassistant.setup import async_setup_component from homeassistant.setup import async_setup_component
@ -15,11 +18,18 @@ from tests.common import (
async_fire_mqtt_message, async_fire_mqtt_message,
mock_integration, mock_integration,
) )
from tests.typing import MqttMockHAClient, WebSocketGenerator
async def test_device_remove( async def test_device_remove(
hass, hass_ws_client, mqtt_mock, caplog, device_reg, entity_reg, setup_tasmota hass: HomeAssistant,
): hass_ws_client: WebSocketGenerator,
mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
device_reg,
entity_reg,
setup_tasmota,
) -> None:
"""Test removing a discovered device through device registry.""" """Test removing a discovered device through device registry."""
assert await async_setup_component(hass, "config", {}) assert await async_setup_component(hass, "config", {})
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
@ -58,8 +68,12 @@ async def test_device_remove(
async def test_device_remove_non_tasmota_device( async def test_device_remove_non_tasmota_device(
hass, device_reg, hass_ws_client, mqtt_mock, setup_tasmota hass: HomeAssistant,
): device_reg,
hass_ws_client: WebSocketGenerator,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test removing a non Tasmota device through device registry.""" """Test removing a non Tasmota device through device registry."""
assert await async_setup_component(hass, "config", {}) assert await async_setup_component(hass, "config", {})
@ -99,8 +113,12 @@ async def test_device_remove_non_tasmota_device(
async def test_device_remove_stale_tasmota_device( async def test_device_remove_stale_tasmota_device(
hass, device_reg, hass_ws_client, mqtt_mock, setup_tasmota hass: HomeAssistant,
): device_reg,
hass_ws_client: WebSocketGenerator,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test removing a stale (undiscovered) Tasmota device through device registry.""" """Test removing a stale (undiscovered) Tasmota device through device registry."""
assert await async_setup_component(hass, "config", {}) assert await async_setup_component(hass, "config", {})
config_entry = hass.config_entries.async_entries("tasmota")[0] config_entry = hass.config_entries.async_entries("tasmota")[0]
@ -126,8 +144,13 @@ async def test_device_remove_stale_tasmota_device(
async def test_tasmota_ws_remove_discovered_device( async def test_tasmota_ws_remove_discovered_device(
hass, device_reg, entity_reg, hass_ws_client, mqtt_mock, setup_tasmota hass: HomeAssistant,
): device_reg,
entity_reg,
hass_ws_client: WebSocketGenerator,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test Tasmota websocket device removal.""" """Test Tasmota websocket device removal."""
assert await async_setup_component(hass, "config", {}) assert await async_setup_component(hass, "config", {})
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)

184
tests/components/tasmota/test_light.py
View file

@ -9,10 +9,12 @@ from hatasmota.utils import (
get_topic_tele_state, get_topic_tele_state,
get_topic_tele_will, get_topic_tele_will,
) )
import pytest
from homeassistant.components.light import LightEntityFeature from homeassistant.components.light import LightEntityFeature
from homeassistant.components.tasmota.const import DEFAULT_PREFIX from homeassistant.components.tasmota.const import DEFAULT_PREFIX
from homeassistant.const import ATTR_ASSUMED_STATE, STATE_OFF, STATE_ON, Platform from homeassistant.const import ATTR_ASSUMED_STATE, STATE_OFF, STATE_ON, Platform
from homeassistant.core import HomeAssistant
from .test_common import ( from .test_common import (
DEFAULT_CONFIG, DEFAULT_CONFIG,
@ -29,9 +31,12 @@ from .test_common import (
from tests.common import async_fire_mqtt_message from tests.common import async_fire_mqtt_message
from tests.components.light import common from tests.components.light import common
from tests.typing import MqttMockHAClient, MqttMockPahoClient
async def test_attributes_on_off(hass, mqtt_mock, setup_tasmota): async def test_attributes_on_off(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 1 config["rl"][0] = 1
@ -57,7 +62,9 @@ async def test_attributes_on_off(hass, mqtt_mock, setup_tasmota):
assert state.attributes.get("color_mode") == "onoff" assert state.attributes.get("color_mode") == "onoff"
async def test_attributes_dimmer_tuya(hass, mqtt_mock, setup_tasmota): async def test_attributes_dimmer_tuya(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -84,7 +91,9 @@ async def test_attributes_dimmer_tuya(hass, mqtt_mock, setup_tasmota):
assert state.attributes.get("color_mode") == "brightness" assert state.attributes.get("color_mode") == "brightness"
async def test_attributes_dimmer(hass, mqtt_mock, setup_tasmota): async def test_attributes_dimmer(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -110,7 +119,9 @@ async def test_attributes_dimmer(hass, mqtt_mock, setup_tasmota):
assert state.attributes.get("color_mode") == "brightness" assert state.attributes.get("color_mode") == "brightness"
async def test_attributes_ct(hass, mqtt_mock, setup_tasmota): async def test_attributes_ct(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -136,7 +147,9 @@ async def test_attributes_ct(hass, mqtt_mock, setup_tasmota):
assert state.attributes.get("color_mode") == "color_temp" assert state.attributes.get("color_mode") == "color_temp"
async def test_attributes_ct_reduced(hass, mqtt_mock, setup_tasmota): async def test_attributes_ct_reduced(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -163,7 +176,9 @@ async def test_attributes_ct_reduced(hass, mqtt_mock, setup_tasmota):
assert state.attributes.get("color_mode") == "color_temp" assert state.attributes.get("color_mode") == "color_temp"
async def test_attributes_rgb(hass, mqtt_mock, setup_tasmota): async def test_attributes_rgb(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -198,7 +213,9 @@ async def test_attributes_rgb(hass, mqtt_mock, setup_tasmota):
assert state.attributes.get("color_mode") == "hs" assert state.attributes.get("color_mode") == "hs"
async def test_attributes_rgbw(hass, mqtt_mock, setup_tasmota): async def test_attributes_rgbw(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -233,7 +250,9 @@ async def test_attributes_rgbw(hass, mqtt_mock, setup_tasmota):
assert state.attributes.get("color_mode") == "hs" assert state.attributes.get("color_mode") == "hs"
async def test_attributes_rgbww(hass, mqtt_mock, setup_tasmota): async def test_attributes_rgbww(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -268,7 +287,9 @@ async def test_attributes_rgbww(hass, mqtt_mock, setup_tasmota):
assert state.attributes.get("color_mode") == "color_temp" assert state.attributes.get("color_mode") == "color_temp"
async def test_attributes_rgbww_reduced(hass, mqtt_mock, setup_tasmota): async def test_attributes_rgbww_reduced(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -304,7 +325,9 @@ async def test_attributes_rgbww_reduced(hass, mqtt_mock, setup_tasmota):
assert state.attributes.get("color_mode") == "color_temp" assert state.attributes.get("color_mode") == "color_temp"
async def test_controlling_state_via_mqtt_on_off(hass, mqtt_mock, setup_tasmota): async def test_controlling_state_via_mqtt_on_off(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 1 config["rl"][0] = 1
@ -353,7 +376,9 @@ async def test_controlling_state_via_mqtt_on_off(hass, mqtt_mock, setup_tasmota)
assert "color_mode" not in state.attributes assert "color_mode" not in state.attributes
async def test_controlling_state_via_mqtt_ct(hass, mqtt_mock, setup_tasmota): async def test_controlling_state_via_mqtt_ct(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -416,7 +441,9 @@ async def test_controlling_state_via_mqtt_ct(hass, mqtt_mock, setup_tasmota):
assert state.attributes.get("color_mode") == "color_temp" assert state.attributes.get("color_mode") == "color_temp"
async def test_controlling_state_via_mqtt_rgbw(hass, mqtt_mock, setup_tasmota): async def test_controlling_state_via_mqtt_rgbw(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -515,7 +542,9 @@ async def test_controlling_state_via_mqtt_rgbw(hass, mqtt_mock, setup_tasmota):
assert state.state == STATE_OFF assert state.state == STATE_OFF
async def test_controlling_state_via_mqtt_rgbww(hass, mqtt_mock, setup_tasmota): async def test_controlling_state_via_mqtt_rgbww(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -614,7 +643,9 @@ async def test_controlling_state_via_mqtt_rgbww(hass, mqtt_mock, setup_tasmota):
assert state.state == STATE_OFF assert state.state == STATE_OFF
async def test_controlling_state_via_mqtt_rgbww_tuya(hass, mqtt_mock, setup_tasmota): async def test_controlling_state_via_mqtt_rgbww_tuya(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -723,7 +754,9 @@ async def test_controlling_state_via_mqtt_rgbww_tuya(hass, mqtt_mock, setup_tasm
assert state.state == STATE_OFF assert state.state == STATE_OFF
async def test_sending_mqtt_commands_on_off(hass, mqtt_mock, setup_tasmota): async def test_sending_mqtt_commands_on_off(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test the sending MQTT commands.""" """Test the sending MQTT commands."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 1 config["rl"][0] = 1
@ -764,7 +797,9 @@ async def test_sending_mqtt_commands_on_off(hass, mqtt_mock, setup_tasmota):
mqtt_mock.async_publish.reset_mock() mqtt_mock.async_publish.reset_mock()
async def test_sending_mqtt_commands_rgbww_tuya(hass, mqtt_mock, setup_tasmota): async def test_sending_mqtt_commands_rgbww_tuya(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test the sending MQTT commands.""" """Test the sending MQTT commands."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -812,7 +847,9 @@ async def test_sending_mqtt_commands_rgbww_tuya(hass, mqtt_mock, setup_tasmota):
) )
async def test_sending_mqtt_commands_rgbw_legacy(hass, mqtt_mock, setup_tasmota): async def test_sending_mqtt_commands_rgbw_legacy(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test the sending MQTT commands.""" """Test the sending MQTT commands."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["sw"] = "9.4.0.3" # RGBW support was added in 9.4.0.4 config["sw"] = "9.4.0.3" # RGBW support was added in 9.4.0.4
@ -910,7 +947,9 @@ async def test_sending_mqtt_commands_rgbw_legacy(hass, mqtt_mock, setup_tasmota)
mqtt_mock.async_publish.reset_mock() mqtt_mock.async_publish.reset_mock()
async def test_sending_mqtt_commands_rgbw(hass, mqtt_mock, setup_tasmota): async def test_sending_mqtt_commands_rgbw(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test the sending MQTT commands.""" """Test the sending MQTT commands."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -1007,7 +1046,9 @@ async def test_sending_mqtt_commands_rgbw(hass, mqtt_mock, setup_tasmota):
mqtt_mock.async_publish.reset_mock() mqtt_mock.async_publish.reset_mock()
async def test_sending_mqtt_commands_rgbww(hass, mqtt_mock, setup_tasmota): async def test_sending_mqtt_commands_rgbww(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test the sending MQTT commands.""" """Test the sending MQTT commands."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -1082,7 +1123,9 @@ async def test_sending_mqtt_commands_rgbww(hass, mqtt_mock, setup_tasmota):
mqtt_mock.async_publish.reset_mock() mqtt_mock.async_publish.reset_mock()
async def test_sending_mqtt_commands_power_unlinked(hass, mqtt_mock, setup_tasmota): async def test_sending_mqtt_commands_power_unlinked(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test the sending MQTT commands to a light with unlinked dimlevel and power.""" """Test the sending MQTT commands to a light with unlinked dimlevel and power."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -1134,7 +1177,9 @@ async def test_sending_mqtt_commands_power_unlinked(hass, mqtt_mock, setup_tasmo
mqtt_mock.async_publish.reset_mock() mqtt_mock.async_publish.reset_mock()
async def test_transition(hass, mqtt_mock, setup_tasmota): async def test_transition(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test transition commands.""" """Test transition commands."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -1324,7 +1369,9 @@ async def test_transition(hass, mqtt_mock, setup_tasmota):
mqtt_mock.async_publish.reset_mock() mqtt_mock.async_publish.reset_mock()
async def test_transition_fixed(hass, mqtt_mock, setup_tasmota): async def test_transition_fixed(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test transition commands.""" """Test transition commands."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -1398,7 +1445,9 @@ async def test_transition_fixed(hass, mqtt_mock, setup_tasmota):
mqtt_mock.async_publish.reset_mock() mqtt_mock.async_publish.reset_mock()
async def test_relay_as_light(hass, mqtt_mock, setup_tasmota): async def test_relay_as_light(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test relay show up as light in light mode.""" """Test relay show up as light in light mode."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 1 config["rl"][0] = 1
@ -1459,7 +1508,9 @@ async def _test_split_light(hass, mqtt_mock, config, num_lights, num_switches):
) )
async def test_split_light(hass, mqtt_mock, setup_tasmota): async def test_split_light(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test multi-channel light split to single-channel dimmers.""" """Test multi-channel light split to single-channel dimmers."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -1473,7 +1524,9 @@ async def test_split_light(hass, mqtt_mock, setup_tasmota):
await _test_split_light(hass, mqtt_mock, config, 5, 0) await _test_split_light(hass, mqtt_mock, config, 5, 0)
async def test_split_light2(hass, mqtt_mock, setup_tasmota): async def test_split_light2(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test multi-channel light split to single-channel dimmers.""" """Test multi-channel light split to single-channel dimmers."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 1 config["rl"][0] = 1
@ -1531,7 +1584,9 @@ async def _test_unlinked_light(hass, mqtt_mock, config, num_switches):
) )
async def test_unlinked_light(hass, mqtt_mock, setup_tasmota): async def test_unlinked_light(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test rgbww light split to rgb+ww.""" """Test rgbww light split to rgb+ww."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -1542,7 +1597,9 @@ async def test_unlinked_light(hass, mqtt_mock, setup_tasmota):
await _test_unlinked_light(hass, mqtt_mock, config, 0) await _test_unlinked_light(hass, mqtt_mock, config, 0)
async def test_unlinked_light2(hass, mqtt_mock, setup_tasmota): async def test_unlinked_light2(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test rgbww light split to rgb+ww.""" """Test rgbww light split to rgb+ww."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 1 config["rl"][0] = 1
@ -1556,8 +1613,11 @@ async def test_unlinked_light2(hass, mqtt_mock, setup_tasmota):
async def test_discovery_update_reconfigure_light( async def test_discovery_update_reconfigure_light(
hass, mqtt_mock, caplog, setup_tasmota hass: HomeAssistant,
): mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
setup_tasmota,
) -> None:
"""Test reconfigure of discovered light.""" """Test reconfigure of discovered light."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -1587,8 +1647,11 @@ async def test_discovery_update_reconfigure_light(
async def test_availability_when_connection_lost( async def test_availability_when_connection_lost(
hass, mqtt_client_mock, mqtt_mock, setup_tasmota hass: HomeAssistant,
): mqtt_client_mock: MqttMockPahoClient,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test availability after MQTT disconnection.""" """Test availability after MQTT disconnection."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -1598,7 +1661,9 @@ async def test_availability_when_connection_lost(
) )
async def test_availability(hass, mqtt_mock, setup_tasmota): async def test_availability(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test availability.""" """Test availability."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -1606,7 +1671,9 @@ async def test_availability(hass, mqtt_mock, setup_tasmota):
await help_test_availability(hass, mqtt_mock, Platform.LIGHT, config) await help_test_availability(hass, mqtt_mock, Platform.LIGHT, config)
async def test_availability_discovery_update(hass, mqtt_mock, setup_tasmota): async def test_availability_discovery_update(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test availability discovery update.""" """Test availability discovery update."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -1617,8 +1684,11 @@ async def test_availability_discovery_update(hass, mqtt_mock, setup_tasmota):
async def test_availability_poll_state( async def test_availability_poll_state(
hass, mqtt_client_mock, mqtt_mock, setup_tasmota hass: HomeAssistant,
): mqtt_client_mock: MqttMockPahoClient,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test polling after MQTT connection (re)established.""" """Test polling after MQTT connection (re)established."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -1629,7 +1699,12 @@ async def test_availability_poll_state(
) )
async def test_discovery_removal_light(hass, mqtt_mock, caplog, setup_tasmota): async def test_discovery_removal_light(
hass: HomeAssistant,
mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
setup_tasmota,
) -> None:
"""Test removal of discovered light.""" """Test removal of discovered light."""
config1 = copy.deepcopy(DEFAULT_CONFIG) config1 = copy.deepcopy(DEFAULT_CONFIG)
config1["rl"][0] = 2 config1["rl"][0] = 2
@ -1643,7 +1718,12 @@ async def test_discovery_removal_light(hass, mqtt_mock, caplog, setup_tasmota):
) )
async def test_discovery_removal_relay_as_light(hass, mqtt_mock, caplog, setup_tasmota): async def test_discovery_removal_relay_as_light(
hass: HomeAssistant,
mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
setup_tasmota,
) -> None:
"""Test removal of discovered relay as light.""" """Test removal of discovered relay as light."""
config1 = copy.deepcopy(DEFAULT_CONFIG) config1 = copy.deepcopy(DEFAULT_CONFIG)
config1["rl"][0] = 1 config1["rl"][0] = 1
@ -1658,8 +1738,11 @@ async def test_discovery_removal_relay_as_light(hass, mqtt_mock, caplog, setup_t
async def test_discovery_removal_relay_as_light2( async def test_discovery_removal_relay_as_light2(
hass, mqtt_mock, caplog, setup_tasmota hass: HomeAssistant,
): mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
setup_tasmota,
) -> None:
"""Test removal of discovered relay as light.""" """Test removal of discovered relay as light."""
config1 = copy.deepcopy(DEFAULT_CONFIG) config1 = copy.deepcopy(DEFAULT_CONFIG)
config1["rl"][0] = 1 config1["rl"][0] = 1
@ -1673,7 +1756,12 @@ async def test_discovery_removal_relay_as_light2(
) )
async def test_discovery_update_unchanged_light(hass, mqtt_mock, caplog, setup_tasmota): async def test_discovery_update_unchanged_light(
hass: HomeAssistant,
mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
setup_tasmota,
) -> None:
"""Test update of discovered light.""" """Test update of discovered light."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -1686,7 +1774,9 @@ async def test_discovery_update_unchanged_light(hass, mqtt_mock, caplog, setup_t
) )
async def test_discovery_device_remove(hass, mqtt_mock, setup_tasmota): async def test_discovery_device_remove(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test device registry remove.""" """Test device registry remove."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -1697,7 +1787,9 @@ async def test_discovery_device_remove(hass, mqtt_mock, setup_tasmota):
) )
async def test_discovery_device_remove_relay_as_light(hass, mqtt_mock, setup_tasmota): async def test_discovery_device_remove_relay_as_light(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test device registry remove.""" """Test device registry remove."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 1 config["rl"][0] = 1
@ -1708,7 +1800,9 @@ async def test_discovery_device_remove_relay_as_light(hass, mqtt_mock, setup_tas
) )
async def test_entity_id_update_subscriptions(hass, mqtt_mock, setup_tasmota): async def test_entity_id_update_subscriptions(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test MQTT subscriptions are managed when entity_id is updated.""" """Test MQTT subscriptions are managed when entity_id is updated."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2
@ -1723,7 +1817,9 @@ async def test_entity_id_update_subscriptions(hass, mqtt_mock, setup_tasmota):
) )
async def test_entity_id_update_discovery_update(hass, mqtt_mock, setup_tasmota): async def test_entity_id_update_discovery_update(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test MQTT discovery update when entity_id is updated.""" """Test MQTT discovery update when entity_id is updated."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 2 config["rl"][0] = 2

9
tests/components/tasmota/test_mixins.py
View file

@ -7,15 +7,20 @@ from hatasmota.const import CONF_MAC
from hatasmota.utils import config_get_state_online, get_topic_tele_will from hatasmota.utils import config_get_state_online, get_topic_tele_will
from homeassistant.components.tasmota.const import DEFAULT_PREFIX from homeassistant.components.tasmota.const import DEFAULT_PREFIX
from homeassistant.core import HomeAssistant
from .test_common import DEFAULT_CONFIG from .test_common import DEFAULT_CONFIG
from tests.common import async_fire_mqtt_message from tests.common import async_fire_mqtt_message
from tests.typing import MqttMockHAClient, MqttMockPahoClient
async def test_availability_poll_state_once( async def test_availability_poll_state_once(
hass, mqtt_client_mock, mqtt_mock, setup_tasmota hass: HomeAssistant,
): mqtt_client_mock: MqttMockPahoClient,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test several entities send a single message to update state.""" """Test several entities send a single message to update state."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 1 config["rl"][0] = 1

111
tests/components/tasmota/test_sensor.py
View file

@ -17,6 +17,7 @@ from homeassistant import config_entries
from homeassistant.components.sensor import ATTR_STATE_CLASS, SensorStateClass from homeassistant.components.sensor import ATTR_STATE_CLASS, SensorStateClass
from homeassistant.components.tasmota.const import DEFAULT_PREFIX from homeassistant.components.tasmota.const import DEFAULT_PREFIX
from homeassistant.const import ATTR_ASSUMED_STATE, STATE_UNKNOWN, Platform from homeassistant.const import ATTR_ASSUMED_STATE, STATE_UNKNOWN, Platform
from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er from homeassistant.helpers import entity_registry as er
from homeassistant.util import dt from homeassistant.util import dt
@ -35,6 +36,7 @@ from .test_common import (
) )
from tests.common import async_fire_mqtt_message, async_fire_time_changed from tests.common import async_fire_mqtt_message, async_fire_time_changed
from tests.typing import MqttMockHAClient, MqttMockPahoClient
BAD_INDEXED_SENSOR_CONFIG_3 = { BAD_INDEXED_SENSOR_CONFIG_3 = {
"sn": { "sn": {
@ -118,7 +120,9 @@ NESTED_SENSOR_CONFIG = {
} }
async def test_controlling_state_via_mqtt(hass, mqtt_mock, setup_tasmota): async def test_controlling_state_via_mqtt(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
sensor_config = copy.deepcopy(DEFAULT_SENSOR_CONFIG) sensor_config = copy.deepcopy(DEFAULT_SENSOR_CONFIG)
@ -170,7 +174,9 @@ async def test_controlling_state_via_mqtt(hass, mqtt_mock, setup_tasmota):
assert state.state == "20.0" assert state.state == "20.0"
async def test_nested_sensor_state_via_mqtt(hass, mqtt_mock, setup_tasmota): async def test_nested_sensor_state_via_mqtt(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
sensor_config = copy.deepcopy(NESTED_SENSOR_CONFIG) sensor_config = copy.deepcopy(NESTED_SENSOR_CONFIG)
@ -216,7 +222,9 @@ async def test_nested_sensor_state_via_mqtt(hass, mqtt_mock, setup_tasmota):
assert state.state == "23.4" assert state.state == "23.4"
async def test_indexed_sensor_state_via_mqtt(hass, mqtt_mock, setup_tasmota): async def test_indexed_sensor_state_via_mqtt(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
sensor_config = copy.deepcopy(INDEXED_SENSOR_CONFIG) sensor_config = copy.deepcopy(INDEXED_SENSOR_CONFIG)
@ -262,7 +270,9 @@ async def test_indexed_sensor_state_via_mqtt(hass, mqtt_mock, setup_tasmota):
assert state.state == "7.8" assert state.state == "7.8"
async def test_indexed_sensor_state_via_mqtt2(hass, mqtt_mock, setup_tasmota): async def test_indexed_sensor_state_via_mqtt2(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT for sensor with last_reset property.""" """Test state update via MQTT for sensor with last_reset property."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
sensor_config = copy.deepcopy(INDEXED_SENSOR_CONFIG) sensor_config = copy.deepcopy(INDEXED_SENSOR_CONFIG)
@ -311,7 +321,9 @@ async def test_indexed_sensor_state_via_mqtt2(hass, mqtt_mock, setup_tasmota):
assert state.state == "5.6" assert state.state == "5.6"
async def test_indexed_sensor_state_via_mqtt3(hass, mqtt_mock, setup_tasmota): async def test_indexed_sensor_state_via_mqtt3(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT for indexed sensor with last_reset property.""" """Test state update via MQTT for indexed sensor with last_reset property."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
sensor_config = copy.deepcopy(INDEXED_SENSOR_CONFIG_2) sensor_config = copy.deepcopy(INDEXED_SENSOR_CONFIG_2)
@ -360,7 +372,9 @@ async def test_indexed_sensor_state_via_mqtt3(hass, mqtt_mock, setup_tasmota):
assert state.state == "7.8" assert state.state == "7.8"
async def test_bad_indexed_sensor_state_via_mqtt(hass, mqtt_mock, setup_tasmota): async def test_bad_indexed_sensor_state_via_mqtt(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT where sensor is not matching configuration.""" """Test state update via MQTT where sensor is not matching configuration."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
sensor_config = copy.deepcopy(BAD_INDEXED_SENSOR_CONFIG_3) sensor_config = copy.deepcopy(BAD_INDEXED_SENSOR_CONFIG_3)
@ -473,7 +487,9 @@ async def test_bad_indexed_sensor_state_via_mqtt(hass, mqtt_mock, setup_tasmota)
@pytest.mark.parametrize("status_sensor_disabled", [False]) @pytest.mark.parametrize("status_sensor_disabled", [False])
async def test_status_sensor_state_via_mqtt(hass, mqtt_mock, setup_tasmota): async def test_status_sensor_state_via_mqtt(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
entity_reg = er.async_get(hass) entity_reg = er.async_get(hass)
@ -533,7 +549,9 @@ async def test_status_sensor_state_via_mqtt(hass, mqtt_mock, setup_tasmota):
@pytest.mark.parametrize("status_sensor_disabled", [False]) @pytest.mark.parametrize("status_sensor_disabled", [False])
async def test_single_shot_status_sensor_state_via_mqtt(hass, mqtt_mock, setup_tasmota): async def test_single_shot_status_sensor_state_via_mqtt(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
entity_reg = er.async_get(hass) entity_reg = er.async_get(hass)
@ -617,8 +635,8 @@ async def test_single_shot_status_sensor_state_via_mqtt(hass, mqtt_mock, setup_t
@pytest.mark.parametrize("status_sensor_disabled", [False]) @pytest.mark.parametrize("status_sensor_disabled", [False])
@patch.object(hatasmota.status_sensor, "datetime", Mock(wraps=datetime.datetime)) @patch.object(hatasmota.status_sensor, "datetime", Mock(wraps=datetime.datetime))
async def test_restart_time_status_sensor_state_via_mqtt( async def test_restart_time_status_sensor_state_via_mqtt(
hass, mqtt_mock, setup_tasmota hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
): ) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
entity_reg = er.async_get(hass) entity_reg = er.async_get(hass)
@ -665,7 +683,9 @@ async def test_restart_time_status_sensor_state_via_mqtt(
assert state.state == "2020-11-11T07:00:00+00:00" assert state.state == "2020-11-11T07:00:00+00:00"
async def test_attributes(hass, mqtt_mock, setup_tasmota): async def test_attributes(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test correct attributes for sensors.""" """Test correct attributes for sensors."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
sensor_config = { sensor_config = {
@ -703,7 +723,9 @@ async def test_attributes(hass, mqtt_mock, setup_tasmota):
assert state.attributes.get("unit_of_measurement") == "ppm" assert state.attributes.get("unit_of_measurement") == "ppm"
async def test_nested_sensor_attributes(hass, mqtt_mock, setup_tasmota): async def test_nested_sensor_attributes(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test correct attributes for sensors.""" """Test correct attributes for sensors."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
sensor_config = copy.deepcopy(NESTED_SENSOR_CONFIG) sensor_config = copy.deepcopy(NESTED_SENSOR_CONFIG)
@ -735,7 +757,9 @@ async def test_nested_sensor_attributes(hass, mqtt_mock, setup_tasmota):
assert state.attributes.get("unit_of_measurement") == " " assert state.attributes.get("unit_of_measurement") == " "
async def test_indexed_sensor_attributes(hass, mqtt_mock, setup_tasmota): async def test_indexed_sensor_attributes(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test correct attributes for sensors.""" """Test correct attributes for sensors."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
sensor_config = { sensor_config = {
@ -788,8 +812,13 @@ async def test_indexed_sensor_attributes(hass, mqtt_mock, setup_tasmota):
], ],
) )
async def test_diagnostic_sensors( async def test_diagnostic_sensors(
hass, mqtt_mock, setup_tasmota, sensor_name, disabled, disabled_by hass: HomeAssistant,
): mqtt_mock: MqttMockHAClient,
setup_tasmota,
sensor_name,
disabled,
disabled_by,
) -> None:
"""Test properties of diagnostic sensors.""" """Test properties of diagnostic sensors."""
entity_reg = er.async_get(hass) entity_reg = er.async_get(hass)
@ -813,7 +842,9 @@ async def test_diagnostic_sensors(
@pytest.mark.parametrize("status_sensor_disabled", [False]) @pytest.mark.parametrize("status_sensor_disabled", [False])
async def test_enable_status_sensor(hass, mqtt_mock, setup_tasmota): async def test_enable_status_sensor(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test enabling status sensor.""" """Test enabling status sensor."""
entity_reg = er.async_get(hass) entity_reg = er.async_get(hass)
@ -868,8 +899,11 @@ async def test_enable_status_sensor(hass, mqtt_mock, setup_tasmota):
async def test_availability_when_connection_lost( async def test_availability_when_connection_lost(
hass, mqtt_client_mock, mqtt_mock, setup_tasmota hass: HomeAssistant,
): mqtt_client_mock: MqttMockPahoClient,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test availability after MQTT disconnection.""" """Test availability after MQTT disconnection."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
sensor_config = copy.deepcopy(DEFAULT_SENSOR_CONFIG) sensor_config = copy.deepcopy(DEFAULT_SENSOR_CONFIG)
@ -884,7 +918,9 @@ async def test_availability_when_connection_lost(
) )
async def test_availability(hass, mqtt_mock, setup_tasmota): async def test_availability(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test availability.""" """Test availability."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
sensor_config = copy.deepcopy(DEFAULT_SENSOR_CONFIG) sensor_config = copy.deepcopy(DEFAULT_SENSOR_CONFIG)
@ -898,7 +934,9 @@ async def test_availability(hass, mqtt_mock, setup_tasmota):
) )
async def test_availability_discovery_update(hass, mqtt_mock, setup_tasmota): async def test_availability_discovery_update(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test availability discovery update.""" """Test availability discovery update."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
sensor_config = copy.deepcopy(DEFAULT_SENSOR_CONFIG) sensor_config = copy.deepcopy(DEFAULT_SENSOR_CONFIG)
@ -913,8 +951,11 @@ async def test_availability_discovery_update(hass, mqtt_mock, setup_tasmota):
async def test_availability_poll_state( async def test_availability_poll_state(
hass, mqtt_client_mock, mqtt_mock, setup_tasmota hass: HomeAssistant,
): mqtt_client_mock: MqttMockPahoClient,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test polling after MQTT connection (re)established.""" """Test polling after MQTT connection (re)established."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
sensor_config = copy.deepcopy(DEFAULT_SENSOR_CONFIG) sensor_config = copy.deepcopy(DEFAULT_SENSOR_CONFIG)
@ -931,7 +972,12 @@ async def test_availability_poll_state(
) )
async def test_discovery_removal_sensor(hass, mqtt_mock, caplog, setup_tasmota): async def test_discovery_removal_sensor(
hass: HomeAssistant,
mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
setup_tasmota,
) -> None:
"""Test removal of discovered sensor.""" """Test removal of discovered sensor."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
sensor_config1 = copy.deepcopy(DEFAULT_SENSOR_CONFIG) sensor_config1 = copy.deepcopy(DEFAULT_SENSOR_CONFIG)
@ -951,8 +997,11 @@ async def test_discovery_removal_sensor(hass, mqtt_mock, caplog, setup_tasmota):
async def test_discovery_update_unchanged_sensor( async def test_discovery_update_unchanged_sensor(
hass, mqtt_mock, caplog, setup_tasmota hass: HomeAssistant,
): mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
setup_tasmota,
) -> None:
"""Test update of discovered sensor.""" """Test update of discovered sensor."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
sensor_config = copy.deepcopy(DEFAULT_SENSOR_CONFIG) sensor_config = copy.deepcopy(DEFAULT_SENSOR_CONFIG)
@ -972,7 +1021,9 @@ async def test_discovery_update_unchanged_sensor(
) )
async def test_discovery_device_remove(hass, mqtt_mock, setup_tasmota): async def test_discovery_device_remove(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test device registry remove.""" """Test device registry remove."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
sensor_config = copy.deepcopy(DEFAULT_SENSOR_CONFIG) sensor_config = copy.deepcopy(DEFAULT_SENSOR_CONFIG)
@ -982,7 +1033,9 @@ async def test_discovery_device_remove(hass, mqtt_mock, setup_tasmota):
) )
async def test_entity_id_update_subscriptions(hass, mqtt_mock, setup_tasmota): async def test_entity_id_update_subscriptions(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test MQTT subscriptions are managed when entity_id is updated.""" """Test MQTT subscriptions are managed when entity_id is updated."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
sensor_config = copy.deepcopy(DEFAULT_SENSOR_CONFIG) sensor_config = copy.deepcopy(DEFAULT_SENSOR_CONFIG)
@ -1002,7 +1055,9 @@ async def test_entity_id_update_subscriptions(hass, mqtt_mock, setup_tasmota):
) )
async def test_entity_id_update_discovery_update(hass, mqtt_mock, setup_tasmota): async def test_entity_id_update_discovery_update(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test MQTT discovery update when entity_id is updated.""" """Test MQTT discovery update when entity_id is updated."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
sensor_config = copy.deepcopy(DEFAULT_SENSOR_CONFIG) sensor_config = copy.deepcopy(DEFAULT_SENSOR_CONFIG)

70
tests/components/tasmota/test_switch.py
View file

@ -8,9 +8,11 @@ from hatasmota.utils import (
get_topic_tele_state, get_topic_tele_state,
get_topic_tele_will, get_topic_tele_will,
) )
import pytest
from homeassistant.components.tasmota.const import DEFAULT_PREFIX from homeassistant.components.tasmota.const import DEFAULT_PREFIX
from homeassistant.const import ATTR_ASSUMED_STATE, STATE_OFF, STATE_ON, Platform from homeassistant.const import ATTR_ASSUMED_STATE, STATE_OFF, STATE_ON, Platform
from homeassistant.core import HomeAssistant
from .test_common import ( from .test_common import (
DEFAULT_CONFIG, DEFAULT_CONFIG,
@ -27,9 +29,12 @@ from .test_common import (
from tests.common import async_fire_mqtt_message from tests.common import async_fire_mqtt_message
from tests.components.switch import common from tests.components.switch import common
from tests.typing import MqttMockHAClient, MqttMockPahoClient
async def test_controlling_state_via_mqtt(hass, mqtt_mock, setup_tasmota): async def test_controlling_state_via_mqtt(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test state update via MQTT.""" """Test state update via MQTT."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 1 config["rl"][0] = 1
@ -73,7 +78,9 @@ async def test_controlling_state_via_mqtt(hass, mqtt_mock, setup_tasmota):
assert state.state == STATE_OFF assert state.state == STATE_OFF
async def test_sending_mqtt_commands(hass, mqtt_mock, setup_tasmota): async def test_sending_mqtt_commands(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test the sending MQTT commands.""" """Test the sending MQTT commands."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 1 config["rl"][0] = 1
@ -115,7 +122,9 @@ async def test_sending_mqtt_commands(hass, mqtt_mock, setup_tasmota):
assert state.state == STATE_OFF assert state.state == STATE_OFF
async def test_relay_as_light(hass, mqtt_mock, setup_tasmota): async def test_relay_as_light(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test relay does not show up as switch in light mode.""" """Test relay does not show up as switch in light mode."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 1 config["rl"][0] = 1
@ -136,8 +145,11 @@ async def test_relay_as_light(hass, mqtt_mock, setup_tasmota):
async def test_availability_when_connection_lost( async def test_availability_when_connection_lost(
hass, mqtt_client_mock, mqtt_mock, setup_tasmota hass: HomeAssistant,
): mqtt_client_mock: MqttMockPahoClient,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test availability after MQTT disconnection.""" """Test availability after MQTT disconnection."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 1 config["rl"][0] = 1
@ -146,14 +158,18 @@ async def test_availability_when_connection_lost(
) )
async def test_availability(hass, mqtt_mock, setup_tasmota): async def test_availability(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test availability.""" """Test availability."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 1 config["rl"][0] = 1
await help_test_availability(hass, mqtt_mock, Platform.SWITCH, config) await help_test_availability(hass, mqtt_mock, Platform.SWITCH, config)
async def test_availability_discovery_update(hass, mqtt_mock, setup_tasmota): async def test_availability_discovery_update(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test availability discovery update.""" """Test availability discovery update."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 1 config["rl"][0] = 1
@ -163,8 +179,11 @@ async def test_availability_discovery_update(hass, mqtt_mock, setup_tasmota):
async def test_availability_poll_state( async def test_availability_poll_state(
hass, mqtt_client_mock, mqtt_mock, setup_tasmota hass: HomeAssistant,
): mqtt_client_mock: MqttMockPahoClient,
mqtt_mock: MqttMockHAClient,
setup_tasmota,
) -> None:
"""Test polling after MQTT connection (re)established.""" """Test polling after MQTT connection (re)established."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 1 config["rl"][0] = 1
@ -174,7 +193,12 @@ async def test_availability_poll_state(
) )
async def test_discovery_removal_switch(hass, mqtt_mock, caplog, setup_tasmota): async def test_discovery_removal_switch(
hass: HomeAssistant,
mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
setup_tasmota,
) -> None:
"""Test removal of discovered switch.""" """Test removal of discovered switch."""
config1 = copy.deepcopy(DEFAULT_CONFIG) config1 = copy.deepcopy(DEFAULT_CONFIG)
config1["rl"][0] = 1 config1["rl"][0] = 1
@ -186,7 +210,12 @@ async def test_discovery_removal_switch(hass, mqtt_mock, caplog, setup_tasmota):
) )
async def test_discovery_removal_relay_as_light(hass, mqtt_mock, caplog, setup_tasmota): async def test_discovery_removal_relay_as_light(
hass: HomeAssistant,
mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
setup_tasmota,
) -> None:
"""Test removal of discovered relay as light.""" """Test removal of discovered relay as light."""
config1 = copy.deepcopy(DEFAULT_CONFIG) config1 = copy.deepcopy(DEFAULT_CONFIG)
config1["rl"][0] = 1 config1["rl"][0] = 1
@ -201,8 +230,11 @@ async def test_discovery_removal_relay_as_light(hass, mqtt_mock, caplog, setup_t
async def test_discovery_update_unchanged_switch( async def test_discovery_update_unchanged_switch(
hass, mqtt_mock, caplog, setup_tasmota hass: HomeAssistant,
): mqtt_mock: MqttMockHAClient,
caplog: pytest.LogCaptureFixture,
setup_tasmota,
) -> None:
"""Test update of discovered switch.""" """Test update of discovered switch."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 1 config["rl"][0] = 1
@ -214,7 +246,9 @@ async def test_discovery_update_unchanged_switch(
) )
async def test_discovery_device_remove(hass, mqtt_mock, setup_tasmota): async def test_discovery_device_remove(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test device registry remove.""" """Test device registry remove."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 1 config["rl"][0] = 1
@ -224,7 +258,9 @@ async def test_discovery_device_remove(hass, mqtt_mock, setup_tasmota):
) )
async def test_entity_id_update_subscriptions(hass, mqtt_mock, setup_tasmota): async def test_entity_id_update_subscriptions(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test MQTT subscriptions are managed when entity_id is updated.""" """Test MQTT subscriptions are managed when entity_id is updated."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 1 config["rl"][0] = 1
@ -238,7 +274,9 @@ async def test_entity_id_update_subscriptions(hass, mqtt_mock, setup_tasmota):
) )
async def test_entity_id_update_discovery_update(hass, mqtt_mock, setup_tasmota): async def test_entity_id_update_discovery_update(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient, setup_tasmota
) -> None:
"""Test MQTT discovery update when entity_id is updated.""" """Test MQTT discovery update when entity_id is updated."""
config = copy.deepcopy(DEFAULT_CONFIG) config = copy.deepcopy(DEFAULT_CONFIG)
config["rl"][0] = 1 config["rl"][0] = 1

7
tests/components/tcp/test_binary_sensor.py
View file

@ -5,6 +5,7 @@ from unittest.mock import call, patch
import pytest import pytest
from homeassistant.const import STATE_OFF, STATE_ON from homeassistant.const import STATE_OFF, STATE_ON
from homeassistant.core import HomeAssistant
from homeassistant.setup import async_setup_component from homeassistant.setup import async_setup_component
from homeassistant.util.dt import utcnow from homeassistant.util.dt import utcnow
@ -36,14 +37,14 @@ def now():
return utcnow() return utcnow()
async def test_setup_platform_valid_config(hass, mock_socket): async def test_setup_platform_valid_config(hass: HomeAssistant, mock_socket) -> None:
"""Check a valid configuration.""" """Check a valid configuration."""
with assert_setup_component(1, "binary_sensor"): with assert_setup_component(1, "binary_sensor"):
assert await async_setup_component(hass, "binary_sensor", TEST_CONFIG) assert await async_setup_component(hass, "binary_sensor", TEST_CONFIG)
await hass.async_block_till_done() await hass.async_block_till_done()
async def test_setup_platform_invalid_config(hass, mock_socket): async def test_setup_platform_invalid_config(hass: HomeAssistant, mock_socket) -> None:
"""Check the invalid configuration.""" """Check the invalid configuration."""
with assert_setup_component(0): with assert_setup_component(0):
assert await async_setup_component( assert await async_setup_component(
@ -54,7 +55,7 @@ async def test_setup_platform_invalid_config(hass, mock_socket):
await hass.async_block_till_done() await hass.async_block_till_done()
async def test_state(hass, mock_socket, now): async def test_state(hass: HomeAssistant, mock_socket, now) -> None:
"""Check the state and update of the binary sensor.""" """Check the state and update of the binary sensor."""
mock_socket.recv.return_value = b"off" mock_socket.recv.return_value = b"off"
assert await async_setup_component(hass, "binary_sensor", TEST_CONFIG) assert await async_setup_component(hass, "binary_sensor", TEST_CONFIG)

27
tests/components/tcp/test_sensor.py
View file

@ -5,6 +5,7 @@ from unittest.mock import call, patch
import pytest import pytest
import homeassistant.components.tcp.common as tcp import homeassistant.components.tcp.common as tcp
from homeassistant.core import HomeAssistant
from homeassistant.setup import async_setup_component from homeassistant.setup import async_setup_component
from tests.common import assert_setup_component from tests.common import assert_setup_component
@ -69,14 +70,14 @@ def mock_ssl_context_fixture():
yield mock_ssl_context yield mock_ssl_context
async def test_setup_platform_valid_config(hass, mock_socket): async def test_setup_platform_valid_config(hass: HomeAssistant, mock_socket) -> None:
"""Check a valid configuration and call add_entities with sensor.""" """Check a valid configuration and call add_entities with sensor."""
with assert_setup_component(1, "sensor"): with assert_setup_component(1, "sensor"):
assert await async_setup_component(hass, "sensor", TEST_CONFIG) assert await async_setup_component(hass, "sensor", TEST_CONFIG)
await hass.async_block_till_done() await hass.async_block_till_done()
async def test_setup_platform_invalid_config(hass, mock_socket): async def test_setup_platform_invalid_config(hass: HomeAssistant, mock_socket) -> None:
"""Check an invalid configuration.""" """Check an invalid configuration."""
with assert_setup_component(0): with assert_setup_component(0):
assert await async_setup_component( assert await async_setup_component(
@ -85,7 +86,7 @@ async def test_setup_platform_invalid_config(hass, mock_socket):
await hass.async_block_till_done() await hass.async_block_till_done()
async def test_state(hass, mock_socket, mock_select): async def test_state(hass: HomeAssistant, mock_socket, mock_select) -> None:
"""Return the contents of _state.""" """Return the contents of _state."""
assert await async_setup_component(hass, "sensor", TEST_CONFIG) assert await async_setup_component(hass, "sensor", TEST_CONFIG)
await hass.async_block_till_done() await hass.async_block_till_done()
@ -111,7 +112,7 @@ async def test_state(hass, mock_socket, mock_select):
assert mock_socket.recv.call_args == call(SENSOR_TEST_CONFIG["buffer_size"]) assert mock_socket.recv.call_args == call(SENSOR_TEST_CONFIG["buffer_size"])
async def test_config_uses_defaults(hass, mock_socket): async def test_config_uses_defaults(hass: HomeAssistant, mock_socket) -> None:
"""Check if defaults were set.""" """Check if defaults were set."""
config = copy(SENSOR_TEST_CONFIG) config = copy(SENSOR_TEST_CONFIG)
@ -132,7 +133,7 @@ async def test_config_uses_defaults(hass, mock_socket):
@pytest.mark.parametrize("sock_attr", ["connect", "send"]) @pytest.mark.parametrize("sock_attr", ["connect", "send"])
async def test_update_socket_error(hass, mock_socket, sock_attr): async def test_update_socket_error(hass: HomeAssistant, mock_socket, sock_attr) -> None:
"""Test socket errors during update.""" """Test socket errors during update."""
socket_method = getattr(mock_socket, sock_attr) socket_method = getattr(mock_socket, sock_attr)
socket_method.side_effect = OSError("Boom") socket_method.side_effect = OSError("Boom")
@ -146,7 +147,9 @@ async def test_update_socket_error(hass, mock_socket, sock_attr):
assert state.state == "unknown" assert state.state == "unknown"
async def test_update_select_fails(hass, mock_socket, mock_select): async def test_update_select_fails(
hass: HomeAssistant, mock_socket, mock_select
) -> None:
"""Test select fails to return a socket for reading.""" """Test select fails to return a socket for reading."""
mock_select.return_value = (False, False, False) mock_select.return_value = (False, False, False)
@ -159,7 +162,9 @@ async def test_update_select_fails(hass, mock_socket, mock_select):
assert state.state == "unknown" assert state.state == "unknown"
async def test_update_returns_if_template_render_fails(hass, mock_socket): async def test_update_returns_if_template_render_fails(
hass: HomeAssistant, mock_socket
) -> None:
"""Return None if rendering the template fails.""" """Return None if rendering the template fails."""
config = copy(SENSOR_TEST_CONFIG) config = copy(SENSOR_TEST_CONFIG)
config[tcp.CONF_VALUE_TEMPLATE] = "{{ value / 0 }}" config[tcp.CONF_VALUE_TEMPLATE] = "{{ value / 0 }}"
@ -173,7 +178,9 @@ async def test_update_returns_if_template_render_fails(hass, mock_socket):
assert state.state == "unknown" assert state.state == "unknown"
async def test_ssl_state(hass, mock_socket, mock_select, mock_ssl_context): async def test_ssl_state(
hass: HomeAssistant, mock_socket, mock_select, mock_ssl_context
) -> None:
"""Return the contents of _state, updated over SSL.""" """Return the contents of _state, updated over SSL."""
config = copy(SENSOR_TEST_CONFIG) config = copy(SENSOR_TEST_CONFIG)
config[tcp.CONF_SSL] = "on" config[tcp.CONF_SSL] = "on"
@ -204,7 +211,9 @@ async def test_ssl_state(hass, mock_socket, mock_select, mock_ssl_context):
assert mock_ssl_socket.recv.call_args == call(SENSOR_TEST_CONFIG["buffer_size"]) assert mock_ssl_socket.recv.call_args == call(SENSOR_TEST_CONFIG["buffer_size"])
async def test_ssl_state_verify_off(hass, mock_socket, mock_select, mock_ssl_context): async def test_ssl_state_verify_off(
hass: HomeAssistant, mock_socket, mock_select, mock_ssl_context
) -> None:
"""Return the contents of _state, updated over SSL (verify_ssl disabled).""" """Return the contents of _state, updated over SSL (verify_ssl disabled)."""
config = copy(SENSOR_TEST_CONFIG) config = copy(SENSOR_TEST_CONFIG)
config[tcp.CONF_SSL] = "on" config[tcp.CONF_SSL] = "on"

38
tests/components/telegram_bot/test_telegram_bot.py
View file

@ -5,8 +5,10 @@ from telegram.ext.dispatcher import Dispatcher
from homeassistant.components.telegram_bot import DOMAIN, SERVICE_SEND_MESSAGE from homeassistant.components.telegram_bot import DOMAIN, SERVICE_SEND_MESSAGE
from homeassistant.components.telegram_bot.webhooks import TELEGRAM_WEBHOOK_URL from homeassistant.components.telegram_bot.webhooks import TELEGRAM_WEBHOOK_URL
from homeassistant.core import HomeAssistant
from tests.common import async_capture_events from tests.common import async_capture_events
from tests.typing import ClientSessionGenerator
@pytest.fixture(autouse=True) @pytest.fixture(autouse=True)
@ -18,19 +20,22 @@ def clear_dispatcher():
Dispatcher._Dispatcher__singleton_semaphore.release() Dispatcher._Dispatcher__singleton_semaphore.release()
async def test_webhook_platform_init(hass, webhook_platform): async def test_webhook_platform_init(hass: HomeAssistant, webhook_platform) -> None:
"""Test initialization of the webhooks platform.""" """Test initialization of the webhooks platform."""
assert hass.services.has_service(DOMAIN, SERVICE_SEND_MESSAGE) is True assert hass.services.has_service(DOMAIN, SERVICE_SEND_MESSAGE) is True
async def test_polling_platform_init(hass, polling_platform): async def test_polling_platform_init(hass: HomeAssistant, polling_platform) -> None:
"""Test initialization of the polling platform.""" """Test initialization of the polling platform."""
assert hass.services.has_service(DOMAIN, SERVICE_SEND_MESSAGE) is True assert hass.services.has_service(DOMAIN, SERVICE_SEND_MESSAGE) is True
async def test_webhook_endpoint_generates_telegram_text_event( async def test_webhook_endpoint_generates_telegram_text_event(
hass, webhook_platform, hass_client, update_message_text hass: HomeAssistant,
): webhook_platform,
hass_client: ClientSessionGenerator,
update_message_text,
) -> None:
"""POST to the configured webhook endpoint and assert fired `telegram_text` event.""" """POST to the configured webhook endpoint and assert fired `telegram_text` event."""
client = await hass_client() client = await hass_client()
events = async_capture_events(hass, "telegram_text") events = async_capture_events(hass, "telegram_text")
@ -47,8 +52,11 @@ async def test_webhook_endpoint_generates_telegram_text_event(
async def test_webhook_endpoint_generates_telegram_command_event( async def test_webhook_endpoint_generates_telegram_command_event(
hass, webhook_platform, hass_client, update_message_command hass: HomeAssistant,
): webhook_platform,
hass_client: ClientSessionGenerator,
update_message_command,
) -> None:
"""POST to the configured webhook endpoint and assert fired `telegram_command` event.""" """POST to the configured webhook endpoint and assert fired `telegram_command` event."""
client = await hass_client() client = await hass_client()
events = async_capture_events(hass, "telegram_command") events = async_capture_events(hass, "telegram_command")
@ -65,8 +73,11 @@ async def test_webhook_endpoint_generates_telegram_command_event(
async def test_webhook_endpoint_generates_telegram_callback_event( async def test_webhook_endpoint_generates_telegram_callback_event(
hass, webhook_platform, hass_client, update_callback_query hass: HomeAssistant,
): webhook_platform,
hass_client: ClientSessionGenerator,
update_callback_query,
) -> None:
"""POST to the configured webhook endpoint and assert fired `telegram_callback` event.""" """POST to the configured webhook endpoint and assert fired `telegram_callback` event."""
client = await hass_client() client = await hass_client()
events = async_capture_events(hass, "telegram_callback") events = async_capture_events(hass, "telegram_callback")
@ -83,8 +94,8 @@ async def test_webhook_endpoint_generates_telegram_callback_event(
async def test_polling_platform_message_text_update( async def test_polling_platform_message_text_update(
hass, polling_platform, update_message_text hass: HomeAssistant, polling_platform, update_message_text
): ) -> None:
"""Provide the `PollBot`s `Dispatcher` with an `Update` and assert fired `telegram_text` event.""" """Provide the `PollBot`s `Dispatcher` with an `Update` and assert fired `telegram_text` event."""
events = async_capture_events(hass, "telegram_text") events = async_capture_events(hass, "telegram_text")
@ -104,8 +115,11 @@ async def test_polling_platform_message_text_update(
async def test_webhook_endpoint_unauthorized_update_doesnt_generate_telegram_text_event( async def test_webhook_endpoint_unauthorized_update_doesnt_generate_telegram_text_event(
hass, webhook_platform, hass_client, unauthorized_update_message_text hass: HomeAssistant,
): webhook_platform,
hass_client: ClientSessionGenerator,
unauthorized_update_message_text,
) -> None:
"""Update with unauthorized user/chat should not trigger event.""" """Update with unauthorized user/chat should not trigger event."""
client = await hass_client() client = await hass_client()
events = async_capture_events(hass, "telegram_text") events = async_capture_events(hass, "telegram_text")

40
tests/components/tellduslive/test_config_flow.py
View file

@ -72,7 +72,7 @@ async def test_abort_if_already_setup(hass: HomeAssistant) -> None:
assert result["reason"] == "already_setup" assert result["reason"] == "already_setup"
async def test_full_flow_implementation(hass, mock_tellduslive): async def test_full_flow_implementation(hass: HomeAssistant, mock_tellduslive) -> None:
"""Test registering an implementation and finishing flow works.""" """Test registering an implementation and finishing flow works."""
flow = init_config_flow(hass) flow = init_config_flow(hass)
flow.context = {"source": SOURCE_DISCOVERY} flow.context = {"source": SOURCE_DISCOVERY}
@ -101,7 +101,7 @@ async def test_full_flow_implementation(hass, mock_tellduslive):
assert result["data"]["session"] == {"token": "token", "host": "localhost"} assert result["data"]["session"] == {"token": "token", "host": "localhost"}
async def test_step_import(hass, mock_tellduslive): async def test_step_import(hass: HomeAssistant, mock_tellduslive) -> None:
"""Test that we trigger auth when configuring from import.""" """Test that we trigger auth when configuring from import."""
flow = init_config_flow(hass) flow = init_config_flow(hass)
@ -110,7 +110,7 @@ async def test_step_import(hass, mock_tellduslive):
assert result["step_id"] == "auth" assert result["step_id"] == "auth"
async def test_step_import_add_host(hass, mock_tellduslive): async def test_step_import_add_host(hass: HomeAssistant, mock_tellduslive) -> None:
"""Test that we add host and trigger user when configuring from import.""" """Test that we add host and trigger user when configuring from import."""
flow = init_config_flow(hass) flow = init_config_flow(hass)
@ -121,7 +121,9 @@ async def test_step_import_add_host(hass, mock_tellduslive):
assert result["step_id"] == "user" assert result["step_id"] == "user"
async def test_step_import_no_config_file(hass, mock_tellduslive): async def test_step_import_no_config_file(
hass: HomeAssistant, mock_tellduslive
) -> None:
"""Test that we trigger user with no config_file configuring from import.""" """Test that we trigger user with no config_file configuring from import."""
flow = init_config_flow(hass) flow = init_config_flow(hass)
@ -132,7 +134,9 @@ async def test_step_import_no_config_file(hass, mock_tellduslive):
assert result["step_id"] == "user" assert result["step_id"] == "user"
async def test_step_import_load_json_matching_host(hass, mock_tellduslive): async def test_step_import_load_json_matching_host(
hass: HomeAssistant, mock_tellduslive
) -> None:
"""Test that we add host and trigger user when configuring from import.""" """Test that we add host and trigger user when configuring from import."""
flow = init_config_flow(hass) flow = init_config_flow(hass)
@ -147,7 +151,7 @@ async def test_step_import_load_json_matching_host(hass, mock_tellduslive):
assert result["step_id"] == "user" assert result["step_id"] == "user"
async def test_step_import_load_json(hass, mock_tellduslive): async def test_step_import_load_json(hass: HomeAssistant, mock_tellduslive) -> None:
"""Test that we create entry when configuring from import.""" """Test that we create entry when configuring from import."""
flow = init_config_flow(hass) flow = init_config_flow(hass)
@ -166,7 +170,7 @@ async def test_step_import_load_json(hass, mock_tellduslive):
@pytest.mark.parametrize("supports_local_api", [False]) @pytest.mark.parametrize("supports_local_api", [False])
async def test_step_disco_no_local_api(hass, mock_tellduslive): async def test_step_disco_no_local_api(hass: HomeAssistant, mock_tellduslive) -> None:
"""Test that we trigger when configuring from discovery, not supporting local api.""" """Test that we trigger when configuring from discovery, not supporting local api."""
flow = init_config_flow(hass) flow = init_config_flow(hass)
flow.context = {"source": SOURCE_DISCOVERY} flow.context = {"source": SOURCE_DISCOVERY}
@ -177,7 +181,7 @@ async def test_step_disco_no_local_api(hass, mock_tellduslive):
assert len(flow._hosts) == 1 assert len(flow._hosts) == 1
async def test_step_auth(hass, mock_tellduslive): async def test_step_auth(hass: HomeAssistant, mock_tellduslive) -> None:
"""Test that create cloud entity from auth.""" """Test that create cloud entity from auth."""
flow = init_config_flow(hass) flow = init_config_flow(hass)
@ -194,7 +198,9 @@ async def test_step_auth(hass, mock_tellduslive):
@pytest.mark.parametrize("authorize", [False]) @pytest.mark.parametrize("authorize", [False])
async def test_wrong_auth_flow_implementation(hass, mock_tellduslive): async def test_wrong_auth_flow_implementation(
hass: HomeAssistant, mock_tellduslive
) -> None:
"""Test wrong auth.""" """Test wrong auth."""
flow = init_config_flow(hass) flow = init_config_flow(hass)
@ -205,7 +211,7 @@ async def test_wrong_auth_flow_implementation(hass, mock_tellduslive):
assert result["errors"]["base"] == "invalid_auth" assert result["errors"]["base"] == "invalid_auth"
async def test_not_pick_host_if_only_one(hass, mock_tellduslive): async def test_not_pick_host_if_only_one(hass: HomeAssistant, mock_tellduslive) -> None:
"""Test not picking host if we have just one.""" """Test not picking host if we have just one."""
flow = init_config_flow(hass) flow = init_config_flow(hass)
@ -214,7 +220,9 @@ async def test_not_pick_host_if_only_one(hass, mock_tellduslive):
assert result["step_id"] == "auth" assert result["step_id"] == "auth"
async def test_abort_if_timeout_generating_auth_url(hass, mock_tellduslive): async def test_abort_if_timeout_generating_auth_url(
hass: HomeAssistant, mock_tellduslive
) -> None:
"""Test abort if generating authorize url timeout.""" """Test abort if generating authorize url timeout."""
flow = init_config_flow(hass, side_effect=asyncio.TimeoutError) flow = init_config_flow(hass, side_effect=asyncio.TimeoutError)
@ -223,7 +231,7 @@ async def test_abort_if_timeout_generating_auth_url(hass, mock_tellduslive):
assert result["reason"] == "authorize_url_timeout" assert result["reason"] == "authorize_url_timeout"
async def test_abort_no_auth_url(hass, mock_tellduslive): async def test_abort_no_auth_url(hass: HomeAssistant, mock_tellduslive) -> None:
"""Test abort if generating authorize url returns none.""" """Test abort if generating authorize url returns none."""
flow = init_config_flow(hass) flow = init_config_flow(hass)
flow._get_auth_url = Mock(return_value=False) flow._get_auth_url = Mock(return_value=False)
@ -233,7 +241,9 @@ async def test_abort_no_auth_url(hass, mock_tellduslive):
assert result["reason"] == "unknown_authorize_url_generation" assert result["reason"] == "unknown_authorize_url_generation"
async def test_abort_if_exception_generating_auth_url(hass, mock_tellduslive): async def test_abort_if_exception_generating_auth_url(
hass: HomeAssistant, mock_tellduslive
) -> None:
"""Test we abort if generating authorize url blows up.""" """Test we abort if generating authorize url blows up."""
flow = init_config_flow(hass, side_effect=ValueError) flow = init_config_flow(hass, side_effect=ValueError)
@ -242,7 +252,9 @@ async def test_abort_if_exception_generating_auth_url(hass, mock_tellduslive):
assert result["reason"] == "unknown_authorize_url_generation" assert result["reason"] == "unknown_authorize_url_generation"
async def test_discovery_already_configured(hass, mock_tellduslive): async def test_discovery_already_configured(
hass: HomeAssistant, mock_tellduslive
) -> None:
"""Test abort if already configured fires from discovery.""" """Test abort if already configured fires from discovery."""
MockConfigEntry(domain="tellduslive", data={"host": "some-host"}).add_to_hass(hass) MockConfigEntry(domain="tellduslive", data={"host": "some-host"}).add_to_hass(hass)
flow = init_config_flow(hass) flow = init_config_flow(hass)

20
tests/components/template/test_alarm_control_panel.py
View file

@ -17,7 +17,7 @@ from homeassistant.const import (
STATE_ALARM_PENDING, STATE_ALARM_PENDING,
STATE_ALARM_TRIGGERED, STATE_ALARM_TRIGGERED,
) )
from homeassistant.core import callback from homeassistant.core import HomeAssistant, callback
TEMPLATE_NAME = "alarm_control_panel.test_template_panel" TEMPLATE_NAME = "alarm_control_panel.test_template_panel"
PANEL_NAME = "alarm_control_panel.test" PANEL_NAME = "alarm_control_panel.test"
@ -99,7 +99,7 @@ TEMPLATE_ALARM_CONFIG = {
}, },
], ],
) )
async def test_template_state_text(hass, start_ha): async def test_template_state_text(hass: HomeAssistant, start_ha) -> None:
"""Test the state text of a template.""" """Test the state text of a template."""
for set_state in [ for set_state in [
@ -136,7 +136,7 @@ async def test_template_state_text(hass, start_ha):
}, },
], ],
) )
async def test_optimistic_states(hass, start_ha): async def test_optimistic_states(hass: HomeAssistant, start_ha) -> None:
"""Test the optimistic state.""" """Test the optimistic state."""
state = hass.states.get(TEMPLATE_NAME) state = hass.states.get(TEMPLATE_NAME)
@ -223,7 +223,9 @@ async def test_optimistic_states(hass, start_ha):
), ),
], ],
) )
async def test_template_syntax_error(hass, msg, start_ha, caplog_setup_text): async def test_template_syntax_error(
hass: HomeAssistant, msg, start_ha, caplog_setup_text
) -> None:
"""Test templating syntax error.""" """Test templating syntax error."""
assert len(hass.states.async_all("alarm_control_panel")) == 0 assert len(hass.states.async_all("alarm_control_panel")) == 0
assert (msg) in caplog_setup_text assert (msg) in caplog_setup_text
@ -247,7 +249,7 @@ async def test_template_syntax_error(hass, msg, start_ha, caplog_setup_text):
}, },
], ],
) )
async def test_name(hass, start_ha): async def test_name(hass: HomeAssistant, start_ha) -> None:
"""Test the accessibility of the name attribute.""" """Test the accessibility of the name attribute."""
state = hass.states.get(TEMPLATE_NAME) state = hass.states.get(TEMPLATE_NAME)
assert state is not None assert state is not None
@ -278,7 +280,7 @@ async def test_name(hass, start_ha):
"alarm_trigger", "alarm_trigger",
], ],
) )
async def test_actions(hass, service, start_ha, service_calls): async def test_actions(hass: HomeAssistant, service, start_ha, service_calls) -> None:
"""Test alarm actions.""" """Test alarm actions."""
await hass.services.async_call( await hass.services.async_call(
ALARM_DOMAIN, service, {"entity_id": TEMPLATE_NAME}, blocking=True ALARM_DOMAIN, service, {"entity_id": TEMPLATE_NAME}, blocking=True
@ -310,7 +312,7 @@ async def test_actions(hass, service, start_ha, service_calls):
}, },
], ],
) )
async def test_unique_id(hass, start_ha): async def test_unique_id(hass: HomeAssistant, start_ha) -> None:
"""Test unique_id option only creates one alarm control panel per id.""" """Test unique_id option only creates one alarm control panel per id."""
assert len(hass.states.async_all()) == 1 assert len(hass.states.async_all()) == 1
@ -382,7 +384,9 @@ async def test_unique_id(hass, start_ha):
), ),
], ],
) )
async def test_code_config(hass, code_format, code_arm_required, start_ha): async def test_code_config(
hass: HomeAssistant, code_format, code_arm_required, start_ha
) -> None:
"""Test configuration options related to alarm code.""" """Test configuration options related to alarm code."""
state = hass.states.get(TEMPLATE_NAME) state = hass.states.get(TEMPLATE_NAME)
assert state.attributes.get("code_format") == code_format assert state.attributes.get("code_format") == code_format

80
tests/components/template/test_binary_sensor.py
View file

@ -67,7 +67,9 @@ OFF = "off"
), ),
], ],
) )
async def test_setup_minimal(hass, start_ha, entity_id, name, attributes): async def test_setup_minimal(
hass: HomeAssistant, start_ha, entity_id, name, attributes
) -> None:
"""Test the setup.""" """Test the setup."""
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state is not None assert state is not None
@ -111,7 +113,7 @@ async def test_setup_minimal(hass, start_ha, entity_id, name, attributes):
), ),
], ],
) )
async def test_setup(hass, start_ha, entity_id): async def test_setup(hass: HomeAssistant, start_ha, entity_id) -> None:
"""Test the setup.""" """Test the setup."""
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state is not None assert state is not None
@ -178,7 +180,7 @@ async def test_setup(hass, start_ha, entity_id):
), ),
], ],
) )
async def test_setup_invalid_sensors(hass, count, start_ha): async def test_setup_invalid_sensors(hass: HomeAssistant, count, start_ha) -> None:
"""Test setup with no sensors.""" """Test setup with no sensors."""
assert len(hass.states.async_entity_ids("binary_sensor")) == count assert len(hass.states.async_entity_ids("binary_sensor")) == count
@ -224,7 +226,7 @@ async def test_setup_invalid_sensors(hass, count, start_ha):
), ),
], ],
) )
async def test_icon_template(hass, start_ha, entity_id): async def test_icon_template(hass: HomeAssistant, start_ha, entity_id) -> None:
"""Test icon template.""" """Test icon template."""
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state.attributes.get("icon") == "" assert state.attributes.get("icon") == ""
@ -276,7 +278,9 @@ async def test_icon_template(hass, start_ha, entity_id):
), ),
], ],
) )
async def test_entity_picture_template(hass, start_ha, entity_id): async def test_entity_picture_template(
hass: HomeAssistant, start_ha, entity_id
) -> None:
"""Test entity_picture template.""" """Test entity_picture template."""
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state.attributes.get("entity_picture") == "" assert state.attributes.get("entity_picture") == ""
@ -324,7 +328,7 @@ async def test_entity_picture_template(hass, start_ha, entity_id):
), ),
], ],
) )
async def test_attribute_templates(hass, start_ha, entity_id): async def test_attribute_templates(hass: HomeAssistant, start_ha, entity_id) -> None:
"""Test attribute_templates template.""" """Test attribute_templates template."""
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state.attributes.get("test_attribute") == "It ." assert state.attributes.get("test_attribute") == "It ."
@ -368,7 +372,7 @@ async def setup_mock():
}, },
], ],
) )
async def test_match_all(hass, setup_mock, start_ha): async def test_match_all(hass: HomeAssistant, setup_mock, start_ha) -> None:
"""Test template that is rerendered on any state lifecycle.""" """Test template that is rerendered on any state lifecycle."""
init_calls = len(setup_mock.mock_calls) init_calls = len(setup_mock.mock_calls)
@ -395,7 +399,7 @@ async def test_match_all(hass, setup_mock, start_ha):
}, },
], ],
) )
async def test_event(hass, start_ha): async def test_event(hass: HomeAssistant, start_ha) -> None:
"""Test the event.""" """Test the event."""
state = hass.states.get("binary_sensor.test") state = hass.states.get("binary_sensor.test")
assert state.state == OFF assert state.state == OFF
@ -505,7 +509,7 @@ async def test_event(hass, start_ha):
), ),
], ],
) )
async def test_template_delay_on_off(hass, start_ha): async def test_template_delay_on_off(hass: HomeAssistant, start_ha) -> None:
"""Test binary sensor template delay on.""" """Test binary sensor template delay on."""
# Ensure the initial state is not on # Ensure the initial state is not on
assert hass.states.get("binary_sensor.test_on").state != ON assert hass.states.get("binary_sensor.test_on").state != ON
@ -583,7 +587,9 @@ async def test_template_delay_on_off(hass, start_ha):
), ),
], ],
) )
async def test_available_without_availability_template(hass, start_ha, entity_id): async def test_available_without_availability_template(
hass: HomeAssistant, start_ha, entity_id
) -> None:
"""Ensure availability is true without an availability_template.""" """Ensure availability is true without an availability_template."""
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
@ -630,7 +636,7 @@ async def test_available_without_availability_template(hass, start_ha, entity_id
), ),
], ],
) )
async def test_availability_template(hass, start_ha, entity_id): async def test_availability_template(hass: HomeAssistant, start_ha, entity_id) -> None:
"""Test availability template.""" """Test availability template."""
hass.states.async_set("sensor.test_state", STATE_OFF) hass.states.async_set("sensor.test_state", STATE_OFF)
await hass.async_block_till_done() await hass.async_block_till_done()
@ -665,7 +671,9 @@ async def test_availability_template(hass, start_ha, entity_id):
}, },
], ],
) )
async def test_invalid_attribute_template(hass, start_ha, caplog_setup_text): async def test_invalid_attribute_template(
hass: HomeAssistant, start_ha, caplog_setup_text
) -> None:
"""Test that errors are logged if rendering template fails.""" """Test that errors are logged if rendering template fails."""
hass.states.async_set("binary_sensor.test_sensor", "true") hass.states.async_set("binary_sensor.test_sensor", "true")
assert len(hass.states.async_all()) == 2 assert len(hass.states.async_all()) == 2
@ -691,8 +699,8 @@ async def test_invalid_attribute_template(hass, start_ha, caplog_setup_text):
], ],
) )
async def test_invalid_availability_template_keeps_component_available( async def test_invalid_availability_template_keeps_component_available(
hass, start_ha, caplog_setup_text hass: HomeAssistant, start_ha, caplog_setup_text
): ) -> None:
"""Test that an invalid availability keeps the device available.""" """Test that an invalid availability keeps the device available."""
assert hass.states.get("binary_sensor.my_sensor").state != STATE_UNAVAILABLE assert hass.states.get("binary_sensor.my_sensor").state != STATE_UNAVAILABLE
@ -796,7 +804,7 @@ async def test_no_update_template_match_all(
}, },
], ],
) )
async def test_unique_id(hass, start_ha): async def test_unique_id(hass: HomeAssistant, start_ha) -> None:
"""Test unique_id option only creates one binary sensor per id.""" """Test unique_id option only creates one binary sensor per id."""
assert len(hass.states.async_all()) == 2 assert len(hass.states.async_all()) == 2
@ -835,7 +843,9 @@ async def test_unique_id(hass, start_ha):
}, },
], ],
) )
async def test_template_validation_error(hass, caplog, start_ha): async def test_template_validation_error(
hass: HomeAssistant, caplog: pytest.LogCaptureFixture, start_ha
) -> None:
"""Test binary sensor template delay on.""" """Test binary sensor template delay on."""
caplog.set_level(logging.ERROR) caplog.set_level(logging.ERROR)
state = hass.states.get("binary_sensor.test") state = hass.states.get("binary_sensor.test")
@ -897,7 +907,9 @@ async def test_template_validation_error(hass, caplog, start_ha):
), ),
], ],
) )
async def test_availability_icon_picture(hass, start_ha, entity_id): async def test_availability_icon_picture(
hass: HomeAssistant, start_ha, entity_id
) -> None:
"""Test name, icon and picture templates are rendered at setup.""" """Test name, icon and picture templates are rendered at setup."""
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state.state == "unavailable" assert state.state == "unavailable"
@ -951,8 +963,14 @@ async def test_availability_icon_picture(hass, start_ha, entity_id):
], ],
) )
async def test_restore_state( async def test_restore_state(
hass, count, domain, config, extra_config, restored_state, initial_state hass: HomeAssistant,
): count,
domain,
config,
extra_config,
restored_state,
initial_state,
) -> None:
"""Test restoring template binary sensor.""" """Test restoring template binary sensor."""
fake_state = State( fake_state = State(
@ -1034,7 +1052,7 @@ async def test_restore_state(
}, },
], ],
) )
async def test_trigger_entity(hass, start_ha): async def test_trigger_entity(hass: HomeAssistant, start_ha) -> None:
"""Test trigger entity works.""" """Test trigger entity works."""
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get("binary_sensor.hello_name") state = hass.states.get("binary_sensor.hello_name")
@ -1103,7 +1121,9 @@ async def test_trigger_entity(hass, start_ha):
}, },
], ],
) )
async def test_template_with_trigger_templated_delay_on(hass, start_ha): async def test_template_with_trigger_templated_delay_on(
hass: HomeAssistant, start_ha
) -> None:
"""Test binary sensor template with template delay on.""" """Test binary sensor template with template delay on."""
state = hass.states.get("binary_sensor.test") state = hass.states.get("binary_sensor.test")
assert state.state == STATE_UNKNOWN assert state.state == STATE_UNKNOWN
@ -1165,8 +1185,14 @@ async def test_template_with_trigger_templated_delay_on(hass, start_ha):
], ],
) )
async def test_trigger_entity_restore_state( async def test_trigger_entity_restore_state(
hass, count, domain, config, restored_state, initial_state, initial_attributes hass: HomeAssistant,
): count,
domain,
config,
restored_state,
initial_state,
initial_attributes,
) -> None:
"""Test restoring trigger template binary sensor.""" """Test restoring trigger template binary sensor."""
restored_attributes = { restored_attributes = {
@ -1234,8 +1260,8 @@ async def test_trigger_entity_restore_state(
) )
@pytest.mark.parametrize("restored_state", [ON, OFF]) @pytest.mark.parametrize("restored_state", [ON, OFF])
async def test_trigger_entity_restore_state_auto_off( async def test_trigger_entity_restore_state_auto_off(
hass, count, domain, config, restored_state, freezer hass: HomeAssistant, count, domain, config, restored_state, freezer
): ) -> None:
"""Test restoring trigger template binary sensor.""" """Test restoring trigger template binary sensor."""
freezer.move_to("2022-02-02 12:02:00+00:00") freezer.move_to("2022-02-02 12:02:00+00:00")
@ -1294,8 +1320,8 @@ async def test_trigger_entity_restore_state_auto_off(
], ],
) )
async def test_trigger_entity_restore_state_auto_off_expired( async def test_trigger_entity_restore_state_auto_off_expired(
hass, count, domain, config, freezer hass: HomeAssistant, count, domain, config, freezer
): ) -> None:
"""Test restoring trigger template binary sensor.""" """Test restoring trigger template binary sensor."""
freezer.move_to("2022-02-02 12:02:00+00:00") freezer.move_to("2022-02-02 12:02:00+00:00")

2
tests/components/template/test_button.py
View file

@ -59,7 +59,7 @@ async def test_missing_required_keys(hass: HomeAssistant) -> None:
assert hass.states.async_all("button") == [] assert hass.states.async_all("button") == []
async def test_all_optional_config(hass, calls): async def test_all_optional_config(hass: HomeAssistant, calls) -> None:
"""Test: including all optional templates is ok.""" """Test: including all optional templates is ok."""
with assert_setup_component(1, "template"): with assert_setup_component(1, "template"):
assert await setup.async_setup_component( assert await setup.async_setup_component(

59
tests/components/template/test_cover.py
View file

@ -22,6 +22,7 @@ from homeassistant.const import (
STATE_OPENING, STATE_OPENING,
STATE_UNAVAILABLE, STATE_UNAVAILABLE,
) )
from homeassistant.core import HomeAssistant
from tests.common import assert_setup_component from tests.common import assert_setup_component
@ -130,7 +131,9 @@ OPEN_CLOSE_COVER_CONFIG = {
), ),
], ],
) )
async def test_template_state_text(hass, states, start_ha, caplog): async def test_template_state_text(
hass: HomeAssistant, states, start_ha, caplog: pytest.LogCaptureFixture
) -> None:
"""Test the state text of a template.""" """Test the state text of a template."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert state.state == STATE_OPEN assert state.state == STATE_OPEN
@ -162,7 +165,7 @@ async def test_template_state_text(hass, states, start_ha, caplog):
}, },
], ],
) )
async def test_template_state_boolean(hass, start_ha): async def test_template_state_boolean(hass: HomeAssistant, start_ha) -> None:
"""Test the value_template attribute.""" """Test the value_template attribute."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert state.state == STATE_OPEN assert state.state == STATE_OPEN
@ -187,7 +190,7 @@ async def test_template_state_boolean(hass, start_ha):
}, },
], ],
) )
async def test_template_position(hass, start_ha): async def test_template_position(hass: HomeAssistant, start_ha) -> None:
"""Test the position_template attribute.""" """Test the position_template attribute."""
hass.states.async_set("cover.test", STATE_OPEN) hass.states.async_set("cover.test", STATE_OPEN)
attrs = {} attrs = {}
@ -222,7 +225,7 @@ async def test_template_position(hass, start_ha):
}, },
], ],
) )
async def test_template_tilt(hass, start_ha): async def test_template_tilt(hass: HomeAssistant, start_ha) -> None:
"""Test the tilt_template attribute.""" """Test the tilt_template attribute."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert state.attributes.get("current_tilt_position") == 42.0 assert state.attributes.get("current_tilt_position") == 42.0
@ -264,7 +267,7 @@ async def test_template_tilt(hass, start_ha):
}, },
], ],
) )
async def test_template_out_of_bounds(hass, start_ha): async def test_template_out_of_bounds(hass: HomeAssistant, start_ha) -> None:
"""Test template out-of-bounds condition.""" """Test template out-of-bounds condition."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert state.attributes.get("current_tilt_position") is None assert state.attributes.get("current_tilt_position") is None
@ -300,7 +303,9 @@ async def test_template_out_of_bounds(hass, start_ha):
}, },
], ],
) )
async def test_template_open_or_position(hass, start_ha, caplog_setup_text): async def test_template_open_or_position(
hass: HomeAssistant, start_ha, caplog_setup_text
) -> None:
"""Test that at least one of open_cover or set_position is used.""" """Test that at least one of open_cover or set_position is used."""
assert hass.states.async_all("cover") == [] assert hass.states.async_all("cover") == []
assert "Invalid config for [cover.template]" in caplog_setup_text assert "Invalid config for [cover.template]" in caplog_setup_text
@ -323,7 +328,7 @@ async def test_template_open_or_position(hass, start_ha, caplog_setup_text):
}, },
], ],
) )
async def test_open_action(hass, start_ha, calls): async def test_open_action(hass: HomeAssistant, start_ha, calls) -> None:
"""Test the open_cover command.""" """Test the open_cover command."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert state.state == STATE_CLOSED assert state.state == STATE_CLOSED
@ -362,7 +367,7 @@ async def test_open_action(hass, start_ha, calls):
}, },
], ],
) )
async def test_close_stop_action(hass, start_ha, calls): async def test_close_stop_action(hass: HomeAssistant, start_ha, calls) -> None:
"""Test the close-cover and stop_cover commands.""" """Test the close-cover and stop_cover commands."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert state.state == STATE_OPEN assert state.state == STATE_OPEN
@ -391,7 +396,7 @@ async def test_close_stop_action(hass, start_ha, calls):
{"input_number": {"test": {"min": "0", "max": "100", "initial": "42"}}}, {"input_number": {"test": {"min": "0", "max": "100", "initial": "42"}}},
], ],
) )
async def test_set_position(hass, start_ha, calls): async def test_set_position(hass: HomeAssistant, start_ha, calls) -> None:
"""Test the set_position command.""" """Test the set_position command."""
with assert_setup_component(1, "cover"): with assert_setup_component(1, "cover"):
assert await setup.async_setup_component( assert await setup.async_setup_component(
@ -520,7 +525,9 @@ async def test_set_position(hass, start_ha, calls):
(SERVICE_CLOSE_COVER_TILT, {ATTR_ENTITY_ID: ENTITY_COVER}, 0), (SERVICE_CLOSE_COVER_TILT, {ATTR_ENTITY_ID: ENTITY_COVER}, 0),
], ],
) )
async def test_set_tilt_position(hass, service, attr, start_ha, calls, tilt_position): async def test_set_tilt_position(
hass: HomeAssistant, service, attr, start_ha, calls, tilt_position
) -> None:
"""Test the set_tilt_position command.""" """Test the set_tilt_position command."""
await hass.services.async_call( await hass.services.async_call(
DOMAIN, DOMAIN,
@ -552,7 +559,7 @@ async def test_set_tilt_position(hass, service, attr, start_ha, calls, tilt_posi
}, },
], ],
) )
async def test_set_position_optimistic(hass, start_ha, calls): async def test_set_position_optimistic(hass: HomeAssistant, start_ha, calls) -> None:
"""Test optimistic position mode.""" """Test optimistic position mode."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert state.attributes.get("current_position") is None assert state.attributes.get("current_position") is None
@ -599,7 +606,9 @@ async def test_set_position_optimistic(hass, start_ha, calls):
}, },
], ],
) )
async def test_set_tilt_position_optimistic(hass, start_ha, calls): async def test_set_tilt_position_optimistic(
hass: HomeAssistant, start_ha, calls
) -> None:
"""Test the optimistic tilt_position mode.""" """Test the optimistic tilt_position mode."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert state.attributes.get("current_tilt_position") is None assert state.attributes.get("current_tilt_position") is None
@ -648,7 +657,7 @@ async def test_set_tilt_position_optimistic(hass, start_ha, calls):
}, },
], ],
) )
async def test_icon_template(hass, start_ha): async def test_icon_template(hass: HomeAssistant, start_ha) -> None:
"""Test icon template.""" """Test icon template."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert state.attributes.get("icon") == "" assert state.attributes.get("icon") == ""
@ -683,7 +692,7 @@ async def test_icon_template(hass, start_ha):
}, },
], ],
) )
async def test_entity_picture_template(hass, start_ha): async def test_entity_picture_template(hass: HomeAssistant, start_ha) -> None:
"""Test icon template.""" """Test icon template."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert state.attributes.get("entity_picture") == "" assert state.attributes.get("entity_picture") == ""
@ -716,7 +725,7 @@ async def test_entity_picture_template(hass, start_ha):
}, },
], ],
) )
async def test_availability_template(hass, start_ha): async def test_availability_template(hass: HomeAssistant, start_ha) -> None:
"""Test availability template.""" """Test availability template."""
hass.states.async_set("availability_state.state", STATE_OFF) hass.states.async_set("availability_state.state", STATE_OFF)
await hass.async_block_till_done() await hass.async_block_till_done()
@ -746,7 +755,9 @@ async def test_availability_template(hass, start_ha):
}, },
], ],
) )
async def test_availability_without_availability_template(hass, start_ha): async def test_availability_without_availability_template(
hass: HomeAssistant, start_ha
) -> None:
"""Test that component is available if there is no.""" """Test that component is available if there is no."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert state.state != STATE_UNAVAILABLE assert state.state != STATE_UNAVAILABLE
@ -771,8 +782,8 @@ async def test_availability_without_availability_template(hass, start_ha):
], ],
) )
async def test_invalid_availability_template_keeps_component_available( async def test_invalid_availability_template_keeps_component_available(
hass, start_ha, caplog_setup_text hass: HomeAssistant, start_ha, caplog_setup_text
): ) -> None:
"""Test that an invalid availability keeps the device available.""" """Test that an invalid availability keeps the device available."""
assert hass.states.get("cover.test_template_cover") != STATE_UNAVAILABLE assert hass.states.get("cover.test_template_cover") != STATE_UNAVAILABLE
assert "UndefinedError: 'x' is undefined" in caplog_setup_text assert "UndefinedError: 'x' is undefined" in caplog_setup_text
@ -796,7 +807,7 @@ async def test_invalid_availability_template_keeps_component_available(
}, },
], ],
) )
async def test_device_class(hass, start_ha): async def test_device_class(hass: HomeAssistant, start_ha) -> None:
"""Test device class.""" """Test device class."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert state.attributes.get("device_class") == "door" assert state.attributes.get("device_class") == "door"
@ -820,7 +831,7 @@ async def test_device_class(hass, start_ha):
}, },
], ],
) )
async def test_invalid_device_class(hass, start_ha): async def test_invalid_device_class(hass: HomeAssistant, start_ha) -> None:
"""Test device class.""" """Test device class."""
state = hass.states.get("cover.test_template_cover") state = hass.states.get("cover.test_template_cover")
assert not state assert not state
@ -849,7 +860,7 @@ async def test_invalid_device_class(hass, start_ha):
}, },
], ],
) )
async def test_unique_id(hass, start_ha): async def test_unique_id(hass: HomeAssistant, start_ha) -> None:
"""Test unique_id option only creates one cover per id.""" """Test unique_id option only creates one cover per id."""
assert len(hass.states.async_all()) == 1 assert len(hass.states.async_all()) == 1
@ -874,7 +885,7 @@ async def test_unique_id(hass, start_ha):
}, },
], ],
) )
async def test_state_gets_lowercased(hass, start_ha): async def test_state_gets_lowercased(hass: HomeAssistant, start_ha) -> None:
"""Test True/False is lowercased.""" """Test True/False is lowercased."""
hass.states.async_set("binary_sensor.garage_door_sensor", "off") hass.states.async_set("binary_sensor.garage_door_sensor", "off")
@ -921,8 +932,8 @@ async def test_state_gets_lowercased(hass, start_ha):
], ],
) )
async def test_self_referencing_icon_with_no_template_is_not_a_loop( async def test_self_referencing_icon_with_no_template_is_not_a_loop(
hass, start_ha, caplog hass: HomeAssistant, start_ha, caplog: pytest.LogCaptureFixture
): ) -> None:
"""Test a self referencing icon with no value template is not a loop.""" """Test a self referencing icon with no value template is not a loop."""
assert len(hass.states.async_all()) == 1 assert len(hass.states.async_all()) == 1

59
tests/components/template/test_fan.py
View file

@ -14,6 +14,7 @@ from homeassistant.components.fan import (
FanEntityFeature, FanEntityFeature,
) )
from homeassistant.const import STATE_OFF, STATE_ON, STATE_UNAVAILABLE from homeassistant.const import STATE_OFF, STATE_ON, STATE_UNAVAILABLE
from homeassistant.core import HomeAssistant
from tests.common import assert_setup_component from tests.common import assert_setup_component
from tests.components.fan import common from tests.components.fan import common
@ -51,7 +52,7 @@ _DIRECTION_INPUT_SELECT = "input_select.direction"
}, },
], ],
) )
async def test_missing_optional_config(hass, start_ha): async def test_missing_optional_config(hass: HomeAssistant, start_ha) -> None:
"""Test: missing optional template is ok.""" """Test: missing optional template is ok."""
_verify(hass, STATE_ON, None, None, None, None) _verify(hass, STATE_ON, None, None, None, None)
@ -118,7 +119,7 @@ async def test_missing_optional_config(hass, start_ha):
}, },
], ],
) )
async def test_wrong_template_config(hass, start_ha): async def test_wrong_template_config(hass: HomeAssistant, start_ha) -> None:
"""Test: missing 'value_template' will fail.""" """Test: missing 'value_template' will fail."""
assert hass.states.async_all("fan") == [] assert hass.states.async_all("fan") == []
@ -160,7 +161,7 @@ async def test_wrong_template_config(hass, start_ha):
}, },
], ],
) )
async def test_templates_with_entities(hass, start_ha): async def test_templates_with_entities(hass: HomeAssistant, start_ha) -> None:
"""Test tempalates with values from other entities.""" """Test tempalates with values from other entities."""
_verify(hass, STATE_OFF, 0, None, None, None) _verify(hass, STATE_OFF, 0, None, None, None)
@ -240,7 +241,9 @@ async def test_templates_with_entities(hass, start_ha):
), ),
], ],
) )
async def test_templates_with_entities2(hass, entity, tests, start_ha): async def test_templates_with_entities2(
hass: HomeAssistant, entity, tests, start_ha
) -> None:
"""Test templates with values from other entities.""" """Test templates with values from other entities."""
for set_percentage, test_percentage, test_type in tests: for set_percentage, test_percentage, test_type in tests:
hass.states.async_set(entity, set_percentage) hass.states.async_set(entity, set_percentage)
@ -271,7 +274,9 @@ async def test_templates_with_entities2(hass, entity, tests, start_ha):
}, },
], ],
) )
async def test_availability_template_with_entities(hass, start_ha): async def test_availability_template_with_entities(
hass: HomeAssistant, start_ha
) -> None:
"""Test availability tempalates with values from other entities.""" """Test availability tempalates with values from other entities."""
for state, test_assert in [(STATE_ON, True), (STATE_OFF, False)]: for state, test_assert in [(STATE_ON, True), (STATE_OFF, False)]:
hass.states.async_set(_STATE_AVAILABILITY_BOOLEAN, state) hass.states.async_set(_STATE_AVAILABILITY_BOOLEAN, state)
@ -354,7 +359,9 @@ async def test_availability_template_with_entities(hass, start_ha):
), ),
], ],
) )
async def test_template_with_unavailable_entities(hass, states, start_ha): async def test_template_with_unavailable_entities(
hass: HomeAssistant, states, start_ha
) -> None:
"""Test unavailability with value_template.""" """Test unavailability with value_template."""
_verify(hass, states[0], states[1], states[2], states[3], None) _verify(hass, states[0], states[1], states[2], states[3], None)
@ -384,15 +391,15 @@ async def test_template_with_unavailable_entities(hass, states, start_ha):
], ],
) )
async def test_invalid_availability_template_keeps_component_available( async def test_invalid_availability_template_keeps_component_available(
hass, start_ha, caplog_setup_text hass: HomeAssistant, start_ha, caplog_setup_text
): ) -> None:
"""Test that an invalid availability keeps the device available.""" """Test that an invalid availability keeps the device available."""
assert hass.states.get("fan.test_fan").state != STATE_UNAVAILABLE assert hass.states.get("fan.test_fan").state != STATE_UNAVAILABLE
assert "TemplateError" in caplog_setup_text assert "TemplateError" in caplog_setup_text
assert "x" in caplog_setup_text assert "x" in caplog_setup_text
async def test_on_off(hass, calls): async def test_on_off(hass: HomeAssistant, calls) -> None:
"""Test turn on and turn off.""" """Test turn on and turn off."""
await _register_components(hass) await _register_components(hass)
expected_calls = 0 expected_calls = 0
@ -410,7 +417,9 @@ async def test_on_off(hass, calls):
assert calls[-1].data["caller"] == _TEST_FAN assert calls[-1].data["caller"] == _TEST_FAN
async def test_set_invalid_direction_from_initial_stage(hass, calls): async def test_set_invalid_direction_from_initial_stage(
hass: HomeAssistant, calls
) -> None:
"""Test set invalid direction when fan is in initial state.""" """Test set invalid direction when fan is in initial state."""
await _register_components(hass) await _register_components(hass)
@ -421,7 +430,7 @@ async def test_set_invalid_direction_from_initial_stage(hass, calls):
_verify(hass, STATE_ON, 0, None, None, None) _verify(hass, STATE_ON, 0, None, None, None)
async def test_set_osc(hass, calls): async def test_set_osc(hass: HomeAssistant, calls) -> None:
"""Test set oscillating.""" """Test set oscillating."""
await _register_components(hass) await _register_components(hass)
expected_calls = 0 expected_calls = 0
@ -439,7 +448,7 @@ async def test_set_osc(hass, calls):
assert calls[-1].data["option"] == state assert calls[-1].data["option"] == state
async def test_set_direction(hass, calls): async def test_set_direction(hass: HomeAssistant, calls) -> None:
"""Test set valid direction.""" """Test set valid direction."""
await _register_components(hass) await _register_components(hass)
expected_calls = 0 expected_calls = 0
@ -457,7 +466,7 @@ async def test_set_direction(hass, calls):
assert calls[-1].data["option"] == cmd assert calls[-1].data["option"] == cmd
async def test_set_invalid_direction(hass, calls): async def test_set_invalid_direction(hass: HomeAssistant, calls) -> None:
"""Test set invalid direction when fan has valid direction.""" """Test set invalid direction when fan has valid direction."""
await _register_components(hass) await _register_components(hass)
@ -468,7 +477,7 @@ async def test_set_invalid_direction(hass, calls):
_verify(hass, STATE_ON, 0, None, DIRECTION_FORWARD, None) _verify(hass, STATE_ON, 0, None, DIRECTION_FORWARD, None)
async def test_preset_modes(hass, calls): async def test_preset_modes(hass: HomeAssistant, calls) -> None:
"""Test preset_modes.""" """Test preset_modes."""
await _register_components( await _register_components(
hass, ["off", "low", "medium", "high", "auto", "smart"], ["auto", "smart"] hass, ["off", "low", "medium", "high", "auto", "smart"], ["auto", "smart"]
@ -491,7 +500,7 @@ async def test_preset_modes(hass, calls):
assert hass.states.get(_PRESET_MODE_INPUT_SELECT).state == "auto" assert hass.states.get(_PRESET_MODE_INPUT_SELECT).state == "auto"
async def test_set_percentage(hass, calls): async def test_set_percentage(hass: HomeAssistant, calls) -> None:
"""Test set valid speed percentage.""" """Test set valid speed percentage."""
await _register_components(hass) await _register_components(hass)
expected_calls = 0 expected_calls = 0
@ -517,7 +526,7 @@ async def test_set_percentage(hass, calls):
_verify(hass, STATE_ON, 50, None, None, None) _verify(hass, STATE_ON, 50, None, None, None)
async def test_increase_decrease_speed(hass, calls): async def test_increase_decrease_speed(hass: HomeAssistant, calls) -> None:
"""Test set valid increase and decrease speed.""" """Test set valid increase and decrease speed."""
await _register_components(hass, speed_count=3) await _register_components(hass, speed_count=3)
@ -534,7 +543,7 @@ async def test_increase_decrease_speed(hass, calls):
_verify(hass, state, value, None, None, None) _verify(hass, state, value, None, None, None)
async def test_no_value_template(hass, calls): async def test_no_value_template(hass: HomeAssistant, calls) -> None:
"""Test a fan without a value_template.""" """Test a fan without a value_template."""
await _register_fan_sources(hass) await _register_fan_sources(hass)
@ -644,7 +653,9 @@ async def test_no_value_template(hass, calls):
_verify(hass, STATE_OFF, percent, None, None, preset) _verify(hass, STATE_OFF, percent, None, None, preset)
async def test_increase_decrease_speed_default_speed_count(hass, calls): async def test_increase_decrease_speed_default_speed_count(
hass: HomeAssistant, calls
) -> None:
"""Test set valid increase and decrease speed.""" """Test set valid increase and decrease speed."""
await _register_components(hass) await _register_components(hass)
@ -661,7 +672,7 @@ async def test_increase_decrease_speed_default_speed_count(hass, calls):
_verify(hass, state, value, None, None, None) _verify(hass, state, value, None, None, None)
async def test_set_invalid_osc_from_initial_state(hass, calls): async def test_set_invalid_osc_from_initial_state(hass: HomeAssistant, calls) -> None:
"""Test set invalid oscillating when fan is in initial state.""" """Test set invalid oscillating when fan is in initial state."""
await _register_components(hass) await _register_components(hass)
@ -672,7 +683,7 @@ async def test_set_invalid_osc_from_initial_state(hass, calls):
_verify(hass, STATE_ON, 0, None, None, None) _verify(hass, STATE_ON, 0, None, None, None)
async def test_set_invalid_osc(hass, calls): async def test_set_invalid_osc(hass: HomeAssistant, calls) -> None:
"""Test set invalid oscillating when fan has valid osc.""" """Test set invalid oscillating when fan has valid osc."""
await _register_components(hass) await _register_components(hass)
@ -926,7 +937,7 @@ async def _register_components(
}, },
], ],
) )
async def test_unique_id(hass, start_ha): async def test_unique_id(hass: HomeAssistant, start_ha) -> None:
"""Test unique_id option only creates one fan per id.""" """Test unique_id option only creates one fan per id."""
assert len(hass.states.async_all()) == 1 assert len(hass.states.async_all()) == 1
@ -934,7 +945,9 @@ async def test_unique_id(hass, start_ha):
@pytest.mark.parametrize( @pytest.mark.parametrize(
("speed_count", "percentage_step"), [(0, 1), (100, 1), (3, 100 / 3)] ("speed_count", "percentage_step"), [(0, 1), (100, 1), (3, 100 / 3)]
) )
async def test_implemented_percentage(hass, speed_count, percentage_step): async def test_implemented_percentage(
hass: HomeAssistant, speed_count, percentage_step
) -> None:
"""Test a fan that implements percentage.""" """Test a fan that implements percentage."""
await setup.async_setup_component( await setup.async_setup_component(
hass, hass,
@ -1066,7 +1079,7 @@ async def test_implemented_percentage(hass, speed_count, percentage_step):
}, },
], ],
) )
async def test_implemented_preset_mode(hass, start_ha): async def test_implemented_preset_mode(hass: HomeAssistant, start_ha) -> None:
"""Test a fan that implements preset_mode.""" """Test a fan that implements preset_mode."""
assert len(hass.states.async_all()) == 1 assert len(hass.states.async_all()) == 1

19
tests/components/template/test_init.py
View file

@ -6,6 +6,7 @@ import pytest
from homeassistant import config from homeassistant import config
from homeassistant.components.template import DOMAIN from homeassistant.components.template import DOMAIN
from homeassistant.core import HomeAssistant
from homeassistant.helpers.reload import SERVICE_RELOAD from homeassistant.helpers.reload import SERVICE_RELOAD
from homeassistant.setup import async_setup_component from homeassistant.setup import async_setup_component
from homeassistant.util import dt as dt_util from homeassistant.util import dt as dt_util
@ -48,7 +49,7 @@ from tests.common import async_fire_time_changed, get_fixture_path
}, },
], ],
) )
async def test_reloadable(hass, start_ha): async def test_reloadable(hass: HomeAssistant, start_ha) -> None:
"""Test that we can reload.""" """Test that we can reload."""
hass.states.async_set("sensor.test_sensor", "mytest") hass.states.async_set("sensor.test_sensor", "mytest")
await hass.async_block_till_done() await hass.async_block_till_done()
@ -99,7 +100,7 @@ async def test_reloadable(hass, start_ha):
}, },
], ],
) )
async def test_reloadable_can_remove(hass, start_ha): async def test_reloadable_can_remove(hass: HomeAssistant, start_ha) -> None:
"""Test that we can reload and remove all template sensors.""" """Test that we can reload and remove all template sensors."""
hass.states.async_set("sensor.test_sensor", "mytest") hass.states.async_set("sensor.test_sensor", "mytest")
await hass.async_block_till_done() await hass.async_block_till_done()
@ -129,7 +130,9 @@ async def test_reloadable_can_remove(hass, start_ha):
}, },
], ],
) )
async def test_reloadable_stops_on_invalid_config(hass, start_ha): async def test_reloadable_stops_on_invalid_config(
hass: HomeAssistant, start_ha
) -> None:
"""Test we stop the reload if configuration.yaml is completely broken.""" """Test we stop the reload if configuration.yaml is completely broken."""
hass.states.async_set("sensor.test_sensor", "mytest") hass.states.async_set("sensor.test_sensor", "mytest")
await hass.async_block_till_done() await hass.async_block_till_done()
@ -157,7 +160,9 @@ async def test_reloadable_stops_on_invalid_config(hass, start_ha):
}, },
], ],
) )
async def test_reloadable_handles_partial_valid_config(hass, start_ha): async def test_reloadable_handles_partial_valid_config(
hass: HomeAssistant, start_ha
) -> None:
"""Test we can still setup valid sensors when configuration.yaml has a broken entry.""" """Test we can still setup valid sensors when configuration.yaml has a broken entry."""
hass.states.async_set("sensor.test_sensor", "mytest") hass.states.async_set("sensor.test_sensor", "mytest")
await hass.async_block_till_done() await hass.async_block_till_done()
@ -188,7 +193,7 @@ async def test_reloadable_handles_partial_valid_config(hass, start_ha):
}, },
], ],
) )
async def test_reloadable_multiple_platforms(hass, start_ha): async def test_reloadable_multiple_platforms(hass: HomeAssistant, start_ha) -> None:
"""Test that we can reload.""" """Test that we can reload."""
hass.states.async_set("sensor.test_sensor", "mytest") hass.states.async_set("sensor.test_sensor", "mytest")
await async_setup_component( await async_setup_component(
@ -232,7 +237,9 @@ async def test_reloadable_multiple_platforms(hass, start_ha):
}, },
], ],
) )
async def test_reload_sensors_that_reference_other_template_sensors(hass, start_ha): async def test_reload_sensors_that_reference_other_template_sensors(
hass: HomeAssistant, start_ha
) -> None:
"""Test that we can reload sensor that reference other template sensors.""" """Test that we can reload sensor that reference other template sensors."""
await async_yaml_patch_helper(hass, "ref_configuration.yaml") await async_yaml_patch_helper(hass, "ref_configuration.yaml")
assert len(hass.states.async_all()) == 3 assert len(hass.states.async_all()) == 3

109
tests/components/template/test_light.py
View file

@ -1,5 +1,4 @@
"""The tests for the Template light platform.""" """The tests for the Template light platform."""
import pytest import pytest
import homeassistant.components.light as light import homeassistant.components.light as light
@ -20,6 +19,7 @@ from homeassistant.const import (
STATE_ON, STATE_ON,
STATE_UNAVAILABLE, STATE_UNAVAILABLE,
) )
from homeassistant.core import HomeAssistant
from homeassistant.setup import async_setup_component from homeassistant.setup import async_setup_component
from tests.common import assert_setup_component from tests.common import assert_setup_component
@ -125,8 +125,8 @@ async def setup_light(hass, count, light_config):
], ],
) )
async def test_template_state_invalid( async def test_template_state_invalid(
hass, supported_features, supported_color_modes, setup_light hass: HomeAssistant, supported_features, supported_color_modes, setup_light
): ) -> None:
"""Test template state with render error.""" """Test template state with render error."""
state = hass.states.get("light.test_template_light") state = hass.states.get("light.test_template_light")
assert state.state == STATE_OFF assert state.state == STATE_OFF
@ -147,7 +147,7 @@ async def test_template_state_invalid(
}, },
], ],
) )
async def test_template_state_text(hass, setup_light): async def test_template_state_text(hass: HomeAssistant, setup_light) -> None:
"""Test the state text of a template.""" """Test the state text of a template."""
set_state = STATE_ON set_state = STATE_ON
hass.states.async_set("light.test_state", set_state) hass.states.async_set("light.test_state", set_state)
@ -185,12 +185,12 @@ async def test_template_state_text(hass, setup_light):
], ],
) )
async def test_templatex_state_boolean( async def test_templatex_state_boolean(
hass, hass: HomeAssistant,
expected_color_mode, expected_color_mode,
expected_state, expected_state,
count, count,
value_template, value_template,
): ) -> None:
"""Test the setting of the state with boolean on.""" """Test the setting of the state with boolean on."""
light_config = { light_config = {
"test_template_light": { "test_template_light": {
@ -225,7 +225,7 @@ async def test_templatex_state_boolean(
{"test_template_light": "Invalid"}, {"test_template_light": "Invalid"},
], ],
) )
async def test_template_syntax_error(hass, setup_light): async def test_template_syntax_error(hass: HomeAssistant, setup_light) -> None:
"""Test templating syntax error.""" """Test templating syntax error."""
assert hass.states.async_all("light") == [] assert hass.states.async_all("light") == []
@ -254,7 +254,7 @@ async def test_template_syntax_error(hass, setup_light):
), ),
], ],
) )
async def test_missing_key(hass, count, setup_light): async def test_missing_key(hass: HomeAssistant, count, setup_light) -> None:
"""Test missing template.""" """Test missing template."""
if count: if count:
assert hass.states.async_all("light") != [] assert hass.states.async_all("light") != []
@ -274,7 +274,7 @@ async def test_missing_key(hass, count, setup_light):
}, },
], ],
) )
async def test_on_action(hass, setup_light, calls): async def test_on_action(hass: HomeAssistant, setup_light, calls) -> None:
"""Test on action.""" """Test on action."""
hass.states.async_set("light.test_state", STATE_OFF) hass.states.async_set("light.test_state", STATE_OFF)
await hass.async_block_till_done() await hass.async_block_till_done()
@ -332,7 +332,9 @@ async def test_on_action(hass, setup_light, calls):
}, },
], ],
) )
async def test_on_action_with_transition(hass, setup_light, calls): async def test_on_action_with_transition(
hass: HomeAssistant, setup_light, calls
) -> None:
"""Test on action with transition.""" """Test on action with transition."""
hass.states.async_set("light.test_state", STATE_OFF) hass.states.async_set("light.test_state", STATE_OFF)
await hass.async_block_till_done() await hass.async_block_till_done()
@ -371,10 +373,10 @@ async def test_on_action_with_transition(hass, setup_light, calls):
], ],
) )
async def test_on_action_optimistic( async def test_on_action_optimistic(
hass, hass: HomeAssistant,
setup_light, setup_light,
calls, calls,
): ) -> None:
"""Test on action with optimistic state.""" """Test on action with optimistic state."""
hass.states.async_set("light.test_state", STATE_OFF) hass.states.async_set("light.test_state", STATE_OFF)
await hass.async_block_till_done() await hass.async_block_till_done()
@ -431,7 +433,7 @@ async def test_on_action_optimistic(
}, },
], ],
) )
async def test_off_action(hass, setup_light, calls): async def test_off_action(hass: HomeAssistant, setup_light, calls) -> None:
"""Test off action.""" """Test off action."""
hass.states.async_set("light.test_state", STATE_ON) hass.states.async_set("light.test_state", STATE_ON)
await hass.async_block_till_done() await hass.async_block_till_done()
@ -488,7 +490,9 @@ async def test_off_action(hass, setup_light, calls):
}, },
], ],
) )
async def test_off_action_with_transition(hass, setup_light, calls): async def test_off_action_with_transition(
hass: HomeAssistant, setup_light, calls
) -> None:
"""Test off action with transition.""" """Test off action with transition."""
hass.states.async_set("light.test_state", STATE_ON) hass.states.async_set("light.test_state", STATE_ON)
await hass.async_block_till_done() await hass.async_block_till_done()
@ -525,7 +529,7 @@ async def test_off_action_with_transition(hass, setup_light, calls):
}, },
], ],
) )
async def test_off_action_optimistic(hass, setup_light, calls): async def test_off_action_optimistic(hass: HomeAssistant, setup_light, calls) -> None:
"""Test off action with optimistic state.""" """Test off action with optimistic state."""
state = hass.states.get("light.test_template_light") state = hass.states.get("light.test_template_light")
assert state.state == STATE_OFF assert state.state == STATE_OFF
@ -561,10 +565,10 @@ async def test_off_action_optimistic(hass, setup_light, calls):
], ],
) )
async def test_level_action_no_template( async def test_level_action_no_template(
hass, hass: HomeAssistant,
setup_light, setup_light,
calls, calls,
): ) -> None:
"""Test setting brightness with optimistic template.""" """Test setting brightness with optimistic template."""
state = hass.states.get("light.test_template_light") state = hass.states.get("light.test_template_light")
assert state.attributes.get("brightness") is None assert state.attributes.get("brightness") is None
@ -606,12 +610,12 @@ async def test_level_action_no_template(
], ],
) )
async def test_level_template( async def test_level_template(
hass, hass: HomeAssistant,
expected_level, expected_level,
expected_color_mode, expected_color_mode,
count, count,
level_template, level_template,
): ) -> None:
"""Test the template for the level.""" """Test the template for the level."""
light_config = { light_config = {
"test_template_light": { "test_template_light": {
@ -642,12 +646,12 @@ async def test_level_template(
], ],
) )
async def test_temperature_template( async def test_temperature_template(
hass, hass: HomeAssistant,
expected_temp, expected_temp,
expected_color_mode, expected_color_mode,
count, count,
temperature_template, temperature_template,
): ) -> None:
"""Test the template for the temperature.""" """Test the template for the temperature."""
light_config = { light_config = {
"test_template_light": { "test_template_light": {
@ -678,10 +682,10 @@ async def test_temperature_template(
], ],
) )
async def test_temperature_action_no_template( async def test_temperature_action_no_template(
hass, hass: HomeAssistant,
setup_light, setup_light,
calls, calls,
): ) -> None:
"""Test setting temperature with optimistic template.""" """Test setting temperature with optimistic template."""
state = hass.states.get("light.test_template_light") state = hass.states.get("light.test_template_light")
assert state.attributes.get("color_template") is None assert state.attributes.get("color_template") is None
@ -720,7 +724,7 @@ async def test_temperature_action_no_template(
}, },
], ],
) )
async def test_friendly_name(hass, setup_light): async def test_friendly_name(hass: HomeAssistant, setup_light) -> None:
"""Test the accessibility of the friendly_name attribute.""" """Test the accessibility of the friendly_name attribute."""
state = hass.states.get("light.test_template_light") state = hass.states.get("light.test_template_light")
@ -745,7 +749,7 @@ async def test_friendly_name(hass, setup_light):
}, },
], ],
) )
async def test_icon_template(hass, setup_light): async def test_icon_template(hass: HomeAssistant, setup_light) -> None:
"""Test icon template.""" """Test icon template."""
state = hass.states.get("light.test_template_light") state = hass.states.get("light.test_template_light")
assert state.attributes.get("icon") == "" assert state.attributes.get("icon") == ""
@ -774,7 +778,7 @@ async def test_icon_template(hass, setup_light):
}, },
], ],
) )
async def test_entity_picture_template(hass, setup_light): async def test_entity_picture_template(hass: HomeAssistant, setup_light) -> None:
"""Test entity_picture template.""" """Test entity_picture template."""
state = hass.states.get("light.test_template_light") state = hass.states.get("light.test_template_light")
assert state.attributes.get("entity_picture") == "" assert state.attributes.get("entity_picture") == ""
@ -800,10 +804,10 @@ async def test_entity_picture_template(hass, setup_light):
], ],
) )
async def test_color_action_no_template( async def test_color_action_no_template(
hass, hass: HomeAssistant,
setup_light, setup_light,
calls, calls,
): ) -> None:
"""Test setting color with optimistic template.""" """Test setting color with optimistic template."""
state = hass.states.get("light.test_template_light") state = hass.states.get("light.test_template_light")
assert state.attributes.get("hs_color") is None assert state.attributes.get("hs_color") is None
@ -844,12 +848,12 @@ async def test_color_action_no_template(
], ],
) )
async def test_color_template( async def test_color_template(
hass, hass: HomeAssistant,
expected_hs, expected_hs,
expected_color_mode, expected_color_mode,
count, count,
color_template, color_template,
): ) -> None:
"""Test the template for the color.""" """Test the template for the color."""
light_config = { light_config = {
"test_template_light": { "test_template_light": {
@ -896,7 +900,9 @@ async def test_color_template(
}, },
], ],
) )
async def test_color_and_temperature_actions_no_template(hass, setup_light, calls): async def test_color_and_temperature_actions_no_template(
hass: HomeAssistant, setup_light, calls
) -> None:
"""Test setting color and color temperature with optimistic template.""" """Test setting color and color temperature with optimistic template."""
state = hass.states.get("light.test_template_light") state = hass.states.get("light.test_template_light")
assert state.attributes.get("hs_color") is None assert state.attributes.get("hs_color") is None
@ -1011,7 +1017,9 @@ async def test_color_and_temperature_actions_no_template(hass, setup_light, call
}, },
], ],
) )
async def test_effect_action_valid_effect(hass, setup_light, calls): async def test_effect_action_valid_effect(
hass: HomeAssistant, setup_light, calls
) -> None:
"""Test setting valid effect with template.""" """Test setting valid effect with template."""
state = hass.states.get("light.test_template_light") state = hass.states.get("light.test_template_light")
assert state is not None assert state is not None
@ -1054,7 +1062,9 @@ async def test_effect_action_valid_effect(hass, setup_light, calls):
}, },
], ],
) )
async def test_effect_action_invalid_effect(hass, setup_light, calls): async def test_effect_action_invalid_effect(
hass: HomeAssistant, setup_light, calls
) -> None:
"""Test setting invalid effect with template.""" """Test setting invalid effect with template."""
state = hass.states.get("light.test_template_light") state = hass.states.get("light.test_template_light")
assert state is not None assert state is not None
@ -1095,8 +1105,8 @@ async def test_effect_action_invalid_effect(hass, setup_light, calls):
], ],
) )
async def test_effect_list_template( async def test_effect_list_template(
hass, expected_effect_list, count, effect_list_template hass: HomeAssistant, expected_effect_list, count, effect_list_template
): ) -> None:
"""Test the template for the effect list.""" """Test the template for the effect list."""
light_config = { light_config = {
"test_template_light": { "test_template_light": {
@ -1130,7 +1140,9 @@ async def test_effect_list_template(
("Strobe color", "{{ 'Strobe color' }}"), ("Strobe color", "{{ 'Strobe color' }}"),
], ],
) )
async def test_effect_template(hass, expected_effect, count, effect_template): async def test_effect_template(
hass: HomeAssistant, expected_effect, count, effect_template
) -> None:
"""Test the template for the effect.""" """Test the template for the effect."""
light_config = { light_config = {
"test_template_light": { "test_template_light": {
@ -1168,8 +1180,8 @@ async def test_effect_template(hass, expected_effect, count, effect_template):
], ],
) )
async def test_min_mireds_template( async def test_min_mireds_template(
hass, expected_min_mireds, count, min_mireds_template hass: HomeAssistant, expected_min_mireds, count, min_mireds_template
): ) -> None:
"""Test the template for the min mireds.""" """Test the template for the min mireds."""
light_config = { light_config = {
"test_template_light": { "test_template_light": {
@ -1205,8 +1217,8 @@ async def test_min_mireds_template(
], ],
) )
async def test_max_mireds_template( async def test_max_mireds_template(
hass, expected_max_mireds, count, max_mireds_template hass: HomeAssistant, expected_max_mireds, count, max_mireds_template
): ) -> None:
"""Test the template for the max mireds.""" """Test the template for the max mireds."""
light_config = { light_config = {
"test_template_light": { "test_template_light": {
@ -1242,8 +1254,11 @@ async def test_max_mireds_template(
], ],
) )
async def test_supports_transition_template( async def test_supports_transition_template(
hass, expected_supports_transition, count, supports_transition_template hass: HomeAssistant,
): expected_supports_transition,
count,
supports_transition_template,
) -> None:
"""Test the template for the supports transition.""" """Test the template for the supports transition."""
light_config = { light_config = {
"test_template_light": { "test_template_light": {
@ -1288,7 +1303,9 @@ async def test_supports_transition_template(
}, },
], ],
) )
async def test_available_template_with_entities(hass, setup_light): async def test_available_template_with_entities(
hass: HomeAssistant, setup_light
) -> None:
"""Test availability templates with values from other entities.""" """Test availability templates with values from other entities."""
# When template returns true.. # When template returns true..
hass.states.async_set(_STATE_AVAILABILITY_BOOLEAN, STATE_ON) hass.states.async_set(_STATE_AVAILABILITY_BOOLEAN, STATE_ON)
@ -1318,8 +1335,8 @@ async def test_available_template_with_entities(hass, setup_light):
], ],
) )
async def test_invalid_availability_template_keeps_component_available( async def test_invalid_availability_template_keeps_component_available(
hass, setup_light, caplog_setup_text hass: HomeAssistant, setup_light, caplog_setup_text
): ) -> None:
"""Test that an invalid availability keeps the device available.""" """Test that an invalid availability keeps the device available."""
assert hass.states.get("light.test_template_light").state != STATE_UNAVAILABLE assert hass.states.get("light.test_template_light").state != STATE_UNAVAILABLE
assert "UndefinedError: 'x' is undefined" in caplog_setup_text assert "UndefinedError: 'x' is undefined" in caplog_setup_text
@ -1341,6 +1358,6 @@ async def test_invalid_availability_template_keeps_component_available(
}, },
], ],
) )
async def test_unique_id(hass, setup_light): async def test_unique_id(hass: HomeAssistant, setup_light) -> None:
"""Test unique_id option only creates one light per id.""" """Test unique_id option only creates one light per id."""
assert len(hass.states.async_all("light")) == 1 assert len(hass.states.async_all("light")) == 1

25
tests/components/template/test_lock.py
View file

@ -4,6 +4,7 @@ import pytest
from homeassistant import setup from homeassistant import setup
from homeassistant.components import lock from homeassistant.components import lock
from homeassistant.const import ATTR_ENTITY_ID, STATE_OFF, STATE_ON, STATE_UNAVAILABLE from homeassistant.const import ATTR_ENTITY_ID, STATE_OFF, STATE_ON, STATE_UNAVAILABLE
from homeassistant.core import HomeAssistant
OPTIMISTIC_LOCK_CONFIG = { OPTIMISTIC_LOCK_CONFIG = {
"platform": "template", "platform": "template",
@ -37,7 +38,7 @@ OPTIMISTIC_LOCK_CONFIG = {
}, },
], ],
) )
async def test_template_state(hass, start_ha): async def test_template_state(hass: HomeAssistant, start_ha) -> None:
"""Test template.""" """Test template."""
hass.states.async_set("switch.test_state", STATE_ON) hass.states.async_set("switch.test_state", STATE_ON)
await hass.async_block_till_done() await hass.async_block_till_done()
@ -64,7 +65,7 @@ async def test_template_state(hass, start_ha):
}, },
], ],
) )
async def test_template_state_boolean_on(hass, start_ha): async def test_template_state_boolean_on(hass: HomeAssistant, start_ha) -> None:
"""Test the setting of the state with boolean on.""" """Test the setting of the state with boolean on."""
state = hass.states.get("lock.template_lock") state = hass.states.get("lock.template_lock")
assert state.state == lock.STATE_LOCKED assert state.state == lock.STATE_LOCKED
@ -82,7 +83,7 @@ async def test_template_state_boolean_on(hass, start_ha):
}, },
], ],
) )
async def test_template_state_boolean_off(hass, start_ha): async def test_template_state_boolean_off(hass: HomeAssistant, start_ha) -> None:
"""Test the setting of the state with off.""" """Test the setting of the state with off."""
state = hass.states.get("lock.template_lock") state = hass.states.get("lock.template_lock")
assert state.state == lock.STATE_UNLOCKED assert state.state == lock.STATE_UNLOCKED
@ -138,7 +139,7 @@ async def test_template_state_boolean_off(hass, start_ha):
}, },
], ],
) )
async def test_template_syntax_error(hass, start_ha): async def test_template_syntax_error(hass: HomeAssistant, start_ha) -> None:
"""Test templating syntax error.""" """Test templating syntax error."""
assert hass.states.async_all("lock") == [] assert hass.states.async_all("lock") == []
@ -155,7 +156,7 @@ async def test_template_syntax_error(hass, start_ha):
}, },
], ],
) )
async def test_template_static(hass, start_ha): async def test_template_static(hass: HomeAssistant, start_ha) -> None:
"""Test that we allow static templates.""" """Test that we allow static templates."""
state = hass.states.get("lock.template_lock") state = hass.states.get("lock.template_lock")
assert state.state == lock.STATE_UNLOCKED assert state.state == lock.STATE_UNLOCKED
@ -178,7 +179,7 @@ async def test_template_static(hass, start_ha):
}, },
], ],
) )
async def test_lock_action(hass, start_ha, calls): async def test_lock_action(hass: HomeAssistant, start_ha, calls) -> None:
"""Test lock action.""" """Test lock action."""
await setup.async_setup_component(hass, "switch", {}) await setup.async_setup_component(hass, "switch", {})
hass.states.async_set("switch.test_state", STATE_OFF) hass.states.async_set("switch.test_state", STATE_OFF)
@ -209,7 +210,7 @@ async def test_lock_action(hass, start_ha, calls):
}, },
], ],
) )
async def test_unlock_action(hass, start_ha, calls): async def test_unlock_action(hass: HomeAssistant, start_ha, calls) -> None:
"""Test unlock action.""" """Test unlock action."""
await setup.async_setup_component(hass, "switch", {}) await setup.async_setup_component(hass, "switch", {})
hass.states.async_set("switch.test_state", STATE_ON) hass.states.async_set("switch.test_state", STATE_ON)
@ -243,7 +244,7 @@ async def test_unlock_action(hass, start_ha, calls):
@pytest.mark.parametrize( @pytest.mark.parametrize(
"test_state", [lock.STATE_UNLOCKING, lock.STATE_LOCKING, lock.STATE_JAMMED] "test_state", [lock.STATE_UNLOCKING, lock.STATE_LOCKING, lock.STATE_JAMMED]
) )
async def test_lock_state(hass, test_state, start_ha): async def test_lock_state(hass: HomeAssistant, test_state, start_ha) -> None:
"""Test value template.""" """Test value template."""
hass.states.async_set("input_select.test_state", test_state) hass.states.async_set("input_select.test_state", test_state)
await hass.async_block_till_done() await hass.async_block_till_done()
@ -265,7 +266,7 @@ async def test_lock_state(hass, test_state, start_ha):
}, },
], ],
) )
async def test_available_template_with_entities(hass, start_ha): async def test_available_template_with_entities(hass: HomeAssistant, start_ha) -> None:
"""Test availability templates with values from other entities.""" """Test availability templates with values from other entities."""
# When template returns true.. # When template returns true..
hass.states.async_set("availability_state.state", STATE_ON) hass.states.async_set("availability_state.state", STATE_ON)
@ -296,8 +297,8 @@ async def test_available_template_with_entities(hass, start_ha):
], ],
) )
async def test_invalid_availability_template_keeps_component_available( async def test_invalid_availability_template_keeps_component_available(
hass, start_ha, caplog_setup_text hass: HomeAssistant, start_ha, caplog_setup_text
): ) -> None:
"""Test that an invalid availability keeps the device available.""" """Test that an invalid availability keeps the device available."""
assert hass.states.get("lock.template_lock").state != STATE_UNAVAILABLE assert hass.states.get("lock.template_lock").state != STATE_UNAVAILABLE
assert ("UndefinedError: 'x' is undefined") in caplog_setup_text assert ("UndefinedError: 'x' is undefined") in caplog_setup_text
@ -317,7 +318,7 @@ async def test_invalid_availability_template_keeps_component_available(
}, },
], ],
) )
async def test_unique_id(hass, start_ha): async def test_unique_id(hass: HomeAssistant, start_ha) -> None:
"""Test unique_id option only creates one lock per id.""" """Test unique_id option only creates one lock per id."""
await setup.async_setup_component( await setup.async_setup_component(
hass, hass,

2
tests/components/template/test_number.py
View file

@ -126,7 +126,7 @@ async def test_all_optional_config(hass: HomeAssistant) -> None:
_verify(hass, 4, 1, 3, 5) _verify(hass, 4, 1, 3, 5)
async def test_templates_with_entities(hass, calls): async def test_templates_with_entities(hass: HomeAssistant, calls) -> None:
"""Test templates with values from other entities.""" """Test templates with values from other entities."""
with assert_setup_component(4, "input_number"): with assert_setup_component(4, "input_number"):
assert await setup.async_setup_component( assert await setup.async_setup_component(

2
tests/components/template/test_select.py
View file

@ -131,7 +131,7 @@ async def test_missing_required_keys(hass: HomeAssistant) -> None:
assert hass.states.async_all("select") == [] assert hass.states.async_all("select") == []
async def test_templates_with_entities(hass, calls): async def test_templates_with_entities(hass: HomeAssistant, calls) -> None:
"""Test templates with values from other entities.""" """Test templates with values from other entities."""
with assert_setup_component(1, "input_select"): with assert_setup_component(1, "input_select"):
assert await setup.async_setup_component( assert await setup.async_setup_component(

72
tests/components/template/test_sensor.py
View file

@ -49,7 +49,7 @@ TEST_NAME = "sensor.test_template_sensor"
}, },
], ],
) )
async def test_template_legacy(hass, start_ha): async def test_template_legacy(hass: HomeAssistant, start_ha) -> None:
"""Test template.""" """Test template."""
assert hass.states.get(TEST_NAME).state == "It ." assert hass.states.get(TEST_NAME).state == "It ."
@ -78,7 +78,7 @@ async def test_template_legacy(hass, start_ha):
}, },
], ],
) )
async def test_icon_template(hass, start_ha): async def test_icon_template(hass: HomeAssistant, start_ha) -> None:
"""Test icon template.""" """Test icon template."""
assert hass.states.get(TEST_NAME).attributes.get("icon") == "" assert hass.states.get(TEST_NAME).attributes.get("icon") == ""
@ -107,7 +107,7 @@ async def test_icon_template(hass, start_ha):
}, },
], ],
) )
async def test_entity_picture_template(hass, start_ha): async def test_entity_picture_template(hass: HomeAssistant, start_ha) -> None:
"""Test entity_picture template.""" """Test entity_picture template."""
assert hass.states.get(TEST_NAME).attributes.get("entity_picture") == "" assert hass.states.get(TEST_NAME).attributes.get("entity_picture") == ""
@ -186,7 +186,9 @@ async def test_entity_picture_template(hass, start_ha):
), ),
], ],
) )
async def test_friendly_name_template(hass, attribute, expected, start_ha): async def test_friendly_name_template(
hass: HomeAssistant, attribute, expected, start_ha
) -> None:
"""Test friendly_name template with an unknown value_template.""" """Test friendly_name template with an unknown value_template."""
assert hass.states.get(TEST_NAME).attributes.get(attribute) == expected[0] assert hass.states.get(TEST_NAME).attributes.get(attribute) == expected[0]
@ -255,7 +257,7 @@ async def test_friendly_name_template(hass, attribute, expected, start_ha):
}, },
], ],
) )
async def test_template_syntax_error(hass, start_ha): async def test_template_syntax_error(hass: HomeAssistant, start_ha) -> None:
"""Test setup with invalid device_class.""" """Test setup with invalid device_class."""
assert hass.states.async_all("sensor") == [] assert hass.states.async_all("sensor") == []
@ -277,7 +279,7 @@ async def test_template_syntax_error(hass, start_ha):
}, },
], ],
) )
async def test_template_attribute_missing(hass, start_ha): async def test_template_attribute_missing(hass: HomeAssistant, start_ha) -> None:
"""Test missing attribute template.""" """Test missing attribute template."""
assert hass.states.get(TEST_NAME).state == STATE_UNAVAILABLE assert hass.states.get(TEST_NAME).state == STATE_UNAVAILABLE
@ -303,7 +305,7 @@ async def test_template_attribute_missing(hass, start_ha):
}, },
], ],
) )
async def test_setup_valid_device_class(hass, start_ha): async def test_setup_valid_device_class(hass: HomeAssistant, start_ha) -> None:
"""Test setup with valid device_class.""" """Test setup with valid device_class."""
hass.states.async_set("sensor.test_sensor", "75") hass.states.async_set("sensor.test_sensor", "75")
await hass.async_block_till_done() await hass.async_block_till_done()
@ -369,7 +371,7 @@ async def test_creating_sensor_loads_group(hass: HomeAssistant) -> None:
}, },
], ],
) )
async def test_available_template_with_entities(hass, start_ha): async def test_available_template_with_entities(hass: HomeAssistant, start_ha) -> None:
"""Test availability tempalates with values from other entities.""" """Test availability tempalates with values from other entities."""
hass.states.async_set("sensor.availability_sensor", STATE_OFF) hass.states.async_set("sensor.availability_sensor", STATE_OFF)
@ -407,7 +409,9 @@ async def test_available_template_with_entities(hass, start_ha):
}, },
], ],
) )
async def test_invalid_attribute_template(hass, caplog, start_ha, caplog_setup_text): async def test_invalid_attribute_template(
hass: HomeAssistant, caplog: pytest.LogCaptureFixture, start_ha, caplog_setup_text
) -> None:
"""Test that errors are logged if rendering template fails.""" """Test that errors are logged if rendering template fails."""
hass.states.async_set("sensor.test_sensor", "startup") hass.states.async_set("sensor.test_sensor", "startup")
await hass.async_block_till_done() await hass.async_block_till_done()
@ -438,8 +442,8 @@ async def test_invalid_attribute_template(hass, caplog, start_ha, caplog_setup_t
], ],
) )
async def test_invalid_availability_template_keeps_component_available( async def test_invalid_availability_template_keeps_component_available(
hass, start_ha, caplog_setup_text hass: HomeAssistant, start_ha, caplog_setup_text
): ) -> None:
"""Test that an invalid availability keeps the device available.""" """Test that an invalid availability keeps the device available."""
assert hass.states.get("sensor.my_sensor").state != STATE_UNAVAILABLE assert hass.states.get("sensor.my_sensor").state != STATE_UNAVAILABLE
assert "UndefinedError: 'x' is undefined" in caplog_setup_text assert "UndefinedError: 'x' is undefined" in caplog_setup_text
@ -554,7 +558,7 @@ async def test_no_template_match_all(
}, },
], ],
) )
async def test_unique_id(hass, start_ha): async def test_unique_id(hass: HomeAssistant, start_ha) -> None:
"""Test unique_id option only creates one sensor per id.""" """Test unique_id option only creates one sensor per id."""
assert len(hass.states.async_all()) == 2 assert len(hass.states.async_all()) == 2
@ -591,7 +595,7 @@ async def test_unique_id(hass, start_ha):
}, },
], ],
) )
async def test_sun_renders_once_per_sensor(hass, start_ha): async def test_sun_renders_once_per_sensor(hass: HomeAssistant, start_ha) -> None:
"""Test sun change renders the template only once per sensor.""" """Test sun change renders the template only once per sensor."""
now = dt_util.utcnow() now = dt_util.utcnow()
@ -660,7 +664,7 @@ async def test_sun_renders_once_per_sensor(hass, start_ha):
}, },
], ],
) )
async def test_this_variable(hass, start_ha): async def test_this_variable(hass: HomeAssistant, start_ha) -> None:
"""Test template.""" """Test template."""
assert hass.states.get(TEST_NAME).state == "It: " + TEST_NAME assert hass.states.get(TEST_NAME).state == "It: " + TEST_NAME
@ -687,7 +691,9 @@ async def test_this_variable(hass, start_ha):
}, },
], ],
) )
async def test_this_variable_early_hass_not_running(hass, config, count, domain): async def test_this_variable_early_hass_not_running(
hass: HomeAssistant, config, count, domain
) -> None:
"""Test referencing 'this' variable before the entity is in the state machine. """Test referencing 'this' variable before the entity is in the state machine.
Hass is not yet started when the entity is added. Hass is not yet started when the entity is added.
@ -749,7 +755,9 @@ async def test_this_variable_early_hass_not_running(hass, config, count, domain)
}, },
], ],
) )
async def test_this_variable_early_hass_running(hass, config, count, domain): async def test_this_variable_early_hass_running(
hass: HomeAssistant, config, count, domain
) -> None:
"""Test referencing 'this' variable before the entity is in the state machine. """Test referencing 'this' variable before the entity is in the state machine.
Hass is already started when the entity is added. Hass is already started when the entity is added.
@ -800,7 +808,9 @@ async def test_this_variable_early_hass_running(hass, config, count, domain):
}, },
], ],
) )
async def test_self_referencing_sensor_loop(hass, start_ha, caplog_setup_text): async def test_self_referencing_sensor_loop(
hass: HomeAssistant, start_ha, caplog_setup_text
) -> None:
"""Test a self referencing sensor does not loop forever.""" """Test a self referencing sensor does not loop forever."""
assert len(hass.states.async_all()) == 1 assert len(hass.states.async_all()) == 1
await hass.async_block_till_done() await hass.async_block_till_done()
@ -829,8 +839,8 @@ async def test_self_referencing_sensor_loop(hass, start_ha, caplog_setup_text):
], ],
) )
async def test_self_referencing_sensor_with_icon_loop( async def test_self_referencing_sensor_with_icon_loop(
hass, start_ha, caplog_setup_text hass: HomeAssistant, start_ha, caplog_setup_text
): ) -> None:
"""Test a self referencing sensor loops forever with a valid self referencing icon.""" """Test a self referencing sensor loops forever with a valid self referencing icon."""
assert len(hass.states.async_all()) == 1 assert len(hass.states.async_all()) == 1
await hass.async_block_till_done() await hass.async_block_till_done()
@ -864,8 +874,8 @@ async def test_self_referencing_sensor_with_icon_loop(
], ],
) )
async def test_self_referencing_sensor_with_icon_and_picture_entity_loop( async def test_self_referencing_sensor_with_icon_and_picture_entity_loop(
hass, start_ha, caplog_setup_text hass: HomeAssistant, start_ha, caplog_setup_text
): ) -> None:
"""Test a self referencing sensor loop forevers with a valid self referencing icon.""" """Test a self referencing sensor loop forevers with a valid self referencing icon."""
assert len(hass.states.async_all()) == 1 assert len(hass.states.async_all()) == 1
await hass.async_block_till_done() await hass.async_block_till_done()
@ -898,7 +908,9 @@ async def test_self_referencing_sensor_with_icon_and_picture_entity_loop(
}, },
], ],
) )
async def test_self_referencing_entity_picture_loop(hass, start_ha, caplog_setup_text): async def test_self_referencing_entity_picture_loop(
hass: HomeAssistant, start_ha, caplog_setup_text
) -> None:
"""Test a self referencing sensor does not loop forever with a looping self referencing entity picture.""" """Test a self referencing sensor does not loop forever with a looping self referencing entity picture."""
assert len(hass.states.async_all()) == 1 assert len(hass.states.async_all()) == 1
next_time = dt_util.utcnow() + timedelta(seconds=1.2) next_time = dt_util.utcnow() + timedelta(seconds=1.2)
@ -1013,7 +1025,7 @@ async def test_self_referencing_icon_with_no_loop(
}, },
], ],
) )
async def test_duplicate_templates(hass, start_ha): async def test_duplicate_templates(hass: HomeAssistant, start_ha) -> None:
"""Test template entity where the value and friendly name as the same template.""" """Test template entity where the value and friendly name as the same template."""
hass.states.async_set("sensor.test_state", "Abc") hass.states.async_set("sensor.test_state", "Abc")
await hass.async_block_till_done() await hass.async_block_till_done()
@ -1082,7 +1094,7 @@ async def test_duplicate_templates(hass, start_ha):
}, },
], ],
) )
async def test_trigger_entity(hass, start_ha): async def test_trigger_entity(hass: HomeAssistant, start_ha) -> None:
"""Test trigger entity works.""" """Test trigger entity works."""
state = hass.states.get("sensor.hello_name") state = hass.states.get("sensor.hello_name")
assert state is not None assert state is not None
@ -1145,7 +1157,7 @@ async def test_trigger_entity(hass, start_ha):
}, },
], ],
) )
async def test_trigger_entity_render_error(hass, start_ha): async def test_trigger_entity_render_error(hass: HomeAssistant, start_ha) -> None:
"""Test trigger entity handles render error.""" """Test trigger entity handles render error."""
state = hass.states.get("sensor.hello") state = hass.states.get("sensor.hello")
assert state is not None assert state is not None
@ -1181,7 +1193,9 @@ async def test_trigger_entity_render_error(hass, start_ha):
}, },
], ],
) )
async def test_trigger_not_allowed_platform_config(hass, start_ha, caplog_setup_text): async def test_trigger_not_allowed_platform_config(
hass: HomeAssistant, start_ha, caplog_setup_text
) -> None:
"""Test we throw a helpful warning if a trigger is configured in platform config.""" """Test we throw a helpful warning if a trigger is configured in platform config."""
state = hass.states.get(TEST_NAME) state = hass.states.get(TEST_NAME)
assert state is None assert state is None
@ -1208,7 +1222,7 @@ async def test_trigger_not_allowed_platform_config(hass, start_ha, caplog_setup_
}, },
], ],
) )
async def test_config_top_level(hass, start_ha): async def test_config_top_level(hass: HomeAssistant, start_ha) -> None:
"""Test unique_id option only creates one sensor per id.""" """Test unique_id option only creates one sensor per id."""
assert len(hass.states.async_all()) == 1 assert len(hass.states.async_all()) == 1
state = hass.states.get("sensor.top_level") state = hass.states.get("sensor.top_level")
@ -1458,7 +1472,7 @@ async def test_entity_device_class_errors_works(hass: HomeAssistant) -> None:
], ],
) )
async def test_trigger_entity_restore_state( async def test_trigger_entity_restore_state(
hass, hass: HomeAssistant,
count, count,
domain, domain,
config, config,
@ -1466,7 +1480,7 @@ async def test_trigger_entity_restore_state(
restored_native_value, restored_native_value,
initial_state, initial_state,
initial_attributes, initial_attributes,
): ) -> None:
"""Test restoring trigger template binary sensor.""" """Test restoring trigger template binary sensor."""
restored_attributes = { restored_attributes = {

8
tests/components/template/test_switch.py
View file

@ -353,7 +353,7 @@ async def test_missing_off_does_not_create(hass: HomeAssistant) -> None:
assert hass.states.async_all("switch") == [] assert hass.states.async_all("switch") == []
async def test_on_action(hass, calls): async def test_on_action(hass: HomeAssistant, calls) -> None:
"""Test on action.""" """Test on action."""
assert await async_setup_component( assert await async_setup_component(
hass, hass,
@ -393,7 +393,7 @@ async def test_on_action(hass, calls):
assert calls[-1].data["caller"] == "switch.test_template_switch" assert calls[-1].data["caller"] == "switch.test_template_switch"
async def test_on_action_optimistic(hass, calls): async def test_on_action_optimistic(hass: HomeAssistant, calls) -> None:
"""Test on action in optimistic mode.""" """Test on action in optimistic mode."""
assert await async_setup_component( assert await async_setup_component(
hass, hass,
@ -434,7 +434,7 @@ async def test_on_action_optimistic(hass, calls):
assert calls[-1].data["caller"] == "switch.test_template_switch" assert calls[-1].data["caller"] == "switch.test_template_switch"
async def test_off_action(hass, calls): async def test_off_action(hass: HomeAssistant, calls) -> None:
"""Test off action.""" """Test off action."""
assert await async_setup_component( assert await async_setup_component(
hass, hass,
@ -474,7 +474,7 @@ async def test_off_action(hass, calls):
assert calls[-1].data["caller"] == "switch.test_template_switch" assert calls[-1].data["caller"] == "switch.test_template_switch"
async def test_off_action_optimistic(hass, calls): async def test_off_action_optimistic(hass: HomeAssistant, calls) -> None:
"""Test off action in optimistic mode.""" """Test off action in optimistic mode."""
assert await async_setup_component( assert await async_setup_component(
hass, hass,

60
tests/components/template/test_trigger.py
View file

@ -8,7 +8,7 @@ import pytest
import homeassistant.components.automation as automation import homeassistant.components.automation as automation
from homeassistant.components.template import trigger as template_trigger from homeassistant.components.template import trigger as template_trigger
from homeassistant.const import ATTR_ENTITY_ID, ENTITY_MATCH_ALL, SERVICE_TURN_OFF from homeassistant.const import ATTR_ENTITY_ID, ENTITY_MATCH_ALL, SERVICE_TURN_OFF
from homeassistant.core import Context, callback from homeassistant.core import Context, HomeAssistant, callback
from homeassistant.setup import async_setup_component from homeassistant.setup import async_setup_component
import homeassistant.util.dt as dt_util import homeassistant.util.dt as dt_util
@ -42,7 +42,7 @@ def setup_comp(hass, calls):
}, },
], ],
) )
async def test_if_fires_on_change_bool(hass, start_ha, calls): async def test_if_fires_on_change_bool(hass: HomeAssistant, start_ha, calls) -> None:
"""Test for firing on boolean change.""" """Test for firing on boolean change."""
assert len(calls) == 0 assert len(calls) == 0
@ -263,7 +263,7 @@ async def test_if_fires_on_change_bool(hass, start_ha, calls):
), ),
], ],
) )
async def test_general(hass, call_setup, start_ha, calls): async def test_general(hass: HomeAssistant, call_setup, start_ha, calls) -> None:
"""Test for firing on change.""" """Test for firing on change."""
assert len(calls) == 0 assert len(calls) == 0
@ -298,7 +298,9 @@ async def test_general(hass, call_setup, start_ha, calls):
), ),
], ],
) )
async def test_if_not_fires_because_fail(hass, call_setup, start_ha, calls): async def test_if_not_fires_because_fail(
hass: HomeAssistant, call_setup, start_ha, calls
) -> None:
"""Test for not firing after TemplateError.""" """Test for not firing after TemplateError."""
assert len(calls) == 0 assert len(calls) == 0
@ -337,7 +339,9 @@ async def test_if_not_fires_because_fail(hass, call_setup, start_ha, calls):
}, },
], ],
) )
async def test_if_fires_on_change_with_template_advanced(hass, start_ha, calls): async def test_if_fires_on_change_with_template_advanced(
hass: HomeAssistant, start_ha, calls
) -> None:
"""Test for firing on change with template advanced.""" """Test for firing on change with template advanced."""
context = Context() context = Context()
await hass.async_block_till_done() await hass.async_block_till_done()
@ -367,7 +371,7 @@ async def test_if_fires_on_change_with_template_advanced(hass, start_ha, calls):
}, },
], ],
) )
async def test_if_action(hass, start_ha, calls): async def test_if_action(hass: HomeAssistant, start_ha, calls) -> None:
"""Test for firing if action.""" """Test for firing if action."""
# Condition is not true yet # Condition is not true yet
hass.bus.async_fire("test_event") hass.bus.async_fire("test_event")
@ -397,7 +401,9 @@ async def test_if_action(hass, start_ha, calls):
}, },
], ],
) )
async def test_if_fires_on_change_with_bad_template(hass, start_ha, calls): async def test_if_fires_on_change_with_bad_template(
hass: HomeAssistant, start_ha, calls
) -> None:
"""Test for firing on change with bad template.""" """Test for firing on change with bad template."""
@ -434,7 +440,7 @@ async def test_if_fires_on_change_with_bad_template(hass, start_ha, calls):
}, },
], ],
) )
async def test_wait_template_with_trigger(hass, start_ha, calls): async def test_wait_template_with_trigger(hass: HomeAssistant, start_ha, calls) -> None:
"""Test using wait template with 'trigger.entity_id'.""" """Test using wait template with 'trigger.entity_id'."""
await hass.async_block_till_done() await hass.async_block_till_done()
@ -450,7 +456,7 @@ async def test_wait_template_with_trigger(hass, start_ha, calls):
assert calls[0].data["some"] == "template - test.entity - hello - world - None" assert calls[0].data["some"] == "template - test.entity - hello - world - None"
async def test_if_fires_on_change_with_for(hass, calls): async def test_if_fires_on_change_with_for(hass: HomeAssistant, calls) -> None:
"""Test for firing on change with for.""" """Test for firing on change with for."""
assert await async_setup_component( assert await async_setup_component(
hass, hass,
@ -505,7 +511,9 @@ async def test_if_fires_on_change_with_for(hass, calls):
}, },
], ],
) )
async def test_if_fires_on_change_with_for_advanced(hass, start_ha, calls): async def test_if_fires_on_change_with_for_advanced(
hass: HomeAssistant, start_ha, calls
) -> None:
"""Test for firing on change with for advanced.""" """Test for firing on change with for advanced."""
context = Context() context = Context()
await hass.async_block_till_done() await hass.async_block_till_done()
@ -550,7 +558,9 @@ async def test_if_fires_on_change_with_for_advanced(hass, start_ha, calls):
}, },
], ],
) )
async def test_if_fires_on_change_with_for_0_advanced(hass, start_ha, calls): async def test_if_fires_on_change_with_for_0_advanced(
hass: HomeAssistant, start_ha, calls
) -> None:
"""Test for firing on change with for: 0 advanced.""" """Test for firing on change with for: 0 advanced."""
context = Context() context = Context()
await hass.async_block_till_done() await hass.async_block_till_done()
@ -592,7 +602,9 @@ async def test_if_fires_on_change_with_for_0_advanced(hass, start_ha, calls):
}, },
], ],
) )
async def test_if_fires_on_change_with_for_2(hass, start_ha, calls): async def test_if_fires_on_change_with_for_2(
hass: HomeAssistant, start_ha, calls
) -> None:
"""Test for firing on change with for.""" """Test for firing on change with for."""
context = Context() context = Context()
hass.states.async_set("test.entity", "world", context=context) hass.states.async_set("test.entity", "world", context=context)
@ -621,7 +633,9 @@ async def test_if_fires_on_change_with_for_2(hass, start_ha, calls):
}, },
], ],
) )
async def test_if_not_fires_on_change_with_for(hass, start_ha, calls): async def test_if_not_fires_on_change_with_for(
hass: HomeAssistant, start_ha, calls
) -> None:
"""Test for firing on change with for.""" """Test for firing on change with for."""
hass.states.async_set("test.entity", "world") hass.states.async_set("test.entity", "world")
await hass.async_block_till_done() await hass.async_block_till_done()
@ -653,7 +667,9 @@ async def test_if_not_fires_on_change_with_for(hass, start_ha, calls):
}, },
], ],
) )
async def test_if_not_fires_when_turned_off_with_for(hass, start_ha, calls): async def test_if_not_fires_when_turned_off_with_for(
hass: HomeAssistant, start_ha, calls
) -> None:
"""Test for firing on change with for.""" """Test for firing on change with for."""
hass.states.async_set("test.entity", "world") hass.states.async_set("test.entity", "world")
await hass.async_block_till_done() await hass.async_block_till_done()
@ -689,7 +705,9 @@ async def test_if_not_fires_when_turned_off_with_for(hass, start_ha, calls):
}, },
], ],
) )
async def test_if_fires_on_change_with_for_template_1(hass, start_ha, calls): async def test_if_fires_on_change_with_for_template_1(
hass: HomeAssistant, start_ha, calls
) -> None:
"""Test for firing on change with for template.""" """Test for firing on change with for template."""
hass.states.async_set("test.entity", "world") hass.states.async_set("test.entity", "world")
await hass.async_block_till_done() await hass.async_block_till_done()
@ -715,7 +733,9 @@ async def test_if_fires_on_change_with_for_template_1(hass, start_ha, calls):
}, },
], ],
) )
async def test_if_fires_on_change_with_for_template_2(hass, start_ha, calls): async def test_if_fires_on_change_with_for_template_2(
hass: HomeAssistant, start_ha, calls
) -> None:
"""Test for firing on change with for template.""" """Test for firing on change with for template."""
hass.states.async_set("test.entity", "world") hass.states.async_set("test.entity", "world")
await hass.async_block_till_done() await hass.async_block_till_done()
@ -741,7 +761,9 @@ async def test_if_fires_on_change_with_for_template_2(hass, start_ha, calls):
}, },
], ],
) )
async def test_if_fires_on_change_with_for_template_3(hass, start_ha, calls): async def test_if_fires_on_change_with_for_template_3(
hass: HomeAssistant, start_ha, calls
) -> None:
"""Test for firing on change with for template.""" """Test for firing on change with for template."""
hass.states.async_set("test.entity", "world") hass.states.async_set("test.entity", "world")
await hass.async_block_till_done() await hass.async_block_till_done()
@ -767,7 +789,7 @@ async def test_if_fires_on_change_with_for_template_3(hass, start_ha, calls):
}, },
], ],
) )
async def test_invalid_for_template_1(hass, start_ha, calls): async def test_invalid_for_template_1(hass: HomeAssistant, start_ha, calls) -> None:
"""Test for invalid for template.""" """Test for invalid for template."""
with mock.patch.object(template_trigger, "_LOGGER") as mock_logger: with mock.patch.object(template_trigger, "_LOGGER") as mock_logger:
hass.states.async_set("test.entity", "world") hass.states.async_set("test.entity", "world")
@ -775,7 +797,7 @@ async def test_invalid_for_template_1(hass, start_ha, calls):
assert mock_logger.error.called assert mock_logger.error.called
async def test_if_fires_on_time_change(hass, calls): async def test_if_fires_on_time_change(hass: HomeAssistant, calls) -> None:
"""Test for firing on time changes.""" """Test for firing on time changes."""
start_time = dt_util.utcnow() + timedelta(hours=24) start_time = dt_util.utcnow() + timedelta(hours=24)
time_that_will_not_match_right_away = start_time.replace(minute=1, second=0) time_that_will_not_match_right_away = start_time.replace(minute=1, second=0)

32
tests/components/template/test_vacuum.py
View file

@ -92,7 +92,9 @@ _BATTERY_LEVEL_INPUT_NUMBER = "input_number.battery_level"
), ),
], ],
) )
async def test_valid_configs(hass, count, parm1, parm2, start_ha): async def test_valid_configs(
hass: HomeAssistant, count, parm1, parm2, start_ha
) -> None:
"""Test: configs.""" """Test: configs."""
assert len(hass.states.async_all("vacuum")) == count assert len(hass.states.async_all("vacuum")) == count
_verify(hass, parm1, parm2) _verify(hass, parm1, parm2)
@ -114,7 +116,7 @@ async def test_valid_configs(hass, count, parm1, parm2, start_ha):
}, },
], ],
) )
async def test_invalid_configs(hass, count, start_ha): async def test_invalid_configs(hass: HomeAssistant, count, start_ha) -> None:
"""Test: configs.""" """Test: configs."""
assert len(hass.states.async_all("vacuum")) == count assert len(hass.states.async_all("vacuum")) == count
@ -140,7 +142,7 @@ async def test_invalid_configs(hass, count, start_ha):
) )
], ],
) )
async def test_templates_with_entities(hass, start_ha): async def test_templates_with_entities(hass: HomeAssistant, start_ha) -> None:
"""Test templates with values from other entities.""" """Test templates with values from other entities."""
_verify(hass, STATE_UNKNOWN, None) _verify(hass, STATE_UNKNOWN, None)
@ -170,7 +172,7 @@ async def test_templates_with_entities(hass, start_ha):
) )
], ],
) )
async def test_available_template_with_entities(hass, start_ha): async def test_available_template_with_entities(hass: HomeAssistant, start_ha) -> None:
"""Test availability templates with values from other entities.""" """Test availability templates with values from other entities."""
# When template returns true.. # When template returns true..
@ -209,8 +211,8 @@ async def test_available_template_with_entities(hass, start_ha):
], ],
) )
async def test_invalid_availability_template_keeps_component_available( async def test_invalid_availability_template_keeps_component_available(
hass, start_ha, caplog_setup_text hass: HomeAssistant, start_ha, caplog_setup_text
): ) -> None:
"""Test that an invalid availability keeps the device available.""" """Test that an invalid availability keeps the device available."""
assert hass.states.get("vacuum.test_template_vacuum") != STATE_UNAVAILABLE assert hass.states.get("vacuum.test_template_vacuum") != STATE_UNAVAILABLE
assert "UndefinedError: 'x' is undefined" in caplog_setup_text assert "UndefinedError: 'x' is undefined" in caplog_setup_text
@ -239,7 +241,7 @@ async def test_invalid_availability_template_keeps_component_available(
) )
], ],
) )
async def test_attribute_templates(hass, start_ha): async def test_attribute_templates(hass: HomeAssistant, start_ha) -> None:
"""Test attribute_templates template.""" """Test attribute_templates template."""
state = hass.states.get("vacuum.test_template_vacuum") state = hass.states.get("vacuum.test_template_vacuum")
assert state.attributes["test_attribute"] == "It ." assert state.attributes["test_attribute"] == "It ."
@ -274,7 +276,9 @@ async def test_attribute_templates(hass, start_ha):
) )
], ],
) )
async def test_invalid_attribute_template(hass, start_ha, caplog_setup_text): async def test_invalid_attribute_template(
hass: HomeAssistant, start_ha, caplog_setup_text
) -> None:
"""Test that errors are logged if rendering template fails.""" """Test that errors are logged if rendering template fails."""
assert len(hass.states.async_all("vacuum")) == 1 assert len(hass.states.async_all("vacuum")) == 1
assert "test_attribute" in caplog_setup_text assert "test_attribute" in caplog_setup_text
@ -307,7 +311,7 @@ async def test_invalid_attribute_template(hass, start_ha, caplog_setup_text):
), ),
], ],
) )
async def test_unique_id(hass, start_ha): async def test_unique_id(hass: HomeAssistant, start_ha) -> None:
"""Test unique_id option only creates one vacuum per id.""" """Test unique_id option only creates one vacuum per id."""
assert len(hass.states.async_all("vacuum")) == 1 assert len(hass.states.async_all("vacuum")) == 1
@ -343,7 +347,7 @@ async def test_unused_services(hass: HomeAssistant) -> None:
_verify(hass, STATE_UNKNOWN, None) _verify(hass, STATE_UNKNOWN, None)
async def test_state_services(hass, calls): async def test_state_services(hass: HomeAssistant, calls) -> None:
"""Test state services.""" """Test state services."""
await _register_components(hass) await _register_components(hass)
@ -392,7 +396,7 @@ async def test_state_services(hass, calls):
assert calls[-1].data["caller"] == _TEST_VACUUM assert calls[-1].data["caller"] == _TEST_VACUUM
async def test_clean_spot_service(hass, calls): async def test_clean_spot_service(hass: HomeAssistant, calls) -> None:
"""Test clean spot service.""" """Test clean spot service."""
await _register_components(hass) await _register_components(hass)
@ -407,7 +411,7 @@ async def test_clean_spot_service(hass, calls):
assert calls[-1].data["caller"] == _TEST_VACUUM assert calls[-1].data["caller"] == _TEST_VACUUM
async def test_locate_service(hass, calls): async def test_locate_service(hass: HomeAssistant, calls) -> None:
"""Test locate service.""" """Test locate service."""
await _register_components(hass) await _register_components(hass)
@ -422,7 +426,7 @@ async def test_locate_service(hass, calls):
assert calls[-1].data["caller"] == _TEST_VACUUM assert calls[-1].data["caller"] == _TEST_VACUUM
async def test_set_fan_speed(hass, calls): async def test_set_fan_speed(hass: HomeAssistant, calls) -> None:
"""Test set valid fan speed.""" """Test set valid fan speed."""
await _register_components(hass) await _register_components(hass)
@ -449,7 +453,7 @@ async def test_set_fan_speed(hass, calls):
assert calls[-1].data["option"] == "medium" assert calls[-1].data["option"] == "medium"
async def test_set_invalid_fan_speed(hass, calls): async def test_set_invalid_fan_speed(hass: HomeAssistant, calls) -> None:
"""Test set invalid fan speed when fan has valid speed.""" """Test set invalid fan speed when fan has valid speed."""
await _register_components(hass) await _register_components(hass)

3
tests/components/template/test_weather.py
View file

@ -12,6 +12,7 @@ from homeassistant.components.weather import (
DOMAIN, DOMAIN,
) )
from homeassistant.const import ATTR_ATTRIBUTION from homeassistant.const import ATTR_ATTRIBUTION
from homeassistant.core import HomeAssistant
@pytest.mark.parametrize(("count", "domain"), [(1, DOMAIN)]) @pytest.mark.parametrize(("count", "domain"), [(1, DOMAIN)])
@ -39,7 +40,7 @@ from homeassistant.const import ATTR_ATTRIBUTION
}, },
], ],
) )
async def test_template_state_text(hass, start_ha): async def test_template_state_text(hass: HomeAssistant, start_ha) -> None:
"""Test the state text of a template.""" """Test the state text of a template."""
for attr, v_attr, value in [ for attr, v_attr, value in [
( (

16
tests/components/tesla_wall_connector/test_config_flow.py
View file

@ -78,8 +78,8 @@ async def test_form_other_error(
async def test_form_already_configured( async def test_form_already_configured(
mock_wall_connector_setup, mock_wall_connector_version, hass mock_wall_connector_setup, mock_wall_connector_version, hass: HomeAssistant
): ) -> None:
"""Test we get already configured.""" """Test we get already configured."""
entry = MockConfigEntry( entry = MockConfigEntry(
@ -105,8 +105,8 @@ async def test_form_already_configured(
async def test_dhcp_can_finish( async def test_dhcp_can_finish(
mock_wall_connector_setup, mock_wall_connector_version, hass mock_wall_connector_setup, mock_wall_connector_version, hass: HomeAssistant
): ) -> None:
"""Test DHCP discovery flow can finish right away.""" """Test DHCP discovery flow can finish right away."""
result = await hass.config_entries.flow.async_init( result = await hass.config_entries.flow.async_init(
@ -132,7 +132,9 @@ async def test_dhcp_can_finish(
assert result["data"] == {CONF_HOST: "1.2.3.4"} assert result["data"] == {CONF_HOST: "1.2.3.4"}
async def test_dhcp_already_exists(mock_wall_connector_version, hass): async def test_dhcp_already_exists(
mock_wall_connector_version, hass: HomeAssistant
) -> None:
"""Test DHCP discovery flow when device already exists.""" """Test DHCP discovery flow when device already exists."""
entry = MockConfigEntry( entry = MockConfigEntry(
@ -155,7 +157,9 @@ async def test_dhcp_already_exists(mock_wall_connector_version, hass):
assert result["reason"] == "already_configured" assert result["reason"] == "already_configured"
async def test_dhcp_error_from_wall_connector(mock_wall_connector_version, hass): async def test_dhcp_error_from_wall_connector(
mock_wall_connector_version, hass: HomeAssistant
) -> None:
"""Test DHCP discovery flow when we cannot communicate with the device.""" """Test DHCP discovery flow when we cannot communicate with the device."""
with patch( with patch(

26
tests/components/text/test_device_action.py
View file

@ -7,7 +7,11 @@ from homeassistant.components.device_automation import DeviceAutomationType
from homeassistant.components.text import DOMAIN, device_action from homeassistant.components.text import DOMAIN, device_action
from homeassistant.const import EntityCategory from homeassistant.const import EntityCategory
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers import config_validation as cv, device_registry as dr from homeassistant.helpers import (
config_validation as cv,
device_registry as dr,
entity_registry as er,
)
from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.helpers.entity_registry import RegistryEntryHider
from homeassistant.setup import async_setup_component from homeassistant.setup import async_setup_component
@ -20,7 +24,11 @@ from tests.common import (
from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401
async def test_get_actions(hass, device_registry, entity_registry): async def test_get_actions(
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
) -> None:
"""Test we get the expected actions for an entity.""" """Test we get the expected actions for an entity."""
config_entry = MockConfigEntry(domain="test", data={}) config_entry = MockConfigEntry(domain="test", data={})
config_entry.add_to_hass(hass) config_entry.add_to_hass(hass)
@ -57,12 +65,12 @@ async def test_get_actions(hass, device_registry, entity_registry):
), ),
) )
async def test_get_actions_hidden_auxiliary( async def test_get_actions_hidden_auxiliary(
hass, hass: HomeAssistant,
device_registry, device_registry: dr.DeviceRegistry,
entity_registry, entity_registry: er.EntityRegistry,
hidden_by, hidden_by,
entity_category, entity_category,
): ) -> None:
"""Test we get the expected actions from a hidden or auxiliary entity.""" """Test we get the expected actions from a hidden or auxiliary entity."""
config_entry = MockConfigEntry(domain="test", data={}) config_entry = MockConfigEntry(domain="test", data={})
config_entry.add_to_hass(hass) config_entry.add_to_hass(hass)
@ -95,7 +103,11 @@ async def test_get_actions_hidden_auxiliary(
assert_lists_same(actions, expected_actions) assert_lists_same(actions, expected_actions)
async def test_get_action_no_state(hass, device_registry, entity_registry): async def test_get_action_no_state(
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
) -> None:
"""Test we get the expected actions for an entity.""" """Test we get the expected actions for an entity."""
config_entry = MockConfigEntry(domain="test", data={}) config_entry = MockConfigEntry(domain="test", data={})
config_entry.add_to_hass(hass) config_entry.add_to_hass(hass)

18
tests/components/text/test_init.py
View file

@ -1,4 +1,6 @@
"""The tests for the text component.""" """The tests for the text component."""
from typing import Any
import pytest import pytest
from homeassistant.components.text import ( from homeassistant.components.text import (
@ -118,10 +120,10 @@ RESTORE_DATA = {
async def test_restore_number_save_state( async def test_restore_number_save_state(
hass, hass: HomeAssistant,
hass_storage, hass_storage: dict[str, Any],
enable_custom_integrations, enable_custom_integrations: None,
): ) -> None:
"""Test RestoreNumber.""" """Test RestoreNumber."""
platform = getattr(hass.components, "test.text") platform = getattr(hass.components, "test.text")
platform.init(empty=True) platform.init(empty=True)
@ -160,15 +162,15 @@ async def test_restore_number_save_state(
], ],
) )
async def test_restore_number_restore_state( async def test_restore_number_restore_state(
hass, hass: HomeAssistant,
enable_custom_integrations, enable_custom_integrations: None,
hass_storage, hass_storage: dict[str, Any],
native_max, native_max,
native_min, native_min,
native_value, native_value,
native_value_type, native_value_type,
extra_data, extra_data,
): ) -> None:
"""Test RestoreNumber.""" """Test RestoreNumber."""
mock_restore_cache_with_extra_data(hass, ((State("text.test", ""), extra_data),)) mock_restore_cache_with_extra_data(hass, ((State("text.test", ""), extra_data),))

5
tests/components/text/test_recorder.py
View file

@ -4,11 +4,12 @@ from __future__ import annotations
from datetime import timedelta from datetime import timedelta
from homeassistant.components import text from homeassistant.components import text
from homeassistant.components.recorder import Recorder
from homeassistant.components.recorder.db_schema import StateAttributes, States from homeassistant.components.recorder.db_schema import StateAttributes, States
from homeassistant.components.recorder.util import session_scope from homeassistant.components.recorder.util import session_scope
from homeassistant.components.text import ATTR_MAX, ATTR_MIN, ATTR_MODE, ATTR_PATTERN from homeassistant.components.text import ATTR_MAX, ATTR_MIN, ATTR_MODE, ATTR_PATTERN
from homeassistant.const import ATTR_FRIENDLY_NAME from homeassistant.const import ATTR_FRIENDLY_NAME
from homeassistant.core import State from homeassistant.core import HomeAssistant, State
from homeassistant.setup import async_setup_component from homeassistant.setup import async_setup_component
from homeassistant.util import dt as dt_util from homeassistant.util import dt as dt_util
@ -16,7 +17,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(recorder_mock, hass): async def test_exclude_attributes(recorder_mock: Recorder, hass: HomeAssistant) -> None:
"""Test siren registered attributes to be excluded.""" """Test siren registered attributes to be excluded."""
await async_setup_component(hass, text.DOMAIN, {text.DOMAIN: {"platform": "demo"}}) await async_setup_component(hass, text.DOMAIN, {text.DOMAIN: {"platform": "demo"}})
await hass.async_block_till_done() await hass.async_block_till_done()

6
tests/components/thread/test_dataset_store.py
View file

@ -1,4 +1,6 @@
"""Test the thread dataset store.""" """Test the thread dataset store."""
from typing import Any
import pytest import pytest
from python_otbr_api.tlv_parser import TLVError from python_otbr_api.tlv_parser import TLVError
@ -186,7 +188,9 @@ async def test_load_datasets(hass: HomeAssistant) -> None:
assert dataset_3_store_1 == dataset_3_store_2 assert dataset_3_store_1 == dataset_3_store_2
async def test_loading_datasets_from_storage(hass: HomeAssistant, hass_storage) -> None: async def test_loading_datasets_from_storage(
hass: HomeAssistant, hass_storage: dict[str, Any]
) -> None:
"""Test loading stored datasets on start.""" """Test loading stored datasets on start."""
hass_storage[dataset_store.STORAGE_KEY] = { hass_storage[dataset_store.STORAGE_KEY] = {
"version": dataset_store.STORAGE_VERSION_MAJOR, "version": dataset_store.STORAGE_VERSION_MAJOR,

12
tests/components/thread/test_discovery.py
View file

@ -19,7 +19,7 @@ from . import (
) )
async def test_discover_routers(hass: HomeAssistant, mock_async_zeroconf) -> None: async def test_discover_routers(hass: HomeAssistant, mock_async_zeroconf: None) -> None:
"""Test discovering thread routers.""" """Test discovering thread routers."""
mock_async_zeroconf.async_add_service_listener = AsyncMock() mock_async_zeroconf.async_add_service_listener = AsyncMock()
mock_async_zeroconf.async_remove_service_listener = AsyncMock() mock_async_zeroconf.async_remove_service_listener = AsyncMock()
@ -130,7 +130,7 @@ async def test_discover_routers(hass: HomeAssistant, mock_async_zeroconf) -> Non
"data", (ROUTER_DISCOVERY_HASS_BAD_DATA, ROUTER_DISCOVERY_HASS_MISSING_DATA) "data", (ROUTER_DISCOVERY_HASS_BAD_DATA, ROUTER_DISCOVERY_HASS_MISSING_DATA)
) )
async def test_discover_routers_bad_data( async def test_discover_routers_bad_data(
hass: HomeAssistant, mock_async_zeroconf, data hass: HomeAssistant, mock_async_zeroconf: None, data
) -> None: ) -> None:
"""Test discovering thread routers with bad or missing vendor mDNS data.""" """Test discovering thread routers with bad or missing vendor mDNS data."""
mock_async_zeroconf.async_add_service_listener = AsyncMock() mock_async_zeroconf.async_add_service_listener = AsyncMock()
@ -168,7 +168,7 @@ async def test_discover_routers_bad_data(
async def test_discover_routers_missing_mandatory_data( async def test_discover_routers_missing_mandatory_data(
hass: HomeAssistant, mock_async_zeroconf hass: HomeAssistant, mock_async_zeroconf: None
) -> None: ) -> None:
"""Test discovering thread routers with missing mandatory mDNS data.""" """Test discovering thread routers with missing mandatory mDNS data."""
mock_async_zeroconf.async_add_service_listener = AsyncMock() mock_async_zeroconf.async_add_service_listener = AsyncMock()
@ -202,7 +202,7 @@ async def test_discover_routers_missing_mandatory_data(
async def test_discover_routers_get_service_info_fails( async def test_discover_routers_get_service_info_fails(
hass: HomeAssistant, mock_async_zeroconf hass: HomeAssistant, mock_async_zeroconf: None
) -> None: ) -> None:
"""Test discovering thread routers with invalid mDNS data.""" """Test discovering thread routers with invalid mDNS data."""
mock_async_zeroconf.async_add_service_listener = AsyncMock() mock_async_zeroconf.async_add_service_listener = AsyncMock()
@ -232,7 +232,7 @@ async def test_discover_routers_get_service_info_fails(
async def test_discover_routers_update_unchanged( async def test_discover_routers_update_unchanged(
hass: HomeAssistant, mock_async_zeroconf hass: HomeAssistant, mock_async_zeroconf: None
) -> None: ) -> None:
"""Test discovering thread routers with identical mDNS data in update.""" """Test discovering thread routers with identical mDNS data in update."""
mock_async_zeroconf.async_add_service_listener = AsyncMock() mock_async_zeroconf.async_add_service_listener = AsyncMock()
@ -274,7 +274,7 @@ async def test_discover_routers_update_unchanged(
async def test_discover_routers_stop_twice( async def test_discover_routers_stop_twice(
hass: HomeAssistant, mock_async_zeroconf hass: HomeAssistant, mock_async_zeroconf: None
) -> None: ) -> None:
"""Test discovering thread routers stopping discovery twice.""" """Test discovering thread routers stopping discovery twice."""
mock_async_zeroconf.async_add_service_listener = AsyncMock() mock_async_zeroconf.async_add_service_listener = AsyncMock()

4
tests/components/thread/test_init.py
View file

@ -5,7 +5,7 @@ from homeassistant.core import HomeAssistant
from homeassistant.setup import async_setup_component from homeassistant.setup import async_setup_component
async def test_create_entry(hass: HomeAssistant): async def test_create_entry(hass: HomeAssistant) -> None:
"""Test an entry is created by async_setup.""" """Test an entry is created by async_setup."""
assert len(hass.config_entries.async_entries(thread.DOMAIN)) == 0 assert len(hass.config_entries.async_entries(thread.DOMAIN)) == 0
assert await async_setup_component(hass, thread.DOMAIN, {}) assert await async_setup_component(hass, thread.DOMAIN, {})
@ -14,7 +14,7 @@ async def test_create_entry(hass: HomeAssistant):
assert len(hass.config_entries.async_entries(thread.DOMAIN)) == 1 assert len(hass.config_entries.async_entries(thread.DOMAIN)) == 1
async def test_remove_entry(hass: HomeAssistant, thread_config_entry): async def test_remove_entry(hass: HomeAssistant, thread_config_entry) -> None:
"""Test removing the entry.""" """Test removing the entry."""
config_entry = hass.config_entries.async_entries(thread.DOMAIN)[0] config_entry = hass.config_entries.async_entries(thread.DOMAIN)[0]

14
tests/components/thread/test_websocket_api.py
View file

@ -20,7 +20,9 @@ from . import (
from tests.typing import WebSocketGenerator from tests.typing import WebSocketGenerator
async def test_add_dataset(hass: HomeAssistant, hass_ws_client) -> None: async def test_add_dataset(
hass: HomeAssistant, hass_ws_client: WebSocketGenerator
) -> None:
"""Test we can add a dataset.""" """Test we can add a dataset."""
assert await async_setup_component(hass, DOMAIN, {}) assert await async_setup_component(hass, DOMAIN, {})
await hass.async_block_till_done() await hass.async_block_till_done()
@ -41,7 +43,9 @@ async def test_add_dataset(hass: HomeAssistant, hass_ws_client) -> None:
assert dataset.tlv == DATASET_1 assert dataset.tlv == DATASET_1
async def test_add_invalid_dataset(hass: HomeAssistant, hass_ws_client) -> None: async def test_add_invalid_dataset(
hass: HomeAssistant, hass_ws_client: WebSocketGenerator
) -> None:
"""Test adding an invalid dataset.""" """Test adding an invalid dataset."""
assert await async_setup_component(hass, DOMAIN, {}) assert await async_setup_component(hass, DOMAIN, {})
await hass.async_block_till_done() await hass.async_block_till_done()
@ -112,7 +116,9 @@ async def test_delete_dataset(
} }
async def test_list_get_dataset(hass: HomeAssistant, hass_ws_client) -> None: async def test_list_get_dataset(
hass: HomeAssistant, hass_ws_client: WebSocketGenerator
) -> None:
"""Test list and get datasets.""" """Test list and get datasets."""
assert await async_setup_component(hass, DOMAIN, {}) assert await async_setup_component(hass, DOMAIN, {})
await hass.async_block_till_done() await hass.async_block_till_done()
@ -192,7 +198,7 @@ async def test_list_get_dataset(hass: HomeAssistant, hass_ws_client) -> None:
async def test_discover_routers( async def test_discover_routers(
hass: HomeAssistant, hass_ws_client, mock_async_zeroconf hass: HomeAssistant, hass_ws_client: WebSocketGenerator, mock_async_zeroconf: None
) -> None: ) -> None:
"""Test discovering thread routers.""" """Test discovering thread routers."""
mock_async_zeroconf.async_add_service_listener = AsyncMock() mock_async_zeroconf.async_add_service_listener = AsyncMock()

10
tests/components/tibber/test_config_flow.py
View file

@ -4,8 +4,10 @@ from unittest.mock import AsyncMock, MagicMock, PropertyMock, patch
import pytest import pytest
from homeassistant import config_entries from homeassistant import config_entries
from homeassistant.components.recorder import Recorder
from homeassistant.components.tibber.const import DOMAIN from homeassistant.components.tibber.const import DOMAIN
from homeassistant.const import CONF_ACCESS_TOKEN from homeassistant.const import CONF_ACCESS_TOKEN
from homeassistant.core import HomeAssistant
@pytest.fixture(name="tibber_setup", autouse=True) @pytest.fixture(name="tibber_setup", autouse=True)
@ -15,7 +17,7 @@ def tibber_setup_fixture():
yield yield
async def test_show_config_form(recorder_mock, hass): async def test_show_config_form(recorder_mock: Recorder, hass: HomeAssistant) -> None:
"""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 +27,7 @@ async def test_show_config_form(recorder_mock, hass):
assert result["step_id"] == "user" assert result["step_id"] == "user"
async def test_create_entry(recorder_mock, hass): async def test_create_entry(recorder_mock: Recorder, hass: HomeAssistant) -> None:
"""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 +51,9 @@ async def test_create_entry(recorder_mock, hass):
assert result["data"] == test_data assert result["data"] == test_data
async def test_flow_entry_already_exists(recorder_mock, hass, config_entry): async def test_flow_entry_already_exists(
recorder_mock: Recorder, hass: HomeAssistant, config_entry
) -> None:
"""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",

10
tests/components/tibber/test_diagnostics.py
View file

@ -1,14 +1,22 @@
"""Test the Netatmo diagnostics.""" """Test the Netatmo diagnostics."""
from unittest.mock import patch from unittest.mock import patch
from homeassistant.components.recorder import Recorder
from homeassistant.core import HomeAssistant
from homeassistant.setup import async_setup_component from homeassistant.setup import async_setup_component
from .test_common import mock_get_homes 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
from tests.typing import ClientSessionGenerator
async def test_entry_diagnostics(recorder_mock, hass, hass_client, config_entry): async def test_entry_diagnostics(
recorder_mock: Recorder,
hass: HomeAssistant,
hass_client: ClientSessionGenerator,
config_entry,
) -> None:
"""Test config entry diagnostics.""" """Test config entry diagnostics."""
with patch( with patch(
"tibber.Tibber.update_info", "tibber.Tibber.update_info",

4
tests/components/tibber/test_statistics.py
View file

@ -1,8 +1,10 @@
"""Test adding external statistics from Tibber.""" """Test adding external statistics from Tibber."""
from unittest.mock import AsyncMock from unittest.mock import AsyncMock
from homeassistant.components.recorder import Recorder
from homeassistant.components.recorder.statistics import statistics_during_period from homeassistant.components.recorder.statistics import statistics_during_period
from homeassistant.components.tibber.sensor import TibberDataCoordinator from homeassistant.components.tibber.sensor import TibberDataCoordinator
from homeassistant.core import HomeAssistant
from homeassistant.util import dt as dt_util from homeassistant.util import dt as dt_util
from .test_common import CONSUMPTION_DATA_1, PRODUCTION_DATA_1, mock_get_homes from .test_common import CONSUMPTION_DATA_1, PRODUCTION_DATA_1, mock_get_homes
@ -10,7 +12,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(recorder_mock, hass): async def test_async_setup_entry(recorder_mock: Recorder, hass: HomeAssistant) -> None:
"""Test setup Tibber.""" """Test setup Tibber."""
tibber_connection = AsyncMock() tibber_connection = AsyncMock()
tibber_connection.name = "tibber" tibber_connection.name = "tibber"

13
tests/components/tile/test_config_flow.py
View file

@ -8,6 +8,7 @@ from homeassistant import data_entry_flow
from homeassistant.components.tile import DOMAIN from homeassistant.components.tile import DOMAIN
from homeassistant.config_entries import SOURCE_IMPORT, SOURCE_REAUTH, SOURCE_USER from homeassistant.config_entries import SOURCE_IMPORT, SOURCE_REAUTH, SOURCE_USER
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import HomeAssistant
from .conftest import TEST_PASSWORD, TEST_USERNAME from .conftest import TEST_PASSWORD, TEST_USERNAME
@ -20,8 +21,8 @@ from .conftest import TEST_PASSWORD, TEST_USERNAME
], ],
) )
async def test_create_entry( async def test_create_entry(
hass, api, config, errors, mock_login_response, mock_pytile hass: HomeAssistant, api, config, errors, mock_login_response, mock_pytile
): ) -> None:
"""Test creating an entry.""" """Test creating an entry."""
result = await hass.config_entries.flow.async_init( result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": SOURCE_USER} DOMAIN, context={"source": SOURCE_USER}
@ -52,7 +53,7 @@ async def test_create_entry(
} }
async def test_duplicate_error(hass, config, setup_config_entry): async def test_duplicate_error(hass: HomeAssistant, config, setup_config_entry) -> None:
"""Test that errors are shown when duplicates are added.""" """Test that errors are shown when duplicates are added."""
result = await hass.config_entries.flow.async_init( result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": SOURCE_USER}, data=config DOMAIN, context={"source": SOURCE_USER}, data=config
@ -61,7 +62,7 @@ async def test_duplicate_error(hass, config, setup_config_entry):
assert result["reason"] == "already_configured" assert result["reason"] == "already_configured"
async def test_import_entry(hass, config, mock_pytile): async def test_import_entry(hass: HomeAssistant, config, mock_pytile) -> None:
"""Test importing an entry.""" """Test importing an entry."""
result = await hass.config_entries.flow.async_init( result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": SOURCE_IMPORT}, data=config DOMAIN, context={"source": SOURCE_IMPORT}, data=config
@ -74,7 +75,9 @@ async def test_import_entry(hass, config, mock_pytile):
} }
async def test_step_reauth(hass, config, config_entry, setup_config_entry): async def test_step_reauth(
hass: HomeAssistant, config, config_entry, setup_config_entry
) -> None:
"""Test that the reauth step works.""" """Test that the reauth step works."""
result = await hass.config_entries.flow.async_init( result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": SOURCE_REAUTH}, data=config DOMAIN, context={"source": SOURCE_REAUTH}, data=config

9
tests/components/tile/test_diagnostics.py
View file

@ -1,10 +1,17 @@
"""Test Tile diagnostics.""" """Test Tile diagnostics."""
from homeassistant.components.diagnostics import REDACTED from homeassistant.components.diagnostics import REDACTED
from homeassistant.core import HomeAssistant
from tests.components.diagnostics import get_diagnostics_for_config_entry from tests.components.diagnostics import get_diagnostics_for_config_entry
from tests.typing import ClientSessionGenerator
async def test_entry_diagnostics(hass, config_entry, hass_client, setup_config_entry): async def test_entry_diagnostics(
hass: HomeAssistant,
config_entry,
hass_client: ClientSessionGenerator,
setup_config_entry,
) -> None:
"""Test config entry diagnostics.""" """Test config entry diagnostics."""
assert await get_diagnostics_for_config_entry(hass, hass_client, config_entry) == { assert await get_diagnostics_for_config_entry(hass, hass_client, config_entry) == {
"tiles": [ "tiles": [

2
tests/components/tilt_ble/test_sensor.py
View file

@ -13,7 +13,7 @@ from tests.common import MockConfigEntry
from tests.components.bluetooth import inject_bluetooth_service_info from tests.components.bluetooth import inject_bluetooth_service_info
async def test_sensors(hass: HomeAssistant): async def test_sensors(hass: HomeAssistant) -> None:
"""Test setting up creates the sensors.""" """Test setting up creates the sensors."""
entry = MockConfigEntry( entry = MockConfigEntry(
domain=DOMAIN, domain=DOMAIN,

4
tests/components/time_date/test_sensor.py
View file

@ -151,7 +151,9 @@ async def test_timezone_intervals(hass: HomeAssistant) -> None:
"homeassistant.util.dt.utcnow", "homeassistant.util.dt.utcnow",
return_value=dt_util.parse_datetime("2017-11-14 02:47:19-00:00"), return_value=dt_util.parse_datetime("2017-11-14 02:47:19-00:00"),
) )
async def test_timezone_intervals_empty_parameter(utcnow_mock, hass): async def test_timezone_intervals_empty_parameter(
utcnow_mock, hass: HomeAssistant
) -> None:
"""Test get_interval() without parameters.""" """Test get_interval() without parameters."""
hass.config.set_time_zone("America/Edmonton") hass.config.set_time_zone("America/Edmonton")
device = time_date.TimeDateSensor(hass, "date") device = time_date.TimeDateSensor(hass, "date")

29
tests/components/timer/test_init.py
View file

@ -53,7 +53,8 @@ from homeassistant.helpers.restore_state import (
from homeassistant.setup import async_setup_component from homeassistant.setup import async_setup_component
from homeassistant.util.dt import utcnow from homeassistant.util.dt import utcnow
from tests.common import async_capture_events, async_fire_time_changed from tests.common import MockUser, async_capture_events, async_fire_time_changed
from tests.typing import WebSocketGenerator
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
@ -296,7 +297,9 @@ async def test_no_initial_state_and_no_restore_state(hass: HomeAssistant) -> Non
assert state.state == STATUS_IDLE assert state.state == STATUS_IDLE
async def test_config_reload(hass, hass_admin_user, hass_read_only_user): async def test_config_reload(
hass: HomeAssistant, hass_admin_user: MockUser, hass_read_only_user: MockUser
) -> None:
"""Test reload service.""" """Test reload service."""
count_start = len(hass.states.async_entity_ids()) count_start = len(hass.states.async_entity_ids())
ent_reg = er.async_get(hass) ent_reg = er.async_get(hass)
@ -500,7 +503,7 @@ async def test_state_changed_when_timer_restarted(hass: HomeAssistant) -> None:
assert len(results) == 2 assert len(results) == 2
async def test_load_from_storage(hass, storage_setup): async def test_load_from_storage(hass: HomeAssistant, storage_setup) -> None:
"""Test set up from storage.""" """Test set up from storage."""
assert await storage_setup() assert await storage_setup()
state = hass.states.get(f"{DOMAIN}.timer_from_storage") state = hass.states.get(f"{DOMAIN}.timer_from_storage")
@ -509,7 +512,7 @@ async def test_load_from_storage(hass, storage_setup):
assert state.attributes.get(ATTR_EDITABLE) assert state.attributes.get(ATTR_EDITABLE)
async def test_editable_state_attribute(hass, storage_setup): async def test_editable_state_attribute(hass: HomeAssistant, storage_setup) -> None:
"""Test editable attribute.""" """Test editable attribute."""
assert await storage_setup(config={DOMAIN: {"from_yaml": None}}) assert await storage_setup(config={DOMAIN: {"from_yaml": None}})
@ -523,7 +526,9 @@ async def test_editable_state_attribute(hass, storage_setup):
assert state.state == STATUS_IDLE assert state.state == STATUS_IDLE
async def test_ws_list(hass, hass_ws_client, storage_setup): async def test_ws_list(
hass: HomeAssistant, hass_ws_client: WebSocketGenerator, storage_setup
) -> None:
"""Test listing via WS.""" """Test listing via WS."""
assert await storage_setup(config={DOMAIN: {"from_yaml": None}}) assert await storage_setup(config={DOMAIN: {"from_yaml": None}})
@ -543,7 +548,9 @@ async def test_ws_list(hass, hass_ws_client, storage_setup):
assert result[storage_ent][ATTR_NAME] == "timer from storage" assert result[storage_ent][ATTR_NAME] == "timer from storage"
async def test_ws_delete(hass, hass_ws_client, storage_setup): async def test_ws_delete(
hass: HomeAssistant, hass_ws_client: WebSocketGenerator, storage_setup
) -> None:
"""Test WS delete cleans up entity registry.""" """Test WS delete cleans up entity registry."""
assert await storage_setup() assert await storage_setup()
@ -569,7 +576,9 @@ async def test_ws_delete(hass, hass_ws_client, storage_setup):
assert ent_reg.async_get_entity_id(DOMAIN, DOMAIN, timer_id) is None assert ent_reg.async_get_entity_id(DOMAIN, DOMAIN, timer_id) is None
async def test_update(hass, hass_ws_client, storage_setup): async def test_update(
hass: HomeAssistant, hass_ws_client: WebSocketGenerator, storage_setup
) -> None:
"""Test updating timer entity.""" """Test updating timer entity."""
assert await storage_setup() assert await storage_setup()
@ -611,7 +620,9 @@ async def test_update(hass, hass_ws_client, storage_setup):
assert state.attributes[ATTR_RESTORE] assert state.attributes[ATTR_RESTORE]
async def test_ws_create(hass, hass_ws_client, storage_setup): async def test_ws_create(
hass: HomeAssistant, hass_ws_client: WebSocketGenerator, storage_setup
) -> None:
"""Test create WS.""" """Test create WS."""
assert await storage_setup(items=[]) assert await storage_setup(items=[])
@ -642,7 +653,7 @@ async def test_ws_create(hass, hass_ws_client, storage_setup):
assert ent_reg.async_get_entity_id(DOMAIN, DOMAIN, timer_id) == timer_entity_id assert ent_reg.async_get_entity_id(DOMAIN, DOMAIN, timer_id) == timer_entity_id
async def test_setup_no_config(hass, hass_admin_user): async def test_setup_no_config(hass: HomeAssistant, hass_admin_user: MockUser) -> None:
"""Test component setup with no config.""" """Test component setup with no config."""
count_start = len(hass.states.async_entity_ids()) count_start = len(hass.states.async_entity_ids())
assert await async_setup_component(hass, DOMAIN, {}) assert await async_setup_component(hass, DOMAIN, {})

32
tests/components/tod/test_binary_sensor.py
View file

@ -104,8 +104,8 @@ async def test_midnight_turnover_before_midnight_inside_period(
async def test_midnight_turnover_after_midnight_inside_period( async def test_midnight_turnover_after_midnight_inside_period(
hass, freezer, hass_tz_info hass: HomeAssistant, freezer, hass_tz_info
): ) -> None:
"""Test midnight turnover setting before midnight inside period .""" """Test midnight turnover setting before midnight inside period ."""
test_time = datetime(2019, 1, 10, 21, 0, 0, tzinfo=hass_tz_info) test_time = datetime(2019, 1, 10, 21, 0, 0, tzinfo=hass_tz_info)
config = { config = {
@ -163,8 +163,8 @@ async def test_after_happens_tomorrow(hass: HomeAssistant) -> None:
async def test_midnight_turnover_after_midnight_outside_period( async def test_midnight_turnover_after_midnight_outside_period(
hass, freezer, hass_tz_info hass: HomeAssistant, freezer, hass_tz_info
): ) -> None:
"""Test midnight turnover setting before midnight inside period .""" """Test midnight turnover setting before midnight inside period ."""
test_time = datetime(2019, 1, 10, 20, 0, 0, tzinfo=hass_tz_info) test_time = datetime(2019, 1, 10, 20, 0, 0, tzinfo=hass_tz_info)
@ -196,7 +196,9 @@ async def test_midnight_turnover_after_midnight_outside_period(
assert state.state == STATE_OFF assert state.state == STATE_OFF
async def test_from_sunrise_to_sunset(hass, freezer, hass_tz_info): async def test_from_sunrise_to_sunset(
hass: HomeAssistant, freezer, hass_tz_info
) -> None:
"""Test period from sunrise to sunset.""" """Test period from sunrise to sunset."""
test_time = datetime(2019, 1, 12, tzinfo=hass_tz_info) test_time = datetime(2019, 1, 12, tzinfo=hass_tz_info)
sunrise = dt_util.as_local( sunrise = dt_util.as_local(
@ -253,7 +255,9 @@ async def test_from_sunrise_to_sunset(hass, freezer, hass_tz_info):
assert state.state == STATE_OFF assert state.state == STATE_OFF
async def test_from_sunset_to_sunrise(hass, freezer, hass_tz_info): async def test_from_sunset_to_sunrise(
hass: HomeAssistant, freezer, hass_tz_info
) -> None:
"""Test period from sunset to sunrise.""" """Test period from sunset to sunrise."""
test_time = datetime(2019, 1, 12, tzinfo=hass_tz_info) test_time = datetime(2019, 1, 12, tzinfo=hass_tz_info)
sunset = dt_util.as_local(get_astral_event_date(hass, "sunset", test_time)) sunset = dt_util.as_local(get_astral_event_date(hass, "sunset", test_time))
@ -307,7 +311,7 @@ async def test_from_sunset_to_sunrise(hass, freezer, hass_tz_info):
assert state.state == STATE_OFF assert state.state == STATE_OFF
async def test_offset(hass, freezer, hass_tz_info): async def test_offset(hass: HomeAssistant, freezer, hass_tz_info) -> None:
"""Test offset.""" """Test offset."""
after = datetime(2019, 1, 10, 18, 0, 0, tzinfo=hass_tz_info) + timedelta( after = datetime(2019, 1, 10, 18, 0, 0, tzinfo=hass_tz_info) + timedelta(
hours=1, minutes=34 hours=1, minutes=34
@ -361,7 +365,7 @@ async def test_offset(hass, freezer, hass_tz_info):
assert state.state == STATE_OFF assert state.state == STATE_OFF
async def test_offset_overnight(hass, freezer, hass_tz_info): async def test_offset_overnight(hass: HomeAssistant, freezer, hass_tz_info) -> None:
"""Test offset overnight.""" """Test offset overnight."""
after = datetime(2019, 1, 10, 18, 0, 0, tzinfo=hass_tz_info) + timedelta( after = datetime(2019, 1, 10, 18, 0, 0, tzinfo=hass_tz_info) + timedelta(
hours=1, minutes=34 hours=1, minutes=34
@ -392,7 +396,9 @@ async def test_offset_overnight(hass, freezer, hass_tz_info):
assert state.state == STATE_ON assert state.state == STATE_ON
async def test_norwegian_case_winter(hass, freezer, hass_tz_info): async def test_norwegian_case_winter(
hass: HomeAssistant, freezer, hass_tz_info
) -> None:
"""Test location in Norway where the sun doesn't set in summer.""" """Test location in Norway where the sun doesn't set in summer."""
hass.config.latitude = 69.6 hass.config.latitude = 69.6
hass.config.longitude = 18.8 hass.config.longitude = 18.8
@ -458,7 +464,9 @@ async def test_norwegian_case_winter(hass, freezer, hass_tz_info):
assert state.state == STATE_OFF assert state.state == STATE_OFF
async def test_norwegian_case_summer(hass, freezer, hass_tz_info): async def test_norwegian_case_summer(
hass: HomeAssistant, freezer, hass_tz_info
) -> None:
"""Test location in Norway where the sun doesn't set in summer.""" """Test location in Norway where the sun doesn't set in summer."""
hass.config.latitude = 69.6 hass.config.latitude = 69.6
hass.config.longitude = 18.8 hass.config.longitude = 18.8
@ -526,7 +534,7 @@ async def test_norwegian_case_summer(hass, freezer, hass_tz_info):
assert state.state == STATE_OFF assert state.state == STATE_OFF
async def test_sun_offset(hass, freezer, hass_tz_info): async def test_sun_offset(hass: HomeAssistant, freezer, hass_tz_info) -> None:
"""Test sun event with offset.""" """Test sun event with offset."""
test_time = datetime(2019, 1, 12, tzinfo=hass_tz_info) test_time = datetime(2019, 1, 12, tzinfo=hass_tz_info)
sunrise = dt_util.as_local( sunrise = dt_util.as_local(
@ -600,7 +608,7 @@ async def test_sun_offset(hass, freezer, hass_tz_info):
assert state.state == STATE_ON assert state.state == STATE_ON
async def test_dst(hass, freezer, hass_tz_info): async def test_dst(hass: HomeAssistant, freezer, hass_tz_info) -> None:
"""Test sun event with offset.""" """Test sun event with offset."""
hass.config.time_zone = "CET" hass.config.time_zone = "CET"
dt_util.set_default_time_zone(dt_util.get_time_zone("CET")) dt_util.set_default_time_zone(dt_util.get_time_zone("CET"))

7
tests/components/todoist/test_calendar.py
View file

@ -7,6 +7,7 @@ from todoist_api_python.models import Due, Label, Project, Task
from homeassistant import setup from homeassistant import setup
from homeassistant.components.todoist.calendar import DOMAIN from homeassistant.components.todoist.calendar import DOMAIN
from homeassistant.const import CONF_TOKEN from homeassistant.const import CONF_TOKEN
from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry from homeassistant.helpers import entity_registry
@ -63,7 +64,7 @@ def mock_api() -> AsyncMock:
@patch("homeassistant.components.todoist.calendar.TodoistAPIAsync") @patch("homeassistant.components.todoist.calendar.TodoistAPIAsync")
async def test_calendar_entity_unique_id(todoist_api, hass, api): async def test_calendar_entity_unique_id(todoist_api, hass: HomeAssistant, api) -> None:
"""Test unique id is set to project id.""" """Test unique id is set to project id."""
todoist_api.return_value = api todoist_api.return_value = api
assert await setup.async_setup_component( assert await setup.async_setup_component(
@ -84,7 +85,9 @@ async def test_calendar_entity_unique_id(todoist_api, hass, api):
@patch("homeassistant.components.todoist.calendar.TodoistAPIAsync") @patch("homeassistant.components.todoist.calendar.TodoistAPIAsync")
async def test_calendar_custom_project_unique_id(todoist_api, hass, api): async def test_calendar_custom_project_unique_id(
todoist_api, hass: HomeAssistant, api
) -> None:
"""Test unique id is None for any custom projects.""" """Test unique id is None for any custom projects."""
todoist_api.return_value = api todoist_api.return_value = api
assert await setup.async_setup_component( assert await setup.async_setup_component(

8
tests/components/tolo/test_config_flow.py
View file

@ -23,7 +23,7 @@ def toloclient_fixture() -> Mock:
yield toloclient yield toloclient
async def test_user_with_timed_out_host(hass: HomeAssistant, toloclient: Mock): async def test_user_with_timed_out_host(hass: HomeAssistant, toloclient: Mock) -> None:
"""Test a user initiated config flow with provided host which times out.""" """Test a user initiated config flow with provided host which times out."""
toloclient().get_status_info.side_effect = ResponseTimedOutError() toloclient().get_status_info.side_effect = ResponseTimedOutError()
@ -38,7 +38,7 @@ async def test_user_with_timed_out_host(hass: HomeAssistant, toloclient: Mock):
assert result["errors"] == {"base": "cannot_connect"} assert result["errors"] == {"base": "cannot_connect"}
async def test_user_walkthrough(hass: HomeAssistant, toloclient: Mock): async def test_user_walkthrough(hass: HomeAssistant, toloclient: Mock) -> None:
"""Test complete user flow with first wrong and then correct host.""" """Test complete user flow with first wrong and then correct host."""
result = await hass.config_entries.flow.async_init( result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": SOURCE_USER} DOMAIN, context={"source": SOURCE_USER}
@ -70,7 +70,7 @@ async def test_user_walkthrough(hass: HomeAssistant, toloclient: Mock):
assert result3["data"][CONF_HOST] == "127.0.0.1" assert result3["data"][CONF_HOST] == "127.0.0.1"
async def test_dhcp(hass: HomeAssistant, toloclient: Mock): async def test_dhcp(hass: HomeAssistant, toloclient: Mock) -> None:
"""Test starting a flow from discovery.""" """Test starting a flow from discovery."""
toloclient().get_status_info.side_effect = lambda *args, **kwargs: object() toloclient().get_status_info.side_effect = lambda *args, **kwargs: object()
@ -91,7 +91,7 @@ async def test_dhcp(hass: HomeAssistant, toloclient: Mock):
assert result["result"].unique_id == "00:11:22:33:44:55" assert result["result"].unique_id == "00:11:22:33:44:55"
async def test_dhcp_invalid_device(hass: HomeAssistant, toloclient: Mock): async def test_dhcp_invalid_device(hass: HomeAssistant, toloclient: Mock) -> None:
"""Test starting a flow from discovery.""" """Test starting a flow from discovery."""
toloclient().get_status_info.side_effect = lambda *args, **kwargs: None toloclient().get_status_info.side_effect = lambda *args, **kwargs: None

27
tests/components/tomato/test_device_tracker.py
View file

@ -17,6 +17,7 @@ from homeassistant.const import (
CONF_USERNAME, CONF_USERNAME,
CONF_VERIFY_SSL, CONF_VERIFY_SSL,
) )
from homeassistant.core import HomeAssistant
def mock_session_response(*args, **kwargs): def mock_session_response(*args, **kwargs):
@ -63,7 +64,7 @@ def mock_session_send():
yield mock_session_send yield mock_session_send
def test_config_missing_optional_params(hass, mock_session_send): def test_config_missing_optional_params(hass: HomeAssistant, mock_session_send) -> None:
"""Test the setup without optional parameters.""" """Test the setup without optional parameters."""
config = { config = {
DOMAIN: tomato.PLATFORM_SCHEMA( DOMAIN: tomato.PLATFORM_SCHEMA(
@ -89,7 +90,7 @@ def test_config_missing_optional_params(hass, mock_session_send):
@mock.patch("os.access", return_value=True) @mock.patch("os.access", return_value=True)
@mock.patch("os.path.isfile", mock.Mock(return_value=True)) @mock.patch("os.path.isfile", mock.Mock(return_value=True))
def test_config_default_nonssl_port(hass, mock_session_send): def test_config_default_nonssl_port(hass: HomeAssistant, mock_session_send) -> None:
"""Test the setup without a default port set without ssl enabled.""" """Test the setup without a default port set without ssl enabled."""
config = { config = {
DOMAIN: tomato.PLATFORM_SCHEMA( DOMAIN: tomato.PLATFORM_SCHEMA(
@ -108,7 +109,7 @@ def test_config_default_nonssl_port(hass, mock_session_send):
@mock.patch("os.access", return_value=True) @mock.patch("os.access", return_value=True)
@mock.patch("os.path.isfile", mock.Mock(return_value=True)) @mock.patch("os.path.isfile", mock.Mock(return_value=True))
def test_config_default_ssl_port(hass, mock_session_send): def test_config_default_ssl_port(hass: HomeAssistant, mock_session_send) -> None:
"""Test the setup without a default port set with ssl enabled.""" """Test the setup without a default port set with ssl enabled."""
config = { config = {
DOMAIN: tomato.PLATFORM_SCHEMA( DOMAIN: tomato.PLATFORM_SCHEMA(
@ -128,7 +129,9 @@ def test_config_default_ssl_port(hass, mock_session_send):
@mock.patch("os.access", return_value=True) @mock.patch("os.access", return_value=True)
@mock.patch("os.path.isfile", mock.Mock(return_value=True)) @mock.patch("os.path.isfile", mock.Mock(return_value=True))
def test_config_verify_ssl_but_no_ssl_enabled(hass, mock_session_send): def test_config_verify_ssl_but_no_ssl_enabled(
hass: HomeAssistant, mock_session_send
) -> None:
"""Test the setup with a string with ssl_verify but ssl not enabled.""" """Test the setup with a string with ssl_verify but ssl not enabled."""
config = { config = {
DOMAIN: tomato.PLATFORM_SCHEMA( DOMAIN: tomato.PLATFORM_SCHEMA(
@ -159,7 +162,7 @@ def test_config_verify_ssl_but_no_ssl_enabled(hass, mock_session_send):
@mock.patch("os.access", return_value=True) @mock.patch("os.access", return_value=True)
@mock.patch("os.path.isfile", mock.Mock(return_value=True)) @mock.patch("os.path.isfile", mock.Mock(return_value=True))
def test_config_valid_verify_ssl_path(hass, mock_session_send): def test_config_valid_verify_ssl_path(hass: HomeAssistant, mock_session_send) -> None:
"""Test the setup with a string for ssl_verify. """Test the setup with a string for ssl_verify.
Representing the absolute path to a CA certificate bundle. Representing the absolute path to a CA certificate bundle.
@ -193,7 +196,7 @@ def test_config_valid_verify_ssl_path(hass, mock_session_send):
) )
def test_config_valid_verify_ssl_bool(hass, mock_session_send): def test_config_valid_verify_ssl_bool(hass: HomeAssistant, mock_session_send) -> None:
"""Test the setup with a bool for ssl_verify.""" """Test the setup with a bool for ssl_verify."""
config = { config = {
DOMAIN: tomato.PLATFORM_SCHEMA( DOMAIN: tomato.PLATFORM_SCHEMA(
@ -294,7 +297,7 @@ def test_config_errors() -> None:
@mock.patch("requests.Session.send", side_effect=mock_session_response) @mock.patch("requests.Session.send", side_effect=mock_session_response)
def test_config_bad_credentials(hass, mock_exception_logger): def test_config_bad_credentials(hass: HomeAssistant, mock_exception_logger) -> None:
"""Test the setup with bad credentials.""" """Test the setup with bad credentials."""
config = { config = {
DOMAIN: tomato.PLATFORM_SCHEMA( DOMAIN: tomato.PLATFORM_SCHEMA(
@ -317,7 +320,7 @@ def test_config_bad_credentials(hass, mock_exception_logger):
@mock.patch("requests.Session.send", side_effect=mock_session_response) @mock.patch("requests.Session.send", side_effect=mock_session_response)
def test_bad_response(hass, mock_exception_logger): def test_bad_response(hass: HomeAssistant, mock_exception_logger) -> None:
"""Test the setup with bad response from router.""" """Test the setup with bad response from router."""
config = { config = {
DOMAIN: tomato.PLATFORM_SCHEMA( DOMAIN: tomato.PLATFORM_SCHEMA(
@ -340,7 +343,7 @@ def test_bad_response(hass, mock_exception_logger):
@mock.patch("requests.Session.send", side_effect=mock_session_response) @mock.patch("requests.Session.send", side_effect=mock_session_response)
def test_scan_devices(hass, mock_exception_logger): def test_scan_devices(hass: HomeAssistant, mock_exception_logger) -> None:
"""Test scanning for new devices.""" """Test scanning for new devices."""
config = { config = {
DOMAIN: tomato.PLATFORM_SCHEMA( DOMAIN: tomato.PLATFORM_SCHEMA(
@ -359,7 +362,7 @@ def test_scan_devices(hass, mock_exception_logger):
@mock.patch("requests.Session.send", side_effect=mock_session_response) @mock.patch("requests.Session.send", side_effect=mock_session_response)
def test_bad_connection(hass, mock_exception_logger): def test_bad_connection(hass: HomeAssistant, mock_exception_logger) -> None:
"""Test the router with a connection error.""" """Test the router with a connection error."""
config = { config = {
DOMAIN: tomato.PLATFORM_SCHEMA( DOMAIN: tomato.PLATFORM_SCHEMA(
@ -387,7 +390,7 @@ def test_bad_connection(hass, mock_exception_logger):
@mock.patch("requests.Session.send", side_effect=mock_session_response) @mock.patch("requests.Session.send", side_effect=mock_session_response)
def test_router_timeout(hass, mock_exception_logger): def test_router_timeout(hass: HomeAssistant, mock_exception_logger) -> None:
"""Test the router with a timeout error.""" """Test the router with a timeout error."""
config = { config = {
DOMAIN: tomato.PLATFORM_SCHEMA( DOMAIN: tomato.PLATFORM_SCHEMA(
@ -415,7 +418,7 @@ def test_router_timeout(hass, mock_exception_logger):
@mock.patch("requests.Session.send", side_effect=mock_session_response) @mock.patch("requests.Session.send", side_effect=mock_session_response)
def test_get_device_name(hass, mock_exception_logger): def test_get_device_name(hass: HomeAssistant, mock_exception_logger) -> None:
"""Test getting device names.""" """Test getting device names."""
config = { config = {
DOMAIN: tomato.PLATFORM_SCHEMA( DOMAIN: tomato.PLATFORM_SCHEMA(