diff --git a/homeassistant/components/mqtt/abbreviations.py b/homeassistant/components/mqtt/abbreviations.py index 00f6d357553..5fe0da90feb 100644 --- a/homeassistant/components/mqtt/abbreviations.py +++ b/homeassistant/components/mqtt/abbreviations.py @@ -169,6 +169,7 @@ ABBREVIATIONS = { "pr_mode_stat_t": "preset_mode_state_topic", "pr_mode_val_tpl": "preset_mode_value_template", "pr_modes": "preset_modes", + "ptrn": "pattern", "r_tpl": "red_template", "rel_s": "release_summary", "rel_u": "release_url", diff --git a/homeassistant/components/mqtt/config_integration.py b/homeassistant/components/mqtt/config_integration.py index d487f1b382f..9db18af0718 100644 --- a/homeassistant/components/mqtt/config_integration.py +++ b/homeassistant/components/mqtt/config_integration.py @@ -32,6 +32,7 @@ from . import ( sensor as sensor_platform, siren as siren_platform, switch as switch_platform, + text as text_platform, update as update_platform, vacuum as vacuum_platform, ) @@ -130,6 +131,9 @@ PLATFORM_CONFIG_SCHEMA_BASE = vol.Schema( Platform.SWITCH.value: vol.All( cv.ensure_list, [switch_platform.PLATFORM_SCHEMA_MODERN] # type: ignore[has-type] ), + Platform.TEXT.value: vol.All( + cv.ensure_list, [text_platform.PLATFORM_SCHEMA_MODERN] # type: ignore[has-type] + ), Platform.UPDATE.value: vol.All( cv.ensure_list, [update_platform.PLATFORM_SCHEMA_MODERN] # type: ignore[has-type] ), diff --git a/homeassistant/components/mqtt/const.py b/homeassistant/components/mqtt/const.py index 7b4c7378b9e..f7fa93a36d0 100644 --- a/homeassistant/components/mqtt/const.py +++ b/homeassistant/components/mqtt/const.py @@ -101,6 +101,7 @@ PLATFORMS = [ Platform.SENSOR, Platform.SIREN, Platform.SWITCH, + Platform.TEXT, Platform.UPDATE, Platform.VACUUM, ] @@ -122,6 +123,7 @@ RELOADABLE_PLATFORMS = [ Platform.SENSOR, Platform.SIREN, Platform.SWITCH, + Platform.TEXT, Platform.UPDATE, Platform.VACUUM, ] diff --git a/homeassistant/components/mqtt/discovery.py b/homeassistant/components/mqtt/discovery.py index 9907de18ee9..2d460a69592 100644 --- a/homeassistant/components/mqtt/discovery.py +++ b/homeassistant/components/mqtt/discovery.py @@ -63,6 +63,7 @@ SUPPORTED_COMPONENTS = [ "sensor", "switch", "tag", + "text", "update", "vacuum", ] diff --git a/homeassistant/components/mqtt/text.py b/homeassistant/components/mqtt/text.py new file mode 100644 index 00000000000..032dba66719 --- /dev/null +++ b/homeassistant/components/mqtt/text.py @@ -0,0 +1,224 @@ +"""Support for MQTT text platform.""" +from __future__ import annotations + +from collections.abc import Callable +import functools +import logging +import re +from typing import Any + +import voluptuous as vol + +from homeassistant.components import text +from homeassistant.components.text import TextEntity +from homeassistant.config_entries import ConfigEntry +from homeassistant.const import ( + CONF_MODE, + CONF_NAME, + CONF_OPTIMISTIC, + CONF_VALUE_TEMPLATE, + MAX_LENGTH_STATE_STATE, +) +from homeassistant.core import HomeAssistant, callback +from homeassistant.helpers import config_validation as cv +from homeassistant.helpers.entity_platform import AddEntitiesCallback +from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType + +from . import subscription +from .config import MQTT_RW_SCHEMA +from .const import ( + CONF_COMMAND_TEMPLATE, + CONF_COMMAND_TOPIC, + CONF_ENCODING, + CONF_QOS, + CONF_RETAIN, + CONF_STATE_TOPIC, +) +from .debug_info import log_messages +from .mixins import MQTT_ENTITY_COMMON_SCHEMA, MqttEntity, async_setup_entry_helper +from .models import ( + MqttCommandTemplate, + MqttValueTemplate, + PublishPayloadType, + ReceiveMessage, + ReceivePayloadType, +) +from .util import get_mqtt_data + +_LOGGER = logging.getLogger(__name__) + +CONF_MAX = "max" +CONF_MIN = "min" +CONF_PATTERN = "pattern" + +DEFAULT_NAME = "MQTT Text" +DEFAULT_OPTIMISTIC = False +DEFAULT_PAYLOAD_RESET = "None" + +MQTT_TEXT_ATTRIBUTES_BLOCKED = frozenset( + { + text.ATTR_MAX, + text.ATTR_MIN, + text.ATTR_MODE, + text.ATTR_PATTERN, + } +) + + +def valid_text_size_configuration(config: ConfigType) -> ConfigType: + """Validate that the text length configuration is valid, throws if it isn't.""" + if config[CONF_MIN] >= config[CONF_MAX]: + raise ValueError("text length min must be >= max") + if config[CONF_MAX] > MAX_LENGTH_STATE_STATE: + raise ValueError(f"max text length must be <= {MAX_LENGTH_STATE_STATE}") + + return config + + +_PLATFORM_SCHEMA_BASE = MQTT_RW_SCHEMA.extend( + { + vol.Optional(CONF_COMMAND_TEMPLATE): cv.template, + vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, + vol.Optional(CONF_MAX, default=MAX_LENGTH_STATE_STATE): cv.positive_int, + vol.Optional(CONF_MIN, default=0): cv.positive_int, + vol.Optional(CONF_MODE, default=text.TextMode.TEXT): vol.In( + [text.TextMode.TEXT, text.TextMode.PASSWORD] + ), + vol.Optional(CONF_OPTIMISTIC, default=DEFAULT_OPTIMISTIC): cv.boolean, + vol.Optional(CONF_PATTERN): cv.is_regex, + vol.Optional(CONF_VALUE_TEMPLATE): cv.template, + }, +).extend(MQTT_ENTITY_COMMON_SCHEMA.schema) + + +DISCOVERY_SCHEMA = vol.All( + _PLATFORM_SCHEMA_BASE.extend({}, extra=vol.REMOVE_EXTRA), + valid_text_size_configuration, +) + +PLATFORM_SCHEMA_MODERN = vol.All(_PLATFORM_SCHEMA_BASE, valid_text_size_configuration) + + +async def async_setup_entry( + hass: HomeAssistant, + config_entry: ConfigEntry, + async_add_entities: AddEntitiesCallback, +) -> None: + """Set up MQTT text through configuration.yaml and dynamically through MQTT discovery.""" + setup = functools.partial( + _async_setup_entity, hass, async_add_entities, config_entry=config_entry + ) + await async_setup_entry_helper(hass, text.DOMAIN, setup, DISCOVERY_SCHEMA) + + +async def _async_setup_entity( + hass: HomeAssistant, + async_add_entities: AddEntitiesCallback, + config: ConfigType, + config_entry: ConfigEntry, + discovery_data: DiscoveryInfoType | None = None, +) -> None: + """Set up the MQTT text.""" + async_add_entities([MqttTextEntity(hass, config, config_entry, discovery_data)]) + + +class MqttTextEntity(MqttEntity, TextEntity): + """Representation of the MQTT text entity.""" + + _attributes_extra_blocked = MQTT_TEXT_ATTRIBUTES_BLOCKED + _entity_id_format = text.ENTITY_ID_FORMAT + + _compiled_pattern: re.Pattern[Any] | None + _optimistic: bool + _command_template: Callable[[PublishPayloadType], PublishPayloadType] + _value_template: Callable[[ReceivePayloadType], ReceivePayloadType] + + def __init__( + self, + hass: HomeAssistant, + config: ConfigType, + config_entry: ConfigEntry, + discovery_data: DiscoveryInfoType | None = None, + ) -> None: + """Initialize MQTT text entity.""" + self._attr_native_value = None + MqttEntity.__init__(self, hass, config, config_entry, discovery_data) + + @staticmethod + def config_schema() -> vol.Schema: + """Return the config schema.""" + return DISCOVERY_SCHEMA + + def _setup_from_config(self, config: ConfigType) -> None: + """(Re)Setup the entity.""" + self._attr_native_max = config[CONF_MAX] + self._attr_native_min = config[CONF_MIN] + self._attr_mode = config[CONF_MODE] + self._compiled_pattern = config.get(CONF_PATTERN) + self._attr_pattern = ( + self._compiled_pattern.pattern if self._compiled_pattern else None + ) + + self._command_template = MqttCommandTemplate( + config.get(CONF_COMMAND_TEMPLATE), + entity=self, + ).async_render + self._value_template = MqttValueTemplate( + config.get(CONF_VALUE_TEMPLATE), + entity=self, + ).async_render_with_possible_json_value + optimistic: bool = config[CONF_OPTIMISTIC] + self._optimistic = optimistic or config.get(CONF_STATE_TOPIC) is None + + def _prepare_subscribe_topics(self) -> None: + """(Re)Subscribe to topics.""" + topics: dict[str, Any] = {} + + def add_subscription( + topics: dict[str, Any], topic: str, msg_callback: Callable + ) -> None: + if self._config.get(topic) is not None: + topics[topic] = { + "topic": self._config[topic], + "msg_callback": msg_callback, + "qos": self._config[CONF_QOS], + "encoding": self._config[CONF_ENCODING] or None, + } + + @callback + @log_messages(self.hass, self.entity_id) + def handle_state_message_received(msg: ReceiveMessage) -> None: + """Handle receiving state message via MQTT.""" + payload = str(self._value_template(msg.payload)) + self._attr_native_value = payload + get_mqtt_data(self.hass).state_write_requests.write_state_request(self) + + add_subscription(topics, CONF_STATE_TOPIC, handle_state_message_received) + + self._sub_state = subscription.async_prepare_subscribe_topics( + self.hass, self._sub_state, topics + ) + + async def _subscribe_topics(self) -> None: + """(Re)Subscribe to topics.""" + await subscription.async_subscribe_topics(self.hass, self._sub_state) + + @property + def assumed_state(self) -> bool: + """Return true if we do optimistic updates.""" + return self._optimistic + + async def async_set_value(self, value: str) -> None: + """Change the text.""" + payload = self._command_template(value) + + await self.async_publish( + self._config[CONF_COMMAND_TOPIC], + payload, + self._config[CONF_QOS], + self._config[CONF_RETAIN], + self._config[CONF_ENCODING], + ) + if self._optimistic: + self._attr_native_value = value + self.async_write_ha_state() diff --git a/tests/components/mqtt/test_text.py b/tests/components/mqtt/test_text.py new file mode 100644 index 00000000000..6b4680bd030 --- /dev/null +++ b/tests/components/mqtt/test_text.py @@ -0,0 +1,674 @@ +"""The tests for the MQTT text platform.""" +from __future__ import annotations + +from unittest.mock import patch + +import pytest + +from homeassistant.components import mqtt, text +from homeassistant.const import ( + ATTR_ASSUMED_STATE, + ATTR_ENTITY_ID, + STATE_UNKNOWN, + Platform, +) +from homeassistant.core import HomeAssistant +from homeassistant.setup import async_setup_component + +from .test_common import ( + help_test_availability_when_connection_lost, + help_test_availability_without_topic, + help_test_custom_availability_payload, + help_test_default_availability_payload, + help_test_discovery_broken, + help_test_discovery_removal, + help_test_discovery_update, + help_test_discovery_update_attr, + help_test_discovery_update_unchanged, + help_test_encoding_subscribable_topics, + help_test_entity_debug_info_message, + help_test_entity_device_info_remove, + help_test_entity_device_info_update, + help_test_entity_device_info_with_connection, + help_test_entity_device_info_with_identifier, + help_test_entity_id_update_discovery_update, + help_test_entity_id_update_subscriptions, + help_test_publishing_with_custom_encoding, + help_test_reloadable, + help_test_setting_attribute_via_mqtt_json_message, + help_test_setting_attribute_with_template, + help_test_setting_blocked_attribute_via_mqtt_json_message, + help_test_setup_manual_entity_from_yaml, + help_test_unique_id, + help_test_unload_config_entry_with_platform, + help_test_update_with_json_attrs_bad_json, + help_test_update_with_json_attrs_not_dict, +) + +from tests.common import async_fire_mqtt_message + +DEFAULT_CONFIG = { + mqtt.DOMAIN: {text.DOMAIN: {"name": "test", "command_topic": "test-topic"}} +} + + +@pytest.fixture(autouse=True) +def text_platform_only(): + """Only setup the text platform to speed up tests.""" + with patch("homeassistant.components.mqtt.PLATFORMS", [Platform.TEXT]): + yield + + +async def async_set_value( + hass: HomeAssistant, entity_id: str, value: str | None +) -> None: + """Set input_text to value.""" + await hass.services.async_call( + text.DOMAIN, + text.SERVICE_SET_VALUE, + {ATTR_ENTITY_ID: entity_id, text.ATTR_VALUE: value}, + blocking=True, + ) + + +async def test_controlling_state_via_topic( + hass: HomeAssistant, mqtt_mock_entry_with_yaml_config +) -> None: + """Test the controlling state via topic.""" + assert await async_setup_component( + hass, + mqtt.DOMAIN, + { + mqtt.DOMAIN: { + text.DOMAIN: { + "name": "test", + "state_topic": "state-topic", + "command_topic": "command-topic", + "mode": "password", + } + } + }, + ) + await hass.async_block_till_done() + await mqtt_mock_entry_with_yaml_config() + + state = hass.states.get("text.test") + assert state.state == STATE_UNKNOWN + assert state.attributes[text.ATTR_MODE] == "password" + assert not state.attributes.get(ATTR_ASSUMED_STATE) + + async_fire_mqtt_message(hass, "state-topic", "some state") + + state = hass.states.get("text.test") + assert state.state == "some state" + + async_fire_mqtt_message(hass, "state-topic", "some other state") + + state = hass.states.get("text.test") + assert state.state == "some other state" + + async_fire_mqtt_message(hass, "state-topic", "") + + state = hass.states.get("text.test") + assert state.state == "" + + +async def test_controlling_validation_state_via_topic( + hass, mqtt_mock_entry_with_yaml_config +) -> None: + """Test the validation of a received state.""" + assert await async_setup_component( + hass, + mqtt.DOMAIN, + { + mqtt.DOMAIN: { + text.DOMAIN: { + "name": "test", + "state_topic": "state-topic", + "command_topic": "command-topic", + "mode": "text", + "min": 2, + "max": 10, + "pattern": "(y|n)", + } + } + }, + ) + await hass.async_block_till_done() + await mqtt_mock_entry_with_yaml_config() + + state = hass.states.get("text.test") + assert state.state == STATE_UNKNOWN + assert state.attributes[text.ATTR_MODE] == "text" + + async_fire_mqtt_message(hass, "state-topic", "yes") + state = hass.states.get("text.test") + assert state.state == "yes" + + # test pattern error + with pytest.raises(ValueError): + async_fire_mqtt_message(hass, "state-topic", "other") + await hass.async_block_till_done() + state = hass.states.get("text.test") + assert state.state == "yes" + + # test text size to large + with pytest.raises(ValueError): + async_fire_mqtt_message(hass, "state-topic", "yesyesyesyes") + await hass.async_block_till_done() + state = hass.states.get("text.test") + assert state.state == "yes" + + # test text size to small + with pytest.raises(ValueError): + async_fire_mqtt_message(hass, "state-topic", "y") + await hass.async_block_till_done() + state = hass.states.get("text.test") + assert state.state == "yes" + + async_fire_mqtt_message(hass, "state-topic", "no") + await hass.async_block_till_done() + state = hass.states.get("text.test") + assert state.state == "no" + + +async def test_attribute_validation_max_greater_then_min(hass) -> None: + """Test the validation of min and max configuration attributes.""" + assert not await async_setup_component( + hass, + mqtt.DOMAIN, + { + mqtt.DOMAIN: { + text.DOMAIN: { + "name": "test", + "command_topic": "command-topic", + "min": 20, + "max": 10, + } + } + }, + ) + + +async def test_attribute_validation_max_not_greater_then_max_state_length(hass) -> None: + """Test the max value of of max configuration attribute.""" + assert not await async_setup_component( + hass, + mqtt.DOMAIN, + { + mqtt.DOMAIN: { + text.DOMAIN: { + "name": "test", + "command_topic": "command-topic", + "min": 20, + "max": 257, + } + } + }, + ) + + +async def test_sending_mqtt_commands_and_optimistic( + hass, mqtt_mock_entry_with_yaml_config +): + """Test the sending MQTT commands in optimistic mode.""" + assert await async_setup_component( + hass, + mqtt.DOMAIN, + { + mqtt.DOMAIN: { + text.DOMAIN: { + "name": "test", + "command_topic": "command-topic", + "qos": "2", + } + } + }, + ) + await hass.async_block_till_done() + mqtt_mock = await mqtt_mock_entry_with_yaml_config() + + state = hass.states.get("text.test") + assert state.state == STATE_UNKNOWN + assert state.attributes.get(ATTR_ASSUMED_STATE) + + await async_set_value(hass, "text.test", "some other state") + await hass.async_block_till_done() + + mqtt_mock.async_publish.assert_called_once_with( + "command-topic", "some other state", 2, False + ) + mqtt_mock.async_publish.reset_mock() + state = hass.states.get("text.test") + assert state.state == "some other state" + + await async_set_value(hass, "text.test", "some new state") + + mqtt_mock.async_publish.assert_called_once_with( + "command-topic", "some new state", 2, False + ) + state = hass.states.get("text.test") + assert state.state == "some new state" + + +async def test_set_text_validation(hass, mqtt_mock_entry_with_yaml_config): + """Test the initial state in optimistic mode.""" + assert await async_setup_component( + hass, + mqtt.DOMAIN, + { + mqtt.DOMAIN: { + text.DOMAIN: { + "name": "test", + "command_topic": "command-topic", + "mode": "text", + "min": 2, + "max": 10, + "pattern": "(y|n)", + } + } + }, + ) + await hass.async_block_till_done() + await mqtt_mock_entry_with_yaml_config() + + state = hass.states.get("text.test") + assert state.state == STATE_UNKNOWN + assert state.attributes.get(ATTR_ASSUMED_STATE) + + # text too long + with pytest.raises(ValueError): + await async_set_value(hass, "text.test", "yes yes yes yes") + + # text too short + with pytest.raises(ValueError): + await async_set_value(hass, "text.test", "y") + + # text not matching pattern + with pytest.raises(ValueError): + await async_set_value(hass, "text.test", "other") + + await async_set_value(hass, "text.test", "no") + state = hass.states.get("text.test") + assert state.state == "no" + + +async def test_availability_when_connection_lost( + hass, mqtt_mock_entry_with_yaml_config +): + """Test availability after MQTT disconnection.""" + await help_test_availability_when_connection_lost( + hass, mqtt_mock_entry_with_yaml_config, text.DOMAIN, DEFAULT_CONFIG + ) + + +async def test_availability_without_topic(hass, mqtt_mock_entry_with_yaml_config): + """Test availability without defined availability topic.""" + await help_test_availability_without_topic( + hass, mqtt_mock_entry_with_yaml_config, text.DOMAIN, DEFAULT_CONFIG + ) + + +async def test_default_availability_payload(hass, mqtt_mock_entry_with_yaml_config): + """Test availability by default payload with defined topic.""" + config = { + mqtt.DOMAIN: { + text.DOMAIN: { + "name": "test", + "state_topic": "state-topic", + "command_topic": "command-topic", + } + } + } + + await help_test_default_availability_payload( + hass, + mqtt_mock_entry_with_yaml_config, + text.DOMAIN, + config, + True, + "state-topic", + "some state", + ) + + +async def test_custom_availability_payload(hass, mqtt_mock_entry_with_yaml_config): + """Test availability by custom payload with defined topic.""" + config = { + mqtt.DOMAIN: { + text.DOMAIN: { + "name": "test", + "state_topic": "state-topic", + "command_topic": "command-topic", + } + } + } + + await help_test_custom_availability_payload( + hass, + mqtt_mock_entry_with_yaml_config, + text.DOMAIN, + config, + True, + "state-topic", + "1", + ) + + +async def test_setting_attribute_via_mqtt_json_message( + hass, mqtt_mock_entry_with_yaml_config +): + """Test the setting of attribute via MQTT with JSON payload.""" + await help_test_setting_attribute_via_mqtt_json_message( + hass, mqtt_mock_entry_with_yaml_config, text.DOMAIN, DEFAULT_CONFIG + ) + + +async def test_setting_blocked_attribute_via_mqtt_json_message( + hass, mqtt_mock_entry_no_yaml_config +): + """Test the setting of attribute via MQTT with JSON payload.""" + await help_test_setting_blocked_attribute_via_mqtt_json_message( + hass, mqtt_mock_entry_no_yaml_config, text.DOMAIN, DEFAULT_CONFIG, {} + ) + + +async def test_setting_attribute_with_template(hass, mqtt_mock_entry_with_yaml_config): + """Test the setting of attribute via MQTT with JSON payload.""" + await help_test_setting_attribute_with_template( + hass, mqtt_mock_entry_with_yaml_config, text.DOMAIN, DEFAULT_CONFIG + ) + + +async def test_update_with_json_attrs_not_dict( + hass, mqtt_mock_entry_with_yaml_config, caplog +): + """Test attributes get extracted from a JSON result.""" + await help_test_update_with_json_attrs_not_dict( + hass, + mqtt_mock_entry_with_yaml_config, + caplog, + text.DOMAIN, + DEFAULT_CONFIG, + ) + + +async def test_update_with_json_attrs_bad_json( + hass, mqtt_mock_entry_with_yaml_config, caplog +): + """Test attributes get extracted from a JSON result.""" + await help_test_update_with_json_attrs_bad_json( + hass, + mqtt_mock_entry_with_yaml_config, + caplog, + text.DOMAIN, + DEFAULT_CONFIG, + ) + + +async def test_discovery_update_attr(hass, mqtt_mock_entry_no_yaml_config, caplog): + """Test update of discovered MQTTAttributes.""" + await help_test_discovery_update_attr( + hass, + mqtt_mock_entry_no_yaml_config, + caplog, + text.DOMAIN, + DEFAULT_CONFIG, + ) + + +async def test_unique_id(hass, mqtt_mock_entry_with_yaml_config): + """Test unique id option only creates one text per unique_id.""" + config = { + mqtt.DOMAIN: { + text.DOMAIN: [ + { + "name": "Test 1", + "state_topic": "test-topic", + "command_topic": "command-topic", + "unique_id": "TOTALLY_UNIQUE", + }, + { + "name": "Test 2", + "state_topic": "test-topic", + "command_topic": "command-topic", + "unique_id": "TOTALLY_UNIQUE", + }, + ] + } + } + await help_test_unique_id( + hass, mqtt_mock_entry_with_yaml_config, text.DOMAIN, config + ) + + +async def test_discovery_removal_text(hass, mqtt_mock_entry_no_yaml_config, caplog): + """Test removal of discovered text entity.""" + data = ( + '{ "name": "test",' + ' "state_topic": "test_topic",' + ' "command_topic": "test_topic" }' + ) + await help_test_discovery_removal( + hass, mqtt_mock_entry_no_yaml_config, caplog, text.DOMAIN, data + ) + + +async def test_discovery_text_update(hass, mqtt_mock_entry_no_yaml_config, caplog): + """Test update of discovered text entity.""" + config1 = { + "name": "Beer", + "command_topic": "command-topic", + "state_topic": "state-topic", + } + config2 = { + "name": "Milk", + "command_topic": "command-topic", + "state_topic": "state-topic", + } + + await help_test_discovery_update( + hass, mqtt_mock_entry_no_yaml_config, caplog, text.DOMAIN, config1, config2 + ) + + +async def test_discovery_update_unchanged_update( + hass, mqtt_mock_entry_no_yaml_config, caplog +): + """Test update of discovered update.""" + data1 = '{ "name": "Beer", "state_topic": "text-topic", "command_topic": "command-topic"}' + with patch( + "homeassistant.components.mqtt.text.MqttTextEntity.discovery_update" + ) as discovery_update: + await help_test_discovery_update_unchanged( + hass, + mqtt_mock_entry_no_yaml_config, + caplog, + text.DOMAIN, + data1, + discovery_update, + ) + + +async def test_discovery_update_text(hass, mqtt_mock_entry_no_yaml_config, caplog): + """Test update of discovered text entity.""" + config1 = {"name": "Beer", "command_topic": "cmd-topic1"} + config2 = {"name": "Milk", "command_topic": "cmd-topic2"} + await help_test_discovery_update( + hass, mqtt_mock_entry_no_yaml_config, caplog, text.DOMAIN, config1, config2 + ) + + +async def test_discovery_update_unchanged_climate( + hass, mqtt_mock_entry_no_yaml_config, caplog +): + """Test update of discovered text entity.""" + data1 = '{ "name": "Beer", "command_topic": "cmd-topic" }' + with patch( + "homeassistant.components.mqtt.text.MqttTextEntity.discovery_update" + ) as discovery_update: + await help_test_discovery_update_unchanged( + hass, + mqtt_mock_entry_no_yaml_config, + caplog, + text.DOMAIN, + data1, + discovery_update, + ) + + +@pytest.mark.no_fail_on_log_exception +async def test_discovery_broken(hass, mqtt_mock_entry_no_yaml_config, caplog): + """Test handling of bad discovery message.""" + data1 = '{ "name": "Beer" }' + data2 = ( + '{ "name": "Milk",' + ' "state_topic": "test_topic",' + ' "command_topic": "test_topic" }' + ) + await help_test_discovery_broken( + hass, mqtt_mock_entry_no_yaml_config, caplog, text.DOMAIN, data1, data2 + ) + + +async def test_entity_device_info_with_connection(hass, mqtt_mock_entry_no_yaml_config): + """Test MQTT text device registry integration.""" + await help_test_entity_device_info_with_connection( + hass, mqtt_mock_entry_no_yaml_config, text.DOMAIN, DEFAULT_CONFIG + ) + + +async def test_entity_device_info_with_identifier(hass, mqtt_mock_entry_no_yaml_config): + """Test MQTT text device registry integration.""" + await help_test_entity_device_info_with_identifier( + hass, mqtt_mock_entry_no_yaml_config, text.DOMAIN, DEFAULT_CONFIG + ) + + +async def test_entity_device_info_update(hass, mqtt_mock_entry_no_yaml_config): + """Test device registry update.""" + await help_test_entity_device_info_update( + hass, mqtt_mock_entry_no_yaml_config, text.DOMAIN, DEFAULT_CONFIG + ) + + +async def test_entity_device_info_remove(hass, mqtt_mock_entry_no_yaml_config): + """Test device registry remove.""" + await help_test_entity_device_info_remove( + hass, mqtt_mock_entry_no_yaml_config, text.DOMAIN, DEFAULT_CONFIG + ) + + +async def test_entity_id_update_subscriptions(hass, mqtt_mock_entry_with_yaml_config): + """Test MQTT subscriptions are managed when entity_id is updated.""" + await help_test_entity_id_update_subscriptions( + hass, mqtt_mock_entry_with_yaml_config, text.DOMAIN, DEFAULT_CONFIG + ) + + +async def test_entity_id_update_discovery_update(hass, mqtt_mock_entry_no_yaml_config): + """Test MQTT discovery update when entity_id is updated.""" + await help_test_entity_id_update_discovery_update( + hass, mqtt_mock_entry_no_yaml_config, text.DOMAIN, DEFAULT_CONFIG + ) + + +async def test_entity_debug_info_message(hass, mqtt_mock_entry_no_yaml_config): + """Test MQTT debug info.""" + await help_test_entity_debug_info_message( + hass, mqtt_mock_entry_no_yaml_config, text.DOMAIN, DEFAULT_CONFIG, None + ) + + +@pytest.mark.parametrize( + "service,topic,parameters,payload,template", + [ + ( + text.SERVICE_SET_VALUE, + "command_topic", + {text.ATTR_VALUE: "some text"}, + "some text", + "command_template", + ), + ], +) +async def test_publishing_with_custom_encoding( + hass, + mqtt_mock_entry_with_yaml_config, + caplog, + service, + topic, + parameters, + payload, + template, +): + """Test publishing MQTT payload with different encoding.""" + domain = text.DOMAIN + config = DEFAULT_CONFIG + + await help_test_publishing_with_custom_encoding( + hass, + mqtt_mock_entry_with_yaml_config, + caplog, + domain, + config, + service, + topic, + parameters, + payload, + template, + ) + + +async def test_reloadable(hass, mqtt_mock_entry_with_yaml_config, caplog, tmp_path): + """Test reloading the MQTT platform.""" + domain = text.DOMAIN + config = DEFAULT_CONFIG + await help_test_reloadable( + hass, mqtt_mock_entry_with_yaml_config, caplog, tmp_path, domain, config + ) + + +@pytest.mark.parametrize( + "topic,value,attribute,attribute_value", + [ + ("state_topic", "some text", None, "some text"), + ], +) +async def test_encoding_subscribable_topics( + hass, + mqtt_mock_entry_with_yaml_config, + caplog, + topic, + value, + attribute, + attribute_value, +): + """Test handling of incoming encoded payload.""" + await help_test_encoding_subscribable_topics( + hass, + mqtt_mock_entry_with_yaml_config, + caplog, + text.DOMAIN, + DEFAULT_CONFIG[mqtt.DOMAIN][text.DOMAIN], + topic, + value, + attribute, + attribute_value, + ) + + +async def test_setup_manual_entity_from_yaml(hass): + """Test setup manual configured MQTT entity.""" + platform = text.DOMAIN + await help_test_setup_manual_entity_from_yaml(hass, DEFAULT_CONFIG) + assert hass.states.get(f"{platform}.test") + + +async def test_unload_entry(hass, mqtt_mock_entry_with_yaml_config, tmp_path): + """Test unloading the config entry.""" + domain = text.DOMAIN + config = DEFAULT_CONFIG + await help_test_unload_config_entry_with_platform( + hass, mqtt_mock_entry_with_yaml_config, tmp_path, domain, config + )