Implement new state property for alarm_control_panel which is using an enum (#126283)

* Alarm state from enum * Fixes * Set final * Fix rebase * Test const * Fix breaking version * Fix other for alarm_control_panel * Fix integrations * More * More * More * More * Fix zha * Replace _attr_state * Fix alarm_control_panel * Fix tests * Fixes * Mods * Change some * More * More * More * Tests * Last tests * Return enum * Fix zha * Remove not needed check * Fix wording * Fix homekit * Mod prometheus * Fix mypy * Fix homekit * Fix ifttt
2025-10-28 04:59:31 +00:00 · 2024-10-21 22:54:27 +02:00
parent 59ad69b637
commit cdfec7ebb4
90 changed files with 2010 additions and 1810 deletions
--- a/tests/components/alarm_control_panel/common.py
+++ b/tests/components/alarm_control_panel/common.py
@@ -8,6 +8,7 @@ from homeassistant.components.alarm_control_panel import (
    DOMAIN,
    AlarmControlPanelEntity,
    AlarmControlPanelEntityFeature,
+    AlarmControlPanelState,
 )
 from homeassistant.const import (
    ATTR_CODE,
@@ -20,12 +21,6 @@ from homeassistant.const import (
    SERVICE_ALARM_ARM_VACATION,
    SERVICE_ALARM_DISARM,
    SERVICE_ALARM_TRIGGER,
-    STATE_ALARM_ARMED_AWAY,
-    STATE_ALARM_ARMED_HOME,
-    STATE_ALARM_ARMED_NIGHT,
-    STATE_ALARM_ARMED_VACATION,
-    STATE_ALARM_DISARMED,
-    STATE_ALARM_TRIGGERED,
 )
 from homeassistant.core import HomeAssistant

@@ -145,31 +140,31 @@ class MockAlarm(MockEntity, AlarmControlPanelEntity):

    def alarm_arm_away(self, code=None):
        """Send arm away command."""
-        self._attr_state = STATE_ALARM_ARMED_AWAY
+        self._attr_alarm_state = AlarmControlPanelState.ARMED_AWAY
        self.schedule_update_ha_state()

    def alarm_arm_home(self, code=None):
        """Send arm home command."""
-        self._attr_state = STATE_ALARM_ARMED_HOME
+        self._attr_alarm_state = AlarmControlPanelState.ARMED_HOME
        self.schedule_update_ha_state()

    def alarm_arm_night(self, code=None):
        """Send arm night command."""
-        self._attr_state = STATE_ALARM_ARMED_NIGHT
+        self._attr_alarm_state = AlarmControlPanelState.ARMED_NIGHT
        self.schedule_update_ha_state()

    def alarm_arm_vacation(self, code=None):
        """Send arm night command."""
-        self._attr_state = STATE_ALARM_ARMED_VACATION
+        self._attr_alarm_state = AlarmControlPanelState.ARMED_VACATION
        self.schedule_update_ha_state()

    def alarm_disarm(self, code=None):
        """Send disarm command."""
        if code == "1234":
-            self._attr_state = STATE_ALARM_DISARMED
+            self._attr_alarm_state = AlarmControlPanelState.DISARMED
            self.schedule_update_ha_state()

    def alarm_trigger(self, code=None):
        """Send alarm trigger command."""
-        self._attr_state = STATE_ALARM_TRIGGERED
+        self._attr_alarm_state = AlarmControlPanelState.TRIGGERED
        self.schedule_update_ha_state()
--- a/tests/components/alarm_control_panel/test_device_action.py
+++ b/tests/components/alarm_control_panel/test_device_action.py
@@ -7,19 +7,10 @@ from homeassistant.components import automation
 from homeassistant.components.alarm_control_panel import (
    DOMAIN,
    AlarmControlPanelEntityFeature,
+    AlarmControlPanelState,
 )
 from homeassistant.components.device_automation import DeviceAutomationType
-from homeassistant.const import (
-    CONF_PLATFORM,
-    STATE_ALARM_ARMED_AWAY,
-    STATE_ALARM_ARMED_HOME,
-    STATE_ALARM_ARMED_NIGHT,
-    STATE_ALARM_ARMED_VACATION,
-    STATE_ALARM_DISARMED,
-    STATE_ALARM_TRIGGERED,
-    STATE_UNKNOWN,
-    EntityCategory,
-)
+from homeassistant.const import CONF_PLATFORM, STATE_UNKNOWN, EntityCategory
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.setup import async_setup_component
@@ -541,27 +532,44 @@ async def test_action(

    hass.bus.async_fire("test_event_arm_away")
    await hass.async_block_till_done()
-    assert hass.states.get(entity_entry.entity_id).state == STATE_ALARM_ARMED_AWAY
+    assert (
+        hass.states.get(entity_entry.entity_id).state
+        == AlarmControlPanelState.ARMED_AWAY
+    )

    hass.bus.async_fire("test_event_arm_home")
    await hass.async_block_till_done()
-    assert hass.states.get(entity_entry.entity_id).state == STATE_ALARM_ARMED_HOME
+    assert (
+        hass.states.get(entity_entry.entity_id).state
+        == AlarmControlPanelState.ARMED_HOME
+    )

    hass.bus.async_fire("test_event_arm_vacation")
    await hass.async_block_till_done()
-    assert hass.states.get(entity_entry.entity_id).state == STATE_ALARM_ARMED_VACATION
+    assert (
+        hass.states.get(entity_entry.entity_id).state
+        == AlarmControlPanelState.ARMED_VACATION
+    )

    hass.bus.async_fire("test_event_arm_night")
    await hass.async_block_till_done()
-    assert hass.states.get(entity_entry.entity_id).state == STATE_ALARM_ARMED_NIGHT
+    assert (
+        hass.states.get(entity_entry.entity_id).state
+        == AlarmControlPanelState.ARMED_NIGHT
+    )

    hass.bus.async_fire("test_event_disarm")
    await hass.async_block_till_done()
-    assert hass.states.get(entity_entry.entity_id).state == STATE_ALARM_DISARMED
+    assert (
+        hass.states.get(entity_entry.entity_id).state == AlarmControlPanelState.DISARMED
+    )

    hass.bus.async_fire("test_event_trigger")
    await hass.async_block_till_done()
-    assert hass.states.get(entity_entry.entity_id).state == STATE_ALARM_TRIGGERED
+    assert (
+        hass.states.get(entity_entry.entity_id).state
+        == AlarmControlPanelState.TRIGGERED
+    )


 async def test_action_legacy(
@@ -615,4 +623,7 @@ async def test_action_legacy(

    hass.bus.async_fire("test_event_arm_away")
    await hass.async_block_till_done()
-    assert hass.states.get(entity_entry.entity_id).state == STATE_ALARM_ARMED_AWAY
+    assert (
+        hass.states.get(entity_entry.entity_id).state
+        == AlarmControlPanelState.ARMED_AWAY
+    )
--- a/tests/components/alarm_control_panel/test_device_condition.py
+++ b/tests/components/alarm_control_panel/test_device_condition.py
@@ -7,18 +7,10 @@ from homeassistant.components import automation
 from homeassistant.components.alarm_control_panel import (
    DOMAIN,
    AlarmControlPanelEntityFeature,
+    AlarmControlPanelState,
 )
 from homeassistant.components.device_automation import DeviceAutomationType
-from homeassistant.const import (
-    STATE_ALARM_ARMED_AWAY,
-    STATE_ALARM_ARMED_CUSTOM_BYPASS,
-    STATE_ALARM_ARMED_HOME,
-    STATE_ALARM_ARMED_NIGHT,
-    STATE_ALARM_ARMED_VACATION,
-    STATE_ALARM_DISARMED,
-    STATE_ALARM_TRIGGERED,
-    EntityCategory,
-)
+from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.setup import async_setup_component
@@ -354,7 +346,7 @@ async def test_if_state(
            ]
        },
    )
-    hass.states.async_set(entry.entity_id, STATE_ALARM_TRIGGERED)
+    hass.states.async_set(entry.entity_id, AlarmControlPanelState.TRIGGERED)
    hass.bus.async_fire("test_event1")
    hass.bus.async_fire("test_event2")
    hass.bus.async_fire("test_event3")
@@ -366,7 +358,7 @@ async def test_if_state(
    assert len(service_calls) == 1
    assert service_calls[0].data["some"] == "is_triggered - event - test_event1"

-    hass.states.async_set(entry.entity_id, STATE_ALARM_DISARMED)
+    hass.states.async_set(entry.entity_id, AlarmControlPanelState.DISARMED)
    hass.bus.async_fire("test_event1")
    hass.bus.async_fire("test_event2")
    hass.bus.async_fire("test_event3")
@@ -378,7 +370,7 @@ async def test_if_state(
    assert len(service_calls) == 2
    assert service_calls[1].data["some"] == "is_disarmed - event - test_event2"

-    hass.states.async_set(entry.entity_id, STATE_ALARM_ARMED_HOME)
+    hass.states.async_set(entry.entity_id, AlarmControlPanelState.ARMED_HOME)
    hass.bus.async_fire("test_event1")
    hass.bus.async_fire("test_event2")
    hass.bus.async_fire("test_event3")
@@ -390,7 +382,7 @@ async def test_if_state(
    assert len(service_calls) == 3
    assert service_calls[2].data["some"] == "is_armed_home - event - test_event3"

-    hass.states.async_set(entry.entity_id, STATE_ALARM_ARMED_AWAY)
+    hass.states.async_set(entry.entity_id, AlarmControlPanelState.ARMED_AWAY)
    hass.bus.async_fire("test_event1")
    hass.bus.async_fire("test_event2")
    hass.bus.async_fire("test_event3")
@@ -402,7 +394,7 @@ async def test_if_state(
    assert len(service_calls) == 4
    assert service_calls[3].data["some"] == "is_armed_away - event - test_event4"

-    hass.states.async_set(entry.entity_id, STATE_ALARM_ARMED_NIGHT)
+    hass.states.async_set(entry.entity_id, AlarmControlPanelState.ARMED_NIGHT)
    hass.bus.async_fire("test_event1")
    hass.bus.async_fire("test_event2")
    hass.bus.async_fire("test_event3")
@@ -414,7 +406,7 @@ async def test_if_state(
    assert len(service_calls) == 5
    assert service_calls[4].data["some"] == "is_armed_night - event - test_event5"

-    hass.states.async_set(entry.entity_id, STATE_ALARM_ARMED_VACATION)
+    hass.states.async_set(entry.entity_id, AlarmControlPanelState.ARMED_VACATION)
    hass.bus.async_fire("test_event1")
    hass.bus.async_fire("test_event2")
    hass.bus.async_fire("test_event3")
@@ -426,7 +418,7 @@ async def test_if_state(
    assert len(service_calls) == 6
    assert service_calls[5].data["some"] == "is_armed_vacation - event - test_event6"

-    hass.states.async_set(entry.entity_id, STATE_ALARM_ARMED_CUSTOM_BYPASS)
+    hass.states.async_set(entry.entity_id, AlarmControlPanelState.ARMED_CUSTOM_BYPASS)
    hass.bus.async_fire("test_event1")
    hass.bus.async_fire("test_event2")
    hass.bus.async_fire("test_event3")
@@ -488,7 +480,7 @@ async def test_if_state_legacy(
            ]
        },
    )
-    hass.states.async_set(entry.entity_id, STATE_ALARM_TRIGGERED)
+    hass.states.async_set(entry.entity_id, AlarmControlPanelState.TRIGGERED)
    hass.bus.async_fire("test_event1")
    await hass.async_block_till_done()
    assert len(service_calls) == 1
--- a/tests/components/alarm_control_panel/test_device_trigger.py
+++ b/tests/components/alarm_control_panel/test_device_trigger.py
@@ -9,18 +9,10 @@ from homeassistant.components import automation
 from homeassistant.components.alarm_control_panel import (
    DOMAIN,
    AlarmControlPanelEntityFeature,
+    AlarmControlPanelState,
 )
 from homeassistant.components.device_automation import DeviceAutomationType
-from homeassistant.const import (
-    STATE_ALARM_ARMED_AWAY,
-    STATE_ALARM_ARMED_HOME,
-    STATE_ALARM_ARMED_NIGHT,
-    STATE_ALARM_ARMED_VACATION,
-    STATE_ALARM_DISARMED,
-    STATE_ALARM_PENDING,
-    STATE_ALARM_TRIGGERED,
-    EntityCategory,
-)
+from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.setup import async_setup_component
@@ -256,7 +248,7 @@ async def test_if_fires_on_state_change(
        DOMAIN, "test", "5678", device_id=device_entry.id
    )

-    hass.states.async_set(entry.entity_id, STATE_ALARM_PENDING)
+    hass.states.async_set(entry.entity_id, AlarmControlPanelState.PENDING)

    assert await async_setup_component(
        hass,
@@ -400,7 +392,7 @@ async def test_if_fires_on_state_change(
    )

    # Fake that the entity is triggered.
-    hass.states.async_set(entry.entity_id, STATE_ALARM_TRIGGERED)
+    hass.states.async_set(entry.entity_id, AlarmControlPanelState.TRIGGERED)
    await hass.async_block_till_done()
    assert len(service_calls) == 1
    assert (
@@ -409,7 +401,7 @@ async def test_if_fires_on_state_change(
    )

    # Fake that the entity is disarmed.
-    hass.states.async_set(entry.entity_id, STATE_ALARM_DISARMED)
+    hass.states.async_set(entry.entity_id, AlarmControlPanelState.DISARMED)
    await hass.async_block_till_done()
    assert len(service_calls) == 2
    assert (
@@ -418,7 +410,7 @@ async def test_if_fires_on_state_change(
    )

    # Fake that the entity is armed home.
-    hass.states.async_set(entry.entity_id, STATE_ALARM_ARMED_HOME)
+    hass.states.async_set(entry.entity_id, AlarmControlPanelState.ARMED_HOME)
    await hass.async_block_till_done()
    assert len(service_calls) == 3
    assert (
@@ -427,7 +419,7 @@ async def test_if_fires_on_state_change(
    )

    # Fake that the entity is armed away.
-    hass.states.async_set(entry.entity_id, STATE_ALARM_ARMED_AWAY)
+    hass.states.async_set(entry.entity_id, AlarmControlPanelState.ARMED_AWAY)
    await hass.async_block_till_done()
    assert len(service_calls) == 4
    assert (
@@ -436,7 +428,7 @@ async def test_if_fires_on_state_change(
    )

    # Fake that the entity is armed night.
-    hass.states.async_set(entry.entity_id, STATE_ALARM_ARMED_NIGHT)
+    hass.states.async_set(entry.entity_id, AlarmControlPanelState.ARMED_NIGHT)
    await hass.async_block_till_done()
    assert len(service_calls) == 5
    assert (
@@ -445,7 +437,7 @@ async def test_if_fires_on_state_change(
    )

    # Fake that the entity is armed vacation.
-    hass.states.async_set(entry.entity_id, STATE_ALARM_ARMED_VACATION)
+    hass.states.async_set(entry.entity_id, AlarmControlPanelState.ARMED_VACATION)
    await hass.async_block_till_done()
    assert len(service_calls) == 6
    assert (
@@ -471,7 +463,7 @@ async def test_if_fires_on_state_change_with_for(
        DOMAIN, "test", "5678", device_id=device_entry.id
    )

-    hass.states.async_set(entry.entity_id, STATE_ALARM_DISARMED)
+    hass.states.async_set(entry.entity_id, AlarmControlPanelState.DISARMED)

    assert await async_setup_component(
        hass,
@@ -506,7 +498,7 @@ async def test_if_fires_on_state_change_with_for(
    await hass.async_block_till_done()
    assert len(service_calls) == 0

-    hass.states.async_set(entry.entity_id, STATE_ALARM_TRIGGERED)
+    hass.states.async_set(entry.entity_id, AlarmControlPanelState.TRIGGERED)
    await hass.async_block_till_done()
    assert len(service_calls) == 0
    async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=10))
@@ -536,7 +528,7 @@ async def test_if_fires_on_state_change_legacy(
        DOMAIN, "test", "5678", device_id=device_entry.id
    )

-    hass.states.async_set(entry.entity_id, STATE_ALARM_DISARMED)
+    hass.states.async_set(entry.entity_id, AlarmControlPanelState.DISARMED)

    assert await async_setup_component(
        hass,
@@ -570,7 +562,7 @@ async def test_if_fires_on_state_change_legacy(
    await hass.async_block_till_done()
    assert len(service_calls) == 0

-    hass.states.async_set(entry.entity_id, STATE_ALARM_TRIGGERED)
+    hass.states.async_set(entry.entity_id, AlarmControlPanelState.TRIGGERED)
    await hass.async_block_till_done()
    assert len(service_calls) == 1
    assert (
--- a/tests/components/alarm_control_panel/test_init.py
+++ b/tests/components/alarm_control_panel/test_init.py
@@ -2,14 +2,17 @@

 from types import ModuleType
 from typing import Any
+from unittest.mock import patch

 import pytest

 from homeassistant.components import alarm_control_panel
-from homeassistant.components.alarm_control_panel.const import (
+from homeassistant.components.alarm_control_panel import (
+    DOMAIN as ALARM_CONTROL_PANEL_DOMAIN,
    AlarmControlPanelEntityFeature,
    CodeFormat,
 )
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
    ATTR_CODE,
    SERVICE_ALARM_ARM_AWAY,
@@ -23,11 +26,20 @@ from homeassistant.const import (
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers import entity_registry as er
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import UNDEFINED, UndefinedType

-from .conftest import MockAlarmControlPanel
+from .conftest import TEST_DOMAIN, MockAlarmControlPanel

-from tests.common import help_test_all, import_and_test_deprecated_constant_enum
+from tests.common import (
+    MockConfigEntry,
+    MockModule,
+    MockPlatform,
+    help_test_all,
+    import_and_test_deprecated_constant_enum,
+    mock_integration,
+    mock_platform,
+)


 async def help_test_async_alarm_control_panel_service(
@@ -283,3 +295,197 @@ async def test_alarm_control_panel_with_default_code(
        hass, mock_alarm_control_panel_entity.entity_id, SERVICE_ALARM_DISARM
    )
    mock_alarm_control_panel_entity.calls_disarm.assert_called_with("1234")
+
+
+async def test_alarm_control_panel_not_log_deprecated_state_warning(
+    hass: HomeAssistant,
+    mock_alarm_control_panel_entity: MockAlarmControlPanel,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test correctly using alarm_state doesn't log issue or raise repair."""
+    state = hass.states.get(mock_alarm_control_panel_entity.entity_id)
+    assert state is not None
+    assert "Entities should implement the 'alarm_state' property and" not in caplog.text
+
+
+async def test_alarm_control_panel_log_deprecated_state_warning_using_state_prop(
+    hass: HomeAssistant,
+    code_format: CodeFormat | None,
+    supported_features: AlarmControlPanelEntityFeature,
+    code_arm_required: bool,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test incorrectly using state property does log issue and raise repair."""
+
+    async def async_setup_entry_init(
+        hass: HomeAssistant, config_entry: ConfigEntry
+    ) -> bool:
+        """Set up test config entry."""
+        await hass.config_entries.async_forward_entry_setups(
+            config_entry, [ALARM_CONTROL_PANEL_DOMAIN]
+        )
+        return True
+
+    mock_integration(
+        hass,
+        MockModule(
+            TEST_DOMAIN,
+            async_setup_entry=async_setup_entry_init,
+        ),
+    )
+
+    class MockLegacyAlarmControlPanel(MockAlarmControlPanel):
+        """Mocked alarm control entity."""
+
+        def __init__(
+            self,
+            supported_features: AlarmControlPanelEntityFeature = AlarmControlPanelEntityFeature(
+                0
+            ),
+            code_format: CodeFormat | None = None,
+            code_arm_required: bool = True,
+        ) -> None:
+            """Initialize the alarm control."""
+            super().__init__(supported_features, code_format, code_arm_required)
+
+        @property
+        def state(self) -> str:
+            """Return the state of the entity."""
+            return "disarmed"
+
+    entity = MockLegacyAlarmControlPanel(
+        supported_features=supported_features,
+        code_format=code_format,
+        code_arm_required=code_arm_required,
+    )
+
+    async def async_setup_entry_platform(
+        hass: HomeAssistant,
+        config_entry: ConfigEntry,
+        async_add_entities: AddEntitiesCallback,
+    ) -> None:
+        """Set up test alarm control panel platform via config entry."""
+        async_add_entities([entity])
+
+    mock_platform(
+        hass,
+        f"{TEST_DOMAIN}.{ALARM_CONTROL_PANEL_DOMAIN}",
+        MockPlatform(async_setup_entry=async_setup_entry_platform),
+    )
+
+    with patch.object(
+        MockLegacyAlarmControlPanel,
+        "__module__",
+        "tests.custom_components.test.alarm_control_panel",
+    ):
+        config_entry = MockConfigEntry(domain=TEST_DOMAIN)
+        config_entry.add_to_hass(hass)
+        assert await hass.config_entries.async_setup(config_entry.entry_id)
+        await hass.async_block_till_done()
+
+    state = hass.states.get(entity.entity_id)
+    assert state is not None
+
+    assert "Entities should implement the 'alarm_state' property and" in caplog.text
+
+
+async def test_alarm_control_panel_log_deprecated_state_warning_using_attr_state_attr(
+    hass: HomeAssistant,
+    code_format: CodeFormat | None,
+    supported_features: AlarmControlPanelEntityFeature,
+    code_arm_required: bool,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test incorrectly using _attr_state attribute does log issue and raise repair."""
+
+    async def async_setup_entry_init(
+        hass: HomeAssistant, config_entry: ConfigEntry
+    ) -> bool:
+        """Set up test config entry."""
+        await hass.config_entries.async_forward_entry_setups(
+            config_entry, [ALARM_CONTROL_PANEL_DOMAIN]
+        )
+        return True
+
+    mock_integration(
+        hass,
+        MockModule(
+            TEST_DOMAIN,
+            async_setup_entry=async_setup_entry_init,
+        ),
+    )
+
+    class MockLegacyAlarmControlPanel(MockAlarmControlPanel):
+        """Mocked alarm control entity."""
+
+        def __init__(
+            self,
+            supported_features: AlarmControlPanelEntityFeature = AlarmControlPanelEntityFeature(
+                0
+            ),
+            code_format: CodeFormat | None = None,
+            code_arm_required: bool = True,
+        ) -> None:
+            """Initialize the alarm control."""
+            super().__init__(supported_features, code_format, code_arm_required)
+
+        def alarm_disarm(self, code: str | None = None) -> None:
+            """Mock alarm disarm calls."""
+            self._attr_state = "disarmed"
+
+    entity = MockLegacyAlarmControlPanel(
+        supported_features=supported_features,
+        code_format=code_format,
+        code_arm_required=code_arm_required,
+    )
+
+    async def async_setup_entry_platform(
+        hass: HomeAssistant,
+        config_entry: ConfigEntry,
+        async_add_entities: AddEntitiesCallback,
+    ) -> None:
+        """Set up test alarm control panel platform via config entry."""
+        async_add_entities([entity])
+
+    mock_platform(
+        hass,
+        f"{TEST_DOMAIN}.{ALARM_CONTROL_PANEL_DOMAIN}",
+        MockPlatform(async_setup_entry=async_setup_entry_platform),
+    )
+
+    with patch.object(
+        MockLegacyAlarmControlPanel,
+        "__module__",
+        "tests.custom_components.test.alarm_control_panel",
+    ):
+        config_entry = MockConfigEntry(domain=TEST_DOMAIN)
+        config_entry.add_to_hass(hass)
+        assert await hass.config_entries.async_setup(config_entry.entry_id)
+        await hass.async_block_till_done()
+
+    state = hass.states.get(entity.entity_id)
+    assert state is not None
+
+    assert "Entities should implement the 'alarm_state' property and" not in caplog.text
+
+    with patch.object(
+        MockLegacyAlarmControlPanel,
+        "__module__",
+        "tests.custom_components.test.alarm_control_panel",
+    ):
+        await help_test_async_alarm_control_panel_service(
+            hass, entity.entity_id, SERVICE_ALARM_DISARM
+        )
+
+    assert "Entities should implement the 'alarm_state' property and" in caplog.text
+    caplog.clear()
+    with patch.object(
+        MockLegacyAlarmControlPanel,
+        "__module__",
+        "tests.custom_components.test.alarm_control_panel",
+    ):
+        await help_test_async_alarm_control_panel_service(
+            hass, entity.entity_id, SERVICE_ALARM_DISARM
+        )
+    # Test we only log once
+    assert "Entities should implement the 'alarm_state' property and" not in caplog.text
--- a/tests/components/alarm_control_panel/test_reproduce_state.py
+++ b/tests/components/alarm_control_panel/test_reproduce_state.py
@@ -2,6 +2,7 @@

 import pytest

+from homeassistant.components.alarm_control_panel import AlarmControlPanelState
 from homeassistant.const import (
    SERVICE_ALARM_ARM_AWAY,
    SERVICE_ALARM_ARM_CUSTOM_BYPASS,
@@ -10,13 +11,6 @@ from homeassistant.const import (
    SERVICE_ALARM_ARM_VACATION,
    SERVICE_ALARM_DISARM,
    SERVICE_ALARM_TRIGGER,
-    STATE_ALARM_ARMED_AWAY,
-    STATE_ALARM_ARMED_CUSTOM_BYPASS,
-    STATE_ALARM_ARMED_HOME,
-    STATE_ALARM_ARMED_NIGHT,
-    STATE_ALARM_ARMED_VACATION,
-    STATE_ALARM_DISARMED,
-    STATE_ALARM_TRIGGERED,
 )
 from homeassistant.core import HomeAssistant, State
 from homeassistant.helpers.state import async_reproduce_state
@@ -29,27 +23,37 @@ async def test_reproducing_states(
 ) -> None:
    """Test reproducing Alarm control panel states."""
    hass.states.async_set(
-        "alarm_control_panel.entity_armed_away", STATE_ALARM_ARMED_AWAY, {}
-    )
-    hass.states.async_set(
-        "alarm_control_panel.entity_armed_custom_bypass",
-        STATE_ALARM_ARMED_CUSTOM_BYPASS,
+        "alarm_control_panel.entity_armed_away",
+        AlarmControlPanelState.ARMED_AWAY,
        {},
    )
    hass.states.async_set(
-        "alarm_control_panel.entity_armed_home", STATE_ALARM_ARMED_HOME, {}
+        "alarm_control_panel.entity_armed_custom_bypass",
+        AlarmControlPanelState.ARMED_CUSTOM_BYPASS,
+        {},
    )
    hass.states.async_set(
-        "alarm_control_panel.entity_armed_night", STATE_ALARM_ARMED_NIGHT, {}
+        "alarm_control_panel.entity_armed_home",
+        AlarmControlPanelState.ARMED_HOME,
+        {},
    )
    hass.states.async_set(
-        "alarm_control_panel.entity_armed_vacation", STATE_ALARM_ARMED_VACATION, {}
+        "alarm_control_panel.entity_armed_night",
+        AlarmControlPanelState.ARMED_NIGHT,
+        {},
    )
    hass.states.async_set(
-        "alarm_control_panel.entity_disarmed", STATE_ALARM_DISARMED, {}
+        "alarm_control_panel.entity_armed_vacation",
+        AlarmControlPanelState.ARMED_VACATION,
+        {},
    )
    hass.states.async_set(
-        "alarm_control_panel.entity_triggered", STATE_ALARM_TRIGGERED, {}
+        "alarm_control_panel.entity_disarmed", AlarmControlPanelState.DISARMED, {}
+    )
+    hass.states.async_set(
+        "alarm_control_panel.entity_triggered",
+        AlarmControlPanelState.TRIGGERED,
+        {},
    )

    arm_away_calls = async_mock_service(
@@ -76,18 +80,34 @@ async def test_reproducing_states(
    await async_reproduce_state(
        hass,
        [
-            State("alarm_control_panel.entity_armed_away", STATE_ALARM_ARMED_AWAY),
+            State(
+                "alarm_control_panel.entity_armed_away",
+                AlarmControlPanelState.ARMED_AWAY,
+            ),
            State(
                "alarm_control_panel.entity_armed_custom_bypass",
-                STATE_ALARM_ARMED_CUSTOM_BYPASS,
+                AlarmControlPanelState.ARMED_CUSTOM_BYPASS,
            ),
-            State("alarm_control_panel.entity_armed_home", STATE_ALARM_ARMED_HOME),
-            State("alarm_control_panel.entity_armed_night", STATE_ALARM_ARMED_NIGHT),
            State(
-                "alarm_control_panel.entity_armed_vacation", STATE_ALARM_ARMED_VACATION
+                "alarm_control_panel.entity_armed_home",
+                AlarmControlPanelState.ARMED_HOME,
+            ),
+            State(
+                "alarm_control_panel.entity_armed_night",
+                AlarmControlPanelState.ARMED_NIGHT,
+            ),
+            State(
+                "alarm_control_panel.entity_armed_vacation",
+                AlarmControlPanelState.ARMED_VACATION,
+            ),
+            State(
+                "alarm_control_panel.entity_disarmed",
+                AlarmControlPanelState.DISARMED,
+            ),
+            State(
+                "alarm_control_panel.entity_triggered",
+                AlarmControlPanelState.TRIGGERED,
            ),
-            State("alarm_control_panel.entity_disarmed", STATE_ALARM_DISARMED),
-            State("alarm_control_panel.entity_triggered", STATE_ALARM_TRIGGERED),
        ],
    )

@@ -117,17 +137,34 @@ async def test_reproducing_states(
    await async_reproduce_state(
        hass,
        [
-            State("alarm_control_panel.entity_armed_away", STATE_ALARM_TRIGGERED),
            State(
-                "alarm_control_panel.entity_armed_custom_bypass", STATE_ALARM_ARMED_AWAY
+                "alarm_control_panel.entity_armed_away",
+                AlarmControlPanelState.TRIGGERED,
            ),
            State(
-                "alarm_control_panel.entity_armed_home", STATE_ALARM_ARMED_CUSTOM_BYPASS
+                "alarm_control_panel.entity_armed_custom_bypass",
+                AlarmControlPanelState.ARMED_AWAY,
+            ),
+            State(
+                "alarm_control_panel.entity_armed_home",
+                AlarmControlPanelState.ARMED_CUSTOM_BYPASS,
+            ),
+            State(
+                "alarm_control_panel.entity_armed_night",
+                AlarmControlPanelState.ARMED_HOME,
+            ),
+            State(
+                "alarm_control_panel.entity_armed_vacation",
+                AlarmControlPanelState.ARMED_NIGHT,
+            ),
+            State(
+                "alarm_control_panel.entity_disarmed",
+                AlarmControlPanelState.ARMED_VACATION,
+            ),
+            State(
+                "alarm_control_panel.entity_triggered",
+                AlarmControlPanelState.DISARMED,
            ),
-            State("alarm_control_panel.entity_armed_night", STATE_ALARM_ARMED_HOME),
-            State("alarm_control_panel.entity_armed_vacation", STATE_ALARM_ARMED_NIGHT),
-            State("alarm_control_panel.entity_disarmed", STATE_ALARM_ARMED_VACATION),
-            State("alarm_control_panel.entity_triggered", STATE_ALARM_DISARMED),
            # Should not raise
            State("alarm_control_panel.non_existing", "on"),
        ],