room_cal_ha/tests/test_coordinator.py

from datetime import date, time
from unittest.mock import AsyncMock, patch

import pytest
from homeassistant.core import HomeAssistant
from pytest_homeassistant_custom_component.common import MockConfigEntry

from custom_components.room_cal_ha.backends import BackendAuthError, BackendConnectError
from custom_components.room_cal_ha.const import (
  CONF_API_BASE_URL,
  CONF_API_TOKEN,
  CONF_CALDAV_URL,
  CONF_CALENDAR_NAME,
  CONF_SYNC_MODE,
  DOMAIN,
  STORE_CURRENT,
  STORE_NEXT,
  SYNC_MODE_API,
  SYNC_MODE_CALDAV,
  SYNC_MODE_MANUAL,
)
from custom_components.room_cal_ha.coordinator import RoomCalCoordinator
from custom_components.room_cal_ha.models import ApiStatusData, ReservationData


SAMPLE = ReservationData(
  guest_name="Alice",
  check_in_date=date(2026, 7, 1),
  check_in_time=time(14, 0),
  check_out_date=date(2026, 7, 5),
  check_out_time=time(12, 0),
  wifi_key="stone-angel-market",
  door_code="0472",
)

_BASE_DATA = {
  "room_state_name": "Room State",
  "current_name": "Current",
  "next_name": "Next",
}


def _make_entry(hass, options: dict) -> MockConfigEntry:
  entry = MockConfigEntry(domain=DOMAIN, data=_BASE_DATA, options=options)
  entry.add_to_hass(hass)
  return entry


@pytest.fixture
async def coordinator(hass: HomeAssistant, mock_entry):
  mock_entry.add_to_hass(hass)
  coord = RoomCalCoordinator(hass, mock_entry)
  await coord.async_setup()
  return coord


# ---------------------------------------------------------------------------
# Manual mode
# ---------------------------------------------------------------------------

async def test_manual_mode_serves_empty(coordinator: RoomCalCoordinator):
  await coordinator.async_refresh()
  assert coordinator.data.current == ReservationData()
  assert coordinator.data.next == ReservationData()
  assert coordinator.data.current_last_refresh is None
  assert coordinator.data.next_last_refresh is None
  assert coordinator.data.api_status is None


# ---------------------------------------------------------------------------
# CalDAV mode
# ---------------------------------------------------------------------------

async def test_caldav_fetch_writes_store_and_timestamps(hass: HomeAssistant):
  entry = _make_entry(hass, {CONF_SYNC_MODE: SYNC_MODE_CALDAV, CONF_CALDAV_URL: "https://cal.example.com", CONF_CALENDAR_NAME: "Room"})
  coord = RoomCalCoordinator(hass, entry)
  await coord.async_setup()

  with patch("custom_components.room_cal_ha.coordinator.CalDavBackend") as MockBackend:
    MockBackend.return_value.async_fetch = AsyncMock(return_value=(SAMPLE, None))
    await coord.async_refresh()

  assert coord.data.current.guest_name == "Alice"
  assert coord.data.current.door_code == "0472"
  assert coord.data.next == ReservationData()
  assert coord.data.current_last_refresh is not None
  assert coord.data.next_last_refresh is not None


async def test_caldav_empty_result_clears_store(hass: HomeAssistant):
  entry = _make_entry(hass, {CONF_SYNC_MODE: SYNC_MODE_CALDAV, CONF_CALDAV_URL: "https://cal.example.com", CONF_CALENDAR_NAME: "Room"})
  coord = RoomCalCoordinator(hass, entry)
  await coord.async_setup()
  await coord.store.async_set(STORE_CURRENT, SAMPLE)

  with patch("custom_components.room_cal_ha.coordinator.CalDavBackend") as MockBackend:
    MockBackend.return_value.async_fetch = AsyncMock(return_value=(None, None))
    await coord.async_refresh()

  assert coord.data.current == ReservationData()
  assert coord.store.get(STORE_CURRENT) is None


async def test_caldav_connect_error_preserves_store(hass: HomeAssistant):
  entry = _make_entry(hass, {CONF_SYNC_MODE: SYNC_MODE_CALDAV, CONF_CALDAV_URL: "https://cal.example.com", CONF_CALENDAR_NAME: "Room"})
  coord = RoomCalCoordinator(hass, entry)
  await coord.async_setup()
  await coord.store.async_set(STORE_CURRENT, SAMPLE)

  with patch("custom_components.room_cal_ha.coordinator.CalDavBackend") as MockBackend:
    MockBackend.return_value.async_fetch = AsyncMock(side_effect=BackendConnectError("timeout"))
    await coord.async_refresh()

  assert coord.data.current.guest_name == "Alice"
  assert coord.data.current_last_refresh is None


