Initial commit: Main Gate Controller HACS integration

tests/test_button.py

@@ -0,0 +1,169 @@
+"""Tests for the open/countdown/close sequence driven by the button."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from homeassistant.const import SERVICE_TURN_OFF, SERVICE_TURN_ON
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import entity_registry as er
+from pytest_homeassistant_custom_component.common import MockConfigEntry
+
+from custom_components.main_gate_controller.const import (
+    DOMAIN,
+    GATE_STATE_CLOSED,
+    GATE_STATE_CLOSING,
+    GATE_STATE_OPEN,
+    GATE_STATE_OPENING,
+    NOTIFY_DOMAIN,
+    SERVICE_SEND_MESSAGE,
+    SWITCH_DOMAIN,
+)
+from tests.conftest import ServiceCalls, make_entry_data
+
+
+async def _press_button(hass: HomeAssistant, entry) -> None:
+    registry = er.async_get(hass)
+    entity_id = registry.async_get_entity_id(
+        "button", DOMAIN, f"{entry.entry_id}_open"
+    )
+    assert entity_id is not None
+    await hass.services.async_call(
+        "button", "press", {"entity_id": entity_id}, blocking=True
+    )
+
+
+async def test_full_open_close_sequence_with_notifications(
+    service_calls: ServiceCalls, loaded_entry
+):
+    """Notifications-enabled entry runs the canonical sequence.
+
+    The spec dictates: ``Closing`` notification fires **before** the closing
+    switch pulses (state-machine transition closing -> closed is logged from
+    the coordinator inside the switch sequence).
+    """
+    controller = loaded_entry.runtime_data
+    assert controller.async_trigger() is True
+    await controller.async_wait_until_idle()
+
+    expected = [
+        (NOTIFY_DOMAIN, SERVICE_SEND_MESSAGE),  # Opening notification
+        (SWITCH_DOMAIN, SERVICE_TURN_OFF),       # OPEN: OFF
+        (SWITCH_DOMAIN, SERVICE_TURN_ON),        # OPEN: ON
+        (SWITCH_DOMAIN, SERVICE_TURN_OFF),       # OPEN: OFF
+        (NOTIFY_DOMAIN, SERVICE_SEND_MESSAGE),   # Closing notification (before close pulse)
+        (SWITCH_DOMAIN, SERVICE_TURN_ON),        # CLOSE: ON
+        (SWITCH_DOMAIN, SERVICE_TURN_OFF),       # CLOSE: OFF
+    ]
+    assert service_calls.order() == expected
+
+    notifies = service_calls.service(NOTIFY_DOMAIN, SERVICE_SEND_MESSAGE)
+    assert notifies[0]["message"].startswith("Opening Main Gate")
+    assert notifies[1]["message"] == "Closing Main Gate"
+
+    targets = notifies[0]["target"]
+    if isinstance(targets, str):
+        targets = [targets]
+    assert targets == ["notify.mobile_app_phone"]
+
+    assert controller.status == GATE_STATE_CLOSED
+    assert controller.is_running is False
+
+
+async def test_sequence_without_notifications(
+    service_calls: ServiceCalls, hass: HomeAssistant, gate_switch: str
+):
+    """Notifications disabled → only switch calls happen."""
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="Main Gate",
+        data=make_entry_data(
+            switch_entity_id=gate_switch, name="Main Gate", notify_enabled=False
+        ),
+        unique_id=gate_switch,
+    )
+    entry.add_to_hass(hass)
+    assert await hass.config_entries.async_setup(entry.entry_id)
+    await hass.async_block_till_done()
+
+    controller = entry.runtime_data
+    assert controller.async_trigger() is True
+    await controller.async_wait_until_idle()
+
+    expected = [
+        (SWITCH_DOMAIN, SERVICE_TURN_OFF),
+        (SWITCH_DOMAIN, SERVICE_TURN_ON),
+        (SWITCH_DOMAIN, SERVICE_TURN_OFF),
+        (SWITCH_DOMAIN, SERVICE_TURN_ON),
+        (SWITCH_DOMAIN, SERVICE_TURN_OFF),
+    ]
+    assert service_calls.order() == expected
+    assert controller.status == GATE_STATE_CLOSED
+
+
+async def test_mode_single_ignores_second_trigger(
+    service_calls: ServiceCalls, loaded_entry
+):
+    """A second trigger during a running cycle does nothing (mode: single)."""
+    controller = loaded_entry.runtime_data
+    first = controller.async_trigger()
+    second = controller.async_trigger()
+    assert first is True
+    assert second is False
+
+    await controller.async_wait_until_idle()
+
+    switch_calls = sum(
+        1 for d, s, _ in service_calls.records if d == SWITCH_DOMAIN
+    )
+    assert switch_calls == 5
+
+
+async def test_button_press_starts_cycle(
+    service_calls: ServiceCalls, hass: HomeAssistant, loaded_entry
+):
+    """Pressing the button entity starts the cycle via the service call."""
+    controller = loaded_entry.runtime_data
+    await _press_button(hass, loaded_entry)
+    await controller.async_wait_until_idle()
+
+    switch_calls = sum(
+        1 for d, s, _ in service_calls.records if d == SWITCH_DOMAIN
+    )
+    # 5 switch calls (no notify because loaded_entry is without notify targets).
+    assert switch_calls == 5
+
+
+async def test_state_transitions_during_cycle(
+    hass: HomeAssistant, service_calls: ServiceCalls, loaded_entry
+):
+    """The status sensor goes opening → open → closing → closed."""
+    # Subscribe to state changes of the status sensor.
+    observed: list[str] = []
+
+    def _capture(event):
+        if event.data.get("entity_id", "").endswith("_status"):
+            new_state: dict[str, Any] = event.data.get("new_state")
+            if new_state is not None and new_state.state in {
+                GATE_STATE_CLOSED,
+                GATE_STATE_OPENING,
+                GATE_STATE_OPEN,
+                GATE_STATE_CLOSING,
+            }:
+                if not observed or observed[-1] != new_state.state:
+                    observed.append(new_state.state)
+
+    hass.bus.async_listen("state_changed", _capture)
+
+    controller = loaded_entry.runtime_data
+    assert controller.async_trigger() is True
+    await controller.async_wait_until_idle()
+    # Let pending state_changed events propagate through the bus.
+    await hass.async_block_till_done()
+
+    # Opening and closing are short with pulse=1s; ``open`` is the dominant state.
+    seen = set(observed)
+    assert GATE_STATE_OPENING in seen
+    assert GATE_STATE_OPEN in seen
+    assert GATE_STATE_CLOSING in seen
+    assert GATE_STATE_CLOSED in seen