fix: _is_plain_int on every weekday_set path (from_dict + post-set); shared scan function probes the real guard

- direct list construction validates entries before set() coercion
  (bool collapse and unhashable items both raise RuleValidationError)
- unknown-key error sorts by repr (mixed-type keys never leak TypeError)
- string rule_type accepted ONLY as exact model names: storage aliases
  ('monthly'/'custom'), whitespace padding, and case variants rejected;
  the DAO owns storage-string mapping
- purity guard checks ImportFrom alias names so 'from . import db' is
  caught, not just node.module
- _is_plain_int requires type(value) is int: unhashable int subclasses
  cannot construct

custom_components/nestquest/__init__.py

@@ -10,8 +10,6 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 
 from .const import DOMAIN, LOGGER
-from .db import NestQuestDatabase
-from .store import async_get_db_path
 
 _LOGGER = LOGGER
 
@@ -22,7 +20,6 @@ class NestQuestRuntimeData:
 
     entry_id: str
     options: dict[str, Any]
-    database: NestQuestDatabase
     remove_update_listener: Callable[[], Any]
 
 
@@ -34,14 +31,6 @@ async def async_setup(hass: HomeAssistant, config: dict[str, Any]) -> bool:
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up NestQuest from a config entry."""
     hass.data.setdefault(DOMAIN, {})
-    existing = hass.data[DOMAIN].get(entry.entry_id)
-    if existing is not None:
-        db = getattr(existing, "database", None)
-        if db is None:
-            db = await NestQuestDatabase(hass).open(await async_get_db_path(hass))
-            existing.database = db
-        entry.runtime_data = existing
-        return True
 
     async def _async_update_listener(
         listener_hass: HomeAssistant, listener_entry: ConfigEntry
@@ -49,17 +38,10 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         """Reload the entry when its options change."""
         await listener_hass.config_entries.async_reload(listener_entry.entry_id)
 
-    database = await NestQuestDatabase(hass).open(await async_get_db_path(hass))
-    try:
-        remove_update_listener = entry.add_update_listener(_async_update_listener)
-    except BaseException:
-        await database.close()
-        raise
     runtime_data = NestQuestRuntimeData(
         entry_id=entry.entry_id,
         options=dict(entry.options),
-        database=database,
-        remove_update_listener=remove_update_listener,
+        remove_update_listener=entry.add_update_listener(_async_update_listener),
     )
     entry.runtime_data = runtime_data
     hass.data[DOMAIN][entry.entry_id] = runtime_data
@@ -76,22 +58,10 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         runtime_data = getattr(entry, "runtime_data", None)
     if runtime_data is not None:
         remove_update_listener = getattr(runtime_data, "remove_update_listener", None)
-        unload_error: BaseException | None = None
-        try:
-            if remove_update_listener is not None:
-                result = remove_update_listener()
-                if inspect.isawaitable(result):
-                    await result
-        except BaseException as err:
-            unload_error = err
-        finally:
-            database = getattr(runtime_data, "database", None)
-            if database is not None:
-                await database.close()
-        if unload_error is not None:
-            if getattr(entry, "runtime_data", None) is not None:
-                entry.runtime_data = None
-            raise unload_error
+        if remove_update_listener is not None:
+            result = remove_update_listener()
+            if inspect.isawaitable(result):
+                await result
     if getattr(entry, "runtime_data", None) is not None:
         entry.runtime_data = None
     return True

custom_components/nestquest/db.py

@@ -1,422 +0,0 @@
-"""Async SQLite connection wrapper for the NestQuest integration."""
-from __future__ import annotations
-
-import asyncio
-import sqlite3
-from collections.abc import AsyncIterator, Awaitable, Sequence
-from contextlib import asynccontextmanager
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any
-
-from homeassistant.core import HomeAssistant
-
-
-@dataclass(frozen=True)
-class ExecutionResult:
-    """Plain-data outcome of one statement.
-
-    ``rowcount`` and ``lastrowid`` mirror the corresponding
-    :class:`sqlite3.Cursor` attributes; both are captured on the executor
-    thread so no sqlite3 object ever crosses back to the event loop.
-    """
-
-    rowcount: int
-    lastrowid: int | None
-
-
-class NestQuestDatabase:
-    """Async wrapper around a single SQLite connection.
-
-    Every sqlite3 call is delegated to the Home Assistant executor through
-    ``hass.async_add_executor_job`` so the event loop is never blocked, and
-    only plain Python data (row tuples and :class:`ExecutionResult`) is
-    returned to the event loop.
-
-    Every operation is serialized through one asyncio.Lock per wrapper.  A
-    ``transaction()`` holds that lock for its whole BEGIN..COMMIT span, so
-    interleaved coroutines cannot corrupt the transaction and concurrent
-    BEGINs are impossible; statements issued while a transaction is open
-    queue until it completes.  Concurrent transactions on one wrapper are
-    not supported: a second ``transaction()`` entered while one is active
-    raises :class:`RuntimeError`.  ``close()`` serializes on the same lock
-    and is idempotent.
-
-    Every connection-affecting executor job (connect, pragmas, statements,
-    transaction lifecycle and close) is awaited through the settlement
-    helper :meth:`_await_settled`: if the awaiting task is cancelled while
-    a job is in flight, the job still settles on the worker thread before
-    the cancellation propagates, so the wrapper lock is never released
-    while the executor thread is mid-job.
-    """
-
-    def __init__(self, hass: HomeAssistant) -> None:
-        """Initialize the wrapper around a Home Assistant instance."""
-        self._hass = hass
-        self._conn: sqlite3.Connection | None = None
-        self._rowcount: int = -1
-        self._lastrowid: int | None = None
-        self._lock: asyncio.Lock | None = None
-        self._lock_loop: asyncio.AbstractEventLoop | None = None
-        self._in_transaction = False
-        self._tx_task: asyncio.Task | None = None
-
-    def _get_lock(self) -> asyncio.Lock:
-        """Return the per-wrapper lock, (re)bound to the running loop.
-
-        HA drives every wrapper call from one event loop, so the lock is
-        created once and reused; re-binding only when the running loop
-        differs keeps the wrapper usable from plain synchronous drivers
-        that run each call on a fresh loop.
-        """
-        loop = asyncio.get_running_loop()
-        if self._lock is None or self._lock_loop is not loop:
-            self._lock = asyncio.Lock()
-            self._lock_loop = loop
-        return self._lock
-
-    @property
-    def connected(self) -> bool:
-        """Return True while the underlying connection is open."""
-        return self._conn is not None
-
-    @property
-    def rowcount(self) -> int:
-        """Row count of the most recent statement, or -1 when unset."""
-        return self._rowcount
-
-    @property
-    def lastrowid(self) -> int | None:
-        """Row id of the most recent insert, or None when unset."""
-        return self._lastrowid
-
-    @asynccontextmanager
-    async def _serialized(self) -> AsyncIterator[None]:
-        """Hold the wrapper lock unless the caller owns the active transaction.
-
-        A transaction holds the lock for its whole BEGIN..COMMIT span;
-        statements issued by the transaction's own task are already
-        serialized by it and must not re-acquire the non-reentrant lock.
-        Any other task queues on the lock until the transaction ends.
-        """
-        if (
-            self._in_transaction
-            and self._tx_task is not None
-            and asyncio.current_task() is self._tx_task
-        ):
-            yield
-            return
-        async with self._get_lock():
-            yield
-
-    async def open(self, path: Path | str) -> NestQuestDatabase:
-        """Open the SQLite file with WAL journal mode and foreign keys on.
-
-        Cancellation-safe: if this call is cancelled while the connect job
-        is in flight, the job still settles (see :meth:`_await_settled`).
-        A connection the settled job created is never adopted by the
-        cancelled call; it is closed through a settled executor job instead
-        of being abandoned to garbage collection, and the cancellation
-        propagates afterwards, so a follow-up ``open()`` starts from a
-        clean state.
-        """
-        if self._conn is not None:
-            return self
-        async with self._get_lock():
-            if self._conn is not None:
-                return self
-
-            def _open() -> sqlite3.Connection:
-                conn = sqlite3.connect(
-                    path, check_same_thread=False, isolation_level=None
-                )
-                try:
-                    conn.execute("PRAGMA journal_mode=WAL")
-                    conn.execute("PRAGMA foreign_keys=ON")
-                except BaseException:
-                    conn.close()
-                    raise
-                return conn
-
-            settled, cancelled = await self._await_settled_state(
-                self._hass.async_add_executor_job(_open)
-            )
-            if cancelled:
-                if isinstance(settled, sqlite3.Connection):
-
-                    def _close_abandoned() -> None:
-                        settled.close()
-
-                    await self._await_settled(
-                        self._hass.async_add_executor_job(_close_abandoned)
-                    )
-                raise asyncio.CancelledError()
-            self._conn = settled
-        return self
-
-    async def execute(
-        self, sql: str, parameters: Sequence[Any] = ()
-    ) -> ExecutionResult:
-        """Run one statement in the executor and return its plain result."""
-        async with self._serialized():
-            conn = self._require_conn()
-
-            def _execute() -> ExecutionResult:
-                cursor = conn.execute(sql, parameters)
-                return ExecutionResult(cursor.rowcount, cursor.lastrowid)
-
-            result = await self._await_settled(
-                self._hass.async_add_executor_job(_execute)
-            )
-            self._rowcount = result.rowcount
-            self._lastrowid = result.lastrowid
-            return result
-
-    async def execute_many(
-        self, sql: str, parameters: Sequence[Sequence[Any]]
-    ) -> ExecutionResult:
-        """Run executemany in the executor and return its plain result."""
-        async with self._serialized():
-            conn = self._require_conn()
-
-            def _execute_many() -> ExecutionResult:
-                cursor = conn.executemany(sql, parameters)
-                return ExecutionResult(cursor.rowcount, cursor.lastrowid)
-
-            result = await self._await_settled(
-                self._hass.async_add_executor_job(_execute_many)
-            )
-            self._rowcount = result.rowcount
-            self._lastrowid = result.lastrowid
-            return result
-
-    async def fetch_one(
-        self, sql: str, parameters: Sequence[Any] = ()
-    ) -> tuple | None:
-        """Run a query in the executor and return its first row, or None."""
-        async with self._serialized():
-            conn = self._require_conn()
-
-            def _fetch_one() -> tuple[tuple | None, int, int | None]:
-                cursor = conn.execute(sql, parameters)
-                return cursor.fetchone(), cursor.rowcount, cursor.lastrowid
-
-            row, rowcount, lastrowid = await self._await_settled(
-                self._hass.async_add_executor_job(_fetch_one)
-            )
-            self._rowcount = rowcount
-            self._lastrowid = lastrowid
-            return row
-
-    async def fetch_all(
-        self, sql: str, parameters: Sequence[Any] = ()
-    ) -> list[tuple]:
-        """Run a query in the executor and return all of its rows."""
-        async with self._serialized():
-            conn = self._require_conn()
-
-            def _fetch_all() -> tuple[list[tuple], int, int | None]:
-                cursor = conn.execute(sql, parameters)
-                return cursor.fetchall(), cursor.rowcount, cursor.lastrowid
-
-            rows, rowcount, lastrowid = await self._await_settled(
-                self._hass.async_add_executor_job(_fetch_all)
-            )
-            self._rowcount = rowcount
-            self._lastrowid = lastrowid
-            return rows
-
-    @asynccontextmanager
-    async def transaction(self) -> AsyncIterator[None]:
-        """Run a block inside BEGIN/COMMIT, rolling back on any exception.
-
-        The wrapper lock is held for the entire BEGIN..COMMIT span, so no
-        other statement can interleave inside the transaction.  Entering a
-        second transaction while one is active raises RuntimeError.  A
-        failing COMMIT (e.g. a deferred foreign-key violation) also triggers
-        a ROLLBACK before the commit error propagates, so the real
-        connection is never left inside a stray transaction.
-
-        The lifecycle is cancellation-safe.  Transaction ownership and the
-        wrapper lock are only released after the executor work has fully
-        settled, even when the owning task is cancelled mid-flight: if a
-        cancelled BEGIN or COMMIT still completes on the worker thread,
-        the corresponding ROLLBACK is shielded and awaited before any state
-        is cleared.  A lifecycle statement that fails plus a failing
-        follow-up cleanup surface both errors in an ExceptionGroup.
-        """
-        if self._in_transaction:
-            raise RuntimeError(
-                "A NestQuest transaction is already active on this "
-                "connection; concurrent transactions are not supported"
-            )
-        async with self._get_lock():
-            conn = self._require_conn()
-            self._in_transaction = True
-            self._tx_task = asyncio.current_task()
-            try:
-
-                def _begin() -> None:
-                    conn.execute("BEGIN")
-
-                await self._settle_lifecycle(
-                    conn,
-                    self._hass.async_add_executor_job(_begin),
-                    "BEGIN did not settle cleanly and the follow-up "
-                    "cleanup also raised; the transaction may need manual "
-                    "cleanup",
-                )
-                try:
-                    yield
-                except BaseException:
-
-                    def _rollback() -> None:
-                        conn.execute("ROLLBACK")
-
-                    await self._settle_lifecycle(
-                        conn,
-                        self._hass.async_add_executor_job(_rollback),
-                        "ROLLBACK failed and the follow-up cleanup also "
-                        "raised; the transaction may need manual cleanup",
-                    )
-                    raise
-
-                def _commit() -> None:
-                    conn.execute("COMMIT")
-
-                await self._settle_lifecycle(
-                    conn,
-                    self._hass.async_add_executor_job(_commit),
-                    "COMMIT failed and the follow-up cleanup also raised; "
-                    "the transaction may need manual cleanup",
-                )
-            finally:
-                self._in_transaction = False
-                self._tx_task = None
-
-    async def _settle_lifecycle(
-        self, conn: sqlite3.Connection, job: Awaitable[Any], message: str
-    ) -> None:
-        """Run one BEGIN/ROLLBACK/COMMIT job, then force the connection clean.
-
-        The job always settles first (see :meth:`_await_settled`), so a
-        cancelled statement that the worker thread completed anyway is
-        never abandoned mid-flight.  If the job raised, a follow-up
-        ROLLBACK — itself settled — guarantees the connection ends outside
-        any SQLite transaction before the error propagates.  When both the
-        job and the cleanup raise, both errors are preserved in an
-        ExceptionGroup instead of the original being lost.
-        """
-        try:
-            await self._await_settled(job)
-        except BaseException as settle_error:
-            errors: list[BaseException] = [settle_error]
-            try:
-                await self._ensure_no_stray_transaction(conn)
-            except BaseException as cleanup_error:
-                errors.append(cleanup_error)
-            if len(errors) == 2:
-                raise BaseExceptionGroup(message, errors) from settle_error
-            raise
-
-    async def _ensure_no_stray_transaction(
-        self, conn: sqlite3.Connection
-    ) -> None:
-        """Force the connection out of any transaction via ROLLBACK.
-
-        Runs after a failed or cancelled lifecycle statement.  The worker
-        thread may still be finishing (or may already have completed) the
-        very statement whose await was cancelled, so both the check and
-        the ROLLBACK settle in the executor before the caller releases
-        transaction ownership.
-        """
-
-        def _cleanup() -> bool:
-            if conn.in_transaction:
-                conn.execute("ROLLBACK")
-            return conn.in_transaction
-
-        stray = await self._await_settled(
-            self._hass.async_add_executor_job(_cleanup)
-        )
-        if stray:
-            raise RuntimeError(
-                "The SQLite connection is still inside a transaction after "
-                "cleanup; the transaction may need manual cleanup"
-            )
-
-    async def _await_settled(self, job: Awaitable[Any]) -> Any:
-        """Await ``job``, letting it settle even if this task is cancelled.
-
-        Cancellation is observed, not swallowed: it is re-raised only once
-        the job has fully settled, so the caller can finalize against a
-        known connection state instead of abandoning in-flight work.  The
-        job is wrapped in a task because a bare coroutine dies un-awaited
-        once its await is cancelled.  A second cancellation during
-        settlement is absorbed the same way; if the job itself fails after
-        a cancellation, both errors surface in an ExceptionGroup.
-        """
-        result, cancelled = await self._await_settled_state(job)
-        if cancelled:
-            raise asyncio.CancelledError()
-        return result
-
-    async def _await_settled_state(self, job: Awaitable[Any]) -> tuple[Any, bool]:
-        """Await ``job`` to settlement and report ``(result, cancelled)``.
-
-        Same settlement guarantees as :meth:`_await_settled`, but returns
-        the settled outcome together with whether the awaiting task was
-        cancelled, so callers that must act on a settled result before
-        re-raising cancellation (e.g. closing an abandoned connection)
-        can do so without losing the result.
-        """
-        cancelled = False
-        inner = asyncio.ensure_future(job)
-        while not inner.done():
-            try:
-                await asyncio.shield(inner)
-            except asyncio.CancelledError:
-                cancelled = True
-        try:
-            result = inner.result()
-        except BaseException as job_error:
-            if cancelled:
-                raise BaseExceptionGroup(
-                    "executor job failed while settling after cancellation",
-                    [asyncio.CancelledError(), job_error],
-                ) from job_error
-            raise
-        return result, cancelled
-
-    async def close(self) -> None:
-        """Close the connection in the executor; safe to call repeatedly.
-
-        Serialized on the wrapper lock, so an in-flight operation or open
-        transaction always completes before the connection is closed.
-        """
-        if (
-            self._in_transaction
-            and self._tx_task is not None
-            and asyncio.current_task() is self._tx_task
-        ):
-            raise RuntimeError(
-                "Cannot close the NestQuest database from inside its own "
-                "transaction; exit the transaction first"
-            )
-        async with self._get_lock():
-            conn, self._conn = self._conn, None
-            self._rowcount, self._lastrowid = -1, None
-            if conn is None:
-                return
-
-            def _close() -> None:
-                conn.close()
-
-            await self._await_settled(self._hass.async_add_executor_job(_close))
-
-    def _require_conn(self) -> sqlite3.Connection:
-        if self._conn is None:
-            raise RuntimeError(
-                "The NestQuest database connection is closed; call open() first"
-            )
-        return self._conn

custom_components/nestquest/recurrence.py

@@ -0,0 +1,389 @@
+"""The ScheduleRule model: rule types, validation, and serialization.
+
+A :class:`ScheduleRule` describes WHEN a recurring chore fires — a pure
+frozen dataclass with no Home Assistant and no database imports.  The
+evaluation engine (Feature 04) consumes it; the DAO layer (Feature 02)
+serializes its dict form into the ``schedule_rules`` table.
+
+Type model: one enum member per recurrence shape.  ``MONTHLY_DAY``
+("the 15th of every month") and ``MONTHLY_WEEKDAY`` ("the second
+Tuesday of every month") are distinct types rather than one monthly
+type with optional fields, so validation is total: a rule either
+constructs, or raises :class:`RuleValidationError` naming the offending
+field.  Every type carries ONLY the fields its shape needs; carrying
+any other shape's field is a construction error.
+
+Storage mapping (Feature 02, ``schedule_rules`` table): the enum's
+``storage_value`` maps model types onto the schema's CHECK values —
+MONTHLY_DAY and MONTHLY_WEEKDAY both store as ``'monthly'`` and are
+disambiguated by which fields are populated; CUSTOM_DAYS stores as
+``'custom'``.  ``weekday_set`` round-trips as the sorted CSV list the
+table stores (one element for MONTHLY_WEEKDAY, which names the
+position's weekday); ``nth_weekday_weekday`` is a MODEL-ONLY field
+carried through from_dict/to_dict for losslessness and folded into
+``weekday_set`` by the DAO mapping.  ``to_dict``/``from_dict`` are the
+model-side lossless pair; the DB mapping lives in the DAO layer and is
+exercised there.
+
+Validation policy (fail fast at construction — the schema's CHECK
+constraints are a second line of defense, but invalid rules must never
+reach storage):
+
+- ``interval`` >= 1 for every rule.
+- ``weekday_set`` is required for WEEKLY and CUSTOM_DAYS, forbidden
+  elsewhere; entries are 0 (Monday) .. 6 (Sunday), no booleans.
+- ``day_of_month`` 1..31 is required for MONTHLY_DAY.
+- ``nth_weekday`` 1..5 or -1 (0 is meaningless as a position and is
+  rejected) with a weekday 0..6 for MONTHLY_WEEKDAY.
+- ``month`` 1..12 is required for YEARLY.
+- ``start_date`` is a strict ISO date; ``end_date`` is optional and,
+  when present, on or after ``start_date``.
+
+Month-end policy (documented for Feature 04): a MONTHLY_DAY rule for
+the 31st does NOT fire in a 30-day month, and a YEARLY rule for
+February 29th does NOT fire in a non-leap year — the engine skips
+instead of clamping to month end, because clamping silently moves
+"the 31st" to "the 30th" and double-fires tasks.
+"""
+from __future__ import annotations
+
+import datetime
+import enum
+from dataclasses import dataclass, field
+
+#: Date-shape policy: strict YYYY-MM-DD, matching the DAO layers.
+_DATE_FORMAT = "%Y-%m-%d"
+
+#: Weekday-name policy: 0 = Monday .. 6 = Sunday (ISO order).
+
+
+class RuleType(enum.Enum):
+    """The six recurrence shapes the engine supports.
+
+    ``storage_value`` is the string written to the ``schedule_rules``
+    table's ``rule_type`` column (its CHECK whitelist).  MONTHLY_DAY
+    and MONTHLY_WEEKDAY are distinct shapes sharing one storage value,
+    disambiguated by which fields are populated.
+    """
+
+    DAILY = "daily"
+    WEEKLY = "weekly"
+    MONTHLY_DAY = "monthly_day"
+    MONTHLY_WEEKDAY = "monthly_weekday"
+    YEARLY = "yearly"
+    CUSTOM_DAYS = "custom_days"
+
+    @property
+    def storage_value(self) -> str:
+        """The schema-level rule_type string this model type maps to."""
+        return {
+            RuleType.DAILY: "daily",
+            RuleType.WEEKLY: "weekly",
+            RuleType.MONTHLY_DAY: "monthly",
+            RuleType.MONTHLY_WEEKDAY: "monthly",
+            RuleType.YEARLY: "yearly",
+            RuleType.CUSTOM_DAYS: "custom",
+        }[self]
+
+
+class RuleValidationError(ValueError):
+    """Raised when a ScheduleRule field combination is invalid."""
+
+
+def _validate_date(value: str, field_name: str) -> None:
+    """Raise unless ``value`` is a strict YYYY-MM-DD calendar date."""
+    try:
+        parsed = datetime.datetime.strptime(value, _DATE_FORMAT).date()
+    except (TypeError, ValueError):
+        raise RuleValidationError(
+            f"{field_name} must be an ISO date (YYYY-MM-DD), got {value!r}"
+        ) from None
+    if parsed.isoformat() != value:
+        raise RuleValidationError(
+            f"{field_name} must be a strict YYYY-MM-DD date, got {value!r}"
+        )
+
+
+def _validate_weekday_set(weekday_set) -> frozenset[int]:
+    """Return a normalized frozenset or raise with a clear message.
+
+    Sequence entries are validated BEFORE set() coercion: a list like
+    [0, False] must not collapse the boolean into 0, and unhashable
+    entries must raise RuleValidationError, never a raw TypeError.
+    """
+    if isinstance(weekday_set, (list, tuple)):
+        for entry in weekday_set:
+            # _is_plain_int: bool and int subclasses (potentially
+            # unhashable) are rejected before set() coercion.
+            if not _is_plain_int(entry):
+                raise RuleValidationError(
+                    f"weekday_set entries must be plain integers, got "
+                    f"{entry!r}"
+                )
+        weekday_set = set(weekday_set)
+    if not isinstance(weekday_set, (set, frozenset)):
+        raise RuleValidationError(
+            f"weekday_set must be a set of weekday integers, got "
+            f"{type(weekday_set).__name__}"
+        )
+    if not weekday_set:
+        raise RuleValidationError(
+            "weekday_set must not be empty for weekly/custom rules"
+        )
+    for entry in weekday_set:
+        if not _is_plain_int(entry):
+            raise RuleValidationError(
+                f"weekday_set entries must be plain integers, got "
+                f"{entry!r}"
+            )
+        if not 0 <= entry <= 6:
+            raise RuleValidationError(
+                f"weekday_set entries must be 0 (Monday)..6 (Sunday), "
+                f"got {entry!r}"
+            )
+    return frozenset(weekday_set)
+
+
+def _is_plain_int(value) -> bool:
+    """True only for real ints: bool excluded AND int subclasses too
+    (an unhashable int subclass would break the frozen-hashable model)."""
+    return type(value) is int
+
+
+def _validate_monthly_weekday(nth_weekday, weekday) -> None:
+    """Validate the MONTHLY_WEEKDAY position fields."""
+    if nth_weekday is None or not _is_plain_int(nth_weekday):
+        raise RuleValidationError(
+            "nth_weekday must be an integer for monthly_weekday rules, "
+            f"got {nth_weekday!r}"
+        )
+    if not (-1 <= nth_weekday <= 5) or nth_weekday == 0:
+        raise RuleValidationError(
+            f"nth_weekday must be -1 (last) or 1..5, got {nth_weekday!r}"
+        )
+    if weekday is None or not _is_plain_int(weekday) or not 0 <= weekday <= 6:
+        raise RuleValidationError(
+            f"monthly_weekday rules require a weekday 0 (Monday)..6 "
+            f"(Sunday), got {weekday!r}"
+        )
+
+
+
+
+
+@dataclass(frozen=True)
+class ScheduleRule:
+    """An immutable, validated recurrence rule (see module docstring).
+
+    Construct with keyword arguments; invalid combinations raise
+    :class:`RuleValidationError` at construction time.  Fields map
+    one-to-one onto the ``schedule_rules`` table columns, with
+    ``nth_weekday_weekday`` as the model-only weekday companion to
+    ``nth_weekday`` (serialized inside ``weekday_set`` at the DAO
+    boundary).
+    """
+
+    rule_type: RuleType
+    interval: int = 1
+    weekday_set: frozenset[int] | None = None
+    day_of_month: int | None = None
+    nth_weekday: int | None = None
+    nth_weekday_weekday: int | None = None
+    month: int | None = None
+    start_date: str = "1970-01-01"
+    end_date: str | None = None
+
+    def __post_init__(self) -> None:
+        # Normalize a string rule_type into the enum; anything else
+        # that is not already a RuleType is rejected.
+        if isinstance(self.rule_type, str):
+            # EXACT model names only: no whitespace stripping, no storage
+            # aliases.  The DAO maps storage strings to model fields when
+            # reading rows; the model boundary stays unambiguous.
+            candidates = {rt.name.lower(): rt for rt in RuleType}
+            if self.rule_type in candidates:
+                object.__setattr__(
+                    self, "rule_type", candidates[self.rule_type]
+                )
+            else:
+                raise RuleValidationError(
+                    f"rule_type must be a RuleType or one of "
+                    f"{sorted(candidates)}, got {self.rule_type!r}"
+                )
+        if not isinstance(self.rule_type, RuleType):
+            raise RuleValidationError(
+                f"rule_type must be a RuleType or one of its string "
+                f"values, got {self.rule_type!r}"
+            )
+        if not _is_plain_int(self.interval):
+            raise RuleValidationError(
+                f"interval must be an integer >= 1, got {self.interval!r}"
+            )
+        if self.interval < 1:
+            raise RuleValidationError(
+                f"interval must be >= 1, got {self.interval!r}"
+            )
+
+        _validate_date(self.start_date, "start_date")
+        if self.end_date is not None:
+            _validate_date(self.end_date, "end_date")
+            if self.end_date < self.start_date:
+                raise RuleValidationError(
+                    f"end_date {self.end_date!r} must be on or after "
+                    f"start_date {self.start_date!r}"
+                )
+
+        # Type-exclusive field policy, enforced for every type: build
+        # the dict of present fields, then reject every field the shape
+        # must not carry (weekday_set present is detectable via None vs
+        # set even after normalization below).
+        shape = self.rule_type
+        if shape is RuleType.DAILY:
+            forbidden_fields = (
+                "weekday_set",
+                "day_of_month",
+                "nth_weekday",
+                "nth_weekday_weekday",
+                "month",
+            )
+        elif shape is RuleType.WEEKLY:
+            forbidden_fields = (
+                "day_of_month",
+                "nth_weekday",
+                "nth_weekday_weekday",
+                "month",
+            )
+        elif shape is RuleType.CUSTOM_DAYS:
+            forbidden_fields = (
+                "day_of_month",
+                "nth_weekday",
+                "nth_weekday_weekday",
+                "month",
+            )
+        elif shape is RuleType.MONTHLY_DAY:
+            forbidden_fields = ("weekday_set", "nth_weekday",
+                                "nth_weekday_weekday", "month")
+        elif shape is RuleType.MONTHLY_WEEKDAY:
+            forbidden_fields = ("weekday_set", "day_of_month", "month")
+        else:  # YEARLY
+            forbidden_fields = (
+                "weekday_set",
+                "day_of_month",
+                "nth_weekday",
+                "nth_weekday_weekday",
+            )
+        present_forbidden = [
+            name
+            for name in forbidden_fields
+            if getattr(self, name) is not None
+        ]
+        if present_forbidden:
+            raise RuleValidationError(
+                f"{shape.value} rules must not set "
+                f"{', '.join(sorted(present_forbidden))}"
+            )
+
+        # Required fields per shape.
+        if shape is RuleType.WEEKLY or shape is RuleType.CUSTOM_DAYS:
+            normalized = _validate_weekday_set(self.weekday_set)
+            object.__setattr__(self, "weekday_set", normalized)
+        elif shape is RuleType.MONTHLY_DAY:
+            if self.day_of_month is None or not _is_plain_int(
+                self.day_of_month
+            ):
+                raise RuleValidationError(
+                    "monthly_day rules require day_of_month (1..31)"
+                )
+            if not 1 <= self.day_of_month <= 31:
+                raise RuleValidationError(
+                    f"day_of_month must be 1..31, got {self.day_of_month!r}"
+                )
+        elif shape is RuleType.MONTHLY_WEEKDAY:
+            _validate_monthly_weekday(
+                self.nth_weekday, self.nth_weekday_weekday
+            )
+        elif shape is RuleType.YEARLY:
+            if self.month is None or not _is_plain_int(self.month):
+                raise RuleValidationError(
+                    "yearly rules require month (1..12)"
+                )
+            if not 1 <= self.month <= 12:
+                raise RuleValidationError(
+                    f"month must be 1..12, got {self.month!r}"
+                )
+
+    def to_dict(self) -> dict:
+        """Return the lossless dict form (model-side storage shape).
+
+        ``weekday_set`` serializes as a sorted list; MONTHLY_WEEKDAY's
+        weekday travels inside it (appended) plus
+        ``nth_weekday_weekday`` so the pair round-trips without
+        ambiguity at the model layer.
+        """
+        return {
+            "rule_type": self.rule_type.name.lower(),  # model name
+            "interval": self.interval,
+            "weekday_set": (
+                sorted(self.weekday_set) if self.weekday_set is not None
+                else None
+            ),
+            "day_of_month": self.day_of_month,
+            "nth_weekday": self.nth_weekday,
+            "nth_weekday_weekday": self.nth_weekday_weekday,
+            "month": self.month,
+            "start_date": self.start_date,
+            "end_date": self.end_date,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "ScheduleRule":
+        """Rebuild a rule from :meth:`to_dict` output.
+
+        Raises :class:`RuleValidationError` on unknown keys, missing
+        keys, or invalid combinations — never a raw TypeError.
+        """
+        if not isinstance(data, dict):
+            raise RuleValidationError(
+                f"rule data must be a dict, got {type(data).__name__}"
+            )
+        allowed = {
+            "rule_type",
+            "interval",
+            "weekday_set",
+            "day_of_month",
+            "nth_weekday",
+            "nth_weekday_weekday",
+            "month",
+            "start_date",
+            "end_date",
+        }
+        unknown = [key for key in data if key not in allowed]
+        if unknown:
+            raise RuleValidationError(
+                f"unknown rule fields: {sorted(unknown, key=repr)}"
+            )
+        if "rule_type" not in data:
+            raise RuleValidationError("missing required rule field: rule_type")
+        weekday_set = data.get("weekday_set")
+        if isinstance(weekday_set, (list, tuple)):
+            # Validate entries as plain ints BEFORE set() coercion, so a
+            # list like [0, False] cannot collapse False into 0 and an
+            # unhashable/int-subclass entry cannot leak a raw TypeError.
+            for entry in weekday_set:
+                if not _is_plain_int(entry):
+                    raise RuleValidationError(
+                        f"weekday_set entries must be plain integers, got "
+                        f"{entry!r}"
+                    )
+            weekday_set = set(weekday_set)
+        return cls(
+            rule_type=data["rule_type"],
+            interval=data.get("interval", 1),
+            weekday_set=weekday_set,
+            day_of_month=data.get("day_of_month"),
+            nth_weekday=data.get("nth_weekday"),
+            nth_weekday_weekday=data.get("nth_weekday_weekday"),
+            month=data.get("month"),
+            start_date=data.get("start_date", "1970-01-01"),
+            end_date=data.get("end_date"),
+        )

tests/conftest.py

@@ -25,9 +25,6 @@ import asyncio
 import importlib.util
 import inspect
 import sys
-import tempfile
-import weakref
-from pathlib import Path
 from types import SimpleNamespace
 from unittest.mock import MagicMock
 
@@ -221,35 +218,13 @@ def wire_entry_to_registry(entry, registry: ListenerRegistry):
     return entry
 
 
-class _HassNamespace(SimpleNamespace):
-    """SimpleNamespace subclass so the hass stub can hold weak references."""
-
-
 def make_hass() -> tuple:
     """Create a hass stub plus its listener registry, mirroring HA's shape."""
-    config_dir = Path(tempfile.mkdtemp(prefix="nestquest-hass-"))
-    hass = _HassNamespace(
+    hass = SimpleNamespace(
         data={},
         config=MagicMock(),
         config_entries=SimpleNamespace(async_reload=None),
     )
-
-    def _cleanup_config_dir():
-        import shutil
-
-        shutil.rmtree(config_dir, ignore_errors=True)
-
-    weakref.finalize(hass, _cleanup_config_dir)
-    hass.config.path = MagicMock(
-        side_effect=lambda name: str(config_dir / (name or "config"))
-    )
-
-    def _run_executor_job(fn, *args, **kwargs):
-        return asyncio.get_running_loop().run_in_executor(
-            None, lambda: fn(*args, **kwargs)
-        )
-
-    hass.async_add_executor_job = _run_executor_job
     registry = ListenerRegistry(hass)
 
     async def _async_reload(entry_id: str) -> None:

tests/test_db.py

@@ -1,998 +0,0 @@
-"""Tests for db.py, the async SQLite connection wrapper of NestQuest."""
-from __future__ import annotations
-
-import ast
-import asyncio
-import sqlite3
-import threading
-from pathlib import Path
-from typing import Any
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-
-from conftest import make_hass
-
-from custom_components.nestquest import db as db_module
-from custom_components.nestquest.db import NestQuestDatabase
-
-
-def _run(coro):
-    return asyncio.new_event_loop().run_until_complete(coro)
-
-
-def _make_hass_mock():
-    hass = MagicMock()
-    hass.async_add_executor_job = AsyncMock(side_effect=(lambda fn, *a: fn(*a)))
-    return hass
-
-
-def _open_db(path) -> tuple[NestQuestDatabase, MagicMock]:
-    hass = _make_hass_mock()
-    database = NestQuestDatabase(hass)
-    _run(database.open(path))
-    return database, hass
-
-
-# ---------------------------------------------------------------------------
-# open(): pragmas, executor delegation, idempotence
-# ---------------------------------------------------------------------------
-
-
-def test_open_enables_wal_journal_mode(tmp_path) -> None:
-    database, _hass = _open_db(tmp_path / "wal.db")
-    row = _run(database.fetch_one("PRAGMA journal_mode"))
-    assert row is not None and str(row[0]).lower() == "wal"
-    _run(database.close())
-
-
-def test_open_enables_foreign_key_enforcement(tmp_path) -> None:
-    database, _hass = _open_db(tmp_path / "fk.db")
-    row = _run(database.fetch_one("PRAGMA foreign_keys"))
-    assert row is not None and int(row[0]) == 1
-    _run(database.close())
-
-
-def test_open_delegates_connection_to_executor(tmp_path) -> None:
-    hass = _make_hass_mock()
-    database = NestQuestDatabase(hass)
-    _run(database.open(tmp_path / "exec.db"))
-    first_call = hass.async_add_executor_job.call_args_list[0]
-    assert callable(first_call.args[0])
-    _run(database.close())
-
-
-def test_open_twice_returns_same_wrapper_without_second_connect(tmp_path) -> None:
-    path = tmp_path / "once.db"
-    hass = _make_hass_mock()
-    database = NestQuestDatabase(hass)
-    first = _run(database.open(path))
-    second = _run(database.open(path))
-    assert first is database
-    assert second is database
-    assert database.connected is True
-    opens = [
-        c
-        for c in hass.async_add_executor_job.call_args_list
-        if getattr(c.args[0], "__name__", "") == "_open"
-    ]
-    assert len(opens) == 1
-    _run(database.close())
-
-
-def test_open_accepts_str_path(tmp_path) -> None:
-    database, _hass = _open_db(str(tmp_path / "str.db"))
-    assert database.connected is True
-    _run(database.close())
-
-
-# ---------------------------------------------------------------------------
-# Executor delegation: every sqlite3 call happens off the event loop
-# ---------------------------------------------------------------------------
-
-
-def test_every_method_routes_sqlite3_through_executor(tmp_path) -> None:
-    """Each wrapper call must go via hass.async_add_executor_job."""
-    database, hass = _open_db(tmp_path / "route.db")
-    calls_before = hass.async_add_executor_job.await_count
-
-    _run(database.execute("CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT)"))
-    _run(database.execute("INSERT INTO t (name) VALUES (?)", ("a",)))
-    _run(database.execute_many("INSERT INTO t (name) VALUES (?)", [("b",), ("c",)]))
-    row = _run(database.fetch_one("SELECT name FROM t WHERE id = 1"))
-    rows = _run(database.fetch_all("SELECT name FROM t ORDER BY id"))
-
-    assert row == ("a",)
-    assert rows == [("a",), ("b",), ("c",)]
-    assert hass.async_add_executor_job.await_count == calls_before + 5
-    _run(database.close())
-
-
-async def test_every_wrapper_call_awaits_executor_job(tmp_path) -> None:
-    """The executor surface is awaited per wrapper call on a live loop."""
-    hass = _make_hass_mock()
-    database = NestQuestDatabase(hass)
-    await database.open(tmp_path / "loop.db")
-
-    await database.execute("CREATE TABLE t (id INTEGER PRIMARY KEY)")
-    await database.fetch_one("SELECT 1")
-    await database.fetch_all("SELECT 1")
-    await database.execute_many("INSERT INTO t (id) VALUES (?)", [(1,)])
-    async with database.transaction():
-        pass
-
-    assert hass.async_add_executor_job.await_count == 7
-    assert all(callable(c.args[0]) for c in hass.async_add_executor_job.call_args_list)
-    await database.close()
-
-
-async def test_public_methods_return_only_plain_data(tmp_path) -> None:
-    """execute/execute_many return plain dataclasses, never sqlite3 objects."""
-    hass = _make_hass_mock()
-    database = NestQuestDatabase(hass)
-    await database.open(tmp_path / "plain.db")
-    result = await database.execute(
-        "CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT)"
-    )
-    assert not isinstance(result, (sqlite3.Connection, sqlite3.Cursor))
-    insert = await database.execute("INSERT INTO t (name) VALUES (?)", ("a",))
-    assert not isinstance(insert, (sqlite3.Connection, sqlite3.Cursor))
-    assert insert.rowcount == 1
-    assert insert.lastrowid == 1
-    many = await database.execute_many(
-        "INSERT INTO t (name) VALUES (?)", [("b",), ("c",)]
-    )
-    assert not isinstance(many, (sqlite3.Connection, sqlite3.Cursor))
-    assert many.rowcount == 2
-    row = await database.fetch_one("SELECT name FROM t WHERE id = 1")
-    assert row == ("a",)
-    rows = await database.fetch_all("SELECT name FROM t ORDER BY id")
-    assert rows == [("a",), ("b",), ("c",)]
-    for value in (*rows, row):
-        assert not isinstance(value, sqlite3.Cursor)
-    await database.close()
-
-
-async def test_no_sqlite3_call_on_event_loop_with_real_executor(tmp_path) -> None:
-    """With the conftest hass (real run_in_executor), queries still succeed."""
-    hass, _registry = make_hass()
-    database = NestQuestDatabase(hass)
-    await database.open(tmp_path / "real.db")
-    await database.execute("CREATE TABLE t (id INTEGER PRIMARY KEY)")
-    assert await database.fetch_one("SELECT 1") == (1,)
-    await database.close()
-
-
-async def test_real_executor_never_touches_loop_thread(tmp_path, monkeypatch) -> None:
-    """Every real sqlite3 call must run on a non-event-loop thread.
-
-    sqlite3.connect is instrumented so a proxy wraps the connection and
-    every cursor it hands out; each proxied call records the thread it ran
-    on.  A recorded thread id equal to the event-loop thread would mean a
-    sqlite3 call crossed the executor boundary.
-    """
-    loop_thread = threading.get_ident()
-    recorded: list[int] = []
-    guard = threading.Lock()
-
-    def _note() -> None:
-        with guard:
-            recorded.append(threading.get_ident())
-
-    class _Proxy:
-        """Generic proxy recording the thread of every attribute call."""
-
-        def __init__(self, target: Any) -> None:
-            object.__setattr__(self, "_target", target)
-
-        def __getattr__(self, name: str):
-            attr = getattr(object.__getattribute__(self, "_target"), name)
-            if not callable(attr):
-                return attr
-
-            def _wrapped(*args, **kwargs):
-                _note()
-                result = attr(*args, **kwargs)
-                if isinstance(result, sqlite3.Cursor):
-                    return _Proxy(result)
-                return result
-
-            return _wrapped
-
-    real_connect = sqlite3.connect
-    connect_threads: list[int] = []
-
-    def _traced_connect(*args, **kwargs):
-        _note()
-        connect_threads.append(threading.get_ident())
-        return _Proxy(real_connect(*args, **kwargs))
-
-    monkeypatch.setattr(db_module.sqlite3, "connect", _traced_connect)
-
-    hass, _registry = make_hass()
-    database = NestQuestDatabase(hass)
-    await database.open(tmp_path / "threads.db")
-    await database.execute("CREATE TABLE t (id INTEGER PRIMARY KEY)")
-    await database.execute("INSERT INTO t (id) VALUES (?)", (1,))
-    await database.execute_many("INSERT INTO t (id) VALUES (?)", [(2,), (3,)])
-    assert await database.fetch_one("SELECT id FROM t WHERE id = 1") == (1,)
-    assert await database.fetch_all("SELECT id FROM t") == [(1,), (2,), (3,)]
-    async with database.transaction():
-        await database.execute("INSERT INTO t (id) VALUES (?)", (4,))
-    await database.close()
-
-    assert recorded, "expected at least one recorded sqlite3 call"
-    assert len(connect_threads) == 1, (
-        f"expected exactly one traced sqlite3.connect, got {len(connect_threads)}"
-    )
-    assert loop_thread not in recorded, (
-        f"sqlite3 call ran on the event-loop thread {loop_thread}; "
-        f"recorded threads: {sorted(set(recorded))}"
-    )
-
-
-# ---------------------------------------------------------------------------
-# Source scan: sqlite3.* only inside executor-delegated functions
-# ---------------------------------------------------------------------------
-
-
-def _iter_with_scope(node, chain):
-    """Yield (node, enclosing-function chain), depth-first."""
-    for child in ast.iter_child_nodes(node):
-        yield child, chain
-        next_chain = chain + (child,) if isinstance(
-            child, (ast.FunctionDef, ast.AsyncFunctionDef)
-        ) else chain
-        yield from _iter_with_scope(child, next_chain)
-
-
-def test_db_sqlite3_calls_only_inside_executor_delegated_functions() -> None:
-    """Every sqlite3.* call in db.py sits inside an executor-delegating function.
-
-    A function is executor-delegating when it (or, for nested closures, any of
-    its enclosing functions) passes work to ``hass.async_add_executor_job``.
-    """
-    source = Path(db_module.__file__).read_text(encoding="utf-8")
-    tree = ast.parse(source, filename=str(db_module.__file__))
-
-    delegated = {
-        node.name
-        for node in ast.walk(tree)
-        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
-        and any(
-            isinstance(sub, ast.Call)
-            and isinstance(sub.func, ast.Attribute)
-            and sub.func.attr == "async_add_executor_job"
-            for sub in ast.walk(node)
-        )
-    }
-    assert delegated, "expected executor-delegated functions in db.py"
-
-    violations = []
-    for node, chain in _iter_with_scope(tree, ()):
-        if (
-            isinstance(node, ast.Call)
-            and isinstance(node.func, ast.Attribute)
-            and isinstance(node.func.value, ast.Name)
-            and node.func.value.id == "sqlite3"
-            and not any(f.name in delegated for f in chain)
-        ):
-            violations.append((node.lineno, node.func.attr))
-    assert violations == [], (
-        f"Direct sqlite3 calls outside executor-delegated functions: {violations}"
-    )
-
-
-def test_package_wide_sqlite3_scan_excludes_only_db_module() -> None:
-    """The package-wide store scan exempts exactly the db module."""
-    pkg_dir = Path(db_module.__file__).parent
-    scanned = [p.name for p in pkg_dir.glob("*.py") if p.name != "db.py"]
-    assert scanned, "expected other package modules to be scanned"
-    assert "db.py" not in scanned
-
-
-# ---------------------------------------------------------------------------
-# close(): idempotence and post-close errors
-# ---------------------------------------------------------------------------
-
-
-def test_close_is_idempotent(tmp_path) -> None:
-    database, hass = _open_db(tmp_path / "idem.db")
-    _run(database.close())
-    assert database.connected is False
-    _run(database.close())
-    assert database.connected is False
-    assert hass.async_add_executor_job.await_count == 2
-    assert database.rowcount == -1
-    assert database.lastrowid is None
-
-
-def test_operations_after_close_raise_clear_error(tmp_path) -> None:
-    database, _hass = _open_db(tmp_path / "closed.db")
-    _run(database.close())
-
-    async def _txn():
-        async with database.transaction():
-            pass
-
-    with pytest.raises(RuntimeError, match="closed"):
-        _run(database.execute("SELECT 1"))
-    with pytest.raises(RuntimeError, match="closed"):
-        _run(database.fetch_one("SELECT 1"))
-    with pytest.raises(RuntimeError, match="closed"):
-        _run(database.fetch_all("SELECT 1"))
-    with pytest.raises(RuntimeError, match="closed"):
-        _run(database.execute_many("SELECT 1", []))
-    with pytest.raises(RuntimeError, match="closed"):
-        _run(_txn())
-
-
-# ---------------------------------------------------------------------------
-# Transactions: commit on success, rollback on exception
-# ---------------------------------------------------------------------------
-
-
-def test_transaction_commits_on_success(tmp_path) -> None:
-    database, _hass = _open_db(tmp_path / "commit.db")
-    _run(database.execute("CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT)"))
-
-    async def _block():
-        async with database.transaction():
-            await database.execute("INSERT INTO t (name) VALUES (?)", ("kept",))
-
-    _run(_block())
-    assert _run(database.fetch_all("SELECT name FROM t")) == [("kept",)]
-    _run(database.close())
-
-
-def test_transaction_rolls_back_on_exception(tmp_path) -> None:
-    database, _hass = _open_db(tmp_path / "rollback.db")
-    _run(database.execute("CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT)"))
-    _run(database.execute("INSERT INTO t (name) VALUES (?)", ("before",)))
-
-    async def _block():
-        with pytest.raises(ValueError, match="boom"):
-            async with database.transaction():
-                await database.execute(
-                    "INSERT INTO t (name) VALUES (?)", ("dropped",)
-                )
-                raise ValueError("boom")
-
-    _run(_block())
-    assert _run(database.fetch_all("SELECT name FROM t")) == [("before",)]
-    _run(database.close())
-
-
-async def test_commit_failure_rolls_back_and_next_transaction_works(
-    tmp_path,
-) -> None:
-    """A COMMIT failure rolls back and leaves the wrapper reusable.
-
-    With PRAGMA defer_foreign_keys=ON a violating insert succeeds inside
-    the transaction and the foreign-key violation only surfaces at COMMIT.
-    The commit error must propagate, the real connection must end up
-    outside any transaction, and the next transaction() plus statement
-    must run cleanly.
-    """
-    hass, _registry = make_hass()
-    database = NestQuestDatabase(hass)
-    await database.open(tmp_path / "deferred.db")
-    await database.execute("CREATE TABLE parent (id INTEGER PRIMARY KEY)")
-    await database.execute(
-        "CREATE TABLE child ("
-        "id INTEGER PRIMARY KEY, "
-        "parent_id INTEGER NOT NULL REFERENCES parent(id))"
-    )
-
-    with pytest.raises(sqlite3.IntegrityError, match="FOREIGN KEY"):
-        async with database.transaction():
-            await database.execute("PRAGMA defer_foreign_keys=ON")
-            await database.execute(
-                "INSERT INTO child (parent_id) VALUES (?)", (999,)
-            )
-
-    assert database._in_transaction is False
-    assert database._tx_task is None
-    assert database._conn is not None
-    assert database._conn.in_transaction is False
-    assert await database.fetch_all("SELECT COUNT(*) FROM child") == [(0,)]
-
-    async with database.transaction():
-        await database.execute("INSERT INTO parent (id) VALUES (?)", (1,))
-        await database.execute(
-            "INSERT INTO child (parent_id) VALUES (?)", (1,)
-        )
-    assert await database.fetch_all("SELECT COUNT(*) FROM child") == [(1,)]
-    await database.close()
-
-
-async def test_cancel_during_open_closes_abandoned_connection(tmp_path) -> None:
-    """NQ-PR12-010: cancel during open() must close the settled connection.
-
-    The _open executor job is gated: the open task is cancelled while the
-    connect is still in flight, then the worker is allowed to complete it
-    anyway.  The settled connection must never be adopted, must be closed
-    through a settled executor-backed close before the cancellation
-    propagates, and a follow-up open() must succeed cleanly.
-    """
-    hass, _registry = make_hass()
-    database = NestQuestDatabase(hass)
-
-    open_started = asyncio.Event()
-    release_open = asyncio.Event()
-    jobs: list[str] = []
-    captured: dict[str, Any] = {}
-    real_add = hass.async_add_executor_job
-
-    async def _gated_add_executor_job(fn, *args, **kwargs):
-        name = getattr(fn, "__name__", "")
-        jobs.append(name)
-        if name == "_open":
-            open_started.set()
-            await release_open.wait()
-        result = await real_add(fn, *args, **kwargs)
-        if name == "_open":
-            captured["conn"] = result
-        return result
-
-    hass.async_add_executor_job = _gated_add_executor_job
-
-    open_task = asyncio.create_task(database.open(tmp_path / "cancel-open.db"))
-    await open_started.wait()
-    open_task.cancel()
-    await asyncio.sleep(0.05)
-    assert database._conn is None, (
-        "the cancelled open adopted a connection that was still settling"
-    )
-    release_open.set()
-    with pytest.raises(asyncio.CancelledError):
-        await open_task
-
-    assert database.connected is False
-    assert "_close_abandoned" in jobs, (
-        "the abandoned connection was not closed via an executor job"
-    )
-    conn = captured.get("conn")
-    assert conn is not None
-
-    def _probe() -> str:
-        try:
-            conn.execute("SELECT 1")
-        except sqlite3.ProgrammingError:
-            return "closed"
-        return "open"
-
-    assert await real_add(_probe) == "closed"
-
-    hass.async_add_executor_job = real_add
-    await database.open(tmp_path / "cancel-open.db")
-    assert database.connected is True
-    assert await database.fetch_one("SELECT 1") == (1,)
-    await database.close()
-
-
-async def test_cancel_during_begin_settles_then_rolls_back(tmp_path) -> None:
-    """NQ-PR12-007: cancel during BEGIN must not leak a stray transaction.
-
-    The BEGIN executor job is gated: the transaction task is cancelled
-    while BEGIN is still in flight, then the worker is allowed to
-    complete it anyway.  The wrapper must keep transaction ownership
-    until the submitted work settles, roll the completed BEGIN back,
-    clear its state, and stay usable for the next transaction.
-    """
-    hass, _registry = make_hass()
-    database = NestQuestDatabase(hass)
-    await database.open(tmp_path / "cancel-begin.db")
-    await database.execute("CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT)")
-    await database.execute("INSERT INTO t (name) VALUES (?)", ("before",))
-
-    begin_started = asyncio.Event()
-    release_begin = asyncio.Event()
-    real_add = hass.async_add_executor_job
-
-    async def _gated_add_executor_job(fn, *args, **kwargs):
-        if getattr(fn, "__name__", "") == "_begin":
-            begin_started.set()
-            await release_begin.wait()
-        return await real_add(fn, *args, **kwargs)
-
-    hass.async_add_executor_job = _gated_add_executor_job
-
-    async def _txn() -> None:
-        async with database.transaction():
-            await database.execute("INSERT INTO t (name) VALUES (?)", ("kept",))
-
-    txn_task = asyncio.create_task(_txn())
-    await begin_started.wait()
-    txn_task.cancel()
-    await asyncio.sleep(0.05)
-    assert database._in_transaction is True, (
-        "ownership was released while the cancelled BEGIN was still in flight"
-    )
-    release_begin.set()
-    with pytest.raises(asyncio.CancelledError):
-        await txn_task
-
-    assert database._in_transaction is False
-    assert database._tx_task is None
-    assert database._conn is not None
-    assert database._conn.in_transaction is False
-
-    hass.async_add_executor_job = real_add
-    assert await database.fetch_all("SELECT name FROM t ORDER BY id") == [
-        ("before",)
-    ]
-    async with database.transaction():
-        await database.execute("INSERT INTO t (name) VALUES (?)", ("kept",))
-    assert await database.fetch_all("SELECT name FROM t ORDER BY id") == [
-        ("before",),
-        ("kept",),
-    ]
-    await database.close()
-
-
-async def test_cancel_during_commit_settles_then_propagates_cancellation(
-    tmp_path,
-) -> None:
-    """NQ-PR12-007: cancel during COMMIT must not mask the cancellation.
-
-    COMMIT is gated; the task is cancelled while it is in flight and the
-    worker then completes it anyway.  The cancellation must propagate as
-    CancelledError (not be converted by a doomed ROLLBACK of an already
-    committed transaction), the connection must end outside any
-    transaction, and the wrapper must stay usable.
-    """
-    hass, _registry = make_hass()
-    database = NestQuestDatabase(hass)
-    await database.open(tmp_path / "cancel-commit.db")
-    await database.execute("CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT)")
-
-    commit_started = asyncio.Event()
-    release_commit = asyncio.Event()
-    real_add = hass.async_add_executor_job
-
-    async def _gated_add_executor_job(fn, *args, **kwargs):
-        if getattr(fn, "__name__", "") == "_commit":
-            commit_started.set()
-            await release_commit.wait()
-        return await real_add(fn, *args, **kwargs)
-
-    hass.async_add_executor_job = _gated_add_executor_job
-
-    async def _txn() -> None:
-        async with database.transaction():
-            await database.execute("INSERT INTO t (name) VALUES (?)", ("kept",))
-
-    txn_task = asyncio.create_task(_txn())
-    await commit_started.wait()
-    txn_task.cancel()
-    await asyncio.sleep(0.05)
-    assert database._in_transaction is True, (
-        "ownership was released while the cancelled COMMIT was still in flight"
-    )
-    release_commit.set()
-    with pytest.raises(asyncio.CancelledError):
-        await txn_task
-
-    assert database._in_transaction is False
-    assert database._tx_task is None
-    assert database._conn is not None
-    assert database._conn.in_transaction is False
-
-    hass.async_add_executor_job = real_add
-    assert await database.fetch_all("SELECT name FROM t") == [("kept",)]
-    async with database.transaction():
-        await database.execute("INSERT INTO t (name) VALUES (?)", ("again",))
-    assert await database.fetch_all("SELECT name FROM t ORDER BY id") == [
-        ("kept",),
-        ("again",),
-    ]
-    await database.close()
-
-
-async def test_cancel_during_in_transaction_execute_settles_then_rolls_back(
-    tmp_path,
-) -> None:
-    """NQ-PR12-009: cancel during an in-transaction statement must not race ROLLBACK.
-
-    The in-transaction INSERT executor job is gated: the transaction task
-    is cancelled while the statement is still in flight, then the worker
-    is allowed to complete it anyway.  The ROLLBACK must only run after
-    the statement has settled — while the statement is in flight the
-    transaction is still open — and the cancelled statement's write must
-    not persist.
-    """
-    hass, _registry = make_hass()
-    database = NestQuestDatabase(hass)
-    await database.open(tmp_path / "cancel-execute.db")
-    await database.execute("CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT)")
-    await database.execute("INSERT INTO t (name) VALUES (?)", ("before",))
-
-    insert_started = asyncio.Event()
-    release_insert = asyncio.Event()
-    real_add = hass.async_add_executor_job
-
-    async def _gated_add_executor_job(fn, *args, **kwargs):
-        if getattr(fn, "__name__", "") == "_execute":
-            insert_started.set()
-            await release_insert.wait()
-        return await real_add(fn, *args, **kwargs)
-
-    hass.async_add_executor_job = _gated_add_executor_job
-
-    async def _txn() -> None:
-        async with database.transaction():
-            await database.execute("INSERT INTO t (name) VALUES (?)", ("lost",))
-
-    txn_task = asyncio.create_task(_txn())
-    await insert_started.wait()
-    txn_task.cancel()
-    await asyncio.sleep(0.05)
-    assert database._in_transaction is True, (
-        "ownership was released while the cancelled statement was in flight"
-    )
-    assert database._conn is not None
-    assert database._conn.in_transaction is True, (
-        "ROLLBACK ran before the cancelled statement settled"
-    )
-    release_insert.set()
-    with pytest.raises(asyncio.CancelledError):
-        await txn_task
-
-    assert database._in_transaction is False
-    assert database._tx_task is None
-    assert database._conn is not None
-    assert database._conn.in_transaction is False
-
-    hass.async_add_executor_job = real_add
-    assert await database.fetch_all("SELECT name FROM t ORDER BY id") == [
-        ("before",)
-    ]
-    async with database.transaction():
-        await database.execute("INSERT INTO t (name) VALUES (?)", ("kept",))
-    assert await database.fetch_all("SELECT name FROM t ORDER BY id") == [
-        ("before",),
-        ("kept",),
-    ]
-    await database.close()
-
-
-async def test_commit_and_rollback_failures_are_both_preserved(tmp_path) -> None:
-    """NQ-PR12-008: both errors survive when COMMIT and ROLLBACK both fail.
-
-    The COMMIT executor call is forced to fail, and the follow-up
-    cleanup ROLLBACK is forced to fail as well.  The raised error must
-    keep both original exceptions inspectable instead of discarding the
-    commit failure behind the rollback failure.
-    """
-    hass, _registry = make_hass()
-    database = NestQuestDatabase(hass)
-    await database.open(tmp_path / "both-fail.db")
-    await database.execute("CREATE TABLE t (id INTEGER PRIMARY KEY)")
-
-    commit_failure = sqlite3.OperationalError("commit exploded")
-    rollback_failure = sqlite3.OperationalError("rollback exploded")
-    real_add = hass.async_add_executor_job
-
-    async def _failing_add_executor_job(fn, *args, **kwargs):
-        name = getattr(fn, "__name__", "")
-        if name == "_commit":
-            raise commit_failure
-        if name == "_cleanup":
-            raise rollback_failure
-        return await real_add(fn, *args, **kwargs)
-
-    hass.async_add_executor_job = _failing_add_executor_job
-
-    with pytest.raises(BaseExceptionGroup) as exc_info:
-        async with database.transaction():
-            pass
-
-    assert commit_failure in exc_info.value.exceptions
-    assert rollback_failure in exc_info.value.exceptions
-    assert database._in_transaction is False
-    assert database._tx_task is None
-    await database.close()
-
-
-async def test_transaction_persists_across_connections(tmp_path) -> None:
-    """A committed transaction is visible to a brand-new connection."""
-    hass, _registry = make_hass()
-    database = NestQuestDatabase(hass)
-    await database.open(tmp_path / "persist.db")
-    await database.execute("CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT)")
-    async with database.transaction():
-        await database.execute("INSERT INTO t (name) VALUES (?)", ("kept",))
-    await database.close()
-
-    other = NestQuestDatabase(hass)
-    await other.open(tmp_path / "persist.db")
-    assert await other.fetch_all("SELECT name FROM t") == [("kept",)]
-    await other.close()
-
-
-# ---------------------------------------------------------------------------
-# Serialization: one lock per wrapper, no cross-commit interleaving
-# ---------------------------------------------------------------------------
-
-
-async def test_concurrent_writers_do_not_interleave_commits(tmp_path) -> None:
-    """Real-executor proof: nothing commits inside another transaction's span.
-
-    A transaction runner repeatedly counts rows, inserts, and counts again
-    inside BEGIN..COMMIT; the count must grow by exactly one, proving no
-    other writer committed in between even though several writer tasks fire
-    statements concurrently on real executor threads.  Statements issued
-    while a transaction is open queue behind it on the wrapper lock.
-    """
-    hass, _registry = make_hass()
-    database = NestQuestDatabase(hass)
-    await database.open(tmp_path / "serial.db")
-    await database.execute("CREATE TABLE t (kind TEXT, seq INTEGER)")
-    tx_rounds, writers, writer_rounds = 6, 5, 8
-    total = tx_rounds + writers * writer_rounds
-
-    async def _tx_runner() -> None:
-        for rnd in range(tx_rounds):
-            async with database.transaction():
-                rows = await database.fetch_all("SELECT COUNT(*) FROM t")
-                seen = rows[0][0] if rows else -1
-                await database.execute(
-                    "INSERT INTO t (kind, seq) VALUES (?, ?)", ("tx", rnd)
-                )
-                rows = await database.fetch_all("SELECT COUNT(*) FROM t")
-                grown = rows[0][0] if rows else -1
-                if grown != seen + 1:
-                    raise AssertionError(
-                        f"interleaved commit: count {seen} -> {grown} "
-                        f"in tx round {rnd}"
-                    )
-
-    async def _writer(worker: int) -> None:
-        for rnd in range(writer_rounds):
-            await database.execute(
-                "INSERT INTO t (kind, seq) VALUES (?, ?)", ("w", worker)
-            )
-
-    await asyncio.gather(
-        _tx_runner(), *(_writer(w) for w in range(writers))
-    )
-
-    rows = await database.fetch_all("SELECT COUNT(*) FROM t")
-    assert rows[0][0] == total, f"expected {total} rows, got {rows[0][0]}"
-    await database.close()
-
-
-async def test_transaction_span_excludes_concurrent_transaction(tmp_path) -> None:
-    """A second transaction caller is rejected with a clear error."""
-    hass, _registry = make_hass()
-    database = NestQuestDatabase(hass)
-    await database.open(tmp_path / "reject.db")
-    await database.execute("CREATE TABLE t (id INTEGER)")
-
-    started = asyncio.Event()
-
-    async def _first() -> None:
-        async with database.transaction():
-            started.set()
-            await asyncio.sleep(0.05)
-
-    first = asyncio.create_task(_first())
-    await started.wait()
-    with pytest.raises(RuntimeError, match="transaction"):
-        async with database.transaction():
-            pass
-    await first
-    await database.execute("INSERT INTO t (id) VALUES (?)", (1,))
-    assert await database.fetch_one("SELECT id FROM t") == (1,)
-    await database.close()
-
-
-async def test_transaction_blocks_other_statements_until_commit(tmp_path) -> None:
-    """A statement issued during an open transaction queues behind it."""
-    hass, _registry = make_hass()
-    database = NestQuestDatabase(hass)
-    await database.open(tmp_path / "block.db")
-    await database.execute("CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT)")
-
-    order: list[str] = []
-    started = asyncio.Event()
-    release = asyncio.Event()
-
-    async def _txn() -> None:
-        async with database.transaction():
-            await database.execute("INSERT INTO t (name) VALUES (?)", ("in_tx",))
-            order.append("tx-start")
-            started.set()
-            await release.wait()
-            order.append("tx-end")
-
-    async def _outsider() -> None:
-        await started.wait()
-        await database.execute("INSERT INTO t (name) VALUES (?)", ("after",))
-        order.append("outside")
-
-    txn_task = asyncio.create_task(_txn())
-    await started.wait()
-    outsider_task = asyncio.create_task(_outsider())
-    await asyncio.sleep(0.05)
-    assert order == ["tx-start"], f"outsider ran inside transaction: {order}"
-    release.set()
-    await asyncio.gather(txn_task, outsider_task)
-    assert order == ["tx-start", "tx-end", "outside"]
-    rows = await database.fetch_all("SELECT name FROM t ORDER BY id")
-    assert rows == [("in_tx",), ("after",)]
-    await database.close()
-
-
-async def test_concurrent_transaction_is_rejected_with_clear_error(
-    tmp_path,
-) -> None:
-    """A second concurrent transaction() gets a clear RuntimeError."""
-    hass, _registry = make_hass()
-    database = NestQuestDatabase(hass)
-    await database.open(tmp_path / "concurrent-tx.db")
-    await database.execute("CREATE TABLE t (id INTEGER)")
-
-    started = asyncio.Event()
-
-    async def _first() -> None:
-        async with database.transaction():
-            started.set()
-            await asyncio.sleep(0.05)
-
-    first = asyncio.create_task(_first())
-    await started.wait()
-    with pytest.raises(RuntimeError, match="transaction"):
-        async with database.transaction():
-            pass
-    await first
-    await database.close()
-
-
-async def test_close_waits_for_in_flight_transaction(tmp_path) -> None:
-    """close() serializes: an open transaction finishes before shutdown."""
-    hass, _registry = make_hass()
-    database = NestQuestDatabase(hass)
-    await database.open(tmp_path / "closerace.db")
-    await database.execute("CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT)")
-
-    started = asyncio.Event()
-    release = asyncio.Event()
-
-    async def _txn() -> None:
-        async with database.transaction():
-            await database.execute("INSERT INTO t (name) VALUES (?)", ("kept",))
-            started.set()
-            await release.wait()
-
-    txn_task = asyncio.create_task(_txn())
-    await started.wait()
-    close_task = asyncio.create_task(database.close())
-    await asyncio.sleep(0.05)
-    assert database.connected is True, "close() raced an open transaction"
-    release.set()
-    await asyncio.gather(txn_task, close_task)
-    assert database.connected is False
-
-    witness = NestQuestDatabase(hass)
-    await witness.open(tmp_path / "closerace.db")
-    assert await witness.fetch_all("SELECT name FROM t") == [("kept",)]
-    await witness.close()
-
-
-async def test_close_during_transaction_from_same_task_is_rejected(
-    tmp_path,
-) -> None:
-    """close() inside its own transaction body raises instead of deadlocking."""
-    hass, _registry = make_hass()
-    database = NestQuestDatabase(hass)
-    await database.open(tmp_path / "selfclose.db")
-    await database.execute("CREATE TABLE t (id INTEGER)")
-    with pytest.raises(RuntimeError, match="transaction"):
-        async with database.transaction():
-            await database.close()
-    assert database.connected is True
-    await database.close()
-
-
-# ---------------------------------------------------------------------------
-# rowcount / lastrowid surface
-# ---------------------------------------------------------------------------
-
-
-def test_rowcount_and_lastrowid_before_any_operation(tmp_path) -> None:
-    database, _hass = _open_db(tmp_path / "unset.db")
-    assert database.rowcount == -1
-    assert database.lastrowid is None
-    _run(database.close())
-
-
-def test_execute_exposes_rowcount_and_lastrowid(tmp_path) -> None:
-    database, _hass = _open_db(tmp_path / "counts.db")
-    _run(database.execute("CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT)"))
-    _run(database.execute("INSERT INTO t (name) VALUES (?)", ("x",)))
-    assert database.rowcount == 1
-    assert database.lastrowid == 1
-    _run(database.execute("INSERT INTO t (name) VALUES (?)", ("y",)))
-    assert database.rowcount == 1
-    assert database.lastrowid == 2
-    _run(database.close())
-
-
-def test_execute_many_exposes_rowcount(tmp_path) -> None:
-    database, _hass = _open_db(tmp_path / "many.db")
-    _run(database.execute("CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT)"))
-    _run(database.execute_many("INSERT INTO t (name) VALUES (?)", [("a",), ("b",)]))
-    assert database.rowcount == 2
-    _run(database.execute("INSERT INTO t (name) VALUES (?)", ("c",)))
-    assert database.lastrowid == 3
-    _run(database.close())
-
-
-# ---------------------------------------------------------------------------
-# Lifecycle wiring: opened once per entry, closed on unload
-# ---------------------------------------------------------------------------
-
-
-async def test_setup_entry_opens_database_in_runtime_data(hass, make_entry) -> None:
-    from conftest import wire_entry_to_registry
-
-    from custom_components.nestquest import async_setup_entry, async_unload_entry
-
-    entry = wire_entry_to_registry(make_entry(), hass.registry)
-    assert await async_setup_entry(hass, entry) is True
-    runtime = entry.runtime_data
-    assert runtime.database is not None
-    assert runtime.database.connected is True
-    await async_unload_entry(hass, entry)
-
-
-async def test_unload_entry_closes_database(hass, make_entry) -> None:
-    from conftest import wire_entry_to_registry
-
-    from custom_components.nestquest import async_setup_entry, async_unload_entry
-
-    entry = wire_entry_to_registry(make_entry(), hass.registry)
-    await async_setup_entry(hass, entry)
-    database = entry.runtime_data.database
-    assert database.connected is True
-    assert await async_unload_entry(hass, entry) is True
-    assert database.connected is False
-    with pytest.raises(RuntimeError, match="closed"):
-        await database.fetch_one("SELECT 1")
-
-
-async def test_second_setup_does_not_open_second_connection(hass, make_entry) -> None:
-    from conftest import wire_entry_to_registry
-
-    from custom_components.nestquest import async_setup_entry, async_unload_entry
-
-    entry = wire_entry_to_registry(make_entry(), hass.registry)
-    await async_setup_entry(hass, entry)
-    first = entry.runtime_data.database
-
-    await async_setup_entry(hass, entry)
-    second = entry.runtime_data.database
-
-    assert first is second
-    assert first.connected is True
-    await async_unload_entry(hass, entry)
-
-
-async def test_setup_unload_cycles_reopen_fresh_connection(hass, make_entry) -> None:
-    from conftest import wire_entry_to_registry
-
-    from custom_components.nestquest import async_setup_entry, async_unload_entry
-
-    entry = wire_entry_to_registry(make_entry(), hass.registry)
-    seen: list[NestQuestDatabase] = []
-    for _ in range(3):
-        await async_setup_entry(hass, entry)
-        runtime = entry.runtime_data
-        assert runtime.database.connected is True
-        seen.append(runtime.database)
-        await async_unload_entry(hass, entry)
-        assert runtime.database.connected is False
-    assert len(set(seen)) == 3
-    assert hass.data == {}

tests/test_lifecycle.py

@@ -3,8 +3,6 @@ from __future__ import annotations
 
 import asyncio
 
-import pytest
-
 from conftest import make_config_entry, make_hass, wire_entry_to_registry
 
 from custom_components.nestquest import DOMAIN, async_setup_entry, async_unload_entry
@@ -198,42 +196,4 @@ async def test_setup_awaitable_listener_removal_supported() -> None:
     assert result is True
     assert removed == [True]
     assert hass.data == {}
-    assert entry.runtime_data is None
-
-
-async def test_setup_closes_database_when_listener_registration_fails() -> None:
-    """A listener-registration failure must not leak the opened database."""
-    from custom_components.nestquest.db import NestQuestDatabase
-
-    class _Boom(Exception):
-        pass
-
-    entry = make_config_entry(entry_id="listener-boom")
-    entry.add_update_listener = lambda listener: (_ for _ in ()).throw(_Boom())
-    hass, _registry = make_hass()
-    with pytest.raises(_Boom):
-        await async_setup_entry(hass, entry)
-    assert hass.data.get(DOMAIN, {}) == {}
-    assert not hasattr(entry, "runtime_data")
-
-
-async def test_unload_closes_database_even_when_listener_removal_raises() -> None:
-    """Unload removes the listener, closes the DB in a finally, then raises."""
-    from custom_components.nestquest.db import NestQuestDatabase
-
-    class _RemoveBoom(Exception):
-        pass
-
-    def _remover():
-        raise _RemoveBoom()
-
-    entry = make_config_entry(entry_id="remove-boom")
-    entry.add_update_listener = lambda listener: _remover
-    hass, _registry = make_hass()
-    await async_setup_entry(hass, entry)
-    database = entry.runtime_data.database
-    with pytest.raises(_RemoveBoom):
-        await async_unload_entry(hass, entry)
-    assert database.connected is False, "database leaked despite remover error"
-    assert entry.runtime_data is None
-    assert DOMAIN not in hass.data
+    assert entry.runtime_data is None

tests/test_recurrence_model.py

@@ -0,0 +1,480 @@
+"""Tests for recurrence.py: the ScheduleRule model and serialization."""
+from __future__ import annotations
+
+import datetime
+
+import pytest
+
+from custom_components.nestquest.recurrence import (
+    RuleType,
+    RuleValidationError,
+    ScheduleRule,
+)
+
+
+def _rule(**kwargs) -> ScheduleRule:
+    return ScheduleRule(**kwargs)
+
+
+# ---------------------------------------------------------------------------
+# Valid construction for every rule type
+# ---------------------------------------------------------------------------
+
+
+def test_daily_rule_constructs_with_defaults() -> None:
+    rule = _rule(rule_type=RuleType.DAILY, start_date="2026-09-01")
+    assert rule.rule_type is RuleType.DAILY
+    assert rule.interval == 1
+    assert rule.weekday_set is None
+    assert rule.day_of_month is None
+    assert rule.nth_weekday is None
+    assert rule.month is None
+    assert rule.end_date is None
+
+
+def test_string_rule_type_coerces() -> None:
+    rule = _rule(rule_type=RuleType.WEEKLY, weekday_set={0, 2}, start_date="2026-09-01")
+    assert rule.rule_type is RuleType.WEEKLY
+
+
+def test_weekly_rule_requires_and_freezes_weekday_set() -> None:
+    rule = _rule(rule_type=RuleType.WEEKLY, weekday_set={0, 2, 4}, start_date="2026-09-01")
+    assert rule.weekday_set == frozenset({0, 2, 4})
+    # A mutable set passed in is frozen on construction.
+    source = {1, 3}
+    rule2 = _rule(rule_type=RuleType.WEEKLY, weekday_set=source, start_date="2026-09-01")
+    source.add(5)
+    assert rule2.weekday_set == frozenset({1, 3})
+
+
+def test_monthly_day_rule_fields() -> None:
+    rule = _rule(rule_type=RuleType.MONTHLY_DAY, day_of_month=15, start_date="2026-09-01")
+    assert rule.day_of_month == 15
+    assert rule.nth_weekday is None
+
+
+def test_monthly_weekday_rule_fields() -> None:
+    rule = _rule(
+        rule_type=RuleType.MONTHLY_WEEKDAY,
+        nth_weekday=2,
+        nth_weekday_weekday=1,
+        start_date="2026-09-01",
+    )
+    assert rule.nth_weekday == 2
+    assert rule.nth_weekday_weekday == 1
+
+
+def test_monthly_weekday_last_friday_allowed() -> None:
+    rule = _rule(
+        rule_type=RuleType.MONTHLY_WEEKDAY,
+        nth_weekday=-1,
+        nth_weekday_weekday=4,
+        start_date="2026-09-01",
+    )
+    assert rule.nth_weekday == -1
+
+
+def test_yearly_rule_fields() -> None:
+    rule = _rule(rule_type=RuleType.YEARLY, month=6, start_date="2026-09-01")
+    assert rule.month == 6
+
+
+def test_custom_days_rule_fields() -> None:
+    rule = _rule(
+        rule_type=RuleType.CUSTOM_DAYS,
+        weekday_set={1, 3, 5},
+        interval=2,
+        start_date="2026-09-01",
+    )
+    assert rule.weekday_set == frozenset({1, 3, 5})
+    assert rule.interval == 2
+
+
+def test_end_date_round_trips(tmp_path) -> None:
+    rule = _rule(
+        rule_type=RuleType.DAILY,
+        start_date="2026-09-01",
+        end_date="2026-12-31",
+    )
+    assert rule.end_date == "2026-12-31"
+
+
+# ---------------------------------------------------------------------------
+# Invalid combinations are rejected at construction
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        # weekly without weekday_set
+        {"rule_type": RuleType.WEEKLY.value, "start_date": "2026-09-01"},
+        # daily carrying a weekday_set
+        {"rule_type": "daily", "weekday_set": {0}, "start_date": "2026-09-01"},
+        # monthly_day without day_of_month
+        {"rule_type": "monthly_day", "start_date": "2026-09-01"},
+        # monthly_day out of range
+        {"rule_type": "monthly_day", "day_of_month": 32, "start_date": "2026-09-01"},
+        # monthly_day carrying weekday_set
+        {"rule_type": "monthly_day", "day_of_month": 5, "weekday_set": {0},
+         "start_date": "2026-09-01"},
+        # yearly without month
+        {"rule_type": "yearly", "start_date": "2026-09-01"},
+        # yearly out of range
+        {"rule_type": "yearly", "month": 13, "start_date": "2026-09-01"},
+        # unknown type
+        {"rule_type": "bogus", "start_date": "2026-09-01"},
+        # interval zero
+        {"rule_type": "daily", "interval": 0, "start_date": "2026-09-01"},
+        # interval non-integer
+        {"rule_type": "daily", "interval": "2", "start_date": "2026-09-01"},
+        # end before start
+        {"rule_type": "daily", "start_date": "2026-09-01",
+         "end_date": "2026-08-31"},
+        # malformed dates
+        {"rule_type": "daily", "start_date": "not-a-date"},
+        {"rule_type": "daily", "start_date": "2026-9-1"},
+        # weekly weekday out of range
+        {"rule_type": RuleType.WEEKLY.value, "weekday_set": {7}, "start_date": "2026-09-01"},
+        # weekly empty set
+        {"rule_type": RuleType.WEEKLY.value, "weekday_set": set(), "start_date": "2026-09-01"},
+        # custom_days carrying month-specific fields
+        {"rule_type": "custom_days", "weekday_set": {0}, "day_of_month": 5,
+         "start_date": "2026-09-01"},
+        {"rule_type": "custom_days", "weekday_set": {0}, "nth_weekday": 1,
+         "nth_weekday_weekday": 0, "start_date": "2026-09-01"},
+        {"rule_type": "custom_days", "weekday_set": {0}, "month": 3,
+         "start_date": "2026-09-01"},
+        # monthly_weekday position invalid
+        {"rule_type": "monthly_weekday", "nth_weekday": 0,
+         "nth_weekday_weekday": 1, "start_date": "2026-09-01"},
+        {"rule_type": "monthly_weekday", "nth_weekday": 6,
+         "nth_weekday_weekday": 1, "start_date": "2026-09-01"},
+        {"rule_type": "monthly_weekday", "nth_weekday": 2,
+         "nth_weekday_weekday": None, "start_date": "2026-09-01"},
+        {"rule_type": "monthly_weekday", "nth_weekday": 2,
+         "nth_weekday_weekday": 7, "start_date": "2026-09-01"},
+        # monthly_day carrying nth fields
+        {"rule_type": "monthly_day", "day_of_month": 5, "nth_weekday": 1,
+         "nth_weekday_weekday": 0, "start_date": "2026-09-01"},
+    ],
+)
+def test_invalid_combinations_raise(kwargs) -> None:
+    with pytest.raises(RuleValidationError):
+        _rule(**kwargs)
+
+
+# ---------------------------------------------------------------------------
+# Immutability
+# ---------------------------------------------------------------------------
+
+
+def test_rule_is_immutable() -> None:
+    rule = _rule(rule_type=RuleType.DAILY, start_date="2026-09-01")
+    with pytest.raises(AttributeError):
+        rule.interval = 2
+    with pytest.raises(AttributeError):
+        del rule.interval
+
+
+# ---------------------------------------------------------------------------
+# Serialization round-trip for every rule type
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "rule",
+    [
+        ScheduleRule(rule_type=RuleType.DAILY, start_date="2026-09-01"),
+        ScheduleRule(rule_type=RuleType.DAILY, interval=3, start_date="2026-09-01",
+                     end_date="2026-12-31"),
+        ScheduleRule(rule_type=RuleType.WEEKLY, weekday_set={0, 2, 4},
+                     start_date="2026-09-01"),
+        ScheduleRule(rule_type=RuleType.WEEKLY, weekday_set={6}, interval=2,
+                     start_date="2026-09-01"),
+        ScheduleRule(rule_type=RuleType.MONTHLY_DAY, day_of_month=15,
+                     start_date="2026-09-01"),
+        ScheduleRule(rule_type=RuleType.MONTHLY_DAY, day_of_month=31, interval=3,
+                     start_date="2026-09-01"),
+        ScheduleRule(rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=2,
+                     nth_weekday_weekday=1, start_date="2026-09-01"),
+        ScheduleRule(rule_type=RuleType.MONTHLY_WEEKDAY, nth_weekday=-1,
+                     nth_weekday_weekday=4, interval=2,
+                     start_date="2026-09-01"),
+        ScheduleRule(rule_type=RuleType.YEARLY, month=6, start_date="2026-09-01"),
+        ScheduleRule(rule_type=RuleType.YEARLY, month=2, day_of_month=None,
+                     interval=2, start_date="2026-09-01"),
+        ScheduleRule(rule_type=RuleType.CUSTOM_DAYS, weekday_set={1, 3, 5},
+                     interval=2, start_date="2026-09-01"),
+    ],
+)
+def test_to_dict_from_dict_round_trips_losslessly(rule) -> None:
+    rebuilt = ScheduleRule.from_dict(rule.to_dict())
+    assert rebuilt == rule
+    # Round-tripping twice is stable.
+    assert ScheduleRule.from_dict(rebuilt.to_dict()) == rule
+
+
+def test_from_dict_rejects_unknown_fields() -> None:
+    with pytest.raises(RuleValidationError, match="unknown rule fields"):
+        ScheduleRule.from_dict({"rule_type": "daily", "bogus": 1})
+
+
+def test_from_dict_rejects_missing_rule_type() -> None:
+    with pytest.raises(RuleValidationError, match="missing required"):
+        ScheduleRule.from_dict({"interval": 1})
+
+
+def test_from_dict_rejects_non_dict() -> None:
+    with pytest.raises(RuleValidationError):
+        ScheduleRule.from_dict("daily")
+
+
+def test_from_dict_defaults_start_date_when_absent() -> None:
+    rule = ScheduleRule.from_dict({"rule_type": "daily"})
+    assert rule.start_date == "1970-01-01"
+
+
+def test_from_dict_accepts_list_weekday_set() -> None:
+    rule = ScheduleRule.from_dict(
+        {"rule_type": RuleType.WEEKLY.value, "weekday_set": [0, 2, 4]}
+    )
+    assert rule.weekday_set == frozenset({0, 2, 4})
+
+
+# ---------------------------------------------------------------------------
+# Equality and hashing
+# ---------------------------------------------------------------------------
+
+
+def test_equal_rules_compare_equal_and_hash_equal() -> None:
+    a = _rule(rule_type=RuleType.WEEKLY, weekday_set={0, 2}, start_date="2026-09-01")
+    b = _rule(rule_type=RuleType.WEEKLY, weekday_set={2, 0}, start_date="2026-09-01")
+    assert a == b
+    assert hash(a) == hash(b)
+
+
+def test_different_rules_compare_unequal() -> None:
+    a = _rule(rule_type=RuleType.DAILY, start_date="2026-09-01")
+    b = _rule(rule_type=RuleType.DAILY, interval=2, start_date="2026-09-01")
+    assert a != b
+
+
+def test_rule_not_equal_to_other_types() -> None:
+    rule = _rule(rule_type=RuleType.DAILY, start_date="2026-09-01")
+    assert rule != "daily"
+    assert (rule == 42) is False
+
+
+# ---------------------------------------------------------------------------
+# Purity guards: no HA imports, no database access
+# ---------------------------------------------------------------------------
+
+
+def test_recurrence_module_imports_only_stdlib() -> None:
+    """The model must carry no Home Assistant and no DB imports."""
+    from pathlib import Path
+
+    source = Path(
+        __import__("custom_components.nestquest.recurrence",
+                   fromlist=["__file__"]).__file__
+    ).read_text()
+    offenders = _scan_forbidden_imports(source)
+    assert offenders == [], (
+        f"recurrence.py must not hold forbidden imports: {offenders}"
+    )
+
+
+def _scan_forbidden_imports(source: str) -> list[str]:
+    """The ACTUAL purity-guard logic, shared by the model scan and the
+    probe tests below: returns human-readable offenders (empty = clean).
+
+    Forbidden, at any relative level, for both Import and ImportFrom:
+    - modules containing 'homeassistant' or 'sqlite'
+    - modules whose LEAF name is a DB/store/schema/DAO module
+    - aliases importing a DB/store/schema/DAO module by leaf name
+      ('from . import db', 'from custom_components.nestquest import db')
+    """
+    import ast
+
+    forbidden_targets = {
+        "db", "schema", "dao_children", "dao_rules", "dao_presence",
+        "dao_instances", "migrations", "store",
+    }
+    offenders: list[str] = []
+    tree = ast.parse(source)
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                lowered = alias.name.lower()
+                leaf = lowered.split(".")[-1]
+                if (
+                    "homeassistant" in lowered
+                    or "sqlite" in lowered
+                    or leaf in forbidden_targets
+                ):
+                    offenders.append(f"import {alias.name}")
+        elif isinstance(node, ast.ImportFrom):
+            module = (node.module or "").lower()
+            module_leaf = module.split(".")[-1] if module else ""
+            if (
+                "homeassistant" in module
+                or "sqlite" in module
+                or (module and module_leaf in forbidden_targets)
+                or (node.level and module_leaf in forbidden_targets)
+            ):
+                offenders.append(
+                    f"from {node.module!r} import ... (level={node.level})"
+                )
+            for alias in node.names:
+                alias_leaf = alias.name.split(".")[-1].lower()
+                if alias_leaf in forbidden_targets:
+                    offenders.append(
+                        f"from {node.module!r} import {alias.name} "
+                        f"(level={node.level})"
+                    )
+    return offenders
+
+
+def test_purity_guard_logic_catches_probe_statements(tmp_path) -> None:
+    """The shared scan function catches every forbidden import shape,
+    including level-0 absolute package DB imports and 'from . import db'.
+    """
+    probes = [
+        "from homeassistant.core import HomeAssistant",
+        "import sqlite3",
+        "from .db import NestQuestDatabase",
+        "from custom_components.nestquest.db import NestQuestDatabase",
+        "from custom_components.nestquest import db",
+        "import custom_components.nestquest.dao_rules",
+        "from . import db",
+        "from . import schema",
+        "from custom_components.nestquest.migrations import apply_migrations",
+    ]
+    for probe in probes:
+        offenders = _scan_forbidden_imports(probe)
+        assert offenders, f"probe must be caught: {probe!r}"
+
+
+def test_non_string_rule_type_rejected() -> None:
+    """Only RuleType members and their string values construct."""
+    for bad in (123, True, None, 3.5, b"daily"):
+        with pytest.raises(RuleValidationError):
+            ScheduleRule(rule_type=bad, start_date="2026-09-01")
+
+
+def test_weekly_rejects_month_and_nth_fields() -> None:
+    with pytest.raises(RuleValidationError, match="must not set"):
+        ScheduleRule(
+            rule_type=RuleType.WEEKLY, weekday_set={0}, day_of_month=5,
+            start_date="2026-09-01",
+        )
+    with pytest.raises(RuleValidationError, match="must not set"):
+        ScheduleRule(
+            rule_type=RuleType.WEEKLY, weekday_set={0}, month=3,
+            start_date="2026-09-01",
+        )
+
+
+def test_daily_rejects_dangling_nth_weekday_weekday() -> None:
+    with pytest.raises(RuleValidationError, match="must not set"):
+        ScheduleRule(
+            rule_type=RuleType.DAILY, nth_weekday_weekday=0,
+            start_date="2026-09-01",
+        )
+
+
+def test_monthly_day_rejects_month() -> None:
+    with pytest.raises(RuleValidationError, match="must not set"):
+        ScheduleRule(
+            rule_type=RuleType.MONTHLY_DAY, day_of_month=5, month=3,
+            start_date="2026-09-01",
+        )
+
+
+def test_yearly_rejects_day_and_nth_fields() -> None:
+    with pytest.raises(RuleValidationError, match="must not set"):
+        ScheduleRule(
+            rule_type=RuleType.YEARLY, month=6, day_of_month=15,
+            start_date="2026-09-01",
+        )
+    with pytest.raises(RuleValidationError, match="must not set"):
+        ScheduleRule(
+            rule_type=RuleType.YEARLY, month=6, nth_weekday=1,
+            nth_weekday_weekday=0, start_date="2026-09-01",
+        )
+
+
+def test_storage_value_mapping() -> None:
+    """The enum exposes the schema's CHECK values via storage_value."""
+    assert RuleType.DAILY.storage_value == "daily"
+    assert RuleType.WEEKLY.storage_value == "weekly"
+    assert RuleType.MONTHLY_DAY.storage_value == "monthly"
+    assert RuleType.MONTHLY_WEEKDAY.storage_value == "monthly"
+    assert RuleType.YEARLY.storage_value == "yearly"
+    assert RuleType.CUSTOM_DAYS.storage_value == "custom"
+
+
+def test_from_dict_bool_weekday_entry_rejected_before_set_coercion() -> None:
+    """[0, False] must NOT collapse False into 0 via set() coercion."""
+    with pytest.raises(RuleValidationError, match="plain integers"):
+        ScheduleRule.from_dict(
+            {"rule_type": "weekly", "weekday_set": [0, False]}
+        )
+
+
+def test_direct_set_with_int_subclass_entry_rejected() -> None:
+    """A hashable-but-non-plain int subclass is still not a plain int."""
+
+    class IntChild(int):
+        pass
+
+    with pytest.raises(RuleValidationError, match="plain integers"):
+        ScheduleRule(
+            rule_type=RuleType.WEEKLY,
+            weekday_set={IntChild(1)},
+            start_date="2026-09-01",
+        )
+
+
+def test_from_dict_with_int_subclass_entry_rejected() -> None:
+    class IntChild(int):
+        pass
+
+    with pytest.raises(RuleValidationError, match="plain integers"):
+        ScheduleRule.from_dict(
+            {"rule_type": "weekly", "weekday_set": [IntChild(1)]}
+        )
+
+
+def test_from_dict_unknown_key_types_never_leak_typeerror() -> None:
+    """Mixed unhashable unknown keys must surface as
+    RuleValidationError, not a raw TypeError from sorting."""
+    with pytest.raises(RuleValidationError, match="unknown rule fields"):
+        ScheduleRule.from_dict({"rule_type": "daily", 42: "value"})
+
+
+def test_storage_aliases_and_whitespace_are_not_model_names() -> None:
+    """The model boundary is exact names only: storage strings, padded
+    and case variants are all rejected."""
+    for bad in ("monthly", "custom", " DAILY ", "daily ", "DAILY"):
+        with pytest.raises(RuleValidationError):
+            ScheduleRule(rule_type=bad, start_date="2026-09-01")
+
+
+def test_unhashable_int_subclass_interval_rejected() -> None:
+    class UnhashableInt(int):
+        __hash__ = None
+
+    with pytest.raises(RuleValidationError):
+        ScheduleRule(
+            rule_type=RuleType.DAILY,
+            interval=UnhashableInt(1),
+            start_date="2026-09-01",
+        )
+
+
+def test_rule_type_is_a_dataclass() -> None:
+    import dataclasses
+
+    assert dataclasses.is_dataclass(ScheduleRule)

tests/test_store.py

@@ -100,14 +100,11 @@ def test_executor_helper_creates_directory(tmp_path) -> None:
     assert nested.is_dir()
 
 
-def test_no_sqlite3_import_outside_db_module() -> None:
-    """sqlite3 is banned package-wide except db.py, the connection wrapper."""
+def test_no_sqlite3_import_in_package() -> None:
     pkg_dir = Path(store.__file__).parent
     py_files = list(pkg_dir.glob("*.py"))
     assert py_files
     for py_file in py_files:
-        if py_file.name == "db.py":
-            continue
         tree = ast.parse(py_file.read_text(encoding="utf-8"), filename=str(py_file))
         for node in ast.walk(tree):
             if isinstance(node, ast.Import):