Add missing translation for connection failure on OpenRGB (#171892)

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

homeassistant/components/flo/entity.py

@@ -10,7 +10,6 @@ from .coordinator import FloDeviceDataUpdateCoordinator
 class FloEntity(Entity):
     """A base class for Flo entities."""
 
-    _attr_force_update = False
     _attr_has_entity_name = True
     _attr_should_poll = False
 

homeassistant/components/matter/__init__.py

@@ -60,7 +60,7 @@ def get_matter_device_info(
         return None
 
     return MatterDeviceInfo(
-        unique_id=node.device_info.uniqueID,
+        unique_id=node.device_info.uniqueID or "",
         vendor_id=hex(node.device_info.vendorID),
         product_id=hex(node.device_info.productID),
     )

homeassistant/components/matter/diagnostics.py

@@ -6,13 +6,14 @@ from typing import Any
 from chip.clusters import Objects
 from matter_server.common.helpers.util import dataclass_to_dict, parse_attribute_path
 
-from homeassistant.components.diagnostics import REDACTED
+from homeassistant.components.diagnostics import REDACTED, async_redact_data
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr
 
 from .helpers import MatterConfigEntry, get_matter, get_node_from_device_entry
 
 ATTRIBUTES_TO_REDACT = {Objects.BasicInformation.Attributes.Location}
+SERVER_INFO_TO_REDACT = {"wifi_ssid"}
 
 
 def redact_matter_attributes(node_data: dict[str, Any]) -> dict[str, Any]:
@@ -44,6 +45,7 @@ async def async_get_config_entry_diagnostics(
     matter = get_matter(hass)
     server_diagnostics = await matter.matter_client.get_diagnostics()
     data = dataclass_to_dict(server_diagnostics)
+    data["info"] = async_redact_data(data["info"], SERVER_INFO_TO_REDACT)
     nodes = [redact_matter_attributes(node_data) for node_data in data["nodes"]]
     data["nodes"] = nodes
 
@@ -59,7 +61,9 @@ async def async_get_device_diagnostics(
     node = get_node_from_device_entry(hass, device)
 
     return {
-        "server_info": dataclass_to_dict(server_diagnostics.info),
+        "server_info": async_redact_data(
+            dataclass_to_dict(server_diagnostics.info), SERVER_INFO_TO_REDACT
+        ),
         "node": redact_matter_attributes(
             remove_serialization_type(dataclass_to_dict(node.node_data) if node else {})
         ),

homeassistant/components/matter/manifest.json

@@ -8,6 +8,6 @@
   "documentation": "https://www.home-assistant.io/integrations/matter",
   "integration_type": "hub",
   "iot_class": "local_push",
-  "requirements": ["matter-python-client==0.6.0"],
+  "requirements": ["matter-python-client==0.7.1"],
   "zeroconf": ["_matter._tcp.local.", "_matterc._udp.local."]
 }

homeassistant/components/mqtt/abbreviations.py

@@ -108,6 +108,7 @@ ABBREVIATIONS = {
     "mode_stat_t": "mode_state_topic",
     "mode_stat_tpl": "mode_state_template",
     "modes": "modes",
+    "msg_exp_int": "message_expiry_interval",
     "name": "name",
     "o": "origin",
     "off_dly": "off_delay",

homeassistant/components/mqtt/config_flow.py

@@ -120,6 +120,8 @@ from homeassistant.helpers.hassio import is_hassio
 from homeassistant.helpers.json import json_dumps
 from homeassistant.helpers.selector import (
     BooleanSelector,
+    DurationSelector,
+    DurationSelectorConfig,
     FileSelector,
     FileSelectorConfig,
     NumberSelector,
@@ -227,6 +229,7 @@ from .const import (
     CONF_LAST_RESET_VALUE_TEMPLATE,
     CONF_MAX,
     CONF_MAX_KELVIN,
+    CONF_MESSAGE_EXPIRY_INTERVAL,
     CONF_MIN,
     CONF_MIN_KELVIN,
     CONF_MODE_COMMAND_TEMPLATE,
@@ -3721,6 +3724,11 @@ MQTT_DEVICE_PLATFORM_FIELDS = {
         default=DEFAULT_QOS,
         section="mqtt_settings",
     ),
+    CONF_MESSAGE_EXPIRY_INTERVAL: PlatformField(
+        selector=DurationSelector(DurationSelectorConfig(enable_day=True)),
+        required=False,
+        section="mqtt_settings",
+    ),
 }
 
 

homeassistant/components/mqtt/const.py

@@ -49,6 +49,7 @@ CONF_IMAGE_TOPIC = "image_topic"
 CONF_JSON_ATTRS_TOPIC = "json_attributes_topic"
 CONF_JSON_ATTRS_TEMPLATE = "json_attributes_template"
 CONF_KEEPALIVE = "keepalive"
+CONF_MESSAGE_EXPIRY_INTERVAL = "message_expiry_interval"
 CONF_ORIGIN = "origin"
 CONF_QOS = ATTR_QOS
 CONF_RETAIN = ATTR_RETAIN

homeassistant/components/mqtt/debug_info.py

@@ -17,7 +17,7 @@ from .models import DATA_MQTT, PublishPayloadType
 STORED_MESSAGES = 10
 
 
-@dataclass
+@dataclass(frozen=True, slots=True)
 class TimestampedPublishMessage:
     """MQTT Message."""
 
@@ -26,6 +26,8 @@ class TimestampedPublishMessage:
     qos: int
     retain: bool
     timestamp: float
+    encoding: str | None
+    kwargs: dict[str, Any]
 
 
 def log_message(
@@ -35,6 +37,8 @@ def log_message(
     payload: PublishPayloadType,
     qos: int,
     retain: bool,
+    encoding: str | None,
+    **kwargs: Any,
 ) -> None:
     """Log an outgoing MQTT message."""
     entity_info = hass.data[DATA_MQTT].debug_info_entities.setdefault(
@@ -45,7 +49,13 @@ def log_message(
             "messages": deque(maxlen=STORED_MESSAGES),
         }
     msg = TimestampedPublishMessage(
-        topic, payload, qos, retain, timestamp=time.monotonic()
+        topic,
+        payload,
+        qos,
+        retain,
+        timestamp=time.monotonic(),
+        encoding=encoding,
+        kwargs=kwargs,
     )
     entity_info["transmitted"][topic]["messages"].append(msg)
 

homeassistant/components/mqtt/entity.py

@@ -84,6 +84,7 @@ from .const import (
     CONF_JSON_ATTRS_TEMPLATE,
     CONF_JSON_ATTRS_TOPIC,
     CONF_MANUFACTURER,
+    CONF_MESSAGE_EXPIRY_INTERVAL,
     CONF_PAYLOAD_AVAILABLE,
     CONF_PAYLOAD_NOT_AVAILABLE,
     CONF_QOS,
@@ -94,7 +95,6 @@ from .const import (
     CONF_SW_VERSION,
     CONF_TOPIC,
     CONF_VIA_DEVICE,
-    DEFAULT_ENCODING,
     DOMAIN,
     MQTT_CONNECTION_STATE,
 )
@@ -153,6 +153,8 @@ MQTT_ATTRIBUTES_BLOCKED = {
     "unit_of_measurement",
 }
 
+PUBLISH_KWARGS = (CONF_MESSAGE_EXPIRY_INTERVAL,)
+
 
 @callback
 def async_handle_schema_error(
@@ -1539,36 +1541,20 @@ class MqttEntity(
         await MqttDiscoveryUpdateMixin.async_will_remove_from_hass(self)
         debug_info.remove_entity_data(self.hass, self.entity_id)
 
-    async def async_publish(
-        self,
-        topic: str,
-        payload: PublishPayloadType,
-        qos: int = 0,
-        retain: bool = False,
-        encoding: str | None = DEFAULT_ENCODING,
-    ) -> None:
-        """Publish message to an MQTT topic."""
-        log_message(self.hass, self.entity_id, topic, payload, qos, retain)
-        await async_publish(
-            self.hass,
-            topic,
-            payload,
-            qos,
-            retain,
-            encoding,
-        )
-
     async def async_publish_with_config(
         self, topic: str, payload: PublishPayloadType
     ) -> None:
         """Publish payload to a topic using config."""
-        await self.async_publish(
-            topic,
-            payload,
-            self._config[CONF_QOS],
-            self._config[CONF_RETAIN],
-            self._config[CONF_ENCODING],
+        kwargs: dict[str, Any] = {
+            key: value for key, value in self._config.items() if key in PUBLISH_KWARGS
+        }
+        qos: int = self._config[CONF_QOS]
+        retain: bool = self._config[CONF_RETAIN]
+        encoding: str = self._config[CONF_ENCODING]
+        log_message(
+            self.hass, self.entity_id, topic, payload, qos, retain, encoding, **kwargs
         )
+        await async_publish(self.hass, topic, payload, qos, retain, encoding, **kwargs)
 
     @staticmethod
     @abstractmethod

homeassistant/components/mqtt/models.py

@@ -509,10 +509,20 @@ class MqttComponentConfig:
     discovery_payload: MQTTDiscoveryPayload
 
 
+class MessageExpiryInterval(TypedDict, total=False):
+    """Hold the Message Expiry Interval."""
+
+    days: float
+    hours: float
+    minutes: float
+    seconds: float
+
+
 class DeviceMqttOptions(TypedDict, total=False):
     """Hold the shared MQTT specific options for an MQTT device."""
 
     qos: int
+    message_expiry_interval: MessageExpiryInterval
 
 
 class MqttDeviceData(TypedDict, total=False):

homeassistant/components/mqtt/schemas.py

@@ -40,6 +40,7 @@ from .const import (
     CONF_JSON_ATTRS_TEMPLATE,
     CONF_JSON_ATTRS_TOPIC,
     CONF_MANUFACTURER,
+    CONF_MESSAGE_EXPIRY_INTERVAL,
     CONF_ORIGIN,
     CONF_PAYLOAD_AVAILABLE,
     CONF_PAYLOAD_NOT_AVAILABLE,
@@ -66,6 +67,7 @@ SHARED_OPTIONS = [
     CONF_AVAILABILITY_TOPIC,
     CONF_COMMAND_TOPIC,
     CONF_ENCODING,
+    CONF_MESSAGE_EXPIRY_INTERVAL,
     CONF_PAYLOAD_AVAILABLE,
     CONF_PAYLOAD_NOT_AVAILABLE,
     CONF_STATE_TOPIC,
@@ -161,6 +163,14 @@ MQTT_ORIGIN_INFO_SCHEMA = vol.All(
     ),
 )
 
+
+def valid_message_expiry_interval(value: Any) -> int:
+    """Return Message Expiry Interval in seconds."""
+    if isinstance(value, int):
+        return cv.positive_int(value)  # type: ignore[no-any-return]
+    return int(cv.positive_time_period_dict(value).total_seconds())
+
+
 MQTT_ENTITY_COMMON_SCHEMA = _MQTT_AVAILABILITY_SCHEMA.extend(
     {
         vol.Optional(CONF_DEVICE): MQTT_ENTITY_DEVICE_INFO_SCHEMA,
@@ -172,6 +182,7 @@ MQTT_ENTITY_COMMON_SCHEMA = _MQTT_AVAILABILITY_SCHEMA.extend(
         vol.Optional(CONF_JSON_ATTRS_TOPIC): valid_subscribe_topic,
         vol.Optional(CONF_JSON_ATTRS_TEMPLATE): cv.template,
         vol.Optional(CONF_DEFAULT_ENTITY_ID): cv.string,
+        vol.Optional(CONF_MESSAGE_EXPIRY_INTERVAL): valid_message_expiry_interval,
         vol.Optional(CONF_UNIQUE_ID): cv.string,
     }
 )
@@ -203,6 +214,7 @@ DEVICE_DISCOVERY_SCHEMA = _MQTT_AVAILABILITY_SCHEMA.extend(
         vol.Required(CONF_ORIGIN): MQTT_ORIGIN_INFO_SCHEMA,
         vol.Optional(CONF_STATE_TOPIC): valid_subscribe_topic,
         vol.Optional(CONF_COMMAND_TOPIC): valid_publish_topic,
+        vol.Optional(CONF_MESSAGE_EXPIRY_INTERVAL): valid_message_expiry_interval,
         vol.Optional(CONF_QOS): valid_qos_schema,
         vol.Optional(CONF_ENCODING): cv.string,
     }

homeassistant/components/mqtt/strings.json

@@ -197,9 +197,11 @@
             },
             "mqtt_settings": {
               "data": {
+                "message_expiry_interval": "Message Expiry Interval",
                 "qos": "QoS"
               },
               "data_description": {
+                "message_expiry_interval": "Retention time interval for published message.",
                 "qos": "The Quality of Service value the device's entities should use."
               },
               "name": "MQTT settings"

homeassistant/components/openrgb/strings.json

@@ -73,6 +73,9 @@
     }
   },
   "exceptions": {
+    "cannot_connect": {
+      "message": "Failed to connect to OpenRGB SDK server {server_address}: {error}"
+    },
     "communication_error": {
       "message": "Failed to communicate with OpenRGB SDK server {server_address}: {error}"
     },

homeassistant/components/system_bridge/__init__.py

@@ -1,9 +1,7 @@
 """The System Bridge integration."""
 
 import asyncio
-from dataclasses import asdict
 import logging
-from typing import Any
 
 from systembridgeconnector.exceptions import (
     AuthenticationException,
@@ -11,71 +9,34 @@ from systembridgeconnector.exceptions import (
     ConnectionErrorException,
     DataMissingException,
 )
-from systembridgeconnector.models.keyboard_key import KeyboardKey
-from systembridgeconnector.models.keyboard_text import KeyboardText
-from systembridgeconnector.models.modules.processes import Process
-from systembridgeconnector.models.open_path import OpenPath
-from systembridgeconnector.models.open_url import OpenUrl
 from systembridgeconnector.version import Version
-import voluptuous as vol
 
-from homeassistant.config_entries import ConfigEntry, ConfigEntryState
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     CONF_API_KEY,
-    CONF_COMMAND,
     CONF_ENTITY_ID,
     CONF_HOST,
-    CONF_ID,
     CONF_NAME,
-    CONF_PATH,
     CONF_PORT,
     CONF_TOKEN,
-    CONF_URL,
     Platform,
 )
-from homeassistant.core import (
-    HomeAssistant,
-    ServiceCall,
-    ServiceResponse,
-    SupportsResponse,
-)
-from homeassistant.exceptions import (
-    ConfigEntryAuthFailed,
-    ConfigEntryNotReady,
-    HomeAssistantError,
-    ServiceValidationError,
-)
-from homeassistant.helpers import (
-    config_validation as cv,
-    device_registry as dr,
-    discovery,
-)
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
+from homeassistant.helpers import config_validation as cv, discovery
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
+from homeassistant.helpers.typing import ConfigType
 
 from .config_flow import SystemBridgeConfigFlow
 from .const import DATA_WAIT_TIMEOUT, DOMAIN, MODULES
 from .coordinator import SystemBridgeConfigEntry, SystemBridgeDataUpdateCoordinator
-
-
-def _get_coordinator(
-    hass: HomeAssistant, entry_id: str
-) -> SystemBridgeDataUpdateCoordinator:
-    """Return the coordinator for a config entry id."""
-    entry: SystemBridgeConfigEntry | None = hass.config_entries.async_get_entry(
-        entry_id
-    )
-    if entry is None or entry.state is not ConfigEntryState.LOADED:
-        raise ServiceValidationError(
-            translation_domain=DOMAIN,
-            translation_key="device_not_found",
-            translation_placeholders={"device": entry_id},
-        )
-    return entry.runtime_data
-
+from .services import async_setup_services
 
 _LOGGER = logging.getLogger(__name__)
 
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
+
 PLATFORMS = [
     Platform.BINARY_SENSOR,
     Platform.MEDIA_PLAYER,
@@ -84,26 +45,12 @@ PLATFORMS = [
     Platform.UPDATE,
 ]
 
-CONF_BRIDGE = "bridge"
-CONF_KEY = "key"
-CONF_TEXT = "text"
 
-SERVICE_GET_PROCESS_BY_ID = "get_process_by_id"
-SERVICE_GET_PROCESSES_BY_NAME = "get_processes_by_name"
-SERVICE_OPEN_PATH = "open_path"
-SERVICE_POWER_COMMAND = "power_command"
-SERVICE_OPEN_URL = "open_url"
-SERVICE_SEND_KEYPRESS = "send_keypress"
-SERVICE_SEND_TEXT = "send_text"
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the System Bridge services."""
 
-POWER_COMMAND_MAP = {
-    "hibernate": "power_hibernate",
-    "lock": "power_lock",
-    "logout": "power_logout",
-    "restart": "power_restart",
-    "shutdown": "power_shutdown",
-    "sleep": "power_sleep",
-}
+    async_setup_services(hass)
+    return True
 
 
 async def async_setup_entry(
@@ -231,219 +178,6 @@ async def async_setup_entry(
         )
     )
 
-    if hass.services.has_service(DOMAIN, SERVICE_OPEN_URL):
-        return True
-
-    def valid_device(device: str) -> str:
-        """Check device is valid."""
-        device_registry = dr.async_get(hass)
-        device_entry = device_registry.async_get(device)
-        if device_entry is not None:
-            try:
-                return next(
-                    entry.entry_id
-                    for entry in hass.config_entries.async_entries(DOMAIN)
-                    if entry.entry_id in device_entry.config_entries
-                )
-            except StopIteration as exception:
-                raise HomeAssistantError(
-                    translation_domain=DOMAIN,
-                    translation_key="device_not_found",
-                    translation_placeholders={"device": device},
-                ) from exception
-        raise HomeAssistantError(
-            translation_domain=DOMAIN,
-            translation_key="device_not_found",
-            translation_placeholders={"device": device},
-        )
-
-    async def handle_get_process_by_id(service_call: ServiceCall) -> ServiceResponse:
-        """Handle the get process by id service call."""
-        _LOGGER.debug("Get process by id: %s", service_call.data)
-        coordinator = _get_coordinator(hass, service_call.data[CONF_BRIDGE])
-        processes: list[Process] = coordinator.data.processes
-
-        # Find process.id from list, raise ServiceValidationError if not found
-        try:
-            return asdict(
-                next(
-                    process
-                    for process in processes
-                    if process.id == service_call.data[CONF_ID]
-                )
-            )
-        except StopIteration as exception:
-            raise ServiceValidationError(
-                translation_domain=DOMAIN,
-                translation_key="process_not_found",
-                translation_placeholders={"id": service_call.data[CONF_ID]},
-            ) from exception
-
-    async def handle_get_processes_by_name(
-        service_call: ServiceCall,
-    ) -> ServiceResponse:
-        """Handle the get process by name service call."""
-        _LOGGER.debug("Get process by name: %s", service_call.data)
-        coordinator = _get_coordinator(hass, service_call.data[CONF_BRIDGE])
-
-        # Find processes from list
-        items: list[dict[str, Any]] = [
-            asdict(process)
-            for process in coordinator.data.processes
-            if process.name is not None
-            and service_call.data[CONF_NAME].lower() in process.name.lower()
-        ]
-
-        return {
-            "count": len(items),
-            "processes": list(items),
-        }
-
-    async def handle_open_path(service_call: ServiceCall) -> ServiceResponse:
-        """Handle the open path service call."""
-        _LOGGER.debug("Open path: %s", service_call.data)
-        coordinator = _get_coordinator(hass, service_call.data[CONF_BRIDGE])
-        response = await coordinator.websocket_client.open_path(
-            OpenPath(path=service_call.data[CONF_PATH])
-        )
-        return asdict(response)
-
-    async def handle_power_command(service_call: ServiceCall) -> ServiceResponse:
-        """Handle the power command service call."""
-        _LOGGER.debug("Power command: %s", service_call.data)
-        coordinator = _get_coordinator(hass, service_call.data[CONF_BRIDGE])
-        response = await getattr(
-            coordinator.websocket_client,
-            POWER_COMMAND_MAP[service_call.data[CONF_COMMAND]],
-        )()
-        return asdict(response)
-
-    async def handle_open_url(service_call: ServiceCall) -> ServiceResponse:
-        """Handle the open url service call."""
-        _LOGGER.debug("Open URL: %s", service_call.data)
-        coordinator = _get_coordinator(hass, service_call.data[CONF_BRIDGE])
-        response = await coordinator.websocket_client.open_url(
-            OpenUrl(url=service_call.data[CONF_URL])
-        )
-        return asdict(response)
-
-    async def handle_send_keypress(service_call: ServiceCall) -> ServiceResponse:
-        """Handle the send_keypress service call."""
-        coordinator = _get_coordinator(hass, service_call.data[CONF_BRIDGE])
-        response = await coordinator.websocket_client.keyboard_keypress(
-            KeyboardKey(key=service_call.data[CONF_KEY])
-        )
-        return asdict(response)
-
-    async def handle_send_text(service_call: ServiceCall) -> ServiceResponse:
-        """Handle the send_keypress service call."""
-        coordinator = _get_coordinator(hass, service_call.data[CONF_BRIDGE])
-        response = await coordinator.websocket_client.keyboard_text(
-            KeyboardText(text=service_call.data[CONF_TEXT])
-        )
-        return asdict(response)
-
-    # pylint: disable-next=home-assistant-service-registered-in-setup-entry
-    hass.services.async_register(
-        DOMAIN,
-        SERVICE_GET_PROCESS_BY_ID,
-        handle_get_process_by_id,
-        schema=vol.Schema(
-            {
-                vol.Required(CONF_BRIDGE): valid_device,
-                vol.Required(CONF_ID): cv.positive_int,
-            },
-        ),
-        supports_response=SupportsResponse.ONLY,
-    )
-
-    # pylint: disable-next=home-assistant-service-registered-in-setup-entry
-    hass.services.async_register(
-        DOMAIN,
-        SERVICE_GET_PROCESSES_BY_NAME,
-        handle_get_processes_by_name,
-        schema=vol.Schema(
-            {
-                vol.Required(CONF_BRIDGE): valid_device,
-                vol.Required(CONF_NAME): cv.string,
-            },
-        ),
-        supports_response=SupportsResponse.ONLY,
-    )
-
-    # pylint: disable-next=home-assistant-service-registered-in-setup-entry
-    hass.services.async_register(
-        DOMAIN,
-        SERVICE_OPEN_PATH,
-        handle_open_path,
-        schema=vol.Schema(
-            {
-                vol.Required(CONF_BRIDGE): valid_device,
-                vol.Required(CONF_PATH): cv.string,
-            },
-        ),
-        supports_response=SupportsResponse.ONLY,
-    )
-
-    # pylint: disable-next=home-assistant-service-registered-in-setup-entry
-    hass.services.async_register(
-        DOMAIN,
-        SERVICE_POWER_COMMAND,
-        handle_power_command,
-        schema=vol.Schema(
-            {
-                vol.Required(CONF_BRIDGE): valid_device,
-                vol.Required(CONF_COMMAND): vol.In(POWER_COMMAND_MAP),
-            },
-        ),
-        supports_response=SupportsResponse.ONLY,
-    )
-
-    # pylint: disable-next=home-assistant-service-registered-in-setup-entry
-    hass.services.async_register(
-        DOMAIN,
-        SERVICE_OPEN_URL,
-        handle_open_url,
-        schema=vol.Schema(
-            {
-                vol.Required(CONF_BRIDGE): valid_device,
-                vol.Required(CONF_URL): cv.string,
-            },
-        ),
-        supports_response=SupportsResponse.ONLY,
-    )
-
-    # pylint: disable-next=home-assistant-service-registered-in-setup-entry
-    hass.services.async_register(
-        DOMAIN,
-        SERVICE_SEND_KEYPRESS,
-        handle_send_keypress,
-        schema=vol.Schema(
-            {
-                vol.Required(CONF_BRIDGE): valid_device,
-                vol.Required(CONF_KEY): cv.string,
-            },
-        ),
-        supports_response=SupportsResponse.ONLY,
-        description_placeholders={
-            "syntax_keys_documentation_url": "https://robotjs.dev/docs/syntax#keys"
-        },
-    )
-
-    # pylint: disable-next=home-assistant-service-registered-in-setup-entry
-    hass.services.async_register(
-        DOMAIN,
-        SERVICE_SEND_TEXT,
-        handle_send_text,
-        schema=vol.Schema(
-            {
-                vol.Required(CONF_BRIDGE): valid_device,
-                vol.Required(CONF_TEXT): cv.string,
-            },
-        ),
-        supports_response=SupportsResponse.ONLY,
-    )
-
     # Reload entry when its updated.
     entry.async_on_unload(entry.add_update_listener(async_reload_entry))
 

homeassistant/components/system_bridge/services.py

@@ -0,0 +1,269 @@
+"""Service registration for System Bridge integration."""
+
+from dataclasses import asdict
+import logging
+from typing import Any
+
+from systembridgeconnector.models.keyboard_key import KeyboardKey
+from systembridgeconnector.models.keyboard_text import KeyboardText
+from systembridgeconnector.models.modules.processes import Process
+from systembridgeconnector.models.open_path import OpenPath
+from systembridgeconnector.models.open_url import OpenUrl
+import voluptuous as vol
+
+from homeassistant.const import CONF_COMMAND, CONF_ID, CONF_NAME, CONF_PATH, CONF_URL
+from homeassistant.core import (
+    HomeAssistant,
+    ServiceCall,
+    ServiceResponse,
+    SupportsResponse,
+    callback,
+)
+from homeassistant.exceptions import ServiceValidationError
+from homeassistant.helpers import (
+    config_validation as cv,
+    device_registry as dr,
+    service,
+)
+
+from .const import DOMAIN
+from .coordinator import SystemBridgeConfigEntry, SystemBridgeDataUpdateCoordinator
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_BRIDGE = "bridge"
+CONF_KEY = "key"
+CONF_TEXT = "text"
+
+POWER_COMMAND_MAP = {
+    "hibernate": "power_hibernate",
+    "lock": "power_lock",
+    "logout": "power_logout",
+    "restart": "power_restart",
+    "shutdown": "power_shutdown",
+    "sleep": "power_sleep",
+}
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Set up services for System Bridge integration."""
+
+    hass.services.async_register(
+        DOMAIN,
+        "get_process_by_id",
+        handle_get_process_by_id,
+        schema=vol.Schema(
+            {
+                vol.Required(CONF_BRIDGE): cv.string,
+                vol.Required(CONF_ID): cv.positive_int,
+            },
+        ),
+        supports_response=SupportsResponse.ONLY,
+    )
+
+    hass.services.async_register(
+        DOMAIN,
+        "get_processes_by_name",
+        handle_get_processes_by_name,
+        schema=vol.Schema(
+            {
+                vol.Required(CONF_BRIDGE): cv.string,
+                vol.Required(CONF_NAME): cv.string,
+            },
+        ),
+        supports_response=SupportsResponse.ONLY,
+    )
+
+    hass.services.async_register(
+        DOMAIN,
+        "open_path",
+        handle_open_path,
+        schema=vol.Schema(
+            {
+                vol.Required(CONF_BRIDGE): cv.string,
+                vol.Required(CONF_PATH): cv.string,
+            },
+        ),
+        supports_response=SupportsResponse.ONLY,
+    )
+
+    hass.services.async_register(
+        DOMAIN,
+        "power_command",
+        handle_power_command,
+        schema=vol.Schema(
+            {
+                vol.Required(CONF_BRIDGE): cv.string,
+                vol.Required(CONF_COMMAND): vol.In(POWER_COMMAND_MAP),
+            },
+        ),
+        supports_response=SupportsResponse.ONLY,
+    )
+
+    hass.services.async_register(
+        DOMAIN,
+        "open_url",
+        handle_open_url,
+        schema=vol.Schema(
+            {
+                vol.Required(CONF_BRIDGE): cv.string,
+                vol.Required(CONF_URL): cv.string,
+            },
+        ),
+        supports_response=SupportsResponse.ONLY,
+    )
+
+    hass.services.async_register(
+        DOMAIN,
+        "send_keypress",
+        handle_send_keypress,
+        schema=vol.Schema(
+            {
+                vol.Required(CONF_BRIDGE): cv.string,
+                vol.Required(CONF_KEY): cv.string,
+            },
+        ),
+        supports_response=SupportsResponse.ONLY,
+        description_placeholders={
+            "syntax_keys_documentation_url": "https://robotjs.dev/docs/syntax#keys"
+        },
+    )
+
+    hass.services.async_register(
+        DOMAIN,
+        "send_text",
+        handle_send_text,
+        schema=vol.Schema(
+            {
+                vol.Required(CONF_BRIDGE): cv.string,
+                vol.Required(CONF_TEXT): cv.string,
+            },
+        ),
+        supports_response=SupportsResponse.ONLY,
+    )
+
+
+def _get_coordinator(
+    hass: HomeAssistant, device_id: str
+) -> SystemBridgeDataUpdateCoordinator:
+    """Return the coordinator for a device id."""
+
+    device_registry = dr.async_get(hass)
+    device_entry = device_registry.async_get(device_id)
+
+    if device_entry is None:
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="device_not_found",
+            translation_placeholders={"device": device_id},
+        )
+    try:
+        entry_id = next(
+            entry.entry_id
+            for entry in hass.config_entries.async_entries(DOMAIN)
+            if entry.entry_id in device_entry.config_entries
+        )
+    except StopIteration as e:
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="device_not_found",
+            translation_placeholders={"device": device_id},
+        ) from e
+    entry: SystemBridgeConfigEntry = service.async_get_config_entry(
+        hass, DOMAIN, entry_id
+    )
+    return entry.runtime_data
+
+
+async def handle_get_process_by_id(service_call: ServiceCall) -> ServiceResponse:
+    """Handle the get process by id service call."""
+    _LOGGER.debug("Get process by id: %s", service_call.data)
+    coordinator = _get_coordinator(service_call.hass, service_call.data[CONF_BRIDGE])
+    processes: list[Process] = coordinator.data.processes
+
+    # Find process.id from list, raise ServiceValidationError if not found
+    try:
+        return asdict(
+            next(
+                process
+                for process in processes
+                if process.id == service_call.data[CONF_ID]
+            )
+        )
+    except StopIteration as e:
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="process_not_found",
+            translation_placeholders={"id": service_call.data[CONF_ID]},
+        ) from e
+
+
+async def handle_get_processes_by_name(
+    service_call: ServiceCall,
+) -> ServiceResponse:
+    """Handle the get process by name service call."""
+    _LOGGER.debug("Get process by name: %s", service_call.data)
+    coordinator = _get_coordinator(service_call.hass, service_call.data[CONF_BRIDGE])
+
+    # Find processes from list
+    items: list[dict[str, Any]] = [
+        asdict(process)
+        for process in coordinator.data.processes
+        if process.name is not None
+        and service_call.data[CONF_NAME].lower() in process.name.lower()
+    ]
+
+    return {
+        "count": len(items),
+        "processes": list(items),
+    }
+
+
+async def handle_open_path(service_call: ServiceCall) -> ServiceResponse:
+    """Handle the open path service call."""
+    _LOGGER.debug("Open path: %s", service_call.data)
+    coordinator = _get_coordinator(service_call.hass, service_call.data[CONF_BRIDGE])
+    response = await coordinator.websocket_client.open_path(
+        OpenPath(path=service_call.data[CONF_PATH])
+    )
+    return asdict(response)
+
+
+async def handle_power_command(service_call: ServiceCall) -> ServiceResponse:
+    """Handle the power command service call."""
+    _LOGGER.debug("Power command: %s", service_call.data)
+    coordinator = _get_coordinator(service_call.hass, service_call.data[CONF_BRIDGE])
+    response = await getattr(
+        coordinator.websocket_client,
+        POWER_COMMAND_MAP[service_call.data[CONF_COMMAND]],
+    )()
+    return asdict(response)
+
+
+async def handle_open_url(service_call: ServiceCall) -> ServiceResponse:
+    """Handle the open url service call."""
+    _LOGGER.debug("Open URL: %s", service_call.data)
+    coordinator = _get_coordinator(service_call.hass, service_call.data[CONF_BRIDGE])
+    response = await coordinator.websocket_client.open_url(
+        OpenUrl(url=service_call.data[CONF_URL])
+    )
+    return asdict(response)
+
+
+async def handle_send_keypress(service_call: ServiceCall) -> ServiceResponse:
+    """Handle the send_keypress service call."""
+    coordinator = _get_coordinator(service_call.hass, service_call.data[CONF_BRIDGE])
+    response = await coordinator.websocket_client.keyboard_keypress(
+        KeyboardKey(key=service_call.data[CONF_KEY])
+    )
+    return asdict(response)
+
+
+async def handle_send_text(service_call: ServiceCall) -> ServiceResponse:
+    """Handle the send_text service call."""
+    coordinator = _get_coordinator(service_call.hass, service_call.data[CONF_BRIDGE])
+    response = await coordinator.websocket_client.keyboard_text(
+        KeyboardText(text=service_call.data[CONF_TEXT])
+    )
+    return asdict(response)

requirements_all.txt

@@ -1516,7 +1516,7 @@ lxml==6.0.1
 matrix-nio==0.25.2
 
 # homeassistant.components.matter
-matter-python-client==0.6.0
+matter-python-client==0.7.1
 
 # homeassistant.components.maxcube
 maxcube-api==0.4.3

tests/components/generic_thermostat/test_init.py

@@ -626,15 +626,20 @@ async def test_migration_from_future_version(
     assert config_entry.state is ConfigEntryState.MIGRATION_ERROR
 
 
-async def test_migration_1_2(hass: HomeAssistant) -> None:
+@pytest.mark.usefixtures("sensor_device")
+async def test_migration_1_2(
+    hass: HomeAssistant,
+    sensor_entity_entry: er.RegistryEntry,
+    switch_entity_entry: er.RegistryEntry,
+) -> None:
     """Test migration from 1.2 to 1.3 copies CONF_MIN_DUR to CONF_DUR_COOLDOWN."""
     config_entry = MockConfigEntry(
         data={},
         domain=DOMAIN,
         options={
             "name": "My generic thermostat",
-            "heater": "switch.test",
-            "target_sensor": "sensor.test",
+            "heater": switch_entity_entry.entity_id,
+            "target_sensor": sensor_entity_entry.entity_id,
             CONF_MIN_DUR: {"hours": 0, "minutes": 5, "seconds": 0},
             "ac_mode": False,
             "cold_tolerance": 0.3,
@@ -646,9 +651,10 @@ async def test_migration_1_2(hass: HomeAssistant) -> None:
     )
     config_entry.add_to_hass(hass)
 
-    # Run migration
-    result = await generic_thermostat.async_migrate_entry(hass, config_entry)
-    assert result is True
+    await hass.config_entries.async_setup(config_entry.entry_id)
+    await hass.async_block_till_done()
+
+    assert config_entry.state is ConfigEntryState.LOADED
 
     # After migration, cooldown should be set to min_cycle_duration
     # and minor version bumped
@@ -657,4 +663,5 @@ async def test_migration_1_2(hass: HomeAssistant) -> None:
         "minutes": 5,
         "seconds": 0,
     }
+    assert config_entry.version == 1
     assert config_entry.minor_version == 3

tests/components/homekit/test_homekit.py

@@ -2363,6 +2363,11 @@ async def test_reload(mock_port_available: MagicMock, hass: HomeAssistant) -> No
         devices=[],
     )
 
+    # Unload while async_port_is_available is still patched so the hass fixture
+    # teardown does not block on the real port check loop in async_unload_entry.
+    await hass.config_entries.async_unload(entry.entry_id)
+    await hass.async_block_till_done()
+
 
 @pytest.mark.usefixtures("mock_async_zeroconf")
 async def test_homekit_start_in_accessory_mode(

tests/components/labs/test_websocket_api.py

@@ -8,9 +8,10 @@ import pytest
 from homeassistant.components.labs import (
     EVENT_LABS_UPDATED,
     async_is_preview_feature_enabled,
-    async_setup,
 )
+from homeassistant.components.labs.const import DOMAIN
 from homeassistant.core import HomeAssistant
+from homeassistant.setup import async_setup_component
 
 from . import assert_stored_labs_data
 
@@ -48,7 +49,7 @@ async def test_websocket_list_preview_features(
     if load_integration:
         hass.config.components.add("kitchen_sink")
 
-    assert await async_setup(hass, {})
+    assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     client = await hass_ws_client(hass)
@@ -68,7 +69,7 @@ async def test_websocket_update_preview_feature_enable(
     """Test enabling a preview feature via WebSocket."""
     # Load kitchen_sink integration
     hass.config.components.add("kitchen_sink")
-    assert await async_setup(hass, {})
+    assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     client = await hass_ws_client(hass)
@@ -132,7 +133,7 @@ async def test_websocket_update_preview_feature_disable(
     }
 
     hass.config.components.add("kitchen_sink")
-    assert await async_setup(hass, {})
+    assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     client = await hass_ws_client(hass)
@@ -164,7 +165,7 @@ async def test_websocket_update_nonexistent_feature(
     hass_storage: dict[str, Any],
 ) -> None:
     """Test updating a preview feature that doesn't exist."""
-    assert await async_setup(hass, {})
+    assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     client = await hass_ws_client(hass)
@@ -193,7 +194,7 @@ async def test_websocket_update_unavailable_preview_feature(
 ) -> None:
     """Test updating a preview feature whose integration is not loaded still works."""
     # Don't load kitchen_sink integration
-    assert await async_setup(hass, {})
+    assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     client = await hass_ws_client(hass)
@@ -235,7 +236,7 @@ async def test_websocket_requires_admin(
     hass_admin_user.groups = []
 
     hass.config.components.add("kitchen_sink")
-    assert await async_setup(hass, {})
+    assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     client = await hass_ws_client(hass)
@@ -264,7 +265,7 @@ async def test_websocket_update_validates_enabled_parameter(
 ) -> None:
     """Test that enabled parameter must be boolean."""
     hass.config.components.add("kitchen_sink")
-    assert await async_setup(hass, {})
+    assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     client = await hass_ws_client(hass)
@@ -291,7 +292,7 @@ async def test_storage_persists_preview_feature_across_calls(
 ) -> None:
     """Test that storage persists preview feature state across multiple calls."""
     hass.config.components.add("kitchen_sink")
-    assert await async_setup(hass, {})
+    assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     client = await hass_ws_client(hass)
@@ -350,7 +351,7 @@ async def test_preview_feature_urls_present(
 ) -> None:
     """Test that preview features include feedback and report URLs."""
     hass.config.components.add("kitchen_sink")
-    assert await async_setup(hass, {})
+    assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     client = await hass_ws_client(hass)
@@ -401,7 +402,7 @@ async def test_websocket_update_preview_feature_backup_scenarios(
 ) -> None:
     """Test various backup scenarios when updating preview features."""
     hass.config.components.add("kitchen_sink")
-    assert await async_setup(hass, {})
+    assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     client = await hass_ws_client(hass)
@@ -463,7 +464,7 @@ async def test_websocket_list_multiple_enabled_features(
     }
 
     hass.config.components.add("kitchen_sink")
-    assert await async_setup(hass, {})
+    assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     client = await hass_ws_client(hass)
@@ -484,7 +485,7 @@ async def test_websocket_update_rapid_toggle(
 ) -> None:
     """Test rapid toggling of a preview feature."""
     hass.config.components.add("kitchen_sink")
-    assert await async_setup(hass, {})
+    assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     client = await hass_ws_client(hass)
@@ -534,7 +535,7 @@ async def test_websocket_update_same_state_idempotent(
 ) -> None:
     """Test that enabling an already-enabled feature is idempotent."""
     hass.config.components.add("kitchen_sink")
-    assert await async_setup(hass, {})
+    assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     client = await hass_ws_client(hass)
@@ -572,7 +573,7 @@ async def test_websocket_list_filtered_by_loaded_components(
 ) -> None:
     """Test that list only shows features from loaded integrations."""
     # Don't load kitchen_sink - its preview feature shouldn't appear
-    assert await async_setup(hass, {})
+    assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     client = await hass_ws_client(hass)
@@ -600,7 +601,7 @@ async def test_websocket_update_with_missing_required_field(
 ) -> None:
     """Test that missing required fields are rejected."""
     hass.config.components.add("kitchen_sink")
-    assert await async_setup(hass, {})
+    assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     client = await hass_ws_client(hass)
@@ -625,7 +626,7 @@ async def test_websocket_event_data_structure(
 ) -> None:
     """Test that event data has correct structure."""
     hass.config.components.add("kitchen_sink")
-    assert await async_setup(hass, {})
+    assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     client = await hass_ws_client(hass)
@@ -666,7 +667,7 @@ async def test_websocket_backup_timeout_handling(
 ) -> None:
     """Test handling of backup timeout/long-running backup."""
     hass.config.components.add("kitchen_sink")
-    assert await async_setup(hass, {})
+    assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     client = await hass_ws_client(hass)
@@ -702,7 +703,7 @@ async def test_websocket_subscribe_feature(
 ) -> None:
     """Test subscribing to a specific preview feature."""
     hass.config.components.add("kitchen_sink")
-    assert await async_setup(hass, {})
+    assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     client = await hass_ws_client(hass)
@@ -739,7 +740,7 @@ async def test_websocket_subscribe_feature_receives_updates(
 ) -> None:
     """Test that subscription receives updates when feature is toggled."""
     hass.config.components.add("kitchen_sink")
-    assert await async_setup(hass, {})
+    assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     client = await hass_ws_client(hass)
@@ -793,7 +794,7 @@ async def test_websocket_subscribe_nonexistent_feature(
     hass_ws_client: WebSocketGenerator,
 ) -> None:
     """Test subscribing to a preview feature that doesn't exist."""
-    assert await async_setup(hass, {})
+    assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     client = await hass_ws_client(hass)
@@ -821,7 +822,7 @@ async def test_websocket_subscribe_does_not_require_admin(
     hass_admin_user.groups = []
 
     hass.config.components.add("kitchen_sink")
-    assert await async_setup(hass, {})
+    assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     client = await hass_ws_client(hass)
@@ -847,7 +848,7 @@ async def test_websocket_subscribe_only_receives_subscribed_feature_updates(
 ) -> None:
     """Test that subscription only receives updates for the subscribed feature."""
     hass.config.components.add("kitchen_sink")
-    assert await async_setup(hass, {})
+    assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     client = await hass_ws_client(hass)

tests/components/matter/fixtures/config_entry_diagnostics.json

@@ -7,7 +7,9 @@
     "wifi_credentials_set": true,
     "thread_credentials_set": false,
     "min_supported_schema_version": 1,
-    "bluetooth_enabled": false
+    "bluetooth_enabled": false,
+    "wifi_ssid": "test_ssid",
+    "ble_proxy_enabled": false
   },
   "nodes": [
     {

tests/components/matter/fixtures/config_entry_diagnostics_redacted.json

@@ -8,7 +8,9 @@
       "wifi_credentials_set": true,
       "thread_credentials_set": false,
       "min_supported_schema_version": 1,
-      "bluetooth_enabled": false
+      "bluetooth_enabled": false,
+      "wifi_ssid": "**REDACTED**",
+      "ble_proxy_enabled": false
     },
     "nodes": [
       {

tests/components/matter/test_diagnostics.py

@@ -9,8 +9,12 @@ from matter_server.common.helpers.util import dataclass_from_dict
 from matter_server.common.models import ServerDiagnostics
 import pytest
 
+from homeassistant.components.diagnostics import async_redact_data
 from homeassistant.components.matter.const import DOMAIN
-from homeassistant.components.matter.diagnostics import redact_matter_attributes
+from homeassistant.components.matter.diagnostics import (
+    SERVER_INFO_TO_REDACT,
+    redact_matter_attributes,
+)
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr
 
@@ -85,7 +89,7 @@ async def test_device_diagnostics(
     """Test the device diagnostics."""
     system_info_dict = config_entry_diagnostics["info"]
     device_diagnostics_redacted = {
-        "server_info": system_info_dict,
+        "server_info": async_redact_data(system_info_dict, SERVER_INFO_TO_REDACT),
         "node": redact_matter_attributes(device_diagnostics),
     }
     server_diagnostics_response = {

tests/components/mqtt/common.py

@@ -749,7 +749,18 @@ MOCK_SUBENTRY_DEVICE_DATA = {
 }
 
 MOCK_NOTIFY_SUBENTRY_DATA_MULTI = {
-    "device": MOCK_SUBENTRY_DEVICE_DATA | {"mqtt_settings": {"qos": 2}},
+    "device": MOCK_SUBENTRY_DEVICE_DATA
+    | {
+        "mqtt_settings": {
+            "qos": 2.0,
+            "message_expiry_interval": {
+                "days": 0,
+                "hours": 0,
+                "minutes": 1,
+                "seconds": 30,
+            },
+        }
+    },
     "components": MOCK_SUBENTRY_NOTIFY_COMPONENT1 | MOCK_SUBENTRY_NOTIFY_COMPONENT2,
 } | MOCK_SUBENTRY_AVAILABILITY_DATA
 
@@ -882,7 +893,18 @@ MOCK_SUBENTRY_DATA_BAD_COMPONENT_SCHEMA = {
     "components": MOCK_SUBENTRY_NOTIFY_BAD_SCHEMA,
 }
 MOCK_SUBENTRY_DATA_SET_MIX = {
-    "device": MOCK_SUBENTRY_DEVICE_DATA | {"mqtt_settings": {"qos": 0}},
+    "device": MOCK_SUBENTRY_DEVICE_DATA
+    | {
+        "mqtt_settings": {
+            "qos": 0,
+            "message_expiry_interval": {
+                "days": 0,
+                "hours": 0,
+                "minutes": 1,
+                "seconds": 30,
+            },
+        }
+    },
     "components": MOCK_SUBENTRY_NOTIFY_COMPONENT1
     | MOCK_SUBENTRY_NOTIFY_COMPONENT2
     | MOCK_SUBENTRY_LIGHT_BASIC_KELVIN_COMPONENT

tests/components/mqtt/test_button.py

@@ -88,6 +88,66 @@ async def test_sending_mqtt_commands(
     assert state.state == "2021-11-08T13:31:44+00:00"
 
 
+@pytest.mark.freeze_time("2021-11-08 13:31:44+00:00")
+@pytest.mark.parametrize(
+    "hass_config",
+    [
+        {
+            mqtt.DOMAIN: {
+                button.DOMAIN: {
+                    "command_topic": "command-topic",
+                    "name": "test",
+                    "default_entity_id": "button.test_button",
+                    "payload_press": "beer press",
+                    "qos": "2",
+                    "message_expiry_interval": {
+                        "days": 0,
+                        "hours": 0,
+                        "minutes": 1,
+                        "seconds": 30,
+                    },
+                }
+            }
+        },
+        {
+            mqtt.DOMAIN: {
+                button.DOMAIN: {
+                    "command_topic": "command-topic",
+                    "name": "test",
+                    "default_entity_id": "button.test_button",
+                    "payload_press": "beer press",
+                    "qos": "2",
+                    "message_expiry_interval": 90,
+                }
+            }
+        },
+    ],
+)
+async def test_sending_mqtt_commands_with_message_expiry_interval(
+    hass: HomeAssistant, mqtt_mock_entry: MqttMockHAClientGenerator
+) -> None:
+    """Test the sending MQTT command with message expiry interval."""
+    mqtt_mock = await mqtt_mock_entry()
+
+    state = hass.states.get("button.test_button")
+    assert state.state == STATE_UNKNOWN
+    assert state.attributes.get(ATTR_FRIENDLY_NAME) == "test"
+
+    await hass.services.async_call(
+        button.DOMAIN,
+        button.SERVICE_PRESS,
+        {ATTR_ENTITY_ID: "button.test_button"},
+        blocking=True,
+    )
+
+    mqtt_mock.async_publish.assert_called_once_with(
+        "command-topic", "beer press", 2, False, message_expiry_interval=90
+    )
+    mqtt_mock.async_publish.reset_mock()
+    state = hass.states.get("button.test_button")
+    assert state.state == "2021-11-08T13:31:44+00:00"
+
+
 @pytest.mark.parametrize(
     "hass_config",
     [

tests/components/mqtt/test_client.py

@@ -1502,12 +1502,13 @@ async def test_publish_error(
 
 async def test_subscribe_error(
     hass: HomeAssistant,
-    setup_with_birth_msg_client_mock: MqttMockPahoClient,
+    mqtt_mock_entry: MqttMockHAClientGenerator,
+    mqtt_client_mock: MqttMockPahoClient,
     record_calls: MessageCallbackType,
     caplog: pytest.LogCaptureFixture,
 ) -> None:
     """Test publish error."""
-    mqtt_client_mock = setup_with_birth_msg_client_mock
+    await mqtt_mock_entry()
     mqtt_client_mock.reset_mock()
     # simulate client is not connected error before subscribing
     mqtt_client_mock.subscribe.side_effect = lambda *args, **kwargs: (4, None)

tests/components/mqtt/test_config_flow.py

@@ -5196,7 +5196,14 @@ async def test_subentry_reconfigure_update_device_properties(
         .schema["mqtt_settings"]
         .schema.schema.items()
     }
-    assert mqtt_settings_key_descriptions == {"qos": {"suggested_value": 2}}
+    assert mqtt_settings_key_descriptions == {
+        "qos": {
+            "suggested_value": 2,
+        },
+        "message_expiry_interval": {
+            "suggested_value": {"days": 0, "hours": 0, "minutes": 1, "seconds": 30}
+        },
+    }
     assert result["data_schema"].schema["mqtt_settings"].options == {"collapsed": False}
 
     # Update the device details
@@ -5209,7 +5216,15 @@ async def test_subentry_reconfigure_update_device_properties(
             "model_id": "bn003",
             "manufacturer": "Beer Masters",
             "configuration_url": "https://example.com",
-            "mqtt_settings": {"qos": 1},
+            "mqtt_settings": {
+                "qos": 1,
+                "message_expiry_interval": {
+                    "days": 0,
+                    "hours": 0,
+                    "minutes": 0,
+                    "seconds": 30,
+                },
+            },
         },
     )
     assert result["type"] is FlowResultType.MENU
@@ -5232,6 +5247,12 @@ async def test_subentry_reconfigure_update_device_properties(
     assert device["sw_version"] == "1.1"
     assert device["manufacturer"] == "Beer Masters"
     assert device["mqtt_settings"]["qos"] == 1
+    assert device["mqtt_settings"]["message_expiry_interval"] == {
+        "days": 0,
+        "hours": 0,
+        "minutes": 0,
+        "seconds": 30,
+    }
     assert "qos" not in device
 
 

tests/components/system_bridge/conftest.py

@@ -126,6 +126,36 @@ def mock_websocket_client(
             message="Data listener registered",
             data={EventKey.MODULES: register_data_listener_model.modules},
         )
+        websocket_client.open_url.return_value = Response(
+            id=FIXTURE_REQUEST_ID,
+            type=EventType.OPENED,
+            message="Opened url",
+            data={"url": "https://example.com"},
+        )
+        websocket_client.open_path.return_value = Response(
+            id=FIXTURE_REQUEST_ID,
+            type=EventType.OPENED,
+            message="Opened file",
+            data={"path": "/home/user/documents"},
+        )
+        websocket_client.power_shutdown.return_value = Response(
+            id=FIXTURE_REQUEST_ID,
+            type=EventType.POWER_SHUTDOWN,
+            message="Shutdown",
+            data={},
+        )
+        websocket_client.keyboard_keypress.return_value = Response(
+            id=FIXTURE_REQUEST_ID,
+            type=EventType.KEYBOARD_KEY_PRESSED,
+            message="Keyboard key pressed",
+            data={"key": "backspace"},
+        )
+        websocket_client.keyboard_text.return_value = Response(
+            id=FIXTURE_REQUEST_ID,
+            type=EventType.KEYBOARD_TEXT_SENT,
+            message="Keyboard text sent",
+            data={"text": "Hello world"},
+        )
         # Trigger callback when listener is registered
         websocket_client.listen.side_effect = mock_data_listener
 

tests/components/system_bridge/snapshots/test_services.ambr

@@ -0,0 +1,91 @@
+# serializer version: 1
+# name: test_get_process_services[get_process_by_id]
+  dict({
+    'cpu_usage': 12.3,
+    'created': 12.3,
+    'id': 1234,
+    'memory_usage': 12.3,
+    'name': 'name',
+    'path': '/path',
+    'status': 'running',
+    'username': 'username',
+    'working_directory': '/working/directory',
+  })
+# ---
+# name: test_get_process_services[get_processes_by_name]
+  dict({
+    'count': 1,
+    'processes': list([
+      dict({
+        'cpu_usage': 12.3,
+        'created': 12.3,
+        'id': 1234,
+        'memory_usage': 12.3,
+        'name': 'name',
+        'path': '/path',
+        'status': 'running',
+        'username': 'username',
+        'working_directory': '/working/directory',
+      }),
+    ]),
+  })
+# ---
+# name: test_services[open_path]
+  dict({
+    'data': dict({
+      'path': '/home/user/documents',
+    }),
+    'id': 'test',
+    'message': 'Opened file',
+    'module': None,
+    'subtype': None,
+    'type': <EventType.OPENED: 'OPENED'>,
+  })
+# ---
+# name: test_services[open_url]
+  dict({
+    'data': dict({
+      'url': 'https://example.com',
+    }),
+    'id': 'test',
+    'message': 'Opened url',
+    'module': None,
+    'subtype': None,
+    'type': <EventType.OPENED: 'OPENED'>,
+  })
+# ---
+# name: test_services[power_command_shutdown]
+  dict({
+    'data': dict({
+    }),
+    'id': 'test',
+    'message': 'Shutdown',
+    'module': None,
+    'subtype': None,
+    'type': <EventType.POWER_SHUTDOWN: 'POWER_SHUTDOWN'>,
+  })
+# ---
+# name: test_services[send_keypress]
+  dict({
+    'data': dict({
+      'key': 'backspace',
+    }),
+    'id': 'test',
+    'message': 'Keyboard key pressed',
+    'module': None,
+    'subtype': None,
+    'type': <EventType.KEYBOARD_KEY_PRESSED: 'KEYBOARD_KEY_PRESSED'>,
+  })
+# ---
+# name: test_services[send_text]
+  dict({
+    'data': dict({
+      'text': 'Hello world',
+    }),
+    'id': 'test',
+    'message': 'Keyboard text sent',
+    'module': None,
+    'subtype': None,
+    'type': <EventType.KEYBOARD_TEXT_SENT: 'KEYBOARD_TEXT_SENT'>,
+  })
+# ---

tests/components/system_bridge/test_services.py

@@ -0,0 +1,155 @@
+"""Tests for System Bridge actions."""
+
+from typing import Any
+
+import pytest
+from syrupy.assertion import SnapshotAssertion
+from systembridgeconnector.models.keyboard_key import KeyboardKey
+from systembridgeconnector.models.keyboard_text import KeyboardText
+from systembridgeconnector.models.open_path import OpenPath
+from systembridgeconnector.models.open_url import OpenUrl
+
+from homeassistant.components.system_bridge.const import DOMAIN
+from homeassistant.components.system_bridge.services import (
+    CONF_BRIDGE,
+    CONF_KEY,
+    CONF_TEXT,
+)
+from homeassistant.config_entries import ConfigEntryState
+from homeassistant.const import CONF_COMMAND, CONF_ID, CONF_NAME, CONF_PATH, CONF_URL
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import device_registry as dr
+
+from . import FIXTURE_UUID
+
+from tests.common import AsyncMock, MockConfigEntry
+
+
+@pytest.mark.parametrize(
+    ("service", "service_data", "call_method", "call_args"),
+    [
+        (
+            "open_path",
+            {CONF_PATH: "/home/user/documents"},
+            "open_path",
+            [OpenPath(path="/home/user/documents")],
+        ),
+        (
+            "open_url",
+            {CONF_URL: "https://example.com"},
+            "open_url",
+            [OpenUrl(url="https://example.com")],
+        ),
+        (
+            "power_command",
+            {CONF_COMMAND: "shutdown"},
+            "power_shutdown",
+            [],
+        ),
+        (
+            "send_keypress",
+            {CONF_KEY: "backspace"},
+            "keyboard_keypress",
+            [KeyboardKey(key="backspace")],
+        ),
+        (
+            "send_text",
+            {CONF_TEXT: "Hello world"},
+            "keyboard_text",
+            [KeyboardText(text="Hello world")],
+        ),
+    ],
+    ids=[
+        "open_path",
+        "open_url",
+        "power_command_shutdown",
+        "send_keypress",
+        "send_text",
+    ],
+)
+@pytest.mark.usefixtures("mock_version")
+async def test_services(
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+    mock_websocket_client: AsyncMock,
+    snapshot: SnapshotAssertion,
+    device_registry: dr.DeviceRegistry,
+    service: str,
+    service_data: dict[str, Any],
+    call_method: str,
+    call_args: list[Any],
+) -> None:
+    """Test System Bridge service action calls."""
+    mock_config_entry.add_to_hass(hass)
+    await hass.config_entries.async_setup(mock_config_entry.entry_id)
+    await hass.async_block_till_done()
+
+    assert mock_config_entry.state is ConfigEntryState.LOADED
+
+    device_entry = device_registry.async_get_device(
+        identifiers={(DOMAIN, FIXTURE_UUID)}
+    )
+    assert device_entry
+
+    resp = await hass.services.async_call(
+        DOMAIN,
+        service,
+        {
+            CONF_BRIDGE: device_entry.id,
+            **service_data,
+        },
+        blocking=True,
+        return_response=True,
+    )
+
+    getattr(mock_websocket_client, call_method).assert_awaited_once_with(*call_args)
+    assert resp == snapshot
+
+
+@pytest.mark.parametrize(
+    ("service", "service_data"),
+    [
+        (
+            "get_process_by_id",
+            {CONF_ID: 1234},
+        ),
+        (
+            "get_processes_by_name",
+            {CONF_NAME: "name"},
+        ),
+    ],
+    ids=["get_process_by_id", "get_processes_by_name"],
+)
+@pytest.mark.usefixtures("mock_version", "mock_websocket_client")
+async def test_get_process_services(
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+    snapshot: SnapshotAssertion,
+    device_registry: dr.DeviceRegistry,
+    service: str,
+    service_data: dict[str, Any],
+) -> None:
+    """Test System Bridge get process service action calls."""
+    mock_config_entry.add_to_hass(hass)
+    await hass.config_entries.async_setup(mock_config_entry.entry_id)
+    await hass.async_block_till_done()
+
+    assert mock_config_entry.state is ConfigEntryState.LOADED
+
+    device_entry = device_registry.async_get_device(
+        identifiers={(DOMAIN, FIXTURE_UUID)}
+    )
+    assert device_entry
+
+    resp = await hass.services.async_call(
+        DOMAIN,
+        service,
+        {
+            CONF_BRIDGE: device_entry.id,
+            **service_data,
+        },
+        blocking=True,
+        return_response=True,
+    )
+
+    assert resp == snapshot

tests/conftest.py

@@ -1074,7 +1074,9 @@ def mqtt_client_mock(hass: HomeAssistant) -> Generator[MqttMockPahoClient]:
 
         @ha.callback
         def _async_fire_mqtt_message(topic, payload, qos, retain, properties=None):
-            async_fire_mqtt_message(hass, topic, payload or b"", qos, retain)
+            async_fire_mqtt_message(
+                hass, topic, payload or b"", qos, retain, properties=properties
+            )
             mid = get_mid()
             hass.loop.call_soon(
                 mock_client.on_publish, Mock(), 0, mid, MockMqttReasonCode(), None