Bump wiim to 1.0.4 (#172334)

Co-authored-by: Tao Jiang <tao.jiang@linkplay.com>

homeassistant/components/device_tracker/device_trigger.py

@@ -12,18 +12,13 @@ from homeassistant.const import (
     CONF_DOMAIN,
     CONF_ENTITY_ID,
     CONF_EVENT,
-    CONF_OPTIONS,
     CONF_PLATFORM,
     CONF_TYPE,
     CONF_ZONE,
 )
 from homeassistant.core import CALLBACK_TYPE, HomeAssistant
 from homeassistant.helpers import config_validation as cv, entity_registry as er
-from homeassistant.helpers.trigger import (
-    TriggerActionType,
-    TriggerInfo,
-    _async_attach_trigger_cls,
-)
+from homeassistant.helpers.trigger import TriggerActionType, TriggerInfo
 from homeassistant.helpers.typing import ConfigType
 
 from .const import DOMAIN
@@ -84,18 +79,16 @@ async def async_attach_trigger(
         event = zone.EVENT_ENTER
     else:
         event = zone.EVENT_LEAVE
-    zone_config = await zone.LegacyZoneTrigger.async_validate_config(
-        hass,
-        {
-            CONF_OPTIONS: {
-                CONF_ENTITY_ID: [config[CONF_ENTITY_ID]],
-                CONF_ZONE: config[CONF_ZONE],
-                CONF_EVENT: event,
-            }
-        },
-    )
-    return await _async_attach_trigger_cls(
-        hass, zone.LegacyZoneTrigger, "device", zone_config, action, trigger_info
+
+    zone_config = {
+        CONF_PLATFORM: ZONE_DOMAIN,
+        CONF_ENTITY_ID: config[CONF_ENTITY_ID],
+        CONF_ZONE: config[CONF_ZONE],
+        CONF_EVENT: event,
+    }
+    zone_config = await zone.async_validate_trigger_config(hass, zone_config)
+    return await zone.async_attach_trigger(
+        hass, zone_config, action, trigger_info, platform_type="device"
     )
 
 

homeassistant/components/device_tracker/entity.py

@@ -169,11 +169,35 @@ class BaseTrackerEntity(Entity):
     _attr_entity_category = EntityCategory.DIAGNOSTIC
     _attr_source_type: SourceType
 
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        """Post initialisation processing."""
+        super().__init_subclass__(**kwargs)
+        if "battery_level" in cls.__dict__:
+            if cls.__module__.startswith("homeassistant.components."):
+                # Don't ask users to report issue for built in integrations,
+                # they already have issues opened on them.
+                return
+            report_issue = async_suggest_report_issue(
+                async_get_hass_or_none(), module=cls.__module__
+            )
+            _LOGGER.warning(
+                (
+                    "%s::%s is overriding the deprecated battery_level property on "
+                    "a subclass of BaseTrackerEntity, this will be unsupported from "
+                    "Home Assistant 2027.7, please %s"
+                ),
+                cls.__module__,
+                cls.__name__,
+                report_issue,
+            )
+
     @cached_property
     def battery_level(self) -> int | None:
         """Return the battery level of the device.
 
         Percentage from 0-100.
+
+        The property is deprecated and will be removed in Home Assistant 2027.7.
         """
         return None
 

homeassistant/components/matter/sensor.py

@@ -439,6 +439,19 @@ DISCOVERY_SCHEMAS = [
         ),
         allow_multi=True,  # also used for climate entity
     ),
+    MatterDiscoverySchema(
+        platform=Platform.SENSOR,
+        entity_description=MatterSensorEntityDescription(
+            key="SoilMoistureSensor",
+            native_unit_of_measurement=PERCENTAGE,
+            device_class=SensorDeviceClass.MOISTURE,
+            state_class=SensorStateClass.MEASUREMENT,
+        ),
+        entity_class=MatterSensor,
+        required_attributes=(
+            clusters.SoilMeasurement.Attributes.SoilMoistureMeasuredValue,
+        ),
+    ),
     MatterDiscoverySchema(
         platform=Platform.SENSOR,
         entity_description=MatterSensorEntityDescription(

homeassistant/components/wiim/manifest.json

@@ -8,6 +8,6 @@
   "iot_class": "local_push",
   "loggers": ["wiim.sdk", "async_upnp_client"],
   "quality_scale": "bronze",
-  "requirements": ["wiim==0.1.2"],
+  "requirements": ["wiim==0.1.4"],
   "zeroconf": ["_linkplay._tcp.local."]
 }

homeassistant/components/wiim/media_player.py

@@ -349,15 +349,12 @@ class WiimMediaPlayerEntity(WiimBaseEntity, MediaPlayerEntity):
                     sdk_status_str,
                 )
             else:
-                self._device.playing_status = sdk_status
                 if sdk_status == SDKPlayingStatus.STOPPED:
                     LOGGER.debug(
                         "Device %s: TransportState is STOPPED."
                         " Resetting media position and metadata",
                         self.entity_id,
                     )
-                    self._device.current_position = 0
-                    self._device.current_track_duration = 0
                     self._attr_media_position_updated_at = None
                     self._attr_media_duration = None
                     self._attr_media_position = None

homeassistant/components/zone/icons.json

@@ -3,13 +3,5 @@
     "reload": {
       "service": "mdi:reload"
     }
-  },
-  "triggers": {
-    "entered": {
-      "trigger": "mdi:map-marker-plus"
-    },
-    "left": {
-      "trigger": "mdi:map-marker-minus"
-    }
   }
 }

