Fix comments

CODEOWNERS

@@ -1184,6 +1184,8 @@ build.json @home-assistant/supervisor
 /tests/components/nzbget/ @chriscla
 /homeassistant/components/obihai/ @dshokouhi @ejpenney
 /tests/components/obihai/ @dshokouhi @ejpenney
+/homeassistant/components/occupancy/ @home-assistant/core
+/tests/components/occupancy/ @home-assistant/core
 /homeassistant/components/octoprint/ @rfleming71
 /tests/components/octoprint/ @rfleming71
 /homeassistant/components/ohmconnect/ @robbiet480
@@ -1905,6 +1907,8 @@ build.json @home-assistant/supervisor
 /tests/components/wiffi/ @mampfes
 /homeassistant/components/wilight/ @leofig-rj
 /tests/components/wilight/ @leofig-rj
+/homeassistant/components/window/ @home-assistant/core
+/tests/components/window/ @home-assistant/core
 /homeassistant/components/wirelesstag/ @sergeymaysak
 /homeassistant/components/withings/ @joostlek
 /tests/components/withings/ @joostlek

homeassistant/bootstrap.py

@@ -245,6 +245,8 @@ DEFAULT_INTEGRATIONS = {
     "garage_door",
     "gate",
     "humidity",
+    "occupancy",
+    "window",
 }
 DEFAULT_INTEGRATIONS_RECOVERY_MODE = {
     # These integrations are set up if recovery mode is activated.

homeassistant/components/automation/__init__.py

@@ -152,6 +152,7 @@ _EXPERIMENTAL_TRIGGER_PLATFORMS = {
     "light",
     "lock",
     "media_player",
+    "occupancy",
     "person",
     "remote",
     "scene",
@@ -161,6 +162,7 @@ _EXPERIMENTAL_TRIGGER_PLATFORMS = {
     "text",
     "update",
     "vacuum",
+    "window",
 }
 
 

homeassistant/components/backup/manager.py

@@ -144,6 +144,7 @@ class CreateBackupStage(StrEnum):
     ADDONS = "addons"
     AWAIT_ADDON_RESTARTS = "await_addon_restarts"
     DOCKER_CONFIG = "docker_config"
+    CLEANING_UP = "cleaning_up"
     FINISHING_FILE = "finishing_file"
     FOLDERS = "folders"
     HOME_ASSISTANT = "home_assistant"
@@ -1290,6 +1291,13 @@ class BackupManager:
                 )
             # delete old backups more numerous than copies
             # try this regardless of agent errors above
+            self.async_on_backup_event(
+                CreateBackupEvent(
+                    reason=None,
+                    stage=CreateBackupStage.CLEANING_UP,
+                    state=CreateBackupState.IN_PROGRESS,
+                )
+            )
             await delete_backups_exceeding_configured_count(self)
 
         finally:

homeassistant/components/growatt_server/strings.json

@@ -38,16 +38,16 @@
       "token_auth": {
         "data": {
           "region": "[%key:component::growatt_server::config::step::password_auth::data::region%]",
-          "token": "API Token"
+          "token": "API token"
         },
         "description": "Token authentication is only supported for MIN/TLX devices. For other device types, please use username/password authentication.",
         "title": "Enter your API token"
       },
       "user": {
-        "description": "Note: API Token authentication is currently only supported for MIN/TLX devices. For other device types, please use Username & Password authentication.",
+        "description": "Note: Token authentication is currently only supported for MIN/TLX devices. For other device types, please use username/password authentication.",
         "menu_options": {
-          "password_auth": "Username & Password",
-          "token_auth": "API Token (MIN/TLX only)"
+          "password_auth": "Username/password",
+          "token_auth": "API token (MIN/TLX only)"
         },
         "title": "Choose authentication method"
       }

homeassistant/components/intellifire/manifest.json

@@ -12,5 +12,5 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["intellifire4py"],
-  "requirements": ["intellifire4py==4.3.1"]
+  "requirements": ["intellifire4py==4.4.0"]
 }

homeassistant/components/occupancy/__init__.py

@@ -0,0 +1,17 @@
+"""Integration for occupancy triggers."""
+
+from __future__ import annotations
+
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.typing import ConfigType
+
+DOMAIN = "occupancy"
+CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
+
+__all__ = []
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the component."""
+    return True

homeassistant/components/occupancy/icons.json

@@ -0,0 +1,10 @@
+{
+  "triggers": {
+    "cleared": {
+      "trigger": "mdi:home-outline"
+    },
+    "detected": {
+      "trigger": "mdi:home-account"
+    }
+  }
+}

homeassistant/components/occupancy/manifest.json

@@ -0,0 +1,8 @@
+{
+  "domain": "occupancy",
+  "name": "Occupancy",
+  "codeowners": ["@home-assistant/core"],
+  "documentation": "https://www.home-assistant.io/integrations/occupancy",
+  "integration_type": "system",
+  "quality_scale": "internal"
+}

homeassistant/components/occupancy/strings.json

@@ -0,0 +1,38 @@
+{
+  "common": {
+    "trigger_behavior_description": "The behavior of the targeted occupancy sensors to trigger on.",
+    "trigger_behavior_name": "Behavior"
+  },
+  "selector": {
+    "trigger_behavior": {
+      "options": {
+        "any": "Any",
+        "first": "First",
+        "last": "Last"
+      }
+    }
+  },
+  "title": "Occupancy",
+  "triggers": {
+    "cleared": {
+      "description": "Triggers after one or more occupancy sensors stop detecting occupancy.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::occupancy::common::trigger_behavior_description%]",
+          "name": "[%key:component::occupancy::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Occupancy cleared"
+    },
+    "detected": {
+      "description": "Triggers after one or more occupancy sensors start detecting occupancy.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::occupancy::common::trigger_behavior_description%]",
+          "name": "[%key:component::occupancy::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Occupancy detected"
+    }
+  }
+}

homeassistant/components/occupancy/trigger.py

@@ -0,0 +1,57 @@
+"""Provides triggers for occupancy."""
+
+from homeassistant.components.binary_sensor import (
+    DOMAIN as BINARY_SENSOR_DOMAIN,
+    BinarySensorDeviceClass,
+)
+from homeassistant.const import STATE_OFF, STATE_ON
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.trigger import (
+    EntityTargetStateTriggerBase,
+    EntityTriggerBase,
+    Trigger,
+    get_device_class_or_undefined,
+)
+
+
+class _OccupancyBinaryTriggerBase(EntityTriggerBase):
+    """Base trigger for occupancy binary sensor state changes."""
+
+    _domains = {BINARY_SENSOR_DOMAIN}
+
+    def entity_filter(self, entities: set[str]) -> set[str]:
+        """Filter entities by occupancy device class."""
+        entities = super().entity_filter(entities)
+        return {
+            entity_id
+            for entity_id in entities
+            if get_device_class_or_undefined(self._hass, entity_id)
+            == BinarySensorDeviceClass.OCCUPANCY
+        }
+
+
+class OccupancyDetectedTrigger(
+    _OccupancyBinaryTriggerBase, EntityTargetStateTriggerBase
+):
+    """Trigger for occupancy detected (binary sensor ON)."""
+
+    _to_states = {STATE_ON}
+
+
+class OccupancyClearedTrigger(
+    _OccupancyBinaryTriggerBase, EntityTargetStateTriggerBase
+):
+    """Trigger for occupancy cleared (binary sensor OFF)."""
+
+    _to_states = {STATE_OFF}
+
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "detected": OccupancyDetectedTrigger,
+    "cleared": OccupancyClearedTrigger,
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for occupancy."""
+    return TRIGGERS