async def test_caldav_auth_error_triggers_reauth(hass: HomeAssistant):
  entry = _make_entry(hass, {CONF_SYNC_MODE: SYNC_MODE_CALDAV, CONF_CALDAV_URL: "https://cal.example.com", CONF_CALENDAR_NAME: "Room"})
  coord = RoomCalCoordinator(hass, entry)
  await coord.async_setup()

  with (
    patch("custom_components.room_cal_ha.coordinator.CalDavBackend") as MockBackend,
    patch.object(entry, "async_start_reauth") as mock_reauth,
  ):
    MockBackend.return_value.async_fetch = AsyncMock(side_effect=BackendAuthError)
    await coord.async_refresh()

  mock_reauth.assert_called_once_with(hass)


# ---------------------------------------------------------------------------
# API mode
# ---------------------------------------------------------------------------

SAMPLE_STATUS = ApiStatusData(
  status="ok",
  checks={"caldav_connection": {"ok": True}, "calendar": {"ok": True}},
)


async def test_api_fetch_writes_store_and_status(hass: HomeAssistant):
  entry = _make_entry(hass, {CONF_SYNC_MODE: SYNC_MODE_API, CONF_API_BASE_URL: "https://api.example.com"})
  coord = RoomCalCoordinator(hass, entry)
  await coord.async_setup()

  with patch("custom_components.room_cal_ha.coordinator.RoomCalApiBackend") as MockBackend:
    instance = MockBackend.return_value
    instance.async_fetch = AsyncMock(return_value=(SAMPLE, None))
    instance.async_fetch_status = AsyncMock(return_value=SAMPLE_STATUS)
    instance.async_fetch_services = AsyncMock(return_value={})
    await coord.async_refresh()

  assert coord.data.current.guest_name == "Alice"
  assert coord.data.api_status.status == "ok"
  assert coord.data.current_last_refresh is not None


async def test_api_connect_error_preserves_store_and_still_fetches_status(hass: HomeAssistant):
  entry = _make_entry(hass, {CONF_SYNC_MODE: SYNC_MODE_API, CONF_API_BASE_URL: "https://api.example.com"})
  coord = RoomCalCoordinator(hass, entry)
  await coord.async_setup()
  await coord.store.async_set(STORE_CURRENT, SAMPLE)

  degraded = ApiStatusData(status="error")
  with patch("custom_components.room_cal_ha.coordinator.RoomCalApiBackend") as MockBackend:
    instance = MockBackend.return_value
    instance.async_fetch = AsyncMock(side_effect=BackendConnectError("timeout"))
    instance.async_fetch_status = AsyncMock(return_value=degraded)
    instance.async_fetch_services = AsyncMock(return_value={})
    await coord.async_refresh()

  assert coord.data.current.guest_name == "Alice"
  assert coord.data.current_last_refresh is None
  assert coord.data.api_status.status == "error"


async def test_api_auth_error_triggers_reauth(hass: HomeAssistant):
  entry = _make_entry(hass, {CONF_SYNC_MODE: SYNC_MODE_API, CONF_API_BASE_URL: "https://api.example.com"})
  coord = RoomCalCoordinator(hass, entry)
  await coord.async_setup()

  with (
    patch("custom_components.room_cal_ha.coordinator.RoomCalApiBackend") as MockBackend,
    patch.object(entry, "async_start_reauth") as mock_reauth,
  ):
    instance = MockBackend.return_value
    instance.async_fetch = AsyncMock(side_effect=BackendAuthError)
    instance.async_fetch_status = AsyncMock(return_value=ApiStatusData(status="auth_error"))
    instance.async_fetch_services = AsyncMock(return_value={})
    await coord.async_refresh()

  mock_reauth.assert_called_once_with(hass)


# ---------------------------------------------------------------------------
# Thin updates
# ---------------------------------------------------------------------------

async def test_thin_update_overlays_fields(coordinator: RoomCalCoordinator):
  await coordinator.store.async_set(STORE_CURRENT, SAMPLE)
  await coordinator.async_refresh()

  await coordinator.async_apply_update(STORE_CURRENT, {"wifi_ssid": "GuestNet", "door_code": "9999"})

  assert coordinator.data.current.wifi_ssid == "GuestNet"
  assert coordinator.data.current.door_code == "9999"
  assert coordinator.data.current.guest_name == "Alice"
  assert coordinator.data.current.wifi_key == "stone-angel-market"


async def test_thin_update_updates_last_refresh(coordinator: RoomCalCoordinator):
  await coordinator.store.async_set(STORE_CURRENT, SAMPLE)
  await coordinator.async_refresh()
  assert coordinator.data.current_last_refresh is None

  await coordinator.async_apply_update(STORE_CURRENT, {"door_code": "1234"})
  assert coordinator.data.current_last_refresh is not None


# ---------------------------------------------------------------------------
# Store persistence
# ---------------------------------------------------------------------------

async def test_store_persists_across_reload(hass: HomeAssistant, mock_entry):
  mock_entry.add_to_hass(hass)
  coord = RoomCalCoordinator(hass, mock_entry)
  await coord.async_setup()
  await coord.store.async_set(STORE_CURRENT, SAMPLE)

  coord2 = RoomCalCoordinator(hass, mock_entry)
  await coord2.async_setup()

  loaded = coord2.store.get(STORE_CURRENT)
  assert loaded is not None
  assert loaded.guest_name == "Alice"
  assert loaded.door_code == "0472"