homeassistant/components/zone/strings.json

@@ -1,48 +1,8 @@
 {
-  "common": {
-    "trigger_behavior_name": "Trigger when",
-    "trigger_for_name": "For at least",
-    "trigger_zone_description": "The zone to trigger on.",
-    "trigger_zone_name": "Zone"
-  },
   "services": {
     "reload": {
       "description": "Reloads zones from the YAML-configuration.",
       "name": "Reload zones"
     }
-  },
-  "triggers": {
-    "entered": {
-      "description": "Triggers when one or more persons or device trackers enter a zone.",
-      "fields": {
-        "behavior": {
-          "name": "[%key:component::zone::common::trigger_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::zone::common::trigger_for_name%]"
-        },
-        "zone": {
-          "description": "[%key:component::zone::common::trigger_zone_description%]",
-          "name": "[%key:component::zone::common::trigger_zone_name%]"
-        }
-      },
-      "name": "Entered zone"
-    },
-    "left": {
-      "description": "Triggers when one or more persons or device trackers leave a zone.",
-      "fields": {
-        "behavior": {
-          "name": "[%key:component::zone::common::trigger_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::zone::common::trigger_for_name%]"
-        },
-        "zone": {
-          "description": "[%key:component::zone::common::trigger_zone_description%]",
-          "name": "[%key:component::zone::common::trigger_zone_name%]"
-        }
-      },
-      "name": "Left zone"
-    }
   }
 }

homeassistant/components/zone/trigger.py

@@ -1,24 +1,22 @@
 """Offer zone automation rules."""
 
 import logging
-from typing import TYPE_CHECKING, Any, cast
 
 import voluptuous as vol
 