homeassistant/components/occupancy/triggers.yaml

@@ -0,0 +1,25 @@
+.trigger_common_fields: &trigger_common_fields
+  behavior:
+    required: true
+    default: any
+    selector:
+      select:
+        translation_key: trigger_behavior
+        options:
+          - first
+          - last
+          - any
+
+detected:
+  fields: *trigger_common_fields
+  target:
+    entity:
+      - domain: binary_sensor
+        device_class: occupancy
+
+cleared:
+  fields: *trigger_common_fields
+  target:
+    entity:
+      - domain: binary_sensor
+        device_class: occupancy

homeassistant/components/waterfurnace/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["waterfurnace"],
   "quality_scale": "legacy",
-  "requirements": ["waterfurnace==1.5.1"]
+  "requirements": ["waterfurnace==1.6.2"]
 }

homeassistant/components/webdav/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["aiowebdav2"],
   "quality_scale": "bronze",
-  "requirements": ["aiowebdav2==0.6.1"]
+  "requirements": ["aiowebdav2==0.6.2"]
 }

homeassistant/components/window/__init__.py

@@ -0,0 +1,17 @@
+"""Integration for window triggers."""
+
+from __future__ import annotations
+
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.typing import ConfigType
+
+DOMAIN = "window"
+CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
+
+__all__ = []
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the component."""
+    return True

homeassistant/components/window/icons.json

@@ -0,0 +1,10 @@
+{
+  "triggers": {
+    "closed": {
+      "trigger": "mdi:window-closed"
+    },
+    "opened": {
+      "trigger": "mdi:window-open"
+    }
+  }
+}

homeassistant/components/window/manifest.json

@@ -0,0 +1,8 @@
+{
+  "domain": "window",
+  "name": "Window",
+  "codeowners": ["@home-assistant/core"],
+  "documentation": "https://www.home-assistant.io/integrations/window",
+  "integration_type": "system",
+  "quality_scale": "internal"
+}

homeassistant/components/window/strings.json

@@ -0,0 +1,38 @@
+{
+  "common": {
+    "trigger_behavior_description": "The behavior of the targeted windows to trigger on.",
+    "trigger_behavior_name": "Behavior"
+  },
+  "selector": {
+    "trigger_behavior": {
+      "options": {
+        "any": "Any",
+        "first": "First",
+        "last": "Last"
+      }
+    }
+  },
+  "title": "Window",
+  "triggers": {
+    "closed": {
+      "description": "Triggers after one or more windows close.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::window::common::trigger_behavior_description%]",
+          "name": "[%key:component::window::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Window closed"
+    },
+    "opened": {
+      "description": "Triggers after one or more windows open.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::window::common::trigger_behavior_description%]",
+          "name": "[%key:component::window::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Window opened"
+    }
+  }
+}

homeassistant/components/window/trigger.py

@@ -0,0 +1,36 @@
+"""Provides triggers for windows."""
+
+from homeassistant.components.binary_sensor import (
+    DOMAIN as BINARY_SENSOR_DOMAIN,
+    BinarySensorDeviceClass,
+)
+from homeassistant.components.cover import (
+    DOMAIN as COVER_DOMAIN,
+    CoverDeviceClass,
+    make_cover_closed_trigger,
+    make_cover_opened_trigger,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.trigger import Trigger
+
+DEVICE_CLASSES_WINDOW: dict[str, str] = {
+    BINARY_SENSOR_DOMAIN: BinarySensorDeviceClass.WINDOW,
+    COVER_DOMAIN: CoverDeviceClass.WINDOW,
+}
+
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "opened": make_cover_opened_trigger(
+        device_classes=DEVICE_CLASSES_WINDOW,
+        domains={BINARY_SENSOR_DOMAIN, COVER_DOMAIN},
+    ),
+    "closed": make_cover_closed_trigger(
+        device_classes=DEVICE_CLASSES_WINDOW,
+        domains={BINARY_SENSOR_DOMAIN, COVER_DOMAIN},
+    ),
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for windows."""
+    return TRIGGERS

homeassistant/components/window/triggers.yaml

@@ -0,0 +1,29 @@
+.trigger_common_fields: &trigger_common_fields
+  behavior:
+    required: true
+    default: any
+    selector:
+      select:
+        translation_key: trigger_behavior
+        options:
+          - first
+          - last
+          - any
+
+closed:
+  fields: *trigger_common_fields
+  target:
+    entity:
+      - domain: binary_sensor
+        device_class: window
+      - domain: cover
+        device_class: window
+
+opened:
+  fields: *trigger_common_fields
+  target:
+    entity:
+      - domain: binary_sensor
+        device_class: window
+      - domain: cover
+        device_class: window

homeassistant/helpers/service.py

@@ -782,6 +782,8 @@ async def entity_service_call(
         all_referenced,
     )
 
+    entity_candidates = [e for e in entity_candidates if e.available]
+
     if not target_all_entities:
         assert referenced is not None
         # Only report on explicit referenced entities
@@ -792,9 +794,6 @@ async def entity_service_call(
 
     entities: list[Entity] = []
     for entity in entity_candidates:
-        if not entity.available:
-            continue
-
         # Skip entities that don't have the required device class.
         if (
             entity_device_classes is not None

requirements_all.txt

@@ -443,7 +443,7 @@ aiowaqi==3.1.0
 aiowatttime==0.1.1
 
 # homeassistant.components.webdav
-aiowebdav2==0.6.1
+aiowebdav2==0.6.2
 
 # homeassistant.components.webostv
 aiowebostv==0.7.5
@@ -1322,7 +1322,7 @@ inkbird-ble==1.1.1
 insteon-frontend-home-assistant==0.6.1
 
 # homeassistant.components.intellifire
-intellifire4py==4.3.1
+intellifire4py==4.4.0
 
 # homeassistant.components.iometer
 iometer==0.4.0
@@ -3247,7 +3247,7 @@ wallbox==0.9.0
 watchdog==6.0.0
 
 # homeassistant.components.waterfurnace
-waterfurnace==1.5.1
+waterfurnace==1.6.2
 
 # homeassistant.components.watergate
 watergate-local-api==2025.1.0

requirements_test_all.txt

@@ -428,7 +428,7 @@ aiowaqi==3.1.0
 aiowatttime==0.1.1
 
 # homeassistant.components.webdav
-aiowebdav2==0.6.1
+aiowebdav2==0.6.2
 
 # homeassistant.components.webostv
 aiowebostv==0.7.5
@@ -1171,7 +1171,7 @@ inkbird-ble==1.1.1
 insteon-frontend-home-assistant==0.6.1
 
 # homeassistant.components.intellifire
-intellifire4py==4.3.1
+intellifire4py==4.4.0
 
 # homeassistant.components.iometer
 iometer==0.4.0
@@ -2735,7 +2735,7 @@ wallbox==0.9.0
 watchdog==6.0.0
 
 # homeassistant.components.waterfurnace
-waterfurnace==1.5.1
+waterfurnace==1.6.2
 
 # homeassistant.components.watergate
 watergate-local-api==2025.1.0

script/hassfest/manifest.py

@@ -103,6 +103,7 @@ NO_IOT_CLASS = [
     "lovelace",
     "media_source",
     "my",
+    "occupancy",
     "onboarding",
     "panel_custom",
     "plant",
@@ -123,6 +124,7 @@ NO_IOT_CLASS = [
     "web_rtc",
     "webhook",
     "websocket_api",
+    "window",
     "zone",
 ]
 

script/hassfest/quality_scale.py

@@ -2138,6 +2138,7 @@ NO_QUALITY_SCALE = [
     "lovelace",
     "media_source",
     "my",
+    "occupancy",
     "onboarding",
     "panel_custom",
     "proxy",
@@ -2157,6 +2158,7 @@ NO_QUALITY_SCALE = [
     "web_rtc",
     "webhook",
     "websocket_api",
+    "window",
     "zone",
 ]
 

tests/components/backup/test_manager.py

@@ -604,6 +604,14 @@ async def test_initiate_backup(
     result = await ws_client.receive_json()
     while "uploaded_bytes" in result["event"]:
         result = await ws_client.receive_json()
+    assert result["event"] == {
+        "manager_state": BackupManagerState.CREATE_BACKUP,
+        "reason": None,
+        "stage": CreateBackupStage.CLEANING_UP,
+        "state": CreateBackupState.IN_PROGRESS,
+    }
+
+    result = await ws_client.receive_json()
     assert result["event"] == {
         "manager_state": BackupManagerState.CREATE_BACKUP,
         "reason": None,
@@ -854,6 +862,14 @@ async def test_initiate_backup_with_agent_error(
     result = await ws_client.receive_json()
     while "uploaded_bytes" in result["event"]:
         result = await ws_client.receive_json()
+    assert result["event"] == {
+        "manager_state": BackupManagerState.CREATE_BACKUP,
+        "reason": None,
+        "stage": CreateBackupStage.CLEANING_UP,
+        "state": CreateBackupState.IN_PROGRESS,
+    }
+
+    result = await ws_client.receive_json()
     assert result["event"] == {
         "manager_state": BackupManagerState.CREATE_BACKUP,
         "reason": "upload_failed",
@@ -3549,6 +3565,14 @@ async def test_initiate_backup_per_agent_encryption(
     result = await ws_client.receive_json()
     while "uploaded_bytes" in result["event"]:
         result = await ws_client.receive_json()
+    assert result["event"] == {
+        "manager_state": BackupManagerState.CREATE_BACKUP,
+        "reason": None,
+        "stage": CreateBackupStage.CLEANING_UP,
+        "state": CreateBackupState.IN_PROGRESS,
+    }
+
+    result = await ws_client.receive_json()
     assert result["event"] == {
         "manager_state": BackupManagerState.CREATE_BACKUP,
         "reason": None,
@@ -3783,7 +3807,7 @@ async def test_upload_progress_event(
     result = await ws_client.receive_json()
     assert result["event"]["stage"] == CreateBackupStage.UPLOAD_TO_AGENTS
 
-    # Collect all upload progress events until the final state event
+    # Collect all upload progress events until the finishing backup stage event
     progress_events = []
     result = await ws_client.receive_json()
     while "uploaded_bytes" in result["event"]:
@@ -3801,6 +3825,9 @@ async def test_upload_progress_event(
     assert len(local_progress) == 1
     assert local_progress[0]["uploaded_bytes"] == local_progress[0]["total_bytes"]
 
+    assert result["event"]["stage"] == CreateBackupStage.CLEANING_UP
+
+    result = await ws_client.receive_json()
     assert result["event"]["state"] == CreateBackupState.COMPLETED
 
     result = await ws_client.receive_json()

tests/components/hassio/test_backup.py

@@ -984,6 +984,14 @@ async def test_reader_writer_create(
     response = await client.receive_json()
     while "uploaded_bytes" in response["event"]:
         response = await client.receive_json()
+    assert response["event"] == {
+        "manager_state": "create_backup",
+        "reason": None,
+        "stage": "cleaning_up",
+        "state": "in_progress",
+    }
+
+    response = await client.receive_json()
     assert response["event"] == {
         "manager_state": "create_backup",
         "reason": None,
@@ -1101,6 +1109,14 @@ async def test_reader_writer_create_addon_folder_error(
     response = await client.receive_json()
     while "uploaded_bytes" in response["event"]:
         response = await client.receive_json()
+    assert response["event"] == {
+        "manager_state": "create_backup",
+        "reason": None,
+        "stage": "cleaning_up",
+        "state": "in_progress",
+    }
+
+    response = await client.receive_json()
     assert response["event"] == {
         "manager_state": "create_backup",
         "reason": None,
@@ -1221,6 +1237,14 @@ async def test_reader_writer_create_report_progress(
     response = await client.receive_json()
     while "uploaded_bytes" in response["event"]:
         response = await client.receive_json()
+    assert response["event"] == {
+        "manager_state": "create_backup",
+        "reason": None,
+        "stage": "cleaning_up",
+        "state": "in_progress",
+    }
+
+    response = await client.receive_json()
     assert response["event"] == {
         "manager_state": "create_backup",
         "reason": None,
@@ -1286,6 +1310,14 @@ async def test_reader_writer_create_job_done(
     response = await client.receive_json()
     while "uploaded_bytes" in response["event"]:
         response = await client.receive_json()
+    assert response["event"] == {
+        "manager_state": "create_backup",
+        "reason": None,
+        "stage": "cleaning_up",
+        "state": "in_progress",
+    }
+
+    response = await client.receive_json()
     assert response["event"] == {
         "manager_state": "create_backup",
         "reason": None,
@@ -1552,6 +1584,14 @@ async def test_reader_writer_create_per_agent_encryption(
     response = await client.receive_json()
     while "uploaded_bytes" in response["event"]:
         response = await client.receive_json()
+    assert response["event"] == {
+        "manager_state": "create_backup",
+        "reason": None,
+        "stage": "cleaning_up",
+        "state": "in_progress",
+    }
+
+    response = await client.receive_json()
     assert response["event"] == {
         "manager_state": "create_backup",
         "reason": None,
@@ -1728,10 +1768,51 @@ async def test_reader_writer_create_missing_reference_error(
 
 
 @pytest.mark.usefixtures("hassio_client", "setup_backup_integration")
-@pytest.mark.parametrize("exception", [SupervisorError("Boom!"), Exception("Boom!")])
 @pytest.mark.parametrize(
-    ("method", "download_call_count", "remove_call_count"),
-    [("download_backup", 1, 1), ("remove_backup", 1, 1)],
+    (
+        "exception",
+        "method",
+        "download_call_count",
+        "remove_call_count",
+        "expected_events_before_failed",
+    ),
+    [
+        (
+            SupervisorError("Boom!"),
+            "download_backup",
+            1,
+            1,
+            [],
+        ),
+        (
+            Exception("Boom!"),
+            "download_backup",
+            1,
+            1,
+            [
+                {
+                    "manager_state": "create_backup",
+                    "reason": None,
+                    "stage": "cleaning_up",
+                    "state": "in_progress",
+                }
+            ],
+        ),
+        (
+            SupervisorError("Boom!"),
+            "remove_backup",
+            1,
+            1,
+            [],
+        ),
+        (
+            Exception("Boom!"),
+            "remove_backup",
+            1,
+            1,
+            [],
+        ),
+    ],
 )
 async def test_reader_writer_create_download_remove_error(
     hass: HomeAssistant,
@@ -1741,6 +1822,7 @@ async def test_reader_writer_create_download_remove_error(
     method: str,
     download_call_count: int,
     remove_call_count: int,
+    expected_events_before_failed: list[dict[str, str]],
 ) -> None:
     """Test download and remove error when generating a backup."""
     client = await hass_ws_client(hass)
@@ -1807,6 +1889,9 @@ async def test_reader_writer_create_download_remove_error(
     response = await client.receive_json()
     while "uploaded_bytes" in response["event"]:
         response = await client.receive_json()
+    for expected_event in expected_events_before_failed:
+        assert response["event"] == expected_event
+        response = await client.receive_json()
     assert response["event"] == {
         "manager_state": "create_backup",
         "reason": "upload_failed",
@@ -1974,6 +2059,14 @@ async def test_reader_writer_create_remote_backup(
     response = await client.receive_json()
     while "uploaded_bytes" in response["event"]:
         response = await client.receive_json()
+    assert response["event"] == {
+        "manager_state": "create_backup",
+        "reason": None,
+        "stage": "cleaning_up",
+        "state": "in_progress",
+    }
+
+    response = await client.receive_json()
     assert response["event"] == {
         "manager_state": "create_backup",
         "reason": None,

tests/components/occupancy/__init__.py

@@ -0,0 +1 @@
+"""Tests for the occupancy integration."""

tests/components/occupancy/test_trigger.py

@@ -0,0 +1,327 @@
+"""Test occupancy trigger."""
+
+from typing import Any
+
+import pytest
+
+from homeassistant.const import (
+    ATTR_DEVICE_CLASS,
+    ATTR_LABEL_ID,
+    CONF_ENTITY_ID,
+    STATE_OFF,
+    STATE_ON,
+)
+from homeassistant.core import HomeAssistant, ServiceCall
+
+from tests.components import (
+    TriggerStateDescription,
+    arm_trigger,
+    parametrize_target_entities,
+    parametrize_trigger_states,
+    set_or_remove_state,
+    target_entities,
+)
+
+
+@pytest.fixture
+async def target_binary_sensors(hass: HomeAssistant) -> dict[str, list[str]]:
+    """Create multiple binary sensor entities associated with different targets."""
+    return await target_entities(hass, "binary_sensor")
+
+
+@pytest.mark.parametrize(
+    "trigger_key",
+    [
+        "occupancy.detected",
+        "occupancy.cleared",
+    ],
+)
+async def test_occupancy_triggers_gated_by_labs_flag(
+    hass: HomeAssistant, caplog: pytest.LogCaptureFixture, trigger_key: str
+) -> None:
+    """Test the occupancy triggers are gated by the labs flag."""
+    await arm_trigger(hass, trigger_key, None, {ATTR_LABEL_ID: "test_label"})
+    assert (
+        "Unnamed automation failed to setup triggers and has been disabled: Trigger "
+        f"'{trigger_key}' requires the experimental 'New triggers and conditions' "
+        "feature to be enabled in Home Assistant Labs settings (feature flag: "
+        "'new_triggers_conditions')"
+    ) in caplog.text
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("trigger_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("binary_sensor"),
+)
+@pytest.mark.parametrize(
+    ("trigger", "trigger_options", "states"),
+    [
+        *parametrize_trigger_states(
+            trigger="occupancy.detected",
+            target_states=[STATE_ON],
+            other_states=[STATE_OFF],
+            additional_attributes={ATTR_DEVICE_CLASS: "occupancy"},
+            trigger_from_none=False,
+        ),
+        *parametrize_trigger_states(
+            trigger="occupancy.cleared",
+            target_states=[STATE_OFF],
+            other_states=[STATE_ON],
+            additional_attributes={ATTR_DEVICE_CLASS: "occupancy"},
+            trigger_from_none=False,
+        ),
+    ],
+)
+async def test_occupancy_trigger_binary_sensor_behavior_any(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    target_binary_sensors: dict[str, list[str]],
+    trigger_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    trigger: str,
+    trigger_options: dict[str, Any],
+    states: list[TriggerStateDescription],
+) -> None:
+    """Test occupancy trigger fires for binary_sensor entities with device_class occupancy."""
+    other_entity_ids = set(target_binary_sensors["included"]) - {entity_id}
+    excluded_entity_ids = set(target_binary_sensors["excluded"]) - {entity_id}
+
+    for eid in target_binary_sensors["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+    for eid in excluded_entity_ids:
+        set_or_remove_state(hass, eid, states[0]["excluded"])
+        await hass.async_block_till_done()
+
+    await arm_trigger(hass, trigger, {}, trigger_target_config)
+
+    for state in states[1:]:
+        excluded_state = state["excluded"]
+        included_state = state["included"]
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert len(service_calls) == state["count"]
+        for service_call in service_calls:
+            assert service_call.data[CONF_ENTITY_ID] == entity_id
+        service_calls.clear()
+
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+        for excluded_entity_id in excluded_entity_ids:
+            set_or_remove_state(hass, excluded_entity_id, excluded_state)
+            await hass.async_block_till_done()
+        assert len(service_calls) == (entities_in_target - 1) * state["count"]
+        service_calls.clear()
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("trigger_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("binary_sensor"),
+)
+@pytest.mark.parametrize(
+    ("trigger", "trigger_options", "states"),
+    [
+        *parametrize_trigger_states(
+            trigger="occupancy.detected",
+            target_states=[STATE_ON],
+            other_states=[STATE_OFF],
+            additional_attributes={ATTR_DEVICE_CLASS: "occupancy"},
+            trigger_from_none=False,
+        ),
+        *parametrize_trigger_states(
+            trigger="occupancy.cleared",
+            target_states=[STATE_OFF],
+            other_states=[STATE_ON],
+            additional_attributes={ATTR_DEVICE_CLASS: "occupancy"},
+            trigger_from_none=False,
+        ),
+    ],
+)
+async def test_occupancy_trigger_binary_sensor_behavior_first(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    target_binary_sensors: dict[str, list[str]],
+    trigger_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    trigger: str,
+    trigger_options: dict[str, Any],
+    states: list[TriggerStateDescription],
+) -> None:
+    """Test occupancy trigger fires on the first binary_sensor state change."""
+    other_entity_ids = set(target_binary_sensors["included"]) - {entity_id}
+    excluded_entity_ids = set(target_binary_sensors["excluded"]) - {entity_id}
+
+    for eid in target_binary_sensors["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+    for eid in excluded_entity_ids:
+        set_or_remove_state(hass, eid, states[0]["excluded"])
+        await hass.async_block_till_done()
+
+    await arm_trigger(hass, trigger, {"behavior": "first"}, trigger_target_config)
+
+    for state in states[1:]:
+        excluded_state = state["excluded"]
+        included_state = state["included"]
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert len(service_calls) == state["count"]
+        for service_call in service_calls:
+            assert service_call.data[CONF_ENTITY_ID] == entity_id
+        service_calls.clear()
+
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, excluded_state)
+            await hass.async_block_till_done()
+        for excluded_entity_id in excluded_entity_ids:
+            set_or_remove_state(hass, excluded_entity_id, excluded_state)
+            await hass.async_block_till_done()
+        assert len(service_calls) == 0
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("trigger_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("binary_sensor"),
+)
+@pytest.mark.parametrize(
+    ("trigger", "trigger_options", "states"),
+    [
+        *parametrize_trigger_states(
+            trigger="occupancy.detected",
+            target_states=[STATE_ON],
+            other_states=[STATE_OFF],
+            additional_attributes={ATTR_DEVICE_CLASS: "occupancy"},
+            trigger_from_none=False,
+        ),
+        *parametrize_trigger_states(
+            trigger="occupancy.cleared",
+            target_states=[STATE_OFF],
+            other_states=[STATE_ON],
+            additional_attributes={ATTR_DEVICE_CLASS: "occupancy"},
+            trigger_from_none=False,
+        ),
+    ],
+)
+async def test_occupancy_trigger_binary_sensor_behavior_last(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    target_binary_sensors: dict[str, list[str]],
+    trigger_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    trigger: str,
+    trigger_options: dict[str, Any],
+    states: list[TriggerStateDescription],
+) -> None:
+    """Test occupancy trigger fires when the last binary_sensor changes state."""
+    other_entity_ids = set(target_binary_sensors["included"]) - {entity_id}
+    excluded_entity_ids = set(target_binary_sensors["excluded"]) - {entity_id}
+
+    for eid in target_binary_sensors["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+    for eid in excluded_entity_ids:
+        set_or_remove_state(hass, eid, states[0]["excluded"])
+        await hass.async_block_till_done()
+
+    await arm_trigger(hass, trigger, {"behavior": "last"}, trigger_target_config)
+
+    for state in states[1:]:
+        excluded_state = state["excluded"]
+        included_state = state["included"]
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, excluded_state)
+            await hass.async_block_till_done()
+        assert len(service_calls) == 0
+
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert len(service_calls) == state["count"]
+        for service_call in service_calls:
+            assert service_call.data[CONF_ENTITY_ID] == entity_id
+        service_calls.clear()
+
+        for excluded_entity_id in excluded_entity_ids:
+            set_or_remove_state(hass, excluded_entity_id, excluded_state)
+            await hass.async_block_till_done()
+        assert len(service_calls) == 0
+
+
+# --- Device class exclusion tests ---
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    (
+        "trigger_key",
+        "trigger_options",
+        "initial_state",
+        "target_state",
+    ),
+    [
+        (
+            "occupancy.detected",
+            {},
+            STATE_OFF,
+            STATE_ON,
+        ),
+        (
+            "occupancy.cleared",
+            {},
+            STATE_ON,
+            STATE_OFF,
+        ),
+    ],
+)
+async def test_occupancy_trigger_excludes_non_occupancy_binary_sensor(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    trigger_key: str,
+    trigger_options: dict[str, Any],
+    initial_state: str,
+    target_state: str,
+) -> None:
+    """Test occupancy trigger does not fire for entities without device_class occupancy."""
+    entity_id_occupancy = "binary_sensor.test_occupancy"
+    entity_id_motion = "binary_sensor.test_motion"
+
+    # Set initial states
+    hass.states.async_set(
+        entity_id_occupancy, initial_state, {ATTR_DEVICE_CLASS: "occupancy"}
+    )
+    hass.states.async_set(
+        entity_id_motion, initial_state, {ATTR_DEVICE_CLASS: "motion"}
+    )
+    await hass.async_block_till_done()
+
+    await arm_trigger(
+        hass,
+        trigger_key,
+        trigger_options,
+        {
+            CONF_ENTITY_ID: [
+                entity_id_occupancy,
+                entity_id_motion,
+            ]
+        },
+    )
+
+    # Occupancy binary_sensor changes - should trigger
+    hass.states.async_set(
+        entity_id_occupancy, target_state, {ATTR_DEVICE_CLASS: "occupancy"}
+    )
+    await hass.async_block_till_done()
+    assert len(service_calls) == 1
+    assert service_calls[0].data[CONF_ENTITY_ID] == entity_id_occupancy
+    service_calls.clear()
+
+    # Motion binary_sensor changes - should NOT trigger (wrong device class)
+    hass.states.async_set(entity_id_motion, target_state, {ATTR_DEVICE_CLASS: "motion"})
+    await hass.async_block_till_done()
+    assert len(service_calls) == 0

tests/components/window/__init__.py

@@ -0,0 +1 @@
+"""Tests for the window integration."""

tests/components/window/test_trigger.py

@@ -0,0 +1,646 @@
+"""Test window trigger."""
+
+from typing import Any
+
+import pytest
+
+from homeassistant.components.cover import ATTR_IS_CLOSED, CoverState
+from homeassistant.const import (
+    ATTR_DEVICE_CLASS,
+    ATTR_LABEL_ID,
+    CONF_ENTITY_ID,
+    STATE_OFF,
+    STATE_ON,
+)
+from homeassistant.core import HomeAssistant, ServiceCall
+
+from tests.components import (
+    TriggerStateDescription,
+    arm_trigger,
+    parametrize_target_entities,
+    parametrize_trigger_states,
+    set_or_remove_state,
+    target_entities,
+)
+
+
+@pytest.fixture
+async def target_binary_sensors(hass: HomeAssistant) -> dict[str, list[str]]:
+    """Create multiple binary sensor entities associated with different targets."""
+    return await target_entities(hass, "binary_sensor")
+
+
+@pytest.fixture
+async def target_covers(hass: HomeAssistant) -> dict[str, list[str]]:
+    """Create multiple cover entities associated with different targets."""
+    return await target_entities(hass, "cover")
+
+
+@pytest.mark.parametrize(
+    "trigger_key",
+    [
+        "window.opened",
+        "window.closed",
+    ],
+)
+async def test_window_triggers_gated_by_labs_flag(
+    hass: HomeAssistant, caplog: pytest.LogCaptureFixture, trigger_key: str
+) -> None:
+    """Test the window triggers are gated by the labs flag."""
+    await arm_trigger(hass, trigger_key, None, {ATTR_LABEL_ID: "test_label"})
+    assert (
+        "Unnamed automation failed to setup triggers and has been disabled: Trigger "
+        f"'{trigger_key}' requires the experimental 'New triggers and conditions' "
+        "feature to be enabled in Home Assistant Labs settings (feature flag: "
+        "'new_triggers_conditions')"
+    ) in caplog.text
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("trigger_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("binary_sensor"),
+)
+@pytest.mark.parametrize(
+    ("trigger", "trigger_options", "states"),
+    [
+        *parametrize_trigger_states(
+            trigger="window.opened",
+            target_states=[STATE_ON],
+            other_states=[STATE_OFF],
+            additional_attributes={ATTR_DEVICE_CLASS: "window"},
+            trigger_from_none=False,
+        ),
+        *parametrize_trigger_states(
+            trigger="window.closed",
+            target_states=[STATE_OFF],
+            other_states=[STATE_ON],
+            additional_attributes={ATTR_DEVICE_CLASS: "window"},
+            trigger_from_none=False,
+        ),
+    ],
+)
+async def test_window_trigger_binary_sensor_behavior_any(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    target_binary_sensors: dict[str, list[str]],
+    trigger_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    trigger: str,
+    trigger_options: dict[str, Any],
+    states: list[TriggerStateDescription],
+) -> None:
+    """Test window trigger fires for binary_sensor entities with device_class window."""
+    other_entity_ids = set(target_binary_sensors["included"]) - {entity_id}
+    excluded_entity_ids = set(target_binary_sensors["excluded"]) - {entity_id}
+
+    for eid in target_binary_sensors["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+    for eid in excluded_entity_ids:
+        set_or_remove_state(hass, eid, states[0]["excluded"])
+        await hass.async_block_till_done()
+
+    await arm_trigger(hass, trigger, {}, trigger_target_config)
+
+    for state in states[1:]:
+        excluded_state = state["excluded"]
+        included_state = state["included"]
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert len(service_calls) == state["count"]
+        for service_call in service_calls:
+            assert service_call.data[CONF_ENTITY_ID] == entity_id
+        service_calls.clear()
+
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+        for excluded_entity_id in excluded_entity_ids:
+            set_or_remove_state(hass, excluded_entity_id, excluded_state)
+            await hass.async_block_till_done()
+        assert len(service_calls) == (entities_in_target - 1) * state["count"]
+        service_calls.clear()
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("trigger_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("cover"),
+)
+@pytest.mark.parametrize(
+    ("trigger", "trigger_options", "states"),
+    [
+        *parametrize_trigger_states(
+            trigger="window.opened",
+            target_states=[
+                (CoverState.OPEN, {ATTR_IS_CLOSED: False}),
+                (CoverState.OPENING, {ATTR_IS_CLOSED: False}),
+            ],
+            other_states=[
+                (CoverState.CLOSED, {ATTR_IS_CLOSED: True}),
+                (CoverState.CLOSING, {ATTR_IS_CLOSED: True}),
+            ],
+            extra_invalid_states=[
+                (CoverState.OPEN, {ATTR_IS_CLOSED: None}),
+                (CoverState.OPEN, {}),
+            ],
+            additional_attributes={ATTR_DEVICE_CLASS: "window"},
+            trigger_from_none=False,
+        ),
+        *parametrize_trigger_states(
+            trigger="window.closed",
+            target_states=[
+                (CoverState.CLOSED, {ATTR_IS_CLOSED: True}),
+                (CoverState.CLOSING, {ATTR_IS_CLOSED: True}),
+            ],
+            other_states=[
+                (CoverState.OPEN, {ATTR_IS_CLOSED: False}),
+                (CoverState.OPENING, {ATTR_IS_CLOSED: False}),
+                (CoverState.CLOSING, {ATTR_IS_CLOSED: False}),
+            ],
+            extra_invalid_states=[
+                (CoverState.OPEN, {ATTR_IS_CLOSED: None}),
+                (CoverState.OPEN, {}),
+            ],
+            additional_attributes={ATTR_DEVICE_CLASS: "window"},
+            trigger_from_none=False,
+        ),
+    ],
+)
+async def test_window_trigger_cover_behavior_any(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    target_covers: dict[str, list[str]],
+    trigger_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    trigger: str,
+    trigger_options: dict[str, Any],
+    states: list[TriggerStateDescription],
+) -> None:
+    """Test window trigger fires for cover entities with device_class window."""
+    other_entity_ids = set(target_covers["included"]) - {entity_id}
+    excluded_entity_ids = set(target_covers["excluded"]) - {entity_id}
+
+    for eid in target_covers["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+    for eid in excluded_entity_ids:
+        set_or_remove_state(hass, eid, states[0]["excluded"])
+        await hass.async_block_till_done()
+
+    await arm_trigger(hass, trigger, {}, trigger_target_config)
+
+    for state in states[1:]:
+        excluded_state = state["excluded"]
+        included_state = state["included"]
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert len(service_calls) == state["count"]
+        for service_call in service_calls:
+            assert service_call.data[CONF_ENTITY_ID] == entity_id
+        service_calls.clear()
+
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, included_state)
+            await hass.async_block_till_done()
+        for excluded_entity_id in excluded_entity_ids:
+            set_or_remove_state(hass, excluded_entity_id, excluded_state)
+            await hass.async_block_till_done()
+        assert len(service_calls) == (entities_in_target - 1) * state["count"]
+        service_calls.clear()
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("trigger_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("binary_sensor"),
+)
+@pytest.mark.parametrize(
+    ("trigger", "trigger_options", "states"),
+    [
+        *parametrize_trigger_states(
+            trigger="window.opened",
+            target_states=[STATE_ON],
+            other_states=[STATE_OFF],
+            additional_attributes={ATTR_DEVICE_CLASS: "window"},
+            trigger_from_none=False,
+        ),
+        *parametrize_trigger_states(
+            trigger="window.closed",
+            target_states=[STATE_OFF],
+            other_states=[STATE_ON],
+            additional_attributes={ATTR_DEVICE_CLASS: "window"},
+            trigger_from_none=False,
+        ),
+    ],
+)
+async def test_window_trigger_binary_sensor_behavior_first(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    target_binary_sensors: dict[str, list[str]],
+    trigger_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    trigger: str,
+    trigger_options: dict[str, Any],
+    states: list[TriggerStateDescription],
+) -> None:
+    """Test window trigger fires on the first binary_sensor state change."""
+    other_entity_ids = set(target_binary_sensors["included"]) - {entity_id}
+    excluded_entity_ids = set(target_binary_sensors["excluded"]) - {entity_id}
+
+    for eid in target_binary_sensors["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+    for eid in excluded_entity_ids:
+        set_or_remove_state(hass, eid, states[0]["excluded"])
+        await hass.async_block_till_done()
+
+    await arm_trigger(hass, trigger, {"behavior": "first"}, trigger_target_config)
+
+    for state in states[1:]:
+        excluded_state = state["excluded"]
+        included_state = state["included"]
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert len(service_calls) == state["count"]
+        for service_call in service_calls:
+            assert service_call.data[CONF_ENTITY_ID] == entity_id
+        service_calls.clear()
+
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, excluded_state)
+            await hass.async_block_till_done()
+        for excluded_entity_id in excluded_entity_ids:
+            set_or_remove_state(hass, excluded_entity_id, excluded_state)
+            await hass.async_block_till_done()
+        assert len(service_calls) == 0
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("trigger_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("binary_sensor"),
+)
+@pytest.mark.parametrize(
+    ("trigger", "trigger_options", "states"),
+    [
+        *parametrize_trigger_states(
+            trigger="window.opened",
+            target_states=[STATE_ON],
+            other_states=[STATE_OFF],
+            additional_attributes={ATTR_DEVICE_CLASS: "window"},
+            trigger_from_none=False,
+        ),
+        *parametrize_trigger_states(
+            trigger="window.closed",
+            target_states=[STATE_OFF],
+            other_states=[STATE_ON],
+            additional_attributes={ATTR_DEVICE_CLASS: "window"},
+            trigger_from_none=False,
+        ),
+    ],
+)
+async def test_window_trigger_binary_sensor_behavior_last(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    target_binary_sensors: dict[str, list[str]],
+    trigger_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    trigger: str,
+    trigger_options: dict[str, Any],
+    states: list[TriggerStateDescription],
+) -> None:
+    """Test window trigger fires when the last binary_sensor changes state."""
+    other_entity_ids = set(target_binary_sensors["included"]) - {entity_id}
+    excluded_entity_ids = set(target_binary_sensors["excluded"]) - {entity_id}
+
+    for eid in target_binary_sensors["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+    for eid in excluded_entity_ids:
+        set_or_remove_state(hass, eid, states[0]["excluded"])
+        await hass.async_block_till_done()
+
+    await arm_trigger(hass, trigger, {"behavior": "last"}, trigger_target_config)
+
+    for state in states[1:]:
+        excluded_state = state["excluded"]
+        included_state = state["included"]
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, excluded_state)
+            await hass.async_block_till_done()
+        assert len(service_calls) == 0
+
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert len(service_calls) == state["count"]
+        for service_call in service_calls:
+            assert service_call.data[CONF_ENTITY_ID] == entity_id
+        service_calls.clear()
+
+        for excluded_entity_id in excluded_entity_ids:
+            set_or_remove_state(hass, excluded_entity_id, excluded_state)
+            await hass.async_block_till_done()
+        assert len(service_calls) == 0
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("trigger_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("cover"),
+)
+@pytest.mark.parametrize(
+    ("trigger", "trigger_options", "states"),
+    [
+        *parametrize_trigger_states(
+            trigger="window.opened",
+            target_states=[
+                (CoverState.OPEN, {ATTR_IS_CLOSED: False}),
+                (CoverState.OPENING, {ATTR_IS_CLOSED: False}),
+            ],
+            other_states=[
+                (CoverState.CLOSED, {ATTR_IS_CLOSED: True}),
+                (CoverState.CLOSING, {ATTR_IS_CLOSED: True}),
+            ],
+            extra_invalid_states=[
+                (CoverState.OPEN, {ATTR_IS_CLOSED: None}),
+                (CoverState.OPEN, {}),
+            ],
+            additional_attributes={ATTR_DEVICE_CLASS: "window"},
+            trigger_from_none=False,
+        ),
+        *parametrize_trigger_states(
+            trigger="window.closed",
+            target_states=[
+                (CoverState.CLOSED, {ATTR_IS_CLOSED: True}),
+                (CoverState.CLOSING, {ATTR_IS_CLOSED: True}),
+            ],
+            other_states=[
+                (CoverState.OPEN, {ATTR_IS_CLOSED: False}),
+                (CoverState.OPENING, {ATTR_IS_CLOSED: False}),
+                (CoverState.CLOSING, {ATTR_IS_CLOSED: False}),
+            ],
+            extra_invalid_states=[
+                (CoverState.OPEN, {ATTR_IS_CLOSED: None}),
+                (CoverState.OPEN, {}),
+            ],
+            additional_attributes={ATTR_DEVICE_CLASS: "window"},
+            trigger_from_none=False,
+        ),
+    ],
+)
+async def test_window_trigger_cover_behavior_first(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    target_covers: dict[str, list[str]],
+    trigger_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    trigger: str,
+    trigger_options: dict[str, Any],
+    states: list[TriggerStateDescription],
+) -> None:
+    """Test window trigger fires on the first cover state change."""
+    other_entity_ids = set(target_covers["included"]) - {entity_id}
+    excluded_entity_ids = set(target_covers["excluded"]) - {entity_id}
+
+    for eid in target_covers["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+    for eid in excluded_entity_ids:
+        set_or_remove_state(hass, eid, states[0]["excluded"])
+        await hass.async_block_till_done()
+
+    await arm_trigger(hass, trigger, {"behavior": "first"}, trigger_target_config)
+
+    for state in states[1:]:
+        excluded_state = state["excluded"]
+        included_state = state["included"]
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert len(service_calls) == state["count"]
+        for service_call in service_calls:
+            assert service_call.data[CONF_ENTITY_ID] == entity_id
+        service_calls.clear()
+
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, excluded_state)
+            await hass.async_block_till_done()
+        for excluded_entity_id in excluded_entity_ids:
+            set_or_remove_state(hass, excluded_entity_id, excluded_state)
+            await hass.async_block_till_done()
+        assert len(service_calls) == 0
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    ("trigger_target_config", "entity_id", "entities_in_target"),
+    parametrize_target_entities("cover"),
+)
+@pytest.mark.parametrize(
+    ("trigger", "trigger_options", "states"),
+    [
+        *parametrize_trigger_states(
+            trigger="window.opened",
+            target_states=[
+                (CoverState.OPEN, {ATTR_IS_CLOSED: False}),
+                (CoverState.OPENING, {ATTR_IS_CLOSED: False}),
+            ],
+            other_states=[
+                (CoverState.CLOSED, {ATTR_IS_CLOSED: True}),
+                (CoverState.CLOSING, {ATTR_IS_CLOSED: True}),
+            ],
+            extra_invalid_states=[
+                (CoverState.OPEN, {ATTR_IS_CLOSED: None}),
+                (CoverState.OPEN, {}),
+            ],
+            additional_attributes={ATTR_DEVICE_CLASS: "window"},
+            trigger_from_none=False,
+        ),
+        *parametrize_trigger_states(
+            trigger="window.closed",
+            target_states=[
+                (CoverState.CLOSED, {ATTR_IS_CLOSED: True}),
+                (CoverState.CLOSING, {ATTR_IS_CLOSED: True}),
+            ],
+            other_states=[
+                (CoverState.OPEN, {ATTR_IS_CLOSED: False}),
+                (CoverState.OPENING, {ATTR_IS_CLOSED: False}),
+                (CoverState.CLOSING, {ATTR_IS_CLOSED: False}),
+            ],
+            extra_invalid_states=[
+                (CoverState.OPEN, {ATTR_IS_CLOSED: None}),
+                (CoverState.OPEN, {}),
+            ],
+            additional_attributes={ATTR_DEVICE_CLASS: "window"},
+            trigger_from_none=False,
+        ),
+    ],
+)
+async def test_window_trigger_cover_behavior_last(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    target_covers: dict[str, list[str]],
+    trigger_target_config: dict,
+    entity_id: str,
+    entities_in_target: int,
+    trigger: str,
+    trigger_options: dict[str, Any],
+    states: list[TriggerStateDescription],
+) -> None:
+    """Test window trigger fires when the last cover changes state."""
+    other_entity_ids = set(target_covers["included"]) - {entity_id}
+    excluded_entity_ids = set(target_covers["excluded"]) - {entity_id}
+
+    for eid in target_covers["included"]:
+        set_or_remove_state(hass, eid, states[0]["included"])
+        await hass.async_block_till_done()
+    for eid in excluded_entity_ids:
+        set_or_remove_state(hass, eid, states[0]["excluded"])
+        await hass.async_block_till_done()
+
+    await arm_trigger(hass, trigger, {"behavior": "last"}, trigger_target_config)
+
+    for state in states[1:]:
+        excluded_state = state["excluded"]
+        included_state = state["included"]
+        for other_entity_id in other_entity_ids:
+            set_or_remove_state(hass, other_entity_id, excluded_state)
+            await hass.async_block_till_done()
+        assert len(service_calls) == 0
+
+        set_or_remove_state(hass, entity_id, included_state)
+        await hass.async_block_till_done()
+        assert len(service_calls) == state["count"]
+        for service_call in service_calls:
+            assert service_call.data[CONF_ENTITY_ID] == entity_id
+        service_calls.clear()
+
+        for excluded_entity_id in excluded_entity_ids:
+            set_or_remove_state(hass, excluded_entity_id, excluded_state)
+            await hass.async_block_till_done()
+        assert len(service_calls) == 0
+
+
+@pytest.mark.usefixtures("enable_labs_preview_features")
+@pytest.mark.parametrize(
+    (
+        "trigger_key",
+        "binary_sensor_initial",
+        "binary_sensor_target",
+        "cover_initial",
+        "cover_initial_is_closed",
+        "cover_target",
+        "cover_target_is_closed",
+    ),
+    [
+        (
+            "window.opened",
+            STATE_OFF,
+            STATE_ON,
+            CoverState.CLOSED,
+            True,
+            CoverState.OPEN,
+            False,
+        ),
+        (
+            "window.closed",
+            STATE_ON,
+            STATE_OFF,
+            CoverState.OPEN,
+            False,
+            CoverState.CLOSED,
+            True,
+        ),
+    ],
+)
+async def test_window_trigger_excludes_non_window_device_class(
+    hass: HomeAssistant,
+    service_calls: list[ServiceCall],
+    trigger_key: str,
+    binary_sensor_initial: str,
+    binary_sensor_target: str,
+    cover_initial: str,
+    cover_initial_is_closed: bool,
+    cover_target: str,
+    cover_target_is_closed: bool,
+) -> None:
+    """Test window trigger does not fire for entities without device_class window."""
+    entity_id_window = "binary_sensor.test_window"
+    entity_id_door = "binary_sensor.test_door"
+    entity_id_cover_window = "cover.test_window"
+    entity_id_cover_door = "cover.test_door"
+
+    # Set initial states
+    hass.states.async_set(
+        entity_id_window, binary_sensor_initial, {ATTR_DEVICE_CLASS: "window"}
+    )
+    hass.states.async_set(
+        entity_id_door, binary_sensor_initial, {ATTR_DEVICE_CLASS: "door"}
+    )
+    hass.states.async_set(
+        entity_id_cover_window,
+        cover_initial,
+        {ATTR_DEVICE_CLASS: "window", ATTR_IS_CLOSED: cover_initial_is_closed},
+    )
+    hass.states.async_set(
+        entity_id_cover_door,
+        cover_initial,
+        {ATTR_DEVICE_CLASS: "door", ATTR_IS_CLOSED: cover_initial_is_closed},
+    )
+    await hass.async_block_till_done()
+
+    await arm_trigger(
+        hass,
+        trigger_key,
+        {},
+        {
+            CONF_ENTITY_ID: [
+                entity_id_window,
+                entity_id_door,
+                entity_id_cover_window,
+                entity_id_cover_door,
+            ]
+        },
+    )
+
+    # Window binary_sensor changes - should trigger
+    hass.states.async_set(
+        entity_id_window, binary_sensor_target, {ATTR_DEVICE_CLASS: "window"}
+    )
+    await hass.async_block_till_done()
+    assert len(service_calls) == 1
+    assert service_calls[0].data[CONF_ENTITY_ID] == entity_id_window
+    service_calls.clear()
+
+    # Door binary_sensor changes - should NOT trigger (wrong device class)
+    hass.states.async_set(
+        entity_id_door, binary_sensor_target, {ATTR_DEVICE_CLASS: "door"}
+    )
+    await hass.async_block_till_done()
+    assert len(service_calls) == 0
+
+    # Cover window changes - should trigger
+    hass.states.async_set(
+        entity_id_cover_window,
+        cover_target,
+        {ATTR_DEVICE_CLASS: "window", ATTR_IS_CLOSED: cover_target_is_closed},
+    )
+    await hass.async_block_till_done()
+    assert len(service_calls) == 1
+    assert service_calls[0].data[CONF_ENTITY_ID] == entity_id_cover_window
+    service_calls.clear()
+
+    # Door cover changes - should NOT trigger (wrong device class)
+    hass.states.async_set(
+        entity_id_cover_door,
+        cover_target,
+        {ATTR_DEVICE_CLASS: "door", ATTR_IS_CLOSED: cover_target_is_closed},
+    )
+    await hass.async_block_till_done()
+    assert len(service_calls) == 0

tests/helpers/test_service.py

@@ -2411,6 +2411,28 @@ async def test_entity_service_call_warn_referenced(
     ) in caplog.text
 
 
+async def test_entity_service_call_warn_unavailable(
+    hass: HomeAssistant,
+    mock_entities: dict[str, MockEntity],
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test that explicitly referenced unavailable entities are logged."""
+    mock_entities["light.kitchen"] = MockEntity(
+        entity_id="light.kitchen", available=False
+    )
+
+    call = ServiceCall(
+        hass,
+        "test_domain",
+        "test_service",
+        {"entity_id": ["light.kitchen"]},
+    )
+    await service.entity_service_call(hass, mock_entities, "", call)
+    assert (
+        "Referenced entities light.kitchen are missing or not currently available"
+    ) in caplog.text
+
+
 async def test_async_extract_entities_warn_referenced(
     hass: HomeAssistant, caplog: pytest.LogCaptureFixture
 ) -> None:

tests/snapshots/test_bootstrap.ambr

@@ -98,6 +98,7 @@
     'weather',
     'web_rtc',
     'websocket_api',
+    'window',
     'zone',
   })
 # ---
@@ -199,6 +200,7 @@
     'weather',
     'web_rtc',
     'websocket_api',
+    'window',
     'zone',
   })
 # ---