-from homeassistant.components.device_tracker import ATTR_IN_ZONES
 from homeassistant.const import (
     ATTR_FRIENDLY_NAME,
     CONF_ENTITY_ID,
     CONF_EVENT,
-    CONF_OPTIONS,
+    CONF_PLATFORM,
     CONF_ZONE,
 )
 from homeassistant.core import (
     CALLBACK_TYPE,
     Event,
     EventStateChangedData,
+    HassJob,
     HomeAssistant,
-    State,
     callback,
 )
 from homeassistant.helpers import (
@@ -26,18 +24,8 @@ from homeassistant.helpers import (
     entity_registry as er,
     location,
 )
-from homeassistant.helpers.automation import (
-    DomainSpec,
-    move_top_level_schema_fields_to_options,
-)
 from homeassistant.helpers.event import async_track_state_change_event
-from homeassistant.helpers.trigger import (
-    ENTITY_STATE_TRIGGER_SCHEMA_WITH_BEHAVIOR,
-    EntityTriggerBase,
-    Trigger,
-    TriggerActionRunner,
-    TriggerConfig,
-)
+from homeassistant.helpers.trigger import TriggerActionType, TriggerInfo
 from homeassistant.helpers.typing import ConfigType
 
 from . import condition
@@ -50,166 +38,93 @@ _LOGGER = logging.getLogger(__name__)
 
 _EVENT_DESCRIPTION = {EVENT_ENTER: "entering", EVENT_LEAVE: "leaving"}
 
-_LEGACY_OPTIONS_SCHEMA: dict[vol.Marker, Any] = {
-    vol.Required(CONF_ENTITY_ID): cv.entity_ids_or_uuids,
-    vol.Required(CONF_ZONE): cv.entity_id,
-    vol.Required(CONF_EVENT, default=DEFAULT_EVENT): vol.Any(EVENT_ENTER, EVENT_LEAVE),
-}
-
-_LEGACY_TRIGGER_OPTIONS_SCHEMA = vol.Schema(
+_TRIGGER_SCHEMA = cv.TRIGGER_BASE_SCHEMA.extend(
     {
-        vol.Required(CONF_OPTIONS): _LEGACY_OPTIONS_SCHEMA,
-    },
-)
-
-# New-style zone trigger schema
-_ZONE_TRIGGER_SCHEMA = ENTITY_STATE_TRIGGER_SCHEMA_WITH_BEHAVIOR.extend(
-    {
-        vol.Required(CONF_OPTIONS): {
-            vol.Required(CONF_ZONE): cv.entity_domain("zone"),
-        },
+        vol.Required(CONF_PLATFORM): "zone",
+        vol.Required(CONF_ENTITY_ID): cv.entity_ids_or_uuids,
+        vol.Required(CONF_ZONE): cv.entity_id,
+        vol.Required(CONF_EVENT, default=DEFAULT_EVENT): vol.Any(
+            EVENT_ENTER, EVENT_LEAVE
+        ),
     }
 )
 
-_DOMAIN_SPECS: dict[str, DomainSpec] = {
-    "person": DomainSpec(),
-    "device_tracker": DomainSpec(),
-}
+
+async def async_validate_trigger_config(
+    hass: HomeAssistant, config: ConfigType
+) -> ConfigType:
+    """Validate trigger config."""
+    config = _TRIGGER_SCHEMA(config)
+    registry = er.async_get(hass)
+    config[CONF_ENTITY_ID] = er.async_validate_entity_ids(
+        registry, config[CONF_ENTITY_ID]
+    )
+    return config
 
 
-class LegacyZoneTrigger(Trigger):
-    """Legacy zone trigger (platform: zone)."""
+async def async_attach_trigger(
+    hass: HomeAssistant,
+    config: ConfigType,
+    action: TriggerActionType,
+    trigger_info: TriggerInfo,
+    *,
+    platform_type: str = "zone",
+) -> CALLBACK_TYPE:
+    """Listen for state changes based on configuration."""
+    trigger_data = trigger_info["trigger_data"]
+    entity_id: list[str] = config[CONF_ENTITY_ID]
+    zone_entity_id: str = config[CONF_ZONE]
+    event: str = config[CONF_EVENT]
+    job = HassJob(action)
 
-    @classmethod
-    async def async_validate_complete_config(
-        cls, hass: HomeAssistant, complete_config: ConfigType
-    ) -> ConfigType:
-        """Validate complete config, migrating legacy format to options."""
-        complete_config = move_top_level_schema_fields_to_options(
-            complete_config, _LEGACY_OPTIONS_SCHEMA
-        )
-        return await super().async_validate_complete_config(hass, complete_config)
+    @callback
+    def zone_automation_listener(zone_event: Event[EventStateChangedData]) -> None:
+        """Listen for state changes and calls action."""
+        entity = zone_event.data["entity_id"]
+        from_s = zone_event.data["old_state"]
+        to_s = zone_event.data["new_state"]
 
-    @classmethod
-    async def async_validate_config(
-        cls, hass: HomeAssistant, config: ConfigType
-    ) -> ConfigType:
-        """Validate config."""
-        config = cast(ConfigType, _LEGACY_TRIGGER_OPTIONS_SCHEMA(config))
-        registry = er.async_get(hass)
-        config[CONF_OPTIONS][CONF_ENTITY_ID] = er.async_validate_entity_ids(
-            registry, config[CONF_OPTIONS][CONF_ENTITY_ID]
-        )
-        return config
+        if (from_s and not location.has_location(from_s)) or (
+            to_s and not location.has_location(to_s)
+        ):
+            return
 
-    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
-        """Initialize trigger."""
-        super().__init__(hass, config)
-        if TYPE_CHECKING:
-            assert config.options is not None
-        self._options = config.options
-
-    async def async_attach_runner(
-        self, run_action: TriggerActionRunner
-    ) -> CALLBACK_TYPE:
-        """Listen for state changes based on configuration."""
-        entity_id: list[str] = self._options[CONF_ENTITY_ID]
-        zone_entity_id: str = self._options[CONF_ZONE]
-        event: str = self._options[CONF_EVENT]
-
-        @callback
-        def zone_automation_listener(zone_event: Event[EventStateChangedData]) -> None:
-            """Listen for state changes and calls action."""
-            entity = zone_event.data["entity_id"]
-            from_s = zone_event.data["old_state"]
-            to_s = zone_event.data["new_state"]
-
-            if (from_s and not location.has_location(from_s)) or (
-                to_s and not location.has_location(to_s)
-            ):
-                return
-
-            if not (zone_state := self._hass.states.get(zone_entity_id)):
-                _LOGGER.warning(
-                    "Non-existing zone '%s' in a zone trigger",
-                    zone_entity_id,
-                )
-                return
-
-            from_match = (
-                condition.zone(self._hass, zone_state, from_s) if from_s else False
+        if not (zone_state := hass.states.get(zone_entity_id)):
+            _LOGGER.warning(
+                (
+                    "Automation '%s' is referencing non-existing zone '%s' in a zone"
+                    " trigger"
+                ),
+                trigger_info["name"],
+                zone_entity_id,
             )
-            to_match = condition.zone(self._hass, zone_state, to_s) if to_s else False
+            return
 
-            if (event == EVENT_ENTER and not from_match and to_match) or (
-                event == EVENT_LEAVE and from_match and not to_match
-            ):
-                description = f"{entity} {_EVENT_DESCRIPTION[event]} {zone_state.attributes[ATTR_FRIENDLY_NAME]}"
-                run_action(
-                    {
+        from_match = condition.zone(hass, zone_state, from_s) if from_s else False
+        to_match = condition.zone(hass, zone_state, to_s) if to_s else False
+
+        if (event == EVENT_ENTER and not from_match and to_match) or (
+            event == EVENT_LEAVE and from_match and not to_match
+        ):
+            description = (
+                f"{entity} {_EVENT_DESCRIPTION[event]}"
+                f" {zone_state.attributes[ATTR_FRIENDLY_NAME]}"
+            )
+            hass.async_run_hass_job(
+                job,
+                {
+                    "trigger": {
+                        **trigger_data,
+                        "platform": platform_type,
                         "entity_id": entity,
                         "from_state": from_s,
                         "to_state": to_s,
                         "zone": zone_state,
                         "event": event,
-                    },
-                    description,
-                    to_s.context if to_s else None,
-                )
+                        "description": description,
+                    }
+                },
+                to_s.context if to_s else None,
+            )
 
-        return async_track_state_change_event(
-            self._hass, entity_id, zone_automation_listener
-        )
-
-
-class ZoneTriggerBase(EntityTriggerBase):
-    """Base for zone-based triggers targeting person and device_tracker entities."""
-
-    _domain_specs = _DOMAIN_SPECS
-    _schema = _ZONE_TRIGGER_SCHEMA
-
-    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
-        """Initialize the trigger."""
-        super().__init__(hass, config)
-        self._zone: str = self._options[CONF_ZONE]
-
-    def _in_target_zone(self, state: State) -> bool:
-        """Check if the entity is in the selected zone."""
-        in_zones = state.attributes.get(ATTR_IN_ZONES) or ()
-        return self._zone in in_zones
-
-
-class EnteredZoneTrigger(ZoneTriggerBase):
-    """Trigger when an entity enters the selected zone."""
-
-    def is_valid_transition(self, from_state: State, to_state: State) -> bool:
-        """Check that the entity was not already in the selected zone."""
-        return not self._in_target_zone(from_state)
-
-    def is_valid_state(self, state: State) -> bool:
-        """Check that the entity is now in the selected zone."""
-        return self._in_target_zone(state)
-
-
-class LeftZoneTrigger(ZoneTriggerBase):
-    """Trigger when an entity leaves the selected zone."""
-
-    def is_valid_transition(self, from_state: State, to_state: State) -> bool:
-        """Check that the entity was previously in the selected zone."""
-        return self._in_target_zone(from_state)
-
-    def is_valid_state(self, state: State) -> bool:
-        """Check that the entity is no longer in the selected zone."""
-        return not self._in_target_zone(state)
-
-
-TRIGGERS: dict[str, type[Trigger]] = {
-    "_": LegacyZoneTrigger,
-    "entered": EnteredZoneTrigger,
-    "left": LeftZoneTrigger,
-}
-
-
-async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
-    """Return the triggers for zones."""
-    return TRIGGERS
+    return async_track_state_change_event(hass, entity_id, zone_automation_listener)

homeassistant/components/zone/triggers.yaml

@@ -1,26 +0,0 @@
-.trigger_zone: &trigger_zone
-  target:
-    entity:
-      domain:
-        - person
-        - device_tracker
-  fields:
-    behavior:
-      required: true
-      default: each
-      selector:
-        automation_behavior:
-          mode: trigger
-    for:
-      required: true
-      default: 00:00:00
-      selector:
-        duration:
-    zone:
-      required: true
-      selector:
-        entity:
-          domain: zone
-
-entered: *trigger_zone
-left: *trigger_zone

homeassistant/helpers/trigger.py

@@ -1714,14 +1714,7 @@ def async_extract_entities(trigger_conf: dict) -> list[str]:
         return [trigger_conf[CONF_OPTIONS][CONF_ENTITY_ID]]
 
     if trigger_conf[CONF_PLATFORM] == "zone":
-        options = trigger_conf[CONF_OPTIONS]
-        return [*options[CONF_ENTITY_ID], options[CONF_ZONE]]
-
-    if trigger_conf[CONF_PLATFORM] in ("zone.entered", "zone.left"):
-        return [
-            *async_extract_targets(trigger_conf, CONF_ENTITY_ID),
-            trigger_conf[CONF_OPTIONS][CONF_ZONE],
-        ]
+        return trigger_conf[CONF_ENTITY_ID] + [trigger_conf[CONF_ZONE]]  # type: ignore[no-any-return]
 
     if trigger_conf[CONF_PLATFORM] == "geo_location":
         return [trigger_conf[CONF_ZONE]]

requirements_all.txt

@@ -3357,7 +3357,7 @@ whois==0.9.27
 wiffi==1.1.2
 
 # homeassistant.components.wiim
-wiim==0.1.2
+wiim==0.1.4
 
 # homeassistant.components.wirelesstag
 wirelesstagpy==0.8.1

tests/components/device_tracker/test_entity.py

@@ -1379,6 +1379,31 @@ def test_base_tracker_entity() -> None:
         entity.state_attributes  # noqa: B018
 
 
+def test_battery_level_override_deprecation_warning(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test that overriding battery_level in a subclass logs a warning."""
+    error_message = "is overriding the deprecated battery_level property"
+
+    caplog.clear()
+
+    class _SubclassWithOverride(TrackerEntity):
+        @property
+        def battery_level(self) -> int | None:
+            return 50
+
+    assert error_message in caplog.text
+    assert _SubclassWithOverride.__name__ in caplog.text
+
+    # No warning for a subclass that does not override battery_level
+    caplog.clear()
+
+    class _SubclassWithoutOverride(TrackerEntity):
+        pass
+
+    assert error_message not in caplog.text
+
+
 async def test_attr_location_name_deprecation_warning(
     hass: HomeAssistant,
     caplog: pytest.LogCaptureFixture,

tests/components/matter/common.py

@@ -78,6 +78,7 @@ FIXTURES = [
     "mock_pressure_sensor",
     "mock_pump",
     "mock_room_airconditioner",
+    "mock_soil_sensor",
     "mock_solar_inverter",
     "mock_speaker",
     "mock_switch_unit",

tests/components/matter/fixtures/nodes/mock_soil_sensor.json

@@ -0,0 +1,87 @@
+{
+  "node_id": 101,
+  "date_commissioned": "2024-11-27T00:00:00.000000",
+  "last_interview": "2024-11-27T00:00:00.000000",
+  "interview_version": 2,
+  "attributes": {
+    "0/29/0": [
+      {
+        "0": 22,
+        "1": 1
+      }
+    ],
+    "0/29/1": [
+      4, 29, 31, 40, 42, 43, 44, 48, 49, 50, 51, 52, 53, 54, 55, 59, 60, 62, 63,
+      64, 65
+    ],
+    "0/29/2": [41],
+    "0/29/3": [1],
+    "0/29/65532": 0,
+    "0/29/65533": 1,
+    "0/29/65528": [],
+    "0/29/65529": [],
+    "0/29/65531": [0, 1, 2, 3, 65528, 65529, 65531, 65532, 65533],
+    "0/40/0": 1,
+    "0/40/1": "Nabu Casa",
+    "0/40/2": 65521,
+    "0/40/3": "Mock SoilSensor",
+    "0/40/4": 32768,
+    "0/40/5": "Mock Soil Sensor",
+    "0/40/6": "XX",
+    "0/40/7": 0,
+    "0/40/8": "v1.0",
+    "0/40/9": 1,
+    "0/40/10": "v1.0",
+    "0/40/11": "20241127",
+    "0/40/12": "",
+    "0/40/13": "",
+    "0/40/14": "",
+    "0/40/15": "TEST_SN",
+    "0/40/16": false,
+    "0/40/17": true,
+    "0/40/18": "mock-soil-sensor",
+    "0/40/19": {
+      "0": 3,
+      "1": 3
+    },
+    "0/40/65532": 0,
+    "0/40/65533": 1,
+    "0/40/65528": [],
+    "0/40/65529": [],
+    "0/40/65531": [
+      0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+      65528, 65529, 65531, 65532, 65533
+    ],
+    "1/3/65529": [0, 64],
+    "1/3/65531": [0, 1, 65528, 65529, 65531, 65532, 65533],
+    "1/29/0": [
+      {
+        "0": 69,
+        "1": 1
+      }
+    ],
+    "1/29/1": [3, 29, 57, 1072, 40],
+    "1/29/2": [],
+    "1/29/3": [9, 10],
+    "1/29/65532": null,
+    "1/29/65533": 1,
+    "1/29/65528": [],
+    "1/29/65529": [],
+    "1/29/65531": [0, 1, 2, 3, 65528, 65529, 65531, 65532, 65533],
+    "1/1072/0": {
+      "0": 17,
+      "1": true,
+      "2": 0,
+      "3": 100,
+      "4": []
+    },
+    "1/1072/1": 50,
+    "1/1072/65532": 0,
+    "1/1072/65533": 1,
+    "1/1072/65528": [],
+    "1/1072/65529": [],
+    "1/1072/65531": [0, 1, 65528, 65529, 65531, 65532, 65533]
+  },
+  "available": true,
+  "attribute_subscriptions": []
+}

tests/components/matter/snapshots/test_sensor.ambr

@@ -18619,6 +18619,61 @@
     'state': '0.0',
   })
 # ---
+# name: test_sensors[mock_soil_sensor][sensor.mock_soil_sensor_moisture-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': list([
+      None,
+    ]),
+    'area_id': None,
+    'capabilities': dict({
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+    }),
+    'config_entry_id': <ANY>,
+    'config_subentry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.mock_soil_sensor_moisture',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'object_id_base': 'Moisture',
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.MOISTURE: 'moisture'>,
+    'original_icon': None,
+    'original_name': 'Moisture',
+    'platform': 'matter',
+    'previous_unique_id': None,
+    'suggested_object_id': None,
+    'supported_features': 0,
+    'translation_key': None,
+    'unique_id': '00000000000004D2-0000000000000065-MatterNodeDevice-1-SoilMoistureSensor-1072-1',
+    'unit_of_measurement': '%',
+  })
+# ---
+# name: test_sensors[mock_soil_sensor][sensor.mock_soil_sensor_moisture-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'moisture',
+      'friendly_name': 'Mock Soil Sensor Moisture',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': '%',
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.mock_soil_sensor_moisture',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '50',
+  })
+# ---
 # name: test_sensors[mock_solar_inverter][sensor.mock_solar_inverter_active_current-entry]
   EntityRegistryEntrySnapshot({
     'aliases': list([

tests/components/matter/test_sensor.py

@@ -85,6 +85,25 @@ async def test_humidity_sensor(
     assert state.state == "40.0"
 
 
+@pytest.mark.parametrize("node_fixture", ["mock_soil_sensor"])
+async def test_soil_moisture_sensor(
+    hass: HomeAssistant,
+    matter_client: MagicMock,
+    matter_node: MatterNode,
+) -> None:
+    """Test soil moisture sensor."""
+    state = hass.states.get("sensor.mock_soil_sensor_moisture")
+    assert state
+    assert state.state == "50"
+
+    set_node_attribute(matter_node, 1, 1072, 1, 75)
+    await trigger_subscription_callback(hass, matter_client)
+
+    state = hass.states.get("sensor.mock_soil_sensor_moisture")
+    assert state
+    assert state.state == "75"
+
+
 @pytest.mark.parametrize("node_fixture", ["mock_light_sensor"])
 async def test_light_sensor(
     hass: HomeAssistant,

tests/components/wiim/__init__.py

@@ -38,5 +38,6 @@ async def fire_transport_update(
     """Trigger the registered AVTransport callback on the mock device."""
     assert mock_device.av_transport_event_callback is not None
     mock_device.event_data = {"TransportState": transport_state.value}
+    mock_device.playing_status = transport_state
     mock_device.av_transport_event_callback(MagicMock(), [])
     await hass.async_block_till_done()

tests/components/zone/test_trigger.py

@@ -1,28 +1,14 @@
 """The tests for the location automation."""
 
-from typing import Any
-
 import pytest
-import voluptuous as vol
 
 from homeassistant.components import automation, zone
 from homeassistant.const import ATTR_ENTITY_ID, ENTITY_MATCH_ALL, SERVICE_TURN_OFF
 from homeassistant.core import Context, HomeAssistant, ServiceCall
 from homeassistant.helpers import entity_registry as er
-from homeassistant.helpers.trigger import async_validate_trigger_config
 from homeassistant.setup import async_setup_component
 
 from tests.common import mock_component
-from tests.components.common import (
-    TriggerStateDescription,
-    assert_trigger_behavior_all,
-    assert_trigger_behavior_each,
-    assert_trigger_behavior_first,
-    assert_trigger_options_supported,
-    parametrize_target_entities,
-    parametrize_trigger_states,
-    target_entities,
-)
 
 
 @pytest.fixture(autouse=True)
@@ -357,7 +343,10 @@ async def test_unknown_zone(
         },
     )
 
-    assert "Non-existing zone 'zone.no_such_zone' in a zone trigger" not in caplog.text
+    assert (
+        "Automation 'My Automation' is referencing non-existing zone"
+        " 'zone.no_such_zone' in a zone trigger" not in caplog.text
+    )
 
     hass.states.async_set(
         "test.entity",
@@ -367,192 +356,7 @@ async def test_unknown_zone(
     )
     await hass.async_block_till_done()
 
-    assert "Non-existing zone 'zone.no_such_zone' in a zone trigger" in caplog.text
-
-
-# --- New-style zone trigger tests ---
-
-ZONE_HOME = "zone.home"
-ZONE_WORK = "zone.work"
-IN_ZONES_HOME = {"in_zones": [ZONE_HOME]}
-IN_ZONES_WORK = {"in_zones": [ZONE_WORK]}
-IN_ZONES_NONE: dict[str, list[str]] = {"in_zones": []}
-TRIGGER_ZONE = ZONE_HOME
-
-
-@pytest.mark.parametrize(
-    ("trigger_key", "base_options", "supports_behavior", "supports_duration"),
-    [
-        ("zone.entered", {"zone": TRIGGER_ZONE}, True, True),
-        ("zone.left", {"zone": TRIGGER_ZONE}, True, True),
-    ],
-)
-async def test_zone_trigger_options_validation(
-    hass: HomeAssistant,
-    trigger_key: str,
-    base_options: dict[str, Any] | None,
-    supports_behavior: bool,
-    supports_duration: bool,
-) -> None:
-    """Test that zone triggers support the expected options."""
-    await assert_trigger_options_supported(
-        hass,
-        trigger_key,
-        base_options,
-        supports_behavior=supports_behavior,
-        supports_duration=supports_duration,
-    )
-
-
-@pytest.mark.parametrize("trigger_key", ["zone.entered", "zone.left"])
-async def test_zone_trigger_rejects_non_zone_entity_id(
-    hass: HomeAssistant, trigger_key: str
-) -> None:
-    """Test that the zone option must reference entities in the zone domain."""
-    with pytest.raises(vol.Invalid):
-        await async_validate_trigger_config(
-            hass,
-            [
-                {
-                    "platform": trigger_key,
-                    "target": {"entity_id": "person.alice"},
-                    "options": {"zone": "person.alice"},
-                }
-            ],
-        )
-
-
-@pytest.fixture
-async def target_zone_entities(
-    hass: HomeAssistant, domain: str
-) -> dict[str, list[str]]:
-    """Create multiple zone-trackable entities associated with different targets."""
-    return await target_entities(hass, domain, domain_excluded="sensor")
-
-
-_ZONE_TRIGGER_STATES = [
-    *parametrize_trigger_states(
-        trigger="zone.entered",
-        trigger_options={"zone": TRIGGER_ZONE},
-        target_states=[
-            ("home", IN_ZONES_HOME),
-        ],
-        other_states=[
-            ("not_home", IN_ZONES_NONE),
-            ("Work", IN_ZONES_WORK),
-        ],
-    ),
-    *parametrize_trigger_states(
-        trigger="zone.left",
-        trigger_options={"zone": TRIGGER_ZONE},
-        target_states=[
-            ("not_home", IN_ZONES_NONE),
-            ("Work", IN_ZONES_WORK),
-        ],
-        other_states=[
-            ("home", IN_ZONES_HOME),
-        ],
-    ),
-]
-
-
-def _parametrize_zone_target_entities() -> list[tuple[dict[str, Any], str, int, str]]:
-    """Parametrize target entities for all supported zone trigger domains."""
-    return [
-        (*params, domain)
-        for domain in ("person", "device_tracker")
-        for params in parametrize_target_entities(domain)
-    ]
-
-
-@pytest.mark.parametrize(
-    ("trigger_target_config", "entity_id", "entities_in_target", "domain"),
-    _parametrize_zone_target_entities(),
-)
-@pytest.mark.parametrize(
-    ("trigger", "trigger_options", "states"),
-    _ZONE_TRIGGER_STATES,
-)
-async def test_zone_trigger_behavior_each(
-    hass: HomeAssistant,
-    target_zone_entities: dict[str, list[str]],
-    trigger_target_config: dict[str, Any],
-    entity_id: str,
-    entities_in_target: int,
-    trigger: str,
-    trigger_options: dict[str, Any],
-    states: list[TriggerStateDescription],
-) -> None:
-    """Test zone triggers fire when any targeted entity changes."""
-    await assert_trigger_behavior_each(
-        hass,
-        target_entities=target_zone_entities,
-        trigger_target_config=trigger_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
-        trigger=trigger,
-        trigger_options=trigger_options,
-        states=states,
-    )
-
-
-@pytest.mark.parametrize(
-    ("trigger_target_config", "entity_id", "entities_in_target", "domain"),
-    _parametrize_zone_target_entities(),
-)
-@pytest.mark.parametrize(
-    ("trigger", "trigger_options", "states"),
-    _ZONE_TRIGGER_STATES,
-)
-async def test_zone_trigger_behavior_first(
-    hass: HomeAssistant,
-    target_zone_entities: dict[str, list[str]],
-    trigger_target_config: dict[str, Any],
-    entity_id: str,
-    entities_in_target: int,
-    trigger: str,
-    trigger_options: dict[str, Any],
-    states: list[TriggerStateDescription],
-) -> None:
-    """Test zone triggers fire when first targeted entity changes."""
-    await assert_trigger_behavior_first(
-        hass,
-        target_entities=target_zone_entities,
-        trigger_target_config=trigger_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
-        trigger=trigger,
-        trigger_options=trigger_options,
-        states=states,
-    )
-
-
-@pytest.mark.parametrize(
-    ("trigger_target_config", "entity_id", "entities_in_target", "domain"),
-    _parametrize_zone_target_entities(),
-)
-@pytest.mark.parametrize(
-    ("trigger", "trigger_options", "states"),
-    _ZONE_TRIGGER_STATES,
-)
-async def test_zone_trigger_behavior_all(
-    hass: HomeAssistant,
-    target_zone_entities: dict[str, list[str]],
-    trigger_target_config: dict[str, Any],
-    entity_id: str,
-    entities_in_target: int,
-    trigger: str,
-    trigger_options: dict[str, Any],
-    states: list[TriggerStateDescription],
-) -> None:
-    """Test zone triggers fire when last targeted entity changes."""
-    await assert_trigger_behavior_all(
-        hass,
-        target_entities=target_zone_entities,
-        trigger_target_config=trigger_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
-        trigger=trigger,
-        trigger_options=trigger_options,
-        states=states,
+    assert (
+        "Automation 'My Automation' is referencing non-existing zone"
+        " 'zone.no_such_zone' in a zone trigger" in caplog.text
     )

tests/helpers/test_trigger.py

@@ -4639,33 +4639,13 @@ async def test_entity_trigger_duration_cancelled_on_invalid_state(
         pytest.param(
             {
                 "platform": "zone",
-                "options": {
-                    "entity_id": ["person.a"],
-                    "zone": "zone.home",
-                    "event": "enter",
-                },
+                "entity_id": ["person.a"],
+                "zone": "zone.home",
+                "event": "enter",
             },
             ["person.a", "zone.home"],
             id="zone-legacy",
         ),
-        pytest.param(
-            {
-                "platform": "zone.entered",
-                "target": {"entity_id": ["person.a", "device_tracker.b"]},
-                "options": {"zone": "zone.home"},
-            },
-            ["person.a", "device_tracker.b", "zone.home"],
-            id="zone-entered-modern",
-        ),
-        pytest.param(
-            {
-                "platform": "zone.left",
-                "target": {"entity_id": "person.a"},
-                "options": {"zone": "zone.home"},
-            },
-            ["person.a", "zone.home"],
-            id="zone-left-modern",
-        ),
         pytest.param(
             {"platform": "geo_location", "zone": "zone.home"},
             ["zone.home"],