test: isolate cwd in relative db path regression test

custom_components/nestquest/__init__.py

@@ -10,9 +10,6 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 
 from .const import DOMAIN, LOGGER
-from .db import NestQuestDatabase
-from .migrations import apply_migrations
-from .store import async_get_db_path
 
 _LOGGER = LOGGER
 
@@ -23,7 +20,6 @@ class NestQuestRuntimeData:
 
     entry_id: str
     options: dict[str, Any]
-    database: NestQuestDatabase
     remove_update_listener: Callable[[], Any]
 
 
@@ -35,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
@@ -50,18 +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:
-        await apply_migrations(database)
-        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
@@ -70,30 +50,15 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
-    domain_data = hass.data.setdefault(DOMAIN, {})
-    runtime_data = domain_data.pop(entry.entry_id, None)
-    if not domain_data:
-        hass.data.pop(DOMAIN, None)
+    runtime_data = hass.data.setdefault(DOMAIN, {}).pop(entry.entry_id, None)
     if runtime_data is None:
         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/config_flow.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 from typing import Any
 
 from homeassistant import config_entries
-from homeassistant.core import callback
 from homeassistant.data_entry_flow import FlowResult
 
 from .const import DOMAIN
@@ -15,16 +14,6 @@ class NestQuestConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
 
     VERSION = 1
 
-    @staticmethod
-    @callback
-    def async_get_options_flow(
-        config_entry: config_entries.ConfigEntry,
-    ) -> Any:
-        """Create the options flow handler for NestQuest."""
-        from .options_flow import NestQuestOptionsFlow
-
-        return NestQuestOptionsFlow(config_entry=config_entry)
-
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> FlowResult:

custom_components/nestquest/dao_children.py

@@ -1,289 +0,0 @@
-"""Typed DAO layer for the children and admin_users tables.
-
-All SQL for ``children`` and ``admin_users`` lives in this module per
-the feature guardrail: callers get typed dataclasses back and never see
-raw rows or SQL.  Every method is async and runs through
-:class:`~.db.NestQuestDatabase`, so each statement executes on the HA
-executor and the event loop never blocks.
-
-Error contract: violations surface as the underlying
-:class:`sqlite3.IntegrityError` (duplicate, foreign-key, or CHECK
-failure) from the execute call; the DAO adds no wrapping exception
-type.  A get that matches nothing returns ``None``; a mutation that
-matches nothing is reported by :class:`~.db.ExecutionResult.rowcount`,
-which each method returns where the caller may need it (reorder, and
-the admin remove/set paths).
-"""
-from __future__ import annotations
-
-import asyncio
-from dataclasses import dataclass
-
-from .db import NestQuestDatabase
-
-
-@dataclass(frozen=True)
-class ChildRecord:
-    """One row of ``children``."""
-
-    id: int
-    display_name: str
-    colour: str | None
-    avatar_ref: str | None
-    sort_order: int
-    is_active: bool
-    created_at: str
-
-
-@dataclass(frozen=True)
-class AdminUserRecord:
-    """One row of ``admin_users``."""
-
-    ha_user_id: str
-    added_at: str
-
-
-def _child_from_row(row: tuple) -> ChildRecord:
-    """Build a :class:`ChildRecord` from a SELECT row."""
-    return ChildRecord(
-        id=row[0],
-        display_name=row[1],
-        colour=row[2],
-        avatar_ref=row[3],
-        sort_order=row[4],
-        is_active=bool(row[5]),
-        created_at=row[6],
-    )
-
-
-_CHILD_COLUMNS = (
-    "id, display_name, colour, avatar_ref, sort_order, is_active, created_at"
-)
-
-
-#: One asyncio.Lock per (connection wrapper, running loop), shared by
-#: every ChildrenDao instance over the same database: the wrapper
-#: rejects a second concurrent transaction with RuntimeError, so ALL
-#: transactional DAO operations on one connection must queue here, not
-#: per-instance.  Keyed like the migration runner's lock; entries are
-#: never evicted (a config entry holds one wrapper per process).
-_CONNECTION_LOCKS: dict[tuple[int, int], asyncio.Lock] = {}
-
-
-def _connection_lock(database) -> asyncio.Lock:
-    """Return the shared transaction-serializing lock for ``database``."""
-    loop = asyncio.get_running_loop()
-    key = (id(database), id(loop))
-    lock = _CONNECTION_LOCKS.get(key)
-    if lock is None:
-        lock = asyncio.Lock()
-        _CONNECTION_LOCKS[key] = lock
-    return lock
-
-
-class ChildrenDao:
-    """Typed async data access for the ``children`` table.
-
-    Deletion is deliberately absent: children are deactivated, never
-    deleted, because completion history references them (feature
-    guardrail).
-    """
-
-    def __init__(self, database) -> None:
-        self._database = database
-
-    async def create(
-        self,
-        display_name: str,
-        created_at: str,
-        *,
-        colour: str | None = None,
-        avatar_ref: str | None = None,
-        sort_order: int = 0,
-        is_active: bool = True,
-    ) -> ChildRecord:
-        """Insert one child and return the record as stored."""
-        result = await self._database.execute(
-            "INSERT INTO children (display_name, colour, avatar_ref, "
-            "sort_order, is_active, created_at) VALUES (?, ?, ?, ?, ?, ?)",
-            (
-                display_name,
-                colour,
-                avatar_ref,
-                sort_order,
-                int(is_active),
-                created_at,
-            ),
-        )
-        child = await self.get(result.lastrowid)
-        assert child is not None
-        return child
-
-    async def get(self, child_id: int) -> ChildRecord | None:
-        """Return the child with ``child_id``, or None."""
-        row = await self._database.fetch_one(
-            f"SELECT {_CHILD_COLUMNS} FROM children WHERE id = ?",
-            (child_id,),
-        )
-        return _child_from_row(row) if row is not None else None
-
-    async def list_active(self) -> list[ChildRecord]:
-        """Return active children ordered by sort_order, then id."""
-        rows = await self._database.fetch_all(
-            f"SELECT {_CHILD_COLUMNS} FROM children WHERE is_active = 1 "
-            "ORDER BY sort_order, id"
-        )
-        return [_child_from_row(row) for row in rows]
-
-    async def list_all(self) -> list[ChildRecord]:
-        """Return all children ordered by sort_order, then id."""
-        rows = await self._database.fetch_all(
-            f"SELECT {_CHILD_COLUMNS} FROM children "
-            "ORDER BY sort_order, id"
-        )
-        return [record for record in map(_child_from_row, rows)]
-
-    async def update(
-        self,
-        child_id: int,
-        *,
-        display_name: str | None = None,
-        colour: str | None = None,
-        avatar_ref: str | None = None,
-        sort_order: int | None = None,
-    ) -> int:
-        """Update the given fields; returns rows updated (0 if absent).
-
-        Only non-None arguments are written, so a caller cannot
-        accidentally blank a column by omitting it.
-        """
-        assignments: list[str] = []
-        parameters: list[object] = []
-        if display_name is not None:
-            assignments.append("display_name = ?")
-            parameters.append(display_name)
-        if colour is not None:
-            assignments.append("colour = ?")
-            parameters.append(colour)
-        if avatar_ref is not None:
-            assignments.append("avatar_ref = ?")
-            parameters.append(avatar_ref)
-        if sort_order is not None:
-            assignments.append("sort_order = ?")
-            parameters.append(sort_order)
-        if not assignments:
-            return 0
-        parameters.append(child_id)
-        result = await self._database.execute(
-            f"UPDATE children SET {', '.join(assignments)} WHERE id = ?",
-            tuple(parameters),
-        )
-        return result.rowcount
-
-    async def set_active(self, child_id: int, is_active: bool) -> int:
-        """Set the child's active flag; returns rows updated (0 if absent)."""
-        result = await self._database.execute(
-            "UPDATE children SET is_active = ? WHERE id = ?",
-            (int(is_active), child_id),
-        )
-        return result.rowcount
-
-    async def reorder(self, ordered_ids: list[int]) -> None:
-        """Persist a new sort order: ``ordered_ids[i]`` gets sort_order i.
-
-        Runs inside one transaction; positions are staged at offset
-        -len (all negative, so any permutation of the same ids never
-        collides mid-reorder under the wrapper's single-connection
-        serialization), then finalized 0..n-1.  Duplicate ids are
-        rejected up front: they cannot all hold distinct positions, and
-        silently assigning the last occurrence's index would hide a
-        caller bug.
-
-        Concurrent reorder() calls on one connection are serialized by
-        a connection-scoped asyncio lock (shared across every ChildrenDao
-        over the same wrapper, however many instances): the wrapper's
-        transaction() rejects a second concurrent transaction with
-        RuntimeError, so racing callers would crash instead of
-        queueing.  The lock makes the second call wait, then run
-        against the first call's final state.
-        """
-        if not ordered_ids:
-            return
-        if len(set(ordered_ids)) != len(ordered_ids):
-            raise ValueError(
-                "reorder() received duplicate child ids; every id must "
-                "appear at most once"
-            )
-        async with _connection_lock(self._database):
-            async with self._database.transaction():
-                offset = len(ordered_ids)
-                await self._database.execute_many(
-                    "UPDATE children SET sort_order = ? WHERE id = ?",
-                    [
-                        (-(offset + index), child_id)
-                        for index, child_id in enumerate(ordered_ids)
-                    ],
-                )
-                await self._database.execute_many(
-                    "UPDATE children SET sort_order = ? WHERE id = ?",
-                    [
-                        (index, child_id)
-                        for index, child_id in enumerate(ordered_ids)
-                    ],
-                )
-
-
-class AdminUsersDao:
-    """Typed async access to the ``admin_users`` allowlist.
-
-    The allowlist stores HA user IDs, never usernames (feature
-    guardrail); an empty allowlist means no admin, enforced by callers
-    resolving through :meth:`exists`.
-    """
-
-    def __init__(self, database) -> None:
-        self._database = database
-
-    async def add(self, ha_user_id: str, added_at: str) -> bool:
-        """Add a user to the allowlist; True if inserted, False if present.
-
-        Idempotent under concurrency: a single INSERT ... ON CONFLICT DO
-        NOTHING decides and inserts in one statement (the wrapper
-        serializes statements, not check-then-insert sequences, so a
-        SELECT/INSERT pair would let two concurrent adds both see no
-        row and the second one raise IntegrityError).  rowcount reports
-        whether the insert actually happened.
-        """
-        result = await self._database.execute(
-            "INSERT INTO admin_users (ha_user_id, added_at) VALUES (?, ?) "
-            "ON CONFLICT (ha_user_id) DO NOTHING",
-            (ha_user_id, added_at),
-        )
-        return result.rowcount > 0
-
-    async def remove(self, ha_user_id: str) -> bool:
-        """Remove a user from the allowlist; True if a row was removed."""
-        result = await self._database.execute(
-            "DELETE FROM admin_users WHERE ha_user_id = ?",
-            (ha_user_id,),
-        )
-        return result.rowcount > 0
-
-    async def list(self) -> list[AdminUserRecord]:
-        """Return every allowlisted user, oldest first."""
-        rows = await self._database.fetch_all(
-            "SELECT ha_user_id, added_at FROM admin_users "
-            "ORDER BY added_at, ha_user_id"
-        )
-        return [
-            AdminUserRecord(ha_user_id=row[0], added_at=row[1])
-            for row in rows
-        ]
-
-    async def exists(self, ha_user_id: str) -> bool:
-        """Return True if ``ha_user_id`` is allowlisted."""
-        row = await self._database.fetch_one(
-            "SELECT 1 FROM admin_users WHERE ha_user_id = ?",
-            (ha_user_id,),
-        )
-        return row is not None

custom_components/nestquest/dao_instances.py

@@ -1,542 +0,0 @@
-"""Typed DAO layer for task_instances and the append-only completion_events.
-
-All SQL for these tables lives in this module per the feature
-guardrails: callers get typed dataclasses back and never see raw rows
-or SQL.  Every method is async and runs through
-:class:`~.db.NestQuestDatabase`, so each statement executes on the HA
-executor and the event loop never blocks.
-
-Append-only policy (Feature 08, D-005): ``completion_events`` is
-strictly append-only.  This module is where that property is enforced
-mechanically — the completion-events DAO below exposes NO update or
-delete method at all; completions append, un-completions append a
-separate reversal event, and instance state derives from the latest
-event.  A package-wide guard test (bottom of the test module) keeps
-mutation SQL for this table out of every other module.
-
-Upsert semantics: ``TaskInstancesDao.upsert`` is idempotent on
-(definition_id, due_date) — re-running materialization for a date
-whose instance already exists updates nothing that matters
-(child_id/due_time are refreshed only in the degenerate re-generation
-case where they changed) and never duplicates a row.  The schema's
-UNIQUE(definition_id, due_date) is the last line of defense.
-
-``delete_future_uncompleted`` implements the Feature 06/07 rule that
-reassignment and schedule edits regenerate future instances: it
-removes only instances at or after the cutoff that have NO completion
-event, inside one transaction, so an instance completed mid-call can
-never be deleted.  Instances in the past are never touched (Feature 07
-guardrail: never delete history), and no method here deletes a single
-instance that has a completion event.
-"""
-from __future__ import annotations
-
-import datetime
-from dataclasses import dataclass
-
-from .dao_children import _connection_lock
-from .dao_rules import _validate_date
-from .db import NestQuestDatabase
-
-#: Timestamp policy for completion_events.occurred_at: strict UTC
-#: ISO-8601 with explicit '+00:00' offset (module timestamp policy).
-#: One accepted shape bounds lexicographic range queries correctly, so
-#: the occurred-at scope does not guess at timestamp spellings.
-_UTC_TIMESTAMP_FORMAT = "%Y-%m-%dT%H:%M:%S+00:00"
-
-
-def _validate_utc_timestamp(value: str, field: str) -> None:
-    """Raise ValueError unless ``value`` is a strict UTC ISO-8601 stamp.
-
-    Same strictness policy as _validate_date: parse with the exact
-    format, then round-trip the parsed value against the input so
-    non-padded or re-ordered shapes are rejected.  The round-trip
-    strips the UTC offset (isoformat() omits it when the offset is
-    zero), so the suffix is appended before comparing.
-    """
-    try:
-        parsed = datetime.datetime.strptime(
-            value, _UTC_TIMESTAMP_FORMAT
-        )
-    except (TypeError, ValueError):
-        raise ValueError(
-            f"{field} must be a UTC ISO-8601 timestamp "
-            f"(YYYY-MM-DDTHH:MM:SS+00:00), got {value!r}"
-        ) from None
-    if parsed.isoformat() + "+00:00" != value:
-        raise ValueError(
-            f"{field} must be a strict UTC timestamp "
-            f"(YYYY-MM-DDTHH:MM:SS+00:00), got {value!r}"
-        )
-
-
-def _next_day_start(date_str: str) -> str:
-    """Return the UTC timestamp one second past ``date_str``'s last second.
-
-    Gives range queries an exact half-open upper bound without
-    fractional-second guessing.
-    """
-    day = datetime.date.fromisoformat(date_str)
-    next_day = day + datetime.timedelta(days=1)
-    return f"{next_day.isoformat()}T00:00:00+00:00"
-
-
-@dataclass(frozen=True)
-class TaskInstanceRecord:
-    """One row of ``task_instances``."""
-
-    id: int
-    definition_id: int
-    child_id: int
-    due_date: str
-    due_time: str | None
-    generated_at: str
-
-
-@dataclass(frozen=True)
-class CompletionEventRecord:
-    """One row of ``completion_events`` (append-only table)."""
-
-    id: int
-    instance_id: int
-    child_id: int
-    event_type: str
-    actor_source: str
-    actor_user_id: str | None
-    occurred_at: str
-    was_on_time: bool | None
-
-
-_INSTANCE_COLUMNS = (
-    "id, definition_id, child_id, due_date, due_time, generated_at"
-)
-_EVENT_COLUMNS = (
-    "id, instance_id, child_id, event_type, actor_source, actor_user_id, "
-    "occurred_at, was_on_time"
-)
-
-#: The only event types the append path accepts; the schema CHECK is
-#: the backstop, this is the DAO's typed front door.
-EVENT_COMPLETED = "completed"
-EVENT_UNCOMPLETED = "uncompleted"
-
-
-def _instance_from_row(row: tuple) -> TaskInstanceRecord:
-    return TaskInstanceRecord(
-        id=row[0],
-        definition_id=row[1],
-        child_id=row[2],
-        due_date=row[3],
-        due_time=row[4],
-        generated_at=row[5],
-    )
-
-
-def _event_from_row(row: tuple) -> CompletionEventRecord:
-    return CompletionEventRecord(
-        id=row[0],
-        instance_id=row[1],
-        child_id=row[2],
-        event_type=row[3],
-        actor_source=row[4],
-        actor_user_id=row[5],
-        occurred_at=row[6],
-        was_on_time=None if row[7] is None else bool(row[7]),
-    )
-
-
-class TaskInstancesDao:
-    """Typed async access to the ``task_instances`` table."""
-
-    def __init__(self, database: NestQuestDatabase) -> None:
-        self._database = database
-
-    async def upsert(
-        self,
-        definition_id: int,
-        child_id: int,
-        due_date: str,
-        generated_at: str,
-        *,
-        due_time: str | None = None,
-    ) -> TaskInstanceRecord:
-        """Create the dated instance for (definition_id, due_date) idempotently.
-
-        Running materialization twice for the same definition/date
-        yields ONE row: the ON CONFLICT path refreshes the
-        generation-time snapshot columns (child_id, due_time) and
-        regenerates the stamp, but can never create a duplicate — the
-        schema UNIQUE(definition_id, due_date) backs this up.
-
-        Guardrails enforced here:
-
-        - ``due_date`` must be TODAY or later: instances are never
-          generated in the past (Feature 07).  The caller's
-          materialization horizon is future-dated by definition.
-        - An existing instance WITH a completion event is IMMUTABLE:
-          the conflict path must not rewrite its snapshot columns
-          (Feature 07/08).  The upsert refuses with ValueError in that
-          case — silently no-oping would mask a materialization bug.
-
-        The definition must exist (validated atomically under the
-        connection lock so a concurrent definition deactivation or
-        child deletion cannot slip between check and insert).
-        """
-        _validate_date(due_date, "due_date")
-        # Fail fast on obviously-past dates BEFORE queuing on the
-        # connection lock (a nice early error); the AUTHORITATIVE
-        # check runs after the lock is acquired, because a caller can
-        # wait on the lock across midnight — a date that was "today"
-        # at call time may be "yesterday" by the time the INSERT runs.
-        today = datetime.date.today().isoformat()
-        if due_date < today:
-            raise ValueError(
-                f"instances are never generated in the past: due_date "
-                f"{due_date!r} is before today {today!r}"
-            )
-        async with _connection_lock(self._database):
-            async with self._database.transaction():
-                # Re-read "today" under the lock: this is the date the
-                # insert actually executes on, so the no-past rule
-                # holds across midnight rollovers.
-                today = datetime.date.today().isoformat()
-                if due_date < today:
-                    raise ValueError(
-                        f"instances are never generated in the past: "
-                        f"due_date {due_date!r} is before today "
-                        f"{today!r}"
-                    )
-                definition = await self._database.fetch_one(
-                    "SELECT child_id FROM task_definitions WHERE id = ?",
-                    (definition_id,),
-                )
-                if definition is None:
-                    raise ValueError(
-                        f"task definition {definition_id} does not exist"
-                    )
-                if definition[0] != child_id:
-                    raise ValueError(
-                        f"task definition {definition_id} is assigned to "
-                        f"child {definition[0]}, not {child_id}; instance "
-                        "must carry the definition's assignee"
-                    )
-                child = await self._database.fetch_one(
-                    "SELECT 1 FROM children WHERE id = ?", (child_id,)
-                )
-                if child is None:
-                    raise ValueError(f"child {child_id} does not exist")
-                existing = await self._database.fetch_one(
-                    "SELECT 1 FROM completion_events "
-                    "WHERE instance_id = (SELECT id FROM task_instances "
-                    "WHERE definition_id = ? AND due_date = ?)",
-                    (definition_id, due_date),
-                )
-                if existing is not None:
-                    raise ValueError(
-                        f"instance for (definition {definition_id}, "
-                        f"due_date {due_date!r}) already has a completion "
-                        "event and is immutable; it cannot be regenerated"
-                    )
-                await self._database.execute(
-                    "INSERT INTO task_instances (definition_id, child_id, "
-                    "due_date, due_time, generated_at) "
-                    "VALUES (?, ?, ?, ?, ?) "
-                    "ON CONFLICT (definition_id, due_date) DO UPDATE SET "
-                    "child_id = excluded.child_id, "
-                    "due_time = excluded.due_time, "
-                    "generated_at = excluded.generated_at",
-                    (
-                        definition_id,
-                        child_id,
-                        due_date,
-                        due_time,
-                        generated_at,
-                    ),
-                )
-                instance = await self.get(definition_id, due_date)
-        assert instance is not None
-        return instance
-
-    async def get(
-        self, definition_id: int, due_date: str
-    ) -> TaskInstanceRecord | None:
-        """Return the instance for (definition_id, due_date), or None."""
-        row = await self._database.fetch_one(
-            f"SELECT {_INSTANCE_COLUMNS} FROM task_instances "
-            "WHERE definition_id = ? AND due_date = ?",
-            (definition_id, due_date),
-        )
-        return _instance_from_row(row) if row is not None else None
-
-    async def get_by_id(self, instance_id: int) -> TaskInstanceRecord | None:
-        """Return the instance with ``instance_id``, or None."""
-        row = await self._database.fetch_one(
-            f"SELECT {_INSTANCE_COLUMNS} FROM task_instances WHERE id = ?",
-            (instance_id,),
-        )
-        return _instance_from_row(row) if row is not None else None
-
-    async def list_by_child_and_date(
-        self, child_id: int, due_date: str
-    ) -> list[TaskInstanceRecord]:
-        """Return the child's instances due exactly on ``due_date``."""
-        _validate_date(due_date, "due_date")
-        rows = await self._database.fetch_all(
-            f"SELECT {_INSTANCE_COLUMNS} FROM task_instances "
-            "WHERE child_id = ? AND due_date = ? ORDER BY id",
-            (child_id, due_date),
-        )
-        return [_instance_from_row(row) for row in rows]
-
-    async def list_by_date_range(
-        self,
-        child_id: int,
-        range_start: str,
-        range_end: str,
-    ) -> list[TaskInstanceRecord]:
-        """Return the child's instances with due_date in the closed range."""
-        _validate_date(range_start, "range_start")
-        _validate_date(range_end, "range_end")
-        if range_end < range_start:
-            raise ValueError(
-                "range_end must be on or after range_start, got "
-                f"{range_end!r} < {range_start!r}"
-            )
-        rows = await self._database.fetch_all(
-            f"SELECT {_INSTANCE_COLUMNS} FROM task_instances "
-            "WHERE child_id = ? AND due_date >= ? AND due_date <= ? "
-            "ORDER BY due_date, id",
-            (child_id, range_start, range_end),
-        )
-        return [_instance_from_row(row) for row in rows]
-
-    async def delete_future_uncompleted(
-        self, definition_id: int, cutoff_date: str
-    ) -> int:
-        """Delete the definition's open instances at/after cutoff.
-
-        Implements regeneration after a definition edit or reassignment
-        (Features 06/07): only instances at or after the cutoff with NO
-        completion event are removed, inside one transaction — an
-        instance that gains a completion event mid-flight cannot be
-        deleted.  The cutoff cannot be backdated below today: "future"
-        is measured against TODAY (materialization regenerates the
-        rolling horizon from now), so a caller cannot use this to
-        rewrite past open instances either — the day-rollover missed
-        sweep (Feature 11) handles past-due instances instead.  Any
-        instance with a completion event is never touched, regardless
-        of its date.  Returns the number deleted.
-        """
-        _validate_date(cutoff_date, "cutoff_date")
-        async with _connection_lock(self._database):
-            async with self._database.transaction():
-                # "today" is read under the lock: the DELETE actually
-                # executes on this date, so a caller queued across
-                # midnight cannot delete instances that became past
-                # while it waited (backdating is clamped to the
-                # execution date, not the call date).
-                today = datetime.date.today().isoformat()
-                effective_cutoff = max(cutoff_date, today)
-                result = await self._database.execute(
-                    "DELETE FROM task_instances WHERE definition_id = ? "
-                    "AND due_date >= ? AND NOT EXISTS ("
-                    "  SELECT 1 FROM completion_events "
-                    "  WHERE instance_id = task_instances.id"
-                    ")",
-                    (definition_id, effective_cutoff),
-                )
-        return result.rowcount
-
-
-class CompletionEventsDao:
-    """Typed append-only access to the ``completion_events`` table.
-
-    APPEND-ONLY BY CONSTRUCTION: this class exposes ``append`` and the
-    three read methods below, and NOTHING else.  There is no update,
-    no delete, no upsert — completions and un-completions both arrive
-    through :meth:`append` as new rows, and history is immutable
-    (Feature 08 done-condition: no code path updates or deletes an
-    event).  The package-wide leak-guard test additionally fails if
-    mutation SQL for this table ever appears in any module.
-    """
-
-    def __init__(self, database: NestQuestDatabase) -> None:
-        self._database = database
-
-    async def append(
-        self,
-        instance_id: int,
-        child_id: int,
-        event_type: str,
-        actor_source: str,
-        occurred_at: str,
-        was_on_time: bool | None,
-        *,
-        actor_user_id: str | None = None,
-    ) -> CompletionEventRecord:
-        """Append one completion or un-completion event.
-
-        ``actor_source`` is 'user' (with ``actor_user_id`` set) or
-        'panel' (no user id — the tapped child is ``child_id``); the
-        actor-pair CHECK enforces this shape at the schema level.
-        ``occurred_at`` must be the module's one strict UTC shape
-        (YYYY-MM-DDTHH:MM:SS+00:00) so lexicographic range queries
-        stay exact.  ``was_on_time`` is required (True/False) for
-        completions; for un-completions it may be None or the reversed
-        completion's flag (Feature 08 still deciding).  The instance
-        and child must exist — validated atomically under the
-        connection lock.
-        """
-        if event_type not in (EVENT_COMPLETED, EVENT_UNCOMPLETED):
-            raise ValueError(
-                f"event_type must be '{EVENT_COMPLETED}' or "
-                f"'{EVENT_UNCOMPLETED}', got {event_type!r}"
-            )
-        if actor_source not in ("user", "panel"):
-            raise ValueError(
-                f"actor_source must be 'user' or 'panel', got "
-                f"{actor_source!r}"
-            )
-        if actor_source == "user" and not actor_user_id:
-            raise ValueError(
-                "actor_source 'user' requires actor_user_id"
-            )
-        if actor_source == "panel" and actor_user_id is not None:
-            raise ValueError(
-                "actor_source 'panel' must not carry actor_user_id"
-            )
-        if was_on_time is not None and type(was_on_time) is not bool:
-            raise ValueError(
-                f"was_on_time must be True, False or None, got "
-                f"{was_on_time!r}"
-            )
-        if event_type == EVENT_COMPLETED and was_on_time is None:
-            raise ValueError(
-                "a completed event requires was_on_time (True/False)"
-            )
-        _validate_utc_timestamp(occurred_at, "occurred_at")
-        async with _connection_lock(self._database):
-            async with self._database.transaction():
-                instance = await self._database.fetch_one(
-                    "SELECT child_id FROM task_instances WHERE id = ?",
-                    (instance_id,),
-                )
-                if instance is None:
-                    raise ValueError(
-                        f"task instance {instance_id} does not exist"
-                    )
-                if instance[0] != child_id:
-                    raise ValueError(
-                        f"task instance {instance_id} belongs to child "
-                        f"{instance[0]}, not {child_id}"
-                    )
-                child = await self._database.fetch_one(
-                    "SELECT 1 FROM children WHERE id = ?", (child_id,)
-                )
-                if child is None:
-                    raise ValueError(f"child {child_id} does not exist")
-                result = await self._database.execute(
-                    "INSERT INTO completion_events (instance_id, child_id, "
-                    "event_type, actor_source, actor_user_id, occurred_at, "
-                    "was_on_time) VALUES (?, ?, ?, ?, ?, ?, ?)",
-                    (
-                        instance_id,
-                        child_id,
-                        event_type,
-                        actor_source,
-                        actor_user_id,
-                        occurred_at,
-                        None if was_on_time is None else int(was_on_time),
-                    ),
-                )
-                event = await self._database.fetch_one(
-                    f"SELECT {_EVENT_COLUMNS} FROM completion_events "
-                    "WHERE id = ?",
-                    (result.lastrowid,),
-                )
-        assert event is not None
-        return _event_from_row(event)
-
-    async def list_by_instance(
-        self, instance_id: int
-    ) -> list[CompletionEventRecord]:
-        """Return every event for the instance, in append order."""
-        rows = await self._database.fetch_all(
-            f"SELECT {_EVENT_COLUMNS} FROM completion_events "
-            "WHERE instance_id = ? ORDER BY id",
-            (instance_id,),
-        )
-        return [_event_from_row(row) for row in rows]
-
-    async def list_by_child_and_date_range(
-        self,
-        child_id: int,
-        range_start: str,
-        range_end: str,
-        *,
-        due_date_scope: bool = True,
-    ) -> list[CompletionEventRecord]:
-        """Return the child's events for instances due in the closed range.
-
-        Scopes by the INSTANCE's due date (the day the task was owed),
-        not the event's wall-clock timestamp: history reporting asks
-        "what happened to the tasks due that day" (Feature 13).  Set
-        ``due_date_scope=False`` to filter by ``occurred_at`` date
-        instead.  Ordered by instance, then event id.
-        """
-        _validate_date(range_start, "range_start")
-        _validate_date(range_end, "range_end")
-        if range_end < range_start:
-            raise ValueError(
-                "range_end must be on or after range_start, got "
-                f"{range_end!r} < {range_start!r}"
-            )
-        if due_date_scope:
-            predicate = (
-                "SELECT id FROM task_instances WHERE child_id = ? "
-                "AND due_date >= ? AND due_date <= ?"
-            )
-            parameters: list[object] = [child_id, range_start, range_end]
-        else:
-            # Occurred-at scope: occurred_at is validated to the one
-            # accepted UTC shape at append time, so half-open day
-            # bounds in that same shape are exact (no spelling drift).
-            occurred_start = f"{range_start}T00:00:00+00:00"
-            occurred_end = f"{range_end}T23:59:59+00:00"
-            query = (
-                f"SELECT {_EVENT_COLUMNS} FROM completion_events "
-                "WHERE child_id = ? AND occurred_at >= ? "
-                "AND occurred_at < ? ORDER BY instance_id, id"
-            )
-            rows = await self._database.fetch_all(
-                query,
-                [
-                    child_id,
-                    occurred_start,
-                    _next_day_start(range_end),
-                ],
-            )
-            return [_event_from_row(row) for row in rows]
-        rows = await self._database.fetch_all(
-            f"SELECT {_EVENT_COLUMNS} FROM completion_events "
-            f"WHERE instance_id IN ({predicate}) "
-            "ORDER BY instance_id, id",
-            tuple(parameters),
-        )
-        return [_event_from_row(row) for row in rows]
-
-    async def get_latest_for_instance(
-        self, instance_id: int
-    ) -> CompletionEventRecord | None:
-        """Return the instance's most recent event, or None if untouched.
-
-        Instance current state derives from this event (Feature 08):
-        'completed' means done, 'uncompleted' as the latest means open
-        again, None means never completed.
-        """
-        row = await self._database.fetch_one(
-            f"SELECT {_EVENT_COLUMNS} FROM completion_events "
-            "WHERE instance_id = ? ORDER BY id DESC LIMIT 1",
-            (instance_id,),
-        )
-        return _event_from_row(row) if row is not None else None

custom_components/nestquest/dao_presence.py

@@ -1,247 +0,0 @@
-"""Typed DAO layer for the presence_schedules and presence_overrides tables.
-
-All SQL for these tables lives in this module per the feature
-guardrails: callers get typed dataclasses back and never see raw rows
-or SQL.  Every method is async and runs through
-:class:`~.db.NestQuestDatabase`, so each statement executes on the HA
-executor and the event loop never blocks.
-
-Semantics per the done-condition and Feature 05:
-
-- A child has AT MOST ONE presence schedule (schema UNIQUE); upserting
-  by child updates the existing row rather than raising.
-- A child with NO schedule row is present every day — the absence of a
-  row is meaningful state, expressed by :meth:`PresenceSchedulesDao.get_by_child`
-  returning None, never by an empty pattern row.
-- Overrides beat the pattern for their date range (that resolution is
-  the presence engine's job, Feature 05); the DAO only stores and
-  lists them.  A single-day override stores the same date as both
-  start and end (schema CHECK requires end >= start).
-
-Date arguments are validated as strict YYYY-MM-DD per the same policy
-the rules DAO applies: the schema's lexical CHECKs cannot prove
-calendar validity.
-"""
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from .dao_children import _connection_lock
-from .dao_rules import _UNSET, _validate_date
-from .db import NestQuestDatabase
-
-
-@dataclass(frozen=True)
-class PresenceScheduleRecord:
-    """One row of ``presence_schedules``."""
-
-    id: int
-    child_id: int
-    cycle_length_weeks: int
-    anchor_date: str
-    pattern: str
-
-
-@dataclass(frozen=True)
-class PresenceOverrideRecord:
-    """One row of ``presence_overrides``."""
-
-    id: int
-    child_id: int
-    start_date: str
-    end_date: str
-    is_present: bool
-    note: str | None
-
-
-_SCHEDULE_COLUMNS = (
-    "id, child_id, cycle_length_weeks, anchor_date, pattern"
-)
-_OVERRIDE_COLUMNS = (
-    "id, child_id, start_date, end_date, is_present, note"
-)
-
-
-def _schedule_from_row(row: tuple) -> PresenceScheduleRecord:
-    return PresenceScheduleRecord(
-        id=row[0],
-        child_id=row[1],
-        cycle_length_weeks=row[2],
-        anchor_date=row[3],
-        pattern=row[4],
-    )
-
-
-def _override_from_row(row: tuple) -> PresenceOverrideRecord:
-    return PresenceOverrideRecord(
-        id=row[0],
-        child_id=row[1],
-        start_date=row[2],
-        end_date=row[3],
-        is_present=bool(row[4]),
-        note=row[5],
-    )
-
-
-class PresenceSchedulesDao:
-    """Typed async access to the ``presence_schedules`` table."""
-
-    def __init__(self, database: NestQuestDatabase) -> None:
-        self._database = database
-
-    async def upsert_by_child(
-        self,
-        child_id: int,
-        cycle_length_weeks: int,
-        anchor_date: str,
-        pattern: str,
-    ) -> PresenceScheduleRecord:
-        """Set the child's presence schedule, replacing any existing one.
-
-        Upsert semantics are the done-condition: a second schedule for
-        the same child updates the existing row rather than raising.
-        Runs under the connection lock so a concurrent upsert/delete
-        for the same child serializes instead of colliding on the
-        schema's UNIQUE(child_id).  Pattern validity (segment shape,
-        segment count = cycle_length_weeks) is enforced by the schema
-        CHECKs; the child must exist (FK) — validated atomically here
-        so a deleted child cannot pass a stale check.
-        """
-        _validate_date(anchor_date, "anchor_date")
-        async with _connection_lock(self._database):
-            async with self._database.transaction():
-                child = await self._database.fetch_one(
-                    "SELECT 1 FROM children WHERE id = ?", (child_id,)
-                )
-                if child is None:
-                    raise ValueError(f"child {child_id} does not exist")
-                await self._database.execute(
-                    "INSERT INTO presence_schedules (child_id, "
-                    "cycle_length_weeks, anchor_date, pattern) "
-                    "VALUES (?, ?, ?, ?) "
-                    "ON CONFLICT (child_id) DO UPDATE SET "
-                    "cycle_length_weeks = excluded.cycle_length_weeks, "
-                    "anchor_date = excluded.anchor_date, "
-                    "pattern = excluded.pattern",
-                    (child_id, cycle_length_weeks, anchor_date, pattern),
-                )
-                schedule = await self.get_by_child(child_id)
-        assert schedule is not None
-        return schedule
-
-    async def get_by_child(
-        self, child_id: int
-    ) -> PresenceScheduleRecord | None:
-        """Return the child's schedule, or None when the child has none.
-
-        None is meaningful and UNAMBIGUOUS here: the child exists and
-        has no schedule row, i.e. the child is present every day
-        (Feature 05 guardrail).  An unknown child id raises ValueError
-        instead of returning None, because "nonexistent child" must
-        never be silently read as "present every day".
-        """
-        child = await self._database.fetch_one(
-            "SELECT 1 FROM children WHERE id = ?", (child_id,)
-        )
-        if child is None:
-            raise ValueError(f"child {child_id} does not exist")
-        row = await self._database.fetch_one(
-            f"SELECT {_SCHEDULE_COLUMNS} FROM presence_schedules "
-            "WHERE child_id = ?",
-            (child_id,),
-        )
-        return _schedule_from_row(row) if row is not None else None
-
-    async def delete(self, child_id: int) -> bool:
-        """Remove the child's schedule; True if a row was removed.
-
-        After deletion the child is present every day (no row means
-        no restriction).  Deleting a schedule the child never had
-        returns False.
-        """
-        result = await self._database.execute(
-            "DELETE FROM presence_schedules WHERE child_id = ?",
-            (child_id,),
-        )
-        return result.rowcount > 0
-
-
-class PresenceOverridesDao:
-    """Typed async access to the ``presence_overrides`` table."""
-
-    def __init__(self, database: NestQuestDatabase) -> None:
-        self._database = database
-
-    async def create(
-        self,
-        child_id: int,
-        start_date: str,
-        end_date: str,
-        is_present: bool,
-        *,
-        note: str | None = None,
-    ) -> PresenceOverrideRecord:
-        """Insert one override and return the record as stored.
-
-        The child must exist (validated atomically under the
-        connection lock).  Date shape is validated strictly, and the
-        schema CHECK rejects end < start.
-        """
-        _validate_date(start_date, "start_date")
-        _validate_date(end_date, "end_date")
-        async with _connection_lock(self._database):
-            async with self._database.transaction():
-                child = await self._database.fetch_one(
-                    "SELECT 1 FROM children WHERE id = ?", (child_id,)
-                )
-                if child is None:
-                    raise ValueError(f"child {child_id} does not exist")
-                result = await self._database.execute(
-                    "INSERT INTO presence_overrides (child_id, "
-                    "start_date, end_date, is_present, note) "
-                    "VALUES (?, ?, ?, ?, ?)",
-                    (child_id, start_date, end_date, int(is_present), note),
-                )
-                override = await self._database.fetch_one(
-                    f"SELECT {_OVERRIDE_COLUMNS} FROM presence_overrides "
-                    "WHERE id = ?",
-                    (result.lastrowid,),
-                )
-        assert override is not None
-        return _override_from_row(override)
-
-    async def list_by_child_and_range(
-        self,
-        child_id: int,
-        range_start: str,
-        range_end: str,
-    ) -> list[PresenceOverrideRecord]:
-        """Return the child's overrides overlapping [range_start, range_end].
-
-        An override overlaps the range when it ends on or after the
-        range starts and starts on or before the range ends (inclusive
-        boundary dates, matching the storage model where overrides are
-        closed date ranges).  Ordered by start date.
-        """
-        _validate_date(range_start, "range_start")
-        _validate_date(range_end, "range_end")
-        if range_end < range_start:
-            raise ValueError(
-                "range_end must be on or after range_start, got "
-                f"{range_end!r} < {range_start!r}"
-            )
-        rows = await self._database.fetch_all(
-            f"SELECT {_OVERRIDE_COLUMNS} FROM presence_overrides "
-            "WHERE child_id = ? AND end_date >= ? AND start_date <= ? "
-            "ORDER BY start_date",
-            (child_id, range_start, range_end),
-        )
-        return [_override_from_row(row) for row in rows]
-
-    async def delete(self, override_id: int) -> bool:
-        """Remove one override by id; True if a row was removed."""
-        result = await self._database.execute(
-            "DELETE FROM presence_overrides WHERE id = ?",
-            (override_id,),
-        )
-        return result.rowcount > 0

custom_components/nestquest/dao_rules.py

@@ -1,465 +0,0 @@
-"""Typed DAO layer for the schedule_rules and task_definitions tables.
-
-All SQL for ``schedule_rules`` and ``task_definitions`` lives in this
-module per the feature guardrails: callers get typed dataclasses back
-and never see raw rows or SQL.  Every method is async and runs through
-:class:`~.db.NestQuestDatabase`, so each statement executes on the HA
-executor and the event loop never blocks.
-
-Guardrail mapping:
-
-- ``schedule_rules`` deletion is delete-if-unreferenced: a rule still
-  referenced by any task definition is rejected (the done-condition),
-  not cascaded.
-- ``task_definitions`` has no delete path at all: definitions are
-  deactivated, never hard-deleted, and history must survive.
-- ``set_assignee`` changes future instances only — the DAO writes the
-  definition row and nothing else; reassignment never rewrites
-  existing instances or completion history (Feature 06 guardrail).
-- Validation of rule well-formedness and child activeness lives partly
-  in the schema CHECKs (rule-type coherence) and partly in
-  :meth:`TaskDefinitionsDao.create` (active child, rule existence);
-  no permission checks here, that is the Feature 09 gate's job.
-
-Concurrency: ``delete_rule_if_unreferenced`` performs its reference
-check and DELETE inside one transaction under the connection-scoped
-lock shared with :mod:`.dao_children`, so a definition referencing the
-rule cannot appear between check and delete on this connection.
-"""
-from __future__ import annotations
-
-import datetime
-from dataclasses import dataclass
-
-from .dao_children import _connection_lock
-from .db import NestQuestDatabase
-
-#: Sentinel distinguishing "argument omitted" from "explicit SQL NULL"
-#: in update methods: passing ``None`` must mean clearing a nullable
-#: column, not skipping it.
-_UNSET = object()
-
-#: Date-shape policy: schedule-rule dates are ISO YYYY-MM-DD.  The
-#: schema's lexical end>=start CHECK cannot prove a value is a real
-#: calendar date, so the DAO validates the shape it accepts.
-_DATE_FORMAT = "%Y-%m-%d"
-
-
-def _validate_date(value: str, field: str) -> None:
-    """Raise ValueError unless ``value`` is a YYYY-MM-DD calendar date.
-
-    ``datetime.date.fromisoformat`` accepts ISO dates but is lenient on
-    some builds (e.g. '2026-9-4'); strptime with an exact format is
-    strict, and strptime round-trips the parsed value to reject zero
-    padding ('2026-9-4' parses but its isoformat differs).
-    """
-    try:
-        parsed = datetime.datetime.strptime(value, _DATE_FORMAT).date()
-    except (TypeError, ValueError):
-        raise ValueError(
-            f"{field} must be an ISO date (YYYY-MM-DD), got {value!r}"
-        ) from None
-    if parsed.isoformat() != value:
-        raise ValueError(
-            f"{field} must be a strict YYYY-MM-DD date, got {value!r}"
-        )
-
-
-@dataclass(frozen=True)
-class ScheduleRuleRecord:
-    """One row of ``schedule_rules``."""
-
-    id: int
-    rule_type: str
-    interval: int
-    weekday_set: str | None
-    day_of_month: int | None
-    nth_weekday: int | None
-    month: int | None
-    start_date: str
-    end_date: str | None
-
-
-@dataclass(frozen=True)
-class TaskDefinitionRecord:
-    """One row of ``task_definitions``."""
-
-    id: int
-    title: str
-    description: str | None
-    icon: str | None
-    child_id: int
-    schedule_rule_id: int
-    due_time: str | None
-    is_active: bool
-    created_at: str
-
-
-_RULE_COLUMNS = (
-    "id, rule_type, interval, weekday_set, day_of_month, nth_weekday, "
-    "month, start_date, end_date"
-)
-_DEFINITION_COLUMNS = (
-    "id, title, description, icon, child_id, schedule_rule_id, due_time, "
-    "is_active, created_at"
-)
-
-
-def _rule_from_row(row: tuple) -> ScheduleRuleRecord:
-    return ScheduleRuleRecord(
-        id=row[0],
-        rule_type=row[1],
-        interval=row[2],
-        weekday_set=row[3],
-        day_of_month=row[4],
-        nth_weekday=row[5],
-        month=row[6],
-        start_date=row[7],
-        end_date=row[8],
-    )
-
-
-def _definition_from_row(row: tuple) -> TaskDefinitionRecord:
-    return TaskDefinitionRecord(
-        id=row[0],
-        title=row[1],
-        description=row[2],
-        icon=row[3],
-        child_id=row[4],
-        schedule_rule_id=row[5],
-        due_time=row[6],
-        is_active=bool(row[7]),
-        created_at=row[8],
-    )
-
-
-class ScheduleRulesDao:
-    """Typed async access to the ``schedule_rules`` table."""
-
-    def __init__(self, database: NestQuestDatabase) -> None:
-        self._database = database
-
-    async def create(
-        self,
-        rule_type: str,
-        start_date: str,
-        *,
-        interval: int = 1,
-        weekday_set: str | None = None,
-        day_of_month: int | None = None,
-        nth_weekday: int | None = None,
-        month: int | None = None,
-        end_date: str | None = None,
-    ) -> ScheduleRuleRecord:
-        """Insert one rule and return the record as stored.
-
-        Rule-type coherence (a weekly rule needs ``weekday_set``, a
-        yearly rule needs ``month``, etc.) is enforced by the schema
-        CHECKs and surfaces as :class:`sqlite3.IntegrityError`.  Date
-        shape (strict YYYY-MM-DD) is validated here because the
-        schema's lexical end>=start CHECK cannot prove a real calendar
-        date.
-        """
-        _validate_date(start_date, "start_date")
-        if end_date is not None:
-            _validate_date(end_date, "end_date")
-        result = await self._database.execute(
-            "INSERT INTO schedule_rules (rule_type, interval, weekday_set, "
-            "day_of_month, nth_weekday, month, start_date, end_date) "
-            "VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
-            (
-                rule_type,
-                interval,
-                weekday_set,
-                day_of_month,
-                nth_weekday,
-                month,
-                start_date,
-                end_date,
-            ),
-        )
-        rule = await self.get(result.lastrowid)
-        assert rule is not None
-        return rule
-
-    async def get(self, rule_id: int) -> ScheduleRuleRecord | None:
-        """Return the rule with ``rule_id``, or None."""
-        row = await self._database.fetch_one(
-            f"SELECT {_RULE_COLUMNS} FROM schedule_rules WHERE id = ?",
-            (rule_id,),
-        )
-        return _rule_from_row(row) if row is not None else None
-
-    async def update(
-        self,
-        rule_id: int,
-        *,
-        rule_type: str | None | object = _UNSET,
-        interval: int | None | object = _UNSET,
-        weekday_set: str | None | object = _UNSET,
-        day_of_month: int | None | object = _UNSET,
-        nth_weekday: int | None | object = _UNSET,
-        month: int | None | object = _UNSET,
-        start_date: str | None | object = _UNSET,
-        end_date: str | None | object = _UNSET,
-    ) -> int:
-        """Update the given fields; returns rows updated (0 if absent).
-
-        Arguments default to the module sentinel ``_UNSET`` meaning
-        "leave this column alone"; passing ``None`` explicitly writes
-        SQL NULL, so callers can reopen an ended rule (``end_date``
-        back to NULL) or clear nullable shape fields.  Passing
-        ``None``/a new value for a date field validates its shape.
-        Editing a rule that a definition references changes future
-        materializations only — this method touches no instances
-        (Feature 06/07 separation).
-        """
-        date_args = (
-            ("start_date", start_date),
-            ("end_date", end_date),
-        )
-        for field, value in date_args:
-            if value is not _UNSET and value is not None:
-                _validate_date(value, field)
-        assignments: list[str] = []
-        parameters: list[object] = []
-        for column, value in (
-            ("rule_type", rule_type),
-            ("interval", interval),
-            ("weekday_set", weekday_set),
-            ("day_of_month", day_of_month),
-            ("nth_weekday", nth_weekday),
-            ("month", month),
-            ("start_date", start_date),
-            ("end_date", end_date),
-        ):
-            if value is not _UNSET:
-                assignments.append(f"{column} = ?")
-                parameters.append(value)
-        if not assignments:
-            return 0
-        parameters.append(rule_id)
-        result = await self._database.execute(
-            f"UPDATE schedule_rules SET {', '.join(assignments)} "
-            "WHERE id = ?",
-            tuple(parameters),
-        )
-        return result.rowcount
-
-    async def delete_if_unreferenced(self, rule_id: int) -> bool:
-        """Delete the rule only if no definition references it.
-
-        Returns True if the rule was deleted, False if it is still
-        referenced (or does not exist — distinguish via :meth:`get`).
-        The reference check and the DELETE run inside one transaction
-        under the connection lock, so a definition cannot start
-        referencing the rule between the check and the delete.
-        """
-        async with _connection_lock(self._database):
-            async with self._database.transaction():
-                row = await self._database.fetch_one(
-                    "SELECT 1 FROM task_definitions "
-                    "WHERE schedule_rule_id = ? LIMIT 1",
-                    (rule_id,),
-                )
-                if row is not None:
-                    return False
-                result = await self._database.execute(
-                    "DELETE FROM schedule_rules WHERE id = ?",
-                    (rule_id,),
-                )
-                return result.rowcount > 0
-
-
-class TaskDefinitionsDao:
-    """Typed async access to the ``task_definitions`` table.
-
-    No delete method exists: definitions are deactivated via
-    :meth:`set_active`, never hard-deleted, so completion history keeps
-    its references (feature guardrail).
-    """
-
-    def __init__(self, database: NestQuestDatabase) -> None:
-        self._database = database
-
-    async def create(
-        self,
-        title: str,
-        child_id: int,
-        schedule_rule_id: int,
-        created_at: str,
-        *,
-        description: str | None = None,
-        icon: str | None = None,
-        due_time: str | None = None,
-        is_active: bool = True,
-    ) -> TaskDefinitionRecord:
-        """Insert one definition and return the record as stored.
-
-        Validates the assignment target as part of the same serialized
-        transaction as the insert: the child must exist and be active,
-        and the rule must exist, AT INSERT TIME — a child deactivated
-        or a rule deleted concurrently cannot slip between the checks
-        and the INSERT, which would otherwise create an invalid
-        assignment or surface as a raw FK IntegrityError instead of
-        the documented ValueError.  An INACTIVE child would pass the
-        schema foreign keys, which is why the activeness check lives
-        here.
-        """
-        async with _connection_lock(self._database):
-            async with self._database.transaction():
-                await self._validate_assignable(
-                    child_id, schedule_rule_id
-                )
-                result = await self._database.execute(
-                    "INSERT INTO task_definitions (title, description, "
-                    "icon, child_id, schedule_rule_id, due_time, "
-                    "is_active, created_at) "
-                    "VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
-                    (
-                        title,
-                        description,
-                        icon,
-                        child_id,
-                        schedule_rule_id,
-                        due_time,
-                        int(is_active),
-                        created_at,
-                    ),
-                )
-                definition = await self.get(result.lastrowid)
-        assert definition is not None
-        return definition
-
-    async def _validate_assignable(
-        self, child_id: int, schedule_rule_id: int
-    ) -> None:
-        """Raise ValueError unless child (active) and rule both exist.
-
-        MUST be called inside the connection lock so the verdict cannot
-        go stale before the caller's INSERT commits.
-        """
-        await self._validate_assignable_child(child_id)
-        rule = await self._database.fetch_one(
-            "SELECT 1 FROM schedule_rules WHERE id = ?",
-            (schedule_rule_id,),
-        )
-        if rule is None:
-            raise ValueError(
-                f"schedule rule {schedule_rule_id} does not exist"
-            )
-
-    async def get(self, definition_id: int) -> TaskDefinitionRecord | None:
-        """Return the definition with ``definition_id``, or None."""
-        row = await self._database.fetch_one(
-            f"SELECT {_DEFINITION_COLUMNS} FROM task_definitions "
-            "WHERE id = ?",
-            (definition_id,),
-        )
-        return _definition_from_row(row) if row is not None else None
-
-    async def list_by_child(self, child_id: int) -> list[TaskDefinitionRecord]:
-        """Return all definitions assigned to ``child_id``, newest first."""
-        rows = await self._database.fetch_all(
-            f"SELECT {_DEFINITION_COLUMNS} FROM task_definitions "
-            "WHERE child_id = ? ORDER BY id DESC",
-            (child_id,),
-        )
-        return [_definition_from_row(row) for row in rows]
-
-    async def list_active(self) -> list[TaskDefinitionRecord]:
-        """Return all active definitions, oldest first (stable order)."""
-        rows = await self._database.fetch_all(
-            f"SELECT {_DEFINITION_COLUMNS} FROM task_definitions "
-            "WHERE is_active = 1 ORDER BY id"
-        )
-        return [_definition_from_row(row) for row in rows]
-
-    async def update(
-        self,
-        definition_id: int,
-        *,
-        title: str | None | object = _UNSET,
-        description: str | None | object = _UNSET,
-        icon: str | None | object = _UNSET,
-        due_time: str | None | object = _UNSET,
-    ) -> int:
-        """Update the given fields; returns rows updated (0 if absent).
-
-        Arguments default to the module sentinel ``_UNSET`` meaning
-        "leave this column alone"; passing ``None`` explicitly writes
-        SQL NULL, so callers can remove optional metadata
-        (description, icon, due_time).  Assignment and activation are
-        deliberately NOT settable here: they have their own explicit
-        operations (:meth:`set_assignee`, :meth:`set_active`) so they
-        stay separately loggable and permission-gateable.
-        """
-        assignments: list[str] = []
-        parameters: list[object] = []
-        for column, value in (
-            ("title", title),
-            ("description", description),
-            ("icon", icon),
-            ("due_time", due_time),
-        ):
-            if value is not _UNSET:
-                assignments.append(f"{column} = ?")
-                parameters.append(value)
-        if not assignments:
-            return 0
-        parameters.append(definition_id)
-        result = await self._database.execute(
-            f"UPDATE task_definitions SET {', '.join(assignments)} "
-            "WHERE id = ?",
-            tuple(parameters),
-        )
-        return result.rowcount
-
-    async def set_active(self, definition_id: int, is_active: bool) -> int:
-        """Deactivate/reactivate; returns rows updated (0 if absent).
-
-        Deactivating stops future instance generation but leaves
-        existing instances and completion history untouched.
-        """
-        result = await self._database.execute(
-            "UPDATE task_definitions SET is_active = ? WHERE id = ?",
-            (int(is_active), definition_id),
-        )
-        return result.rowcount
-
-    async def set_assignee(
-        self, definition_id: int, child_id: int
-    ) -> int:
-        """Reassign the definition to ``child_id``; rows updated (0 if absent).
-
-        Validates the new assignee inside the same serialized
-        transaction as the UPDATE (existing and active AT ASSIGNMENT
-        TIME), so a child deactivated concurrently cannot become the
-        assignee.  Changes future instances only: already-generated
-        instances and completion history are never rewritten here.
-        """
-        async with _connection_lock(self._database):
-            async with self._database.transaction():
-                await self._validate_assignable_child(child_id)
-                result = await self._database.execute(
-                    "UPDATE task_definitions SET child_id = ? "
-                    "WHERE id = ?",
-                    (child_id, definition_id),
-                )
-        return result.rowcount
-
-    async def _validate_assignable_child(self, child_id: int) -> None:
-        """Raise ValueError unless the child exists and is active.
-
-        MUST be called inside the connection lock so the verdict cannot
-        go stale before the caller's UPDATE commits.
-        """
-        child = await self._database.fetch_one(
-            "SELECT is_active FROM children WHERE id = ?", (child_id,)
-        )
-        if child is None:
-            raise ValueError(f"child {child_id} does not exist")
-        if not child[0]:
-            raise ValueError(
-                f"child {child_id} is inactive and cannot be assigned"
-            )

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/migrations.py

@@ -1,236 +0,0 @@
-"""Versioned schema migration runner for the NestQuest SQLite database.
-
-The runner owns one metadata table, ``nestquest_schema_version``, holding
-a single row with the schema version the database file currently
-reflects.  Migrations are declared as an ordered list: entry ``n``
-upgrades version ``n-1`` to version ``n``.  Applying a migration means
-running its DDL inside one transaction and stamping the new version in
-that same transaction, so a database never persists a half-applied
-migration: any failure rolls the statements and the version stamp back
-together, leaving the file at its prior version.
-
-Version 0 means "the file exists but carries no NestQuest schema yet"
-— a fresh file, or a file this integration has never written.  Starting
-the runner against version 0 applies migration 1, which applies the
-full v1 DDL from :mod:`.schema` and stamps version 1.
-
-Each migration's statements and its version stamp run inside ONE
-transaction, and the stamp is written as DELETE + INSERT rather than
-UPDATE because a version-0 database has no version row to update yet.
-An UPDATE form would silently match zero rows there and leave the
-database migrated but unstamped — reporting version 0 forever, and
-re-applying migration 1 on every startup.  The DELETE+INSERT shape is
-also what makes the stamp a replace, so the row never duplicates.
-
-Idempotence across restarts: a database already at the latest version
-has no pending migrations, so the runner opens a read-only check, finds
-nothing to do, and leaves the file byte-untouched (no write transaction
-is opened, so no WAL churn).
-
-Migration list policy: entries are append-only.  Once shipped, a
-migration's SQL must never be edited — an old database applying it for
-the first time and a fresh database would then diverge.  Fix-forward
-with a new migration instead.  The version stamp lives in the same
-SQLite file as the data it describes, so restoring a backup restores
-its matching schema version with it.
-
-Corrupt or missing files are not this module's concern: startup
-handling of those cases is task d5bca74b, which decides whether to
-open fresh or raise ConfigEntryNotReady.  This runner assumes it is
-handed an open, working connection.
-"""
-from __future__ import annotations
-
-import asyncio
-import logging
-from collections.abc import Sequence
-
-from .db import NestQuestDatabase
-from .schema import SCHEMA_V1_STATEMENTS
-
-LOGGER = logging.getLogger(__name__)
-
-#: Metadata table holding the applied schema version.  Prefixed with the
-#: integration domain so a config directory shared with other tools can
-#: never collide with a foreign ``schema_version`` table.
-VERSION_TABLE = "nestquest_schema_version"
-
-#: DDL for the version metadata table.  The singleton-row invariant is
-#: enforced by the schema itself: ``id`` is fixed at 1 by CHECK, keyed
-#: PRIMARY KEY, so the table can never hold a second row, and the
-#: stamp write is an UPDATE (no DELETE+INSERT needed).  ``version`` is
-#: a positive integer: version 0 means "no row" and is never stored,
-#: so a negative or zero stored value is corruption, not a state the
-#: runner can act on.
-VERSION_TABLE_DDL = f"""
-    CREATE TABLE IF NOT EXISTS {VERSION_TABLE} (
-        id INTEGER NOT NULL PRIMARY KEY CHECK (id = 1),
-        version INTEGER NOT NULL CHECK (version >= 1)
-    )
-"""
-
-#: One-based index into :data:`MIGRATIONS`: entry ``n`` upgrades
-#: version ``n-1`` to version ``n``.
-MIGRATION_1_V1_DDL: list[str] = list(SCHEMA_V1_STATEMENTS)
-
-#: The ordered migration list.  Append-only: never edit an applied
-#: entry, add the next one instead.
-MIGRATIONS: Sequence[Sequence[str]] = [
-    MIGRATION_1_V1_DDL,
-]
-
-
-async def _create_version_table(database: NestQuestDatabase) -> None:
-    """Create the version metadata table if it does not exist.
-
-    The table is created before any version check: it is the runner's
-    own bookkeeping, and creating it is idempotent.  The DDL enforces
-    the singleton-row invariant (``id`` fixed at 1) and a positive
-    integer version at the database level.
-    """
-    await database.execute(VERSION_TABLE_DDL)
-
-
-async def read_schema_version(database: NestQuestDatabase) -> int:
-    """Return the schema version recorded in the database.
-
-    Returns 0 when the version table or its row is missing — the
-    "fresh file" case.  A stored version higher than the runner knows
-    is surfaced as-is; the caller decides how to treat a future version.
-
-    Reading is deliberately passive: a missing table raises, it is not
-    swallowed into 0, because :func:`apply_migrations` always creates
-    the table before reading and a direct reader hitting "no such
-    table" is a caller bug worth surfacing, not a fresh file.
-    """
-    row = await database.fetch_one(
-        f"SELECT version FROM {VERSION_TABLE} LIMIT 1"
-    )
-    if row is None:
-        return 0
-    version = row[0]
-    if not isinstance(version, int) or isinstance(version, bool):
-        raise RuntimeError(
-            f"Schema version metadata is not an integer: {version!r}"
-        )
-    if version < 1:
-        raise RuntimeError(
-            f"Schema version metadata is invalid (must be >= 1): {version!r}"
-        )
-    return version
-
-
-#: One asyncio.Lock per connection wrapper, created lazily and bound to
-#: the running loop, serializing whole apply_migrations runs so two
-#: concurrent callers on one connection queue instead of colliding on
-#: the wrapper's single-transaction rule.
-_MIGRATION_LOCKS: dict[int, asyncio.Lock] = {}
-
-
-def _migration_lock(database: NestQuestDatabase) -> asyncio.Lock:
-    """Return the migration lock bound to ``database``'s running loop."""
-    loop = asyncio.get_running_loop()
-    key = (id(database), id(loop))
-    lock = _MIGRATION_LOCKS.get(key)
-    if lock is None:
-        lock = asyncio.Lock()
-        _MIGRATION_LOCKS[key] = lock
-    return lock
-
-
-async def apply_migrations(
-    database: NestQuestDatabase,
-    migrations: Sequence[Sequence[str]] = MIGRATIONS,
-) -> int:
-    """Bring the database schema up to the latest version.
-
-    Reads the current version, applies every pending migration in order
-    — each inside one transaction that also stamps the new version —
-    and returns the resulting version.  Applying zero pending
-    migrations (database already current) is a no-op that logs at debug
-    level and opens no write transaction.
-
-    The version is re-read inside each migration transaction before
-    deciding to apply it: the outer read is advisory only (loop bounds,
-    no-op fast path), and on one shared connection two interleaved
-    runners would otherwise both read the same version and both apply
-    a non-idempotent migration.  Under the transaction's lock the
-    second runner sees the first runner's stamp and skips.
-
-    Runners on one connection are serialized by an asyncio lock held
-    for the whole decide-and-apply span: NestQuestDatabase rejects a
-    second transaction while one is active (RuntimeError), so
-    concurrent callers must queue, and the lock makes that queueing
-    explicit.  The loser of the race re-reads the version once it
-    acquires the lock, sees the winner's stamp, and applies nothing.
-
-    Raises whatever the failing migration raised, with the database
-    rolled back to its prior version and prior rows untouched.
-    """
-    async with _migration_lock(database):
-        await _create_version_table(database)
-        current = await read_schema_version(database)
-        latest = len(migrations)
-
-        if current > latest:
-            raise RuntimeError(
-                f"Database schema version {current} is newer than this "
-                f"integration understands (latest known: {latest}); "
-                "downgrades are not supported"
-            )
-
-        if current == latest:
-            LOGGER.debug(
-                "NestQuest schema already at version %d; "
-                "no migrations to apply",
-                current,
-            )
-            return current
-
-        for target in range(current + 1, latest + 1):
-            applied = False
-            async with database.transaction():
-                # Re-read the version INSIDE the write transaction: the
-                # outer read was advisory, and the wrapper serializes
-                # individual statements, not the read-decide-apply
-                # decision.  Under the transaction's lock the version
-                # cannot change between the read and the stamp, and the
-                # loser of an interleaved race (a queued second caller
-                # re-running apply_migrations after the winner already
-                # migrated) re-reads here, sees the winner's stamp, and
-                # skips instead of re-applying a non-idempotent
-                # migration with a stale version.
-                in_tx_version = await read_schema_version(database)
-                if in_tx_version > latest:
-                    raise RuntimeError(
-                        f"Database schema version {in_tx_version} is newer "
-                        f"than this integration understands (latest known: "
-                        f"{latest}); downgrades are not supported"
-                    )
-                if in_tx_version < target:
-                    for sql in migrations[target - 1]:
-                        await database.execute(sql)
-                    # INSERT keyed on the singleton row (id = 1): a
-                    # fresh file has no row yet, and migration 1 is the
-                    # only migration a version-0 database can run, so
-                    # the row is seeded by the same statement batch
-                    # when needed.  UPDATE alone would silently match
-                    # zero rows there.
-                    await database.execute(
-                        f"INSERT INTO {VERSION_TABLE} (id, version) "
-                        "VALUES (1, ?) "
-                        "ON CONFLICT (id) DO UPDATE SET version = "
-                        "excluded.version",
-                        (target,),
-                    )
-                    applied = True
-            if applied:
-                LOGGER.info(
-                    "NestQuest schema migrated to version %d "
-                    "(%d statement%s)",
-                    target,
-                    len(migrations[target - 1]),
-                    "s" if len(migrations[target - 1]) != 1 else "",
-                )
-
-        return latest

custom_components/nestquest/options_flow.py

@@ -1,120 +0,0 @@
-"""Options flow for NestQuest post-setup settings."""
-from __future__ import annotations
-
-import re
-from typing import Any
-
-import voluptuous as vol
-from homeassistant import config_entries
-from homeassistant.data_entry_flow import FlowResult
-
-from .const import (
-    CONF_DAY_ROLLOVER_TIME,
-    CONF_HORIZON_DAYS,
-    CONF_PANEL_IDLE_TIMEOUT,
-    DEFAULT_DAY_ROLLOVER_TIME,
-    DEFAULT_HORIZON_DAYS,
-    DEFAULT_PANEL_IDLE_TIMEOUT,
-)
-
-MIN_HORIZON_DAYS = 1
-MIN_PANEL_IDLE_TIMEOUT = 30
-
-_TIME_PATTERN = re.compile(r"(?:[01]\d|2[0-3]):[0-5]\d")
-
-
-def _parse_time(value: str) -> bool:
-    """Return True when value is a valid 24-hour HH:MM string."""
-    return _TIME_PATTERN.fullmatch(value) is not None
-
-
-def _async_validate(user_input: dict[str, Any]) -> dict[str, str]:
-    """Validate user input and return field-level errors instead of raising."""
-    errors: dict[str, str] = {}
-
-    horizon_days = user_input.get(CONF_HORIZON_DAYS)
-    if (
-        isinstance(horizon_days, bool)
-        or not isinstance(horizon_days, int)
-        or horizon_days < MIN_HORIZON_DAYS
-    ):
-        errors[CONF_HORIZON_DAYS] = "invalid"
-
-    day_rollover_time = user_input.get(CONF_DAY_ROLLOVER_TIME)
-    if not isinstance(day_rollover_time, str) or not _parse_time(day_rollover_time):
-        errors[CONF_DAY_ROLLOVER_TIME] = "invalid_time"
-
-    panel_idle_timeout = user_input.get(CONF_PANEL_IDLE_TIMEOUT)
-    if (
-        isinstance(panel_idle_timeout, bool)
-        or not isinstance(panel_idle_timeout, int)
-        or panel_idle_timeout < MIN_PANEL_IDLE_TIMEOUT
-    ):
-        errors[CONF_PANEL_IDLE_TIMEOUT] = "invalid"
-
-    return errors
-
-
-def _build_schema(current: dict[str, Any]) -> vol.Schema:
-    """Build the form schema, pre-filled with the current values."""
-    return vol.Schema(
-        {
-            vol.Required(
-                CONF_HORIZON_DAYS, default=current[CONF_HORIZON_DAYS]
-            ): int,
-            vol.Required(
-                CONF_DAY_ROLLOVER_TIME, default=current[CONF_DAY_ROLLOVER_TIME]
-            ): str,
-            vol.Required(
-                CONF_PANEL_IDLE_TIMEOUT, default=current[CONF_PANEL_IDLE_TIMEOUT]
-            ): int,
-        }
-    )
-
-
-class NestQuestOptionsFlow(config_entries.OptionsFlowWithConfigEntry):
-    """Handle the options flow for NestQuest."""
-
-    async def async_step_init(
-        self, user_input: dict[str, Any] | None = None
-    ) -> FlowResult:
-        """Manage the NestQuest options."""
-        if user_input is None:
-            return self.async_show_form(
-                step_id="init", data_schema=_build_schema(self._current_values())
-            )
-
-        errors = _async_validate(user_input)
-        if errors:
-            return self.async_show_form(
-                step_id="init",
-                data_schema=_build_schema(self._current_values()),
-                errors=errors,
-            )
-
-        return self.async_create_entry(
-            title="NestQuest",
-            data={
-                CONF_HORIZON_DAYS: user_input[CONF_HORIZON_DAYS],
-                CONF_DAY_ROLLOVER_TIME: user_input[CONF_DAY_ROLLOVER_TIME],
-                CONF_PANEL_IDLE_TIMEOUT: user_input[CONF_PANEL_IDLE_TIMEOUT],
-            },
-        )
-
-    def _current_values(self) -> dict[str, Any]:
-        """Resolve current values from entry options, then entry data, then defaults."""
-        options = self.options
-        entry_data = getattr(self.config_entry, "data", None) or {}
-        values: dict[str, Any] = {}
-        for key, default in (
-            (CONF_HORIZON_DAYS, DEFAULT_HORIZON_DAYS),
-            (CONF_DAY_ROLLOVER_TIME, DEFAULT_DAY_ROLLOVER_TIME),
-            (CONF_PANEL_IDLE_TIMEOUT, DEFAULT_PANEL_IDLE_TIMEOUT),
-        ):
-            if key in options:
-                values[key] = options[key]
-            elif key in entry_data:
-                values[key] = entry_data[key]
-            else:
-                values[key] = default
-        return values

custom_components/nestquest/schema.py

@@ -1,336 +0,0 @@
-"""Declarative schema DDL for the NestQuest SQLite database.
-
-Every v1 table is declared here as plain SQL statements so later schema
-tasks can append their own DDL to :data:`SCHEMA_V1_STATEMENTS` without
-touching this module's tables.  All statements use
-``CREATE TABLE IF NOT EXISTS`` so application is idempotent; the versioned
-migration runner is a separate later concern.
-
-Timestamp policy: all timestamps are UTC ISO-8601 strings, set by the
-caller/DAO rather than a DB default, per the feature guardrails.  No
-``length(created_at) = 25`` CHECK is added: the exact string shape
-produced by callers is not fixed yet (``datetime.isoformat()`` may
-include microseconds, changing the length), so enforcing a fixed length
-here would reject valid values.  Only non-null is enforced for now.
-
-Date policy: ``start_date``/``end_date`` are ISO date strings (YYYY-MM-DD,
-no time component) compared lexically by the ``end_date >= start_date``
-CHECK; due_date/due_time string shapes are caller-validated by the rule
-engine and DAO layers, not by DDL.
-
-``weekday_set`` format: comma-separated weekday integers (CSV), 0 =
-Monday .. 6 = Sunday, e.g. ``'0,2,4'`` for Mon/Wed/Fri.  Chosen over JSON
-because it sorts, compares and parses trivially in SQL.  The format is
-enforced at the DB level: a CHECK matches ``weekday_set`` against GLOB
-patterns for element counts 1..7 of single digits 0-6 (GLOB has no
-repetition quantifier, so the element count is enumerated; more than 7
-elements is impossible for a weekday set).  ``''``, ``'x'``, ``'7'`` and
-``'0,x'`` are all rejected; NULL stays allowed for non-weekly rules.
-This keeps the schema layer storage-only — the DAO layer (tasks
-8c72300c+) does not need its own validator, it can rely on the CHECK.
-
-Type affinity: SQLite applies column affinity on insert, but CHECKs
-still observe text and fractional values ('abc' stays text, '1.5'
-becomes REAL), so every INTEGER column carrying rule semantics carries
-a ``typeof(...) = 'integer'`` guard in its CHECK.
-
-Rule-type coherence: two CHECKs enforce that ``weekly`` carries a
-non-null ``weekday_set``, ``monthly`` carries a ``day_of_month`` or an
-``nth_weekday``, ``yearly`` carries a ``month``, and ``daily``/``custom``
-carry none of the month-specific fields.  Relaxed deliberately: the DDL
-does NOT forbid ``month`` on weekly/monthly rules (an "every 2 weeks"
-rule or a monthly rule could later be pinned to a month) nor extra
-fields on weekly/monthly/yearly rules generally, so the CHECKs only
-reject what the rule engine definitively cannot express now.
-
-Presence pattern format: ``presence_schedules.pattern`` encodes the
-whole N-week repeating cycle in one TEXT column as pipe-separated
-segments, one per week of the cycle: segment ``i`` is a ``weekday_set``
-CSV (same single-digit 0-6 convention as ``schedule_rules.weekday_set``)
-for week ``i``, e.g. ``'0,2,4|1,3'`` = Mon/Wed/Fri in week 0, Tue/Thu in
-week 1.  An empty segment means the child is absent every day of that
-week; a wholly empty pattern with ``cycle_length_weeks = 1`` means
-absent every day of every week, which is distinct from having no
-schedule row at all (a child with no schedule is present every day, per
-the feature guardrails).  Chosen over JSON or per-week rows to stay
-consistent with the CSV ``weekday_set`` convention and fully checkable
-by plain CHECKs.  DB-level validation is pure CHECK, no triggers or
-custom functions: char-class GLOBs reject every character outside
-digits 0-6, comma and pipe; adjacency GLOBs reject empty elements
-(double comma, comma next to a pipe, leading/trailing comma) and
-two-digit runs; a further GLOB rejects contiguous runs of 8+ comma
-separated digits, which caps a segment at 7 elements — the GLOB cannot
-match across a ``|``, so cross-segment boundaries stay safe; and the
-segment count is pinned to ``cycle_length_weeks`` by
-``LENGTH(pattern) - LENGTH(REPLACE(pattern, '|', '')) + 1``.  Per
-weekday_set this is not full CSV-set normalisation (duplicates like
-``'0,0'`` or unsorted sets stay storable, as with ``schedule_rules``);
-the engine treats the segment as a set.  A
-one-row-per-``week_index`` normalization was considered and rejected:
-the flat single-column encoding keeps the done-condition's table shape
-and proved fully checkable with plain CHECKs.
-
-``cycle_length_weeks`` is capped at 4: 2 (alternating weeks) is the
-common case, and a small cap keeps anchor arithmetic and the encoded
-pattern human-readable.  Revisit the cap — and re-run the pattern
-validation matrix in tests — if a longer cycle is ever needed.
-``anchor_date`` is an ISO date string pinning the cycle: the week index
-of a date is (days since anchor) // 7 mod ``cycle_length_weeks``,
-computed by the presence engine (Feature 05) from anchor-date
-arithmetic, never ISO week parity.  Like other date columns it carries
-no shape CHECK, matching the established date policy.
-
-Presence overrides: ``presence_overrides.end_date`` is NOT NULL,
-unlike ``schedule_rules.end_date`` — an override is always a concrete
-date range; a single-day override stores the same date in both columns.
-``is_present`` 0/1 marks the child absent/present for the whole range;
-``note`` is optional free text.
-
-Task instances: ``task_instances`` deliberately carries NO completion
-status column.  An instance's current state derives from the latest row
-in ``completion_events`` (Feature 08), so materialization (Feature 07)
-can insert instances without knowing anything about completion and the
-append-only log stays the single source of truth.  ``definition_id``,
-``due_date`` and ``child_id`` snapshot the materialization-time facts
-("why this instance exists"): reassignment and rule edits change future
-instances only and never rewrite these rows.  ``due_time`` snapshots
-the definition's optional due time at generation for the same reason —
-the instance keeps its generation-time value even if the definition is
-edited later.  ``generated_at`` is a caller-set UTC ISO-8601 timestamp
-per the module timestamp policy (no DB default, so a generation batch
-stamps one coherent time).
-
-Uniqueness: the (definition_id, due_date) pair is declared as a
-table-level ``UNIQUE`` constraint rather than a separate ``CREATE
-UNIQUE INDEX`` statement.  SQLite materializes it as an implicit unique
-index (``sqlite_autoindex_task_instances_1``) — the required "unique
-index prevents duplicate instances" — and the constraint form cannot be
-silently dropped the way a standalone index can, so the duplicate door
-stays shut.  Idempotent materialization keys on exactly this pair.  No
-secondary indexes beyond it are declared yet: history and board queries
-(Features 08/10/13) should justify their indexes as a later migration
-once their query shapes exist.
-
-No ``ON DELETE`` clauses are declared on any foreign key in this
-module: children and definitions are deactivated, never deleted, so a
-deletion that would orphan instances or events is a bug and must fail
-loudly rather than cascade.
-
-Completion events: ``completion_events`` is strictly append-only.  That
-property is enforced at the DAO layer — the completion-events DAO
-exposes no UPDATE or DELETE path (task a9ea75fc) — and deliberately NOT
-by database triggers, matching the module's no-trigger policy: a RAISE
-trigger would be the one exception to "pure CHECK, no triggers",
-complicate the later migration runner, and still prove nothing (any
-writer can run raw SQL).  ``event_type`` is constrained to
-``completed``/``uncompleted``; a ``missed`` row is intentionally not
-representable — missed is a derived state announced on the HA event bus
-(Feature 10), never an appended event.
-
-``child_id`` is deliberately denormalized (it is also derivable via
-``task_instances``): history reporting (Feature 13) filters and rates
-per child directly against the log, and the log should stay
-self-describing without joins.
-
-Actor policy: ``actor_source`` distinguishes an authenticated HA user
-(``'user'``, with ``actor_user_id`` holding the HA user id) from a
-panel tap with no user context (``'panel'``, with ``actor_user_id``
-NULL — the tapped child profile is already ``child_id``).  A coherence
-CHECK makes the pair shape non-negotiable: ``'user'`` requires
-``actor_user_id``, ``'panel'`` forbids it.  Other actor sources are
-rejected; if an unattended system actor is ever needed, that is a
-schema migration, not a silent widening.
-
-On-time policy: ``was_on_time`` is required (integer 0 or 1) for
-``completed`` events — at completion time the due date is known and the
-flag is decidable.  For ``uncompleted`` events the flag is optional:
-Feature 08 decides whether a reversal carries the reversed completion's
-on-time flag or NULL, and the DDL deliberately accepts both rather than
-guessing.
-"""
-from __future__ import annotations
-
-from .db import NestQuestDatabase
-
-#: GLOB patterns matching a valid ``weekday_set`` CSV: one GLOB per
-#: possible element count 1..7 (a weekday set cannot exceed 7 elements).
-#: Each element is a single digit 0-6, separated by a literal comma.
-#: GLOB has no repetition quantifier, so the element count is enumerated.
-#: ``''`` and NULL are deliberately NOT matched: NULL is allowed for
-#: non-weekly rules via a separate ``IS NULL`` arm, and '' is invalid
-#: because weekly rules need at least one weekday.
-WEEKDAY_SET_GLOB_PATTERNS: list[str] = [
-    "[0-6]",
-    "[0-6],[0-6]",
-    "[0-6],[0-6],[0-6]",
-    "[0-6],[0-6],[0-6],[0-6]",
-    "[0-6],[0-6],[0-6],[0-6],[0-6]",
-    "[0-6],[0-6],[0-6],[0-6],[0-6],[0-6]",
-    "[0-6],[0-6],[0-6],[0-6],[0-6],[0-6],[0-6]",
-]
-
-SCHEMA_V1_CHILDREN_DDL: list[str] = [
-    """
-    CREATE TABLE IF NOT EXISTS children (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        display_name TEXT NOT NULL,
-        colour TEXT,
-        avatar_ref TEXT,
-        sort_order INTEGER NOT NULL DEFAULT 0 CHECK (typeof(sort_order) = 'integer'),
-        is_active INTEGER NOT NULL DEFAULT 1 CHECK (typeof(is_active) = 'integer' AND is_active IN (0, 1)),
-        created_at TEXT NOT NULL
-    )
-    """,
-]
-
-SCHEMA_V1_ADMIN_USERS_DDL: list[str] = [
-    """
-    CREATE TABLE IF NOT EXISTS admin_users (
-        ha_user_id TEXT PRIMARY KEY NOT NULL,
-        added_at TEXT NOT NULL
-    )
-    """,
-]
-
-_WEEKDAY_SET_CHECK = " OR ".join(
-    f"weekday_set GLOB '{pattern}'" for pattern in WEEKDAY_SET_GLOB_PATTERNS
-)
-
-SCHEMA_V1_SCHEDULE_RULES_DDL: list[str] = [
-    f"""
-    CREATE TABLE IF NOT EXISTS schedule_rules (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        rule_type TEXT NOT NULL CHECK (rule_type IN ('daily', 'weekly', 'monthly', 'yearly', 'custom')),
-        interval INTEGER NOT NULL DEFAULT 1 CHECK (typeof(interval) = 'integer' AND interval >= 1),
-        weekday_set TEXT CHECK (weekday_set IS NULL OR ({_WEEKDAY_SET_CHECK})),
-        day_of_month INTEGER CHECK (day_of_month IS NULL OR (typeof(day_of_month) = 'integer' AND day_of_month >= 1 AND day_of_month <= 31)),
-        nth_weekday INTEGER CHECK (nth_weekday IS NULL OR (typeof(nth_weekday) = 'integer' AND nth_weekday IN (-1, 1, 2, 3, 4, 5))),
-        month INTEGER CHECK (month IS NULL OR (typeof(month) = 'integer' AND month >= 1 AND month <= 12)),
-        start_date TEXT NOT NULL,
-        end_date TEXT,
-        CHECK (end_date IS NULL OR end_date >= start_date),
-        CHECK (
-            (rule_type = 'weekly' AND weekday_set IS NOT NULL)
-            OR (rule_type = 'monthly' AND (day_of_month IS NOT NULL OR nth_weekday IS NOT NULL))
-            OR (rule_type = 'yearly' AND month IS NOT NULL)
-            OR (rule_type IN ('daily', 'custom') AND day_of_month IS NULL AND nth_weekday IS NULL AND month IS NULL)
-        )
-    )
-    """,
-]
-
-SCHEMA_V1_TASK_DEFINITIONS_DDL: list[str] = [
-    """
-    CREATE TABLE IF NOT EXISTS task_definitions (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        title TEXT NOT NULL,
-        description TEXT,
-        icon TEXT,
-        child_id INTEGER NOT NULL REFERENCES children(id),
-        schedule_rule_id INTEGER NOT NULL REFERENCES schedule_rules(id),
-        due_time TEXT,
-        is_active INTEGER NOT NULL DEFAULT 1 CHECK (typeof(is_active) = 'integer' AND is_active IN (0, 1)),
-        created_at TEXT NOT NULL
-    )
-    """,
-]
-
-SCHEMA_V1_PRESENCE_SCHEDULES_DDL: list[str] = [
-    f"""
-    CREATE TABLE IF NOT EXISTS presence_schedules (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        child_id INTEGER NOT NULL UNIQUE REFERENCES children(id),
-        cycle_length_weeks INTEGER NOT NULL CHECK (typeof(cycle_length_weeks) = 'integer' AND cycle_length_weeks >= 1 AND cycle_length_weeks <= 4),
-        anchor_date TEXT NOT NULL,
-        pattern TEXT NOT NULL CHECK (
-            NOT pattern GLOB '*[^0-6,|]*'
-            AND NOT pattern GLOB '*[0-6][0-6]*'
-            AND NOT pattern GLOB '*,,*'
-            AND NOT pattern GLOB '*,|*'
-            AND NOT pattern GLOB '*|,*'
-            AND NOT pattern GLOB ',*'
-            AND NOT pattern GLOB '*,'
-            AND NOT pattern GLOB '*[0-6],[0-6],[0-6],[0-6],[0-6],[0-6],[0-6],[0-6]*'
-            AND (LENGTH(pattern) - LENGTH(REPLACE(pattern, '|', '')) + 1) = cycle_length_weeks
-        )
-    )
-    """,
-]
-
-SCHEMA_V1_PRESENCE_OVERRIDES_DDL: list[str] = [
-    """
-    CREATE TABLE IF NOT EXISTS presence_overrides (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        child_id INTEGER NOT NULL REFERENCES children(id),
-        start_date TEXT NOT NULL,
-        end_date TEXT NOT NULL,
-        is_present INTEGER NOT NULL CHECK (typeof(is_present) = 'integer' AND is_present IN (0, 1)),
-        note TEXT,
-        CHECK (end_date >= start_date)
-    )
-    """,
-]
-
-SCHEMA_V1_TASK_INSTANCES_DDL: list[str] = [
-    """
-    CREATE TABLE IF NOT EXISTS task_instances (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        definition_id INTEGER NOT NULL REFERENCES task_definitions(id),
-        child_id INTEGER NOT NULL REFERENCES children(id),
-        due_date TEXT NOT NULL,
-        due_time TEXT,
-        generated_at TEXT NOT NULL,
-        UNIQUE (definition_id, due_date)
-    )
-    """,
-]
-
-SCHEMA_V1_COMPLETION_EVENTS_DDL: list[str] = [
-    """
-    CREATE TABLE IF NOT EXISTS completion_events (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        instance_id INTEGER NOT NULL REFERENCES task_instances(id),
-        child_id INTEGER NOT NULL REFERENCES children(id),
-        event_type TEXT NOT NULL CHECK (event_type IN ('completed', 'uncompleted')),
-        actor_source TEXT NOT NULL CHECK (actor_source IN ('user', 'panel')),
-        actor_user_id TEXT,
-        occurred_at TEXT NOT NULL,
-        was_on_time INTEGER CHECK (
-            was_on_time IS NULL
-            OR (typeof(was_on_time) = 'integer' AND was_on_time IN (0, 1))
-        ),
-        CHECK (
-            (actor_source = 'user' AND actor_user_id IS NOT NULL)
-            OR (actor_source = 'panel' AND actor_user_id IS NULL)
-        ),
-        CHECK (
-            (event_type = 'completed' AND was_on_time IS NOT NULL)
-            OR (event_type = 'uncompleted')
-        )
-    )
-    """,
-]
-
-SCHEMA_V1_STATEMENTS: list[str] = [
-    *SCHEMA_V1_CHILDREN_DDL,
-    *SCHEMA_V1_ADMIN_USERS_DDL,
-    *SCHEMA_V1_SCHEDULE_RULES_DDL,
-    *SCHEMA_V1_TASK_DEFINITIONS_DDL,
-    *SCHEMA_V1_PRESENCE_SCHEDULES_DDL,
-    *SCHEMA_V1_PRESENCE_OVERRIDES_DDL,
-    *SCHEMA_V1_TASK_INSTANCES_DDL,
-    *SCHEMA_V1_COMPLETION_EVENTS_DDL,
-]
-
-
-async def async_apply_ddl(
-    database: NestQuestDatabase, statements: list[str]
-) -> None:
-    """Apply each DDL statement inside one transaction on ``database``.
-
-    Idempotent: every statement is ``CREATE TABLE IF NOT EXISTS``, so
-    applying the same list twice leaves the schema and its rows intact.
-    """
-    async with database.transaction():
-        for sql in statements:
-            await database.execute(sql)

custom_components/nestquest/strings.json

@@ -13,22 +13,5 @@
     "create_entry": {
       "default": "NestQuest was successfully configured."
     }
-  },
-  "options": {
-    "step": {
-      "init": {
-        "title": "NestQuest Settings",
-        "description": "Adjust how NestQuest plans, rolls over days, and idles its panel.",
-        "data": {
-          "horizon_days": "Generation horizon (days)",
-          "day_rollover_time": "Day rollover time (HH:MM)",
-          "panel_idle_timeout": "Panel idle timeout (seconds)"
-        }
-      }
-    },
-    "errors": {
-      "invalid": "Invalid value.",
-      "invalid_time": "Time must use 24-hour HH:MM format."
-    }
   }
 }

custom_components/nestquest/translations/en.json

@@ -13,22 +13,5 @@
     "create_entry": {
       "default": "NestQuest was successfully configured."
     }
-  },
-  "options": {
-    "step": {
-      "init": {
-        "title": "NestQuest Settings",
-        "description": "Adjust how NestQuest plans, rolls over days, and idles its panel.",
-        "data": {
-          "horizon_days": "Generation horizon (days)",
-          "day_rollover_time": "Day rollover time (HH:MM)",
-          "panel_idle_timeout": "Panel idle timeout (seconds)"
-        }
-      }
-    },
-    "errors": {
-      "invalid": "Invalid value.",
-      "invalid_time": "Time must use 24-hour HH:MM format."
-    }
   }
 }

pyproject.toml

@@ -9,11 +9,8 @@ dependencies = []
 [dependency-groups]
 dev = [
     "pytest>=8.0.0",
-    "pytest-asyncio>=0.24",
-    "voluptuous>=0.14",
 ]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 pythonpath = ["."]
-asyncio_mode = "auto"

tests/conftest.py

@@ -1,333 +0,0 @@
-"""Shared pytest fixtures for the NestQuest test suite.
-
-pytest-homeassistant-custom-component could not be adopted: it pins
-``pytest==9.0.3`` and ``voluptuous==0.13.1``, which conflicts with the dev
-group's ``voluptuous>=0.14`` (used directly by the options flow's schema and
-its tests), and its back-releases raise the floor to Python >=3.12 while this
-project supports >=3.11.  The documented fallback is therefore used:
-``pytest-asyncio`` plus a standard-shaped ``hass`` fixture below.
-
-conftest.py is the single place where ``homeassistant`` modules are provided:
-this harness is explicitly MOCK-ONLY.  It unconditionally installs a coherent
-set of MagicMock stand-ins via ``sys.modules`` and wires the parent-package
-attributes.  All of that happens here, before any test module imports the
-integration, so no test module needs its own ``sys.modules`` setup.  It also
-provides the ``hass`` fixture plus shared helpers used by the behavior tests
-(config-entry factory, listener registry).
-
-Run this suite in its own venv *without* homeassistant installed (``uv run
-pytest -q``); it is never meant to run against a real HA install.
-"""
-
-from __future__ import annotations
-
-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
-
-import pytest
-
-# ---------------------------------------------------------------------------
-# Homeassistant module provisioning (explicitly mock-only).
-# ---------------------------------------------------------------------------
-_HA_MODULES = (
-    "homeassistant",
-    "homeassistant.core",
-    "homeassistant.config_entries",
-    "homeassistant.data_entry_flow",
-)
-
-def _find_spec(name: str):
-    """find_spec that returns None when the module (or its parent) is absent."""
-    try:
-        return importlib.util.find_spec(name)
-    except (ModuleNotFoundError, ValueError):
-        return None
-
-
-def _ensure_mock_only():
-    """Fail fast if real homeassistant is importable: this harness is mock-only."""
-    for _mod in _HA_MODULES:
-        # Anything already in sys.modules at load time is real HA; our mocks
-        # are only installed after this check.
-        if _mod in sys.modules or _find_spec(_mod) is not None:
-            raise pytest.UsageError(
-                "The NestQuest test harness is mock-only: real homeassistant is "
-                f"importable ({_mod!r} found), and mixing real HA modules with the "
-                "shaped mocks is not supported. Run the suite in its own venv "
-                "without homeassistant installed, e.g. `uv run pytest -q`."
-            )
-
-
-_ensure_mock_only()
-
-for _mod in _HA_MODULES:
-    sys.modules.setdefault(_mod, MagicMock())
-
-# Wire parent package attributes so "from homeassistant import
-# config_entries" resolves to the mocked submodule, mirroring real HA's
-# package layout.
-for _parent, _child in (
-    ("homeassistant", "config_entries"),
-    ("homeassistant", "data_entry_flow"),
-    ("homeassistant", "core"),
-):
-    setattr(sys.modules[_parent], _child, sys.modules[f"{_parent}.{_child}"])
-
-
-def _ha_mock(name: str):
-    """Return the shaped mock module object for a homeassistant module."""
-    return sys.modules[name]
-
-
-def options_flow_base():
-    """Return the mocked OptionsFlowWithConfigEntry class."""
-    return getattr(sys.modules["homeassistant.config_entries"], "OptionsFlowWithConfigEntry")
-
-
-class _ConfigFlowBase:
-    """Stand-in for homeassistant.config_entries.ConfigFlow.
-
-    A superset covering both the config-flow and options-flow tests: it must
-    satisfy every consumer of the mocked surface.
-    """
-
-    VERSION = 1
-
-    def __init_subclass__(cls, domain=None, **kwargs):
-        super().__init_subclass__(**kwargs)
-        cls._domain = domain
-
-    def __init__(self):
-        self.context = {}
-
-    def async_show_form(self, *, step_id, **kwargs):
-        return {"type": "form", "step_id": step_id, **kwargs}
-
-    def async_abort(self, *, reason, **kwargs):
-        return {"type": "abort", "reason": reason}
-
-    def async_create_entry(self, *, title, data, **kwargs):
-        """Return the flow result only; the flow manager persists the entry."""
-        return {"type": "create_entry", "title": title, "data": data}
-
-    async def async_set_unique_id(self, unique_id, raise_on_progress=True):
-        self.context["unique_id"] = unique_id
-        return None
-
-    def _async_current_entries(self):
-        return self.hass.config_entries.async_entries(self._domain)
-
-    def _async_in_progress(self):
-        return []
-
-    @staticmethod
-    def async_get_options_flow(config_entry):
-        raise NotImplementedError
-
-
-class _OptionsFlowWithConfigEntryBase:
-    """Stand-in mirroring HA 2024.6 config_entries.OptionsFlowWithConfigEntry."""
-
-    def __init__(self, config_entry=None):
-        self.config_entry = config_entry
-        self.hass = None
-        self.options = dict(config_entry.options) if config_entry is not None else {}
-
-    def async_show_form(self, *, step_id, **kwargs):
-        return {"type": "form", "step_id": step_id, **kwargs}
-
-    def async_create_entry(self, *, title, data, **kwargs):
-        return {"type": "create_entry", "title": title, "data": data}
-
-
-def _callback_decorator(fn):
-    """Mirror homeassistant.core.callback: flags the fn and returns it unchanged."""
-    fn.__ha_callback__ = True
-    return fn
-
-
-# The concrete 2024.6-shaped surface the integration is written against
-# (mirrors the shapes the tests previously installed per module).
-_config_entries_mock = _ha_mock("homeassistant.config_entries")
-_core_mock = _ha_mock("homeassistant.core")
-_data_entry_flow_mock = _ha_mock("homeassistant.data_entry_flow")
-
-_config_entries_mock.ConfigFlow = _ConfigFlowBase
-_config_entries_mock.OptionsFlowWithConfigEntry = _OptionsFlowWithConfigEntryBase
-_core_mock.callback = _callback_decorator
-_data_entry_flow_mock.RESULT_TYPE_FORM = "form"
-_data_entry_flow_mock.RESULT_TYPE_CREATE_ENTRY = "create_entry"
-_data_entry_flow_mock.RESULT_TYPE_ABORT = "abort"
-_data_entry_flow_mock.FlowResult = dict
-
-
-# ---------------------------------------------------------------------------
-# Shared helpers for the behavior tests.
-# ---------------------------------------------------------------------------
-class ListenerRegistry:
-    """Models HA's update-listener bookkeeping: appends to a list per entry, with per-listener removers."""
-
-    def __init__(self, hass=None):
-        self._hass = hass
-        self._listeners: dict[str, list[object]] = {}
-        self.reloaded: list[str] = []
-
-    def add(self, entry_id: str, listener) -> object:
-        def _remove():
-            self._listeners.get(entry_id, []).remove(listener)
-
-        self._listeners.setdefault(entry_id, []).append(listener)
-        return _remove
-
-    async def dispatch_options_update(self, entry) -> None:
-        """Dispatch on the running loop; sync listeners run inline, async ones awaited."""
-        for listener in list(self._listeners.get(entry.entry_id, [])):
-            result = listener(self._hass, entry)
-            if inspect.isawaitable(result):
-                await result
-
-    async_dispatch_options_update = dispatch_options_update
-
-    @property
-    def size(self) -> int:
-        return sum(len(listeners) for listeners in self._listeners.values())
-
-
-def make_config_entry(
-    entry_id: str = "test_entry",
-    options: dict | None = None,
-    data: dict | None = None,
-):
-    """Create a stub config entry shaped like HA's ConfigEntry for tests."""
-    entry = SimpleNamespace(
-        entry_id=entry_id,
-        options=dict(options or {}),
-        data=dict(data or {}),
-    )
-    entry.add_update_listener = None
-    return entry
-
-
-def wire_entry_to_registry(entry, registry: ListenerRegistry):
-    """Attach an update-listener registration function to the entry."""
-    entry.add_update_listener = lambda listener: registry.add(entry.entry_id, listener)
-    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(
-        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:
-        registry.reloaded.append(entry_id)
-
-    hass.config_entries.async_reload = MagicMock(side_effect=_async_reload)
-    hass.config_entries._entries = []
-    hass.config_entries.async_add = (
-        lambda entry: hass.config_entries._entries.append(entry)
-    )
-
-    def _async_entries(domain: str):
-        return [e for e in hass.config_entries._entries if e.domain == domain]
-
-    hass.config_entries.async_entries = _async_entries
-    return hass, registry
-
-
-@pytest.fixture
-async def hass():
-    """Provide a standard-shaped hass fixture bound to the running test loop.
-
-    Mirrors the surface of Home Assistant's ``hass`` fixture: a ``config``
-    namespace, a ``config_entries`` manager wired to a listener registry, a
-    ``data`` dict for integration state, and a ``loop`` bound to the
-    pytest-asyncio loop the test itself runs on (HA's running-loop contract),
-    so code scheduling on ``hass.loop`` runs on the actual test loop.
-    """
-    _hass, registry = make_hass()
-    _hass.registry = registry
-    _hass.loop = asyncio.get_running_loop()
-    yield _hass
-
-
-@pytest.fixture
-def make_entry():
-    """Provide the config-entry factory as a fixture."""
-
-    def _factory(entry_id: str = "test_entry", options: dict | None = None, data: dict | None = None):
-        return make_config_entry(entry_id=entry_id, options=options, data=data)
-
-    return _factory
-
-
-@pytest.fixture
-def listener_registry():
-    """Provide a fresh listener registry for manual wiring."""
-
-    def _factory(hass=None):
-        return ListenerRegistry(hass)
-
-    return _factory
-
-
-@pytest.fixture
-def make_flow():
-    """Provide a factory for a stubbed NestQuestConfigFlow bound to hass."""
-
-    def _factory(hass=None, existing_entries=None, in_progress=None):
-        from custom_components.nestquest import config_flow
-
-        flow = config_flow.NestQuestConfigFlow()
-        flow.hass = hass if hass is not None else make_hass()[0]
-        for entry in existing_entries or []:
-            if getattr(entry, "domain", None) == flow._domain:
-                flow.hass.config_entries.async_add(entry)
-        if in_progress:
-            flow._async_in_progress = lambda: in_progress
-        return flow
-
-    return _factory
-
-
-@pytest.fixture
-def make_config_flow_entry():
-    """Provide an entry stub carrying a domain, for current-entries checks."""
-
-    def _factory(domain: str, entry_id: str = "existing"):
-        return SimpleNamespace(domain=domain, entry_id=entry_id)
-
-    return _factory

tests/test_config_flow.py

@@ -4,6 +4,58 @@ from __future__ import annotations
 import ast
 import json
 from pathlib import Path
+import sys
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+# Mock homeassistant modules if not installed in environment
+for _mod in (
+    "homeassistant",
+    "homeassistant.core",
+    "homeassistant.config_entries",
+    "homeassistant.data_entry_flow",
+):
+    sys.modules.setdefault(_mod, MagicMock())
+
+# Wire parent package attributes to the actual module mocks so that
+# "from homeassistant import config_entries" resolves to the mocked module.
+sys.modules["homeassistant"].config_entries = sys.modules["homeassistant.config_entries"]
+sys.modules["homeassistant"].data_entry_flow = sys.modules["homeassistant.data_entry_flow"]
+
+
+class _ConfigFlowBase:
+    """Minimal stand-in for homeassistant ConfigFlow."""
+
+    VERSION = 1
+
+    def __init_subclass__(cls, domain=None, **kwargs):
+        super().__init_subclass__(**kwargs)
+        cls._domain = domain
+
+    def __init__(self):
+        self.context = {}
+
+    def async_show_form(self, *, step_id, **kwargs):
+        return {"type": "form", "step_id": step_id}
+
+    def async_abort(self, *, reason, **kwargs):
+        return {"type": "abort", "reason": reason}
+
+    def async_create_entry(self, *, title, data, **kwargs):
+        return {"type": "create_entry", "title": title, "data": data}
+
+    async def async_set_unique_id(self, unique_id, raise_on_progress=True):
+        self.context["unique_id"] = unique_id
+        return None
+
+    def _async_current_entries(self):
+        return self.hass.config_entries.async_entries(self._domain)
+
+    def _async_in_progress(self):
+        return []
+
+
+sys.modules["homeassistant.config_entries"].ConfigFlow = _ConfigFlowBase
 
 import pytest
 
@@ -15,63 +67,79 @@ STRINGS_PATH = PKG_DIR / "strings.json"
 TRANSLATIONS_EN_PATH = PKG_DIR / "translations" / "en.json"
 
 
-async def test_flow_shows_form_initially(hass, make_flow) -> None:
+def _run(coro):
+    import asyncio
+
+    return asyncio.new_event_loop().run_until_complete(coro)
+
+
+def _make_flow(existing_entries: list | None = None, in_progress: list | None = None):
+    """Create a config flow instance with a stubbed hass."""
+    flow = config_flow.NestQuestConfigFlow()
+    flow.hass = SimpleNamespace(
+        config_entries=SimpleNamespace(
+            async_entries=lambda domain: [
+                entry
+                for entry in (existing_entries or [])
+                if entry.domain == domain
+            ]
+        )
+    )
+    if in_progress:
+        flow._async_in_progress = lambda: in_progress
+    return flow
+
+
+def _make_entry(domain: str):
+    """Create a stub config entry with the given domain."""
+    return SimpleNamespace(domain=domain)
+
+
+def test_flow_shows_form_initially() -> None:
     """The initial user step shows a form."""
-    flow = make_flow(hass)
-    result = await flow.async_step_user(None)
+    flow = _make_flow()
+    result = _run(flow.async_step_user(None))
     assert result["type"] == "form"
     assert result["step_id"] == "user"
 
 
-async def test_flow_creates_entry_on_submit(hass, make_flow) -> None:
-    """Submitting the user step returns a create-entry result with the payload.
-
-    Real HA's ConfigFlow.async_create_entry only returns the flow result; the
-    flow manager persists the entry afterward.  The manager surface therefore
-    stays empty here — persistence is the manager's job, not the flow's.
-    """
-    flow = make_flow(hass)
-    assert hass.config_entries.async_entries(DOMAIN) == []
-    result = await flow.async_step_user({})
+def test_flow_creates_entry_on_submit() -> None:
+    """Submitting the user step creates a config entry."""
+    flow = _make_flow()
+    result = _run(flow.async_step_user({}))
     assert result["type"] == "create_entry"
     assert result["title"] == "NestQuest"
     assert result["data"] == {}
-    assert hass.config_entries.async_entries(DOMAIN) == []
 
 
-async def test_second_flow_aborts_single_instance(
-    hass, make_flow, make_config_flow_entry
-) -> None:
+def test_second_flow_aborts_single_instance() -> None:
     """A second flow aborts with single_instance_allowed."""
-    existing = make_config_flow_entry(DOMAIN)
-    flow = make_flow(hass, existing_entries=[existing])
-    assert hass.config_entries.async_entries(DOMAIN) == [existing]
-    result = await flow.async_step_user(None)
+    flow = _make_flow([_make_entry(DOMAIN)])
+    result = _run(flow.async_step_user(None))
     assert result["type"] == "abort"
     assert result["reason"] == "single_instance_allowed"
-    assert hass.config_entries.async_entries(DOMAIN) == [existing]
 
 
-async def test_flow_aborts_when_in_progress(hass, make_flow) -> None:
+def test_flow_aborts_when_in_progress() -> None:
     """A concurrent flow in progress aborts with single_instance_allowed."""
-    flow = make_flow(hass, in_progress=[{"flow_id": "other"}])
-    result = await flow.async_step_user(None)
+    flow = _make_flow(in_progress=[{"flow_id": "other"}])
+    result = _run(flow.async_step_user(None))
     assert result["type"] == "abort"
     assert result["reason"] == "single_instance_allowed"
 
 
-async def test_flow_sets_stable_unique_id(hass, make_flow) -> None:
+def test_flow_sets_stable_unique_id() -> None:
     """The flow assigns a stable unique id equal to the domain."""
-    flow = make_flow(hass)
+    flow = _make_flow()
     assert flow.context.get("unique_id") is None
-    await flow.async_step_user(None)
+    _run(flow.async_step_user(None))
     assert flow.context["unique_id"] == DOMAIN
 
 
-async def test_flow_ignores_other_domain_entries(hass, make_flow, make_config_flow_entry) -> None:
+def test_flow_ignores_other_domain_entries() -> None:
     """Entries of other domains do not trigger the abort."""
-    flow = make_flow(hass, existing_entries=[make_config_flow_entry("other_domain")])
-    result = await flow.async_step_user(None)
+    flow = _make_flow([_make_entry("other_domain")])
+    result = _run(flow.async_step_user(None))
     assert result["type"] == "form"
     assert result["step_id"] == "user"
 

tests/test_const.py

@@ -5,6 +5,12 @@ import ast
 from datetime import datetime
 import logging
 from pathlib import Path
+import sys
+from unittest.mock import MagicMock
+
+# Mock homeassistant modules if not installed in environment
+for _mod in ("homeassistant", "homeassistant.core", "homeassistant.config_entries"):
+    sys.modules.setdefault(_mod, MagicMock())
 
 from custom_components.nestquest import const
 

tests/test_dao_children.py

@@ -1,563 +0,0 @@
-"""Tests for dao_children.py: typed DAO for children and admin_users."""
-from __future__ import annotations
-
-import asyncio
-import sqlite3
-
-import pytest
-
-from custom_components.nestquest.dao_children import (
-    AdminUserRecord,
-    AdminUsersDao,
-    ChildRecord,
-    ChildrenDao,
-)
-from custom_components.nestquest.db import NestQuestDatabase
-from custom_components.nestquest.schema import SCHEMA_V1_STATEMENTS
-from custom_components.nestquest.migrations import apply_migrations
-
-
-def _run(coro):
-    return asyncio.new_event_loop().run_until_complete(coro)
-
-
-def _make_hass_mock():
-    from unittest.mock import AsyncMock, MagicMock
-
-    hass = MagicMock()
-    hass.async_add_executor_job = AsyncMock(side_effect=(lambda fn, *a: fn(*a)))
-    return hass
-
-
-def _open_db(path) -> NestQuestDatabase:
-    database = NestQuestDatabase(_make_hass_mock())
-    _run(database.open(path))
-    _run(apply_migrations(database))
-    return database
-
-
-def _daos(database) -> tuple[ChildrenDao, AdminUsersDao]:
-    return ChildrenDao(database), AdminUsersDao(database)
-
-
-NOW = "2026-09-14T11:00:00+00:00"
-
-
-def _make_child(dao, name="Ada", **kwargs) -> ChildRecord:
-    return _run(dao.create(name, NOW, **kwargs))
-
-
-# ---------------------------------------------------------------------------
-# children: create and get
-# ---------------------------------------------------------------------------
-
-
-def test_create_returns_typed_record(tmp_path) -> None:
-    database = _open_db(tmp_path / "create.db")
-    try:
-        dao, _ = _daos(database)
-        child = _make_child(dao, colour="#ff0000", avatar_ref="avatars/1")
-        assert isinstance(child, ChildRecord)
-        assert child.id == 1
-        assert child.display_name == "Ada"
-        assert child.colour == "#ff0000"
-        assert child.avatar_ref == "avatars/1"
-        assert child.sort_order == 0
-        assert child.is_active is True
-        assert child.created_at == NOW
-    finally:
-        _run(database.close())
-
-
-def test_get_returns_none_for_missing_child(tmp_path) -> None:
-    database = _open_db(tmp_path / "get-missing.db")
-    try:
-        dao, _ = _daos(database)
-        assert _run(dao.get(999)) is None
-    finally:
-        _run(database.close())
-
-
-def test_create_duplicate_name_is_allowed(tmp_path) -> None:
-    database = _open_db(tmp_path / "dup-name.db")
-    try:
-        dao, _ = _daos(database)
-        first = _make_child(dao, "Ada")
-        second = _make_child(dao, "Ada")
-        assert first.id != second.id
-    finally:
-        _run(database.close())
-
-
-# ---------------------------------------------------------------------------
-# children: list active / list all
-# ---------------------------------------------------------------------------
-
-
-def test_list_active_excludes_inactive_and_sorts(tmp_path) -> None:
-    database = _open_db(tmp_path / "list-active.db")
-    try:
-        dao, _ = _daos(database)
-        _make_child(dao, "Bo", sort_order=2)
-        ada = _make_child(dao, "Ada", sort_order=1)
-        cy = _make_child(dao, "Cy", sort_order=1)
-        _make_child(dao, "Dee", sort_order=0)
-        _run(dao.set_active(ada.id, False))
-        active = _run(dao.list_active())
-        assert [c.display_name for c in active] == ["Dee", "Cy", "Bo"]
-        assert all(c.is_active for c in active)
-    finally:
-        _run(database.close())
-
-
-def test_list_all_includes_inactive(tmp_path) -> None:
-    database = _open_db(tmp_path / "list-all.db")
-    try:
-        dao, _ = _daos(database)
-        ada = _make_child(dao, "Ada", sort_order=1)
-        _make_child(dao, "Bo", sort_order=0)
-        _run(dao.set_active(ada.id, False))
-        all_children = _run(dao.list_all())
-        assert [c.display_name for c in all_children] == ["Bo", "Ada"]
-        assert all_children[1].is_active is False
-    finally:
-        _run(database.close())
-
-
-# ---------------------------------------------------------------------------
-# children: update, set_active, reorder
-# ---------------------------------------------------------------------------
-
-
-def test_update_fields_round_trip(tmp_path) -> None:
-    database = _open_db(tmp_path / "update.db")
-    try:
-        dao, _ = _daos(database)
-        child = _make_child(dao, "Ada", colour="#111111")
-        updated = _run(
-            dao.update(
-                child.id,
-                display_name="Ada L.",
-                colour="#222222",
-                avatar_ref="avatars/x.png",
-            )
-        )
-        assert updated == 1
-        fetched = _run(dao.get(child.id))
-        assert fetched is not None
-        assert fetched.display_name == "Ada L."
-        assert fetched.colour == "#222222"
-        assert fetched.avatar_ref == "avatars/x.png"
-        assert fetched.sort_order == 0
-    finally:
-        _run(database.close())
-
-
-def test_update_omitted_fields_untouched(tmp_path) -> None:
-    database = _open_db(tmp_path / "update-partial.db")
-    try:
-        dao, _ = _daos(database)
-        child = _make_child(dao, "Ada", colour="#111111")
-        _run(dao.update(child.id, display_name="Ada L."))
-        fetched = _run(dao.get(child.id))
-        assert fetched.colour == "#111111"
-    finally:
-        _run(database.close())
-
-
-def test_update_no_fields_returns_zero_and_changes_nothing(tmp_path) -> None:
-    database = _open_db(tmp_path / "update-empty.db")
-    try:
-        dao, _ = _daos(database)
-        child = _make_child(dao, "Ada")
-        assert _run(dao.update(child.id)) == 0
-        fetched = _run(dao.get(child.id))
-        assert fetched is not None and fetched.display_name == "Ada"
-    finally:
-        _run(database.close())
-
-
-def test_update_missing_child_returns_zero(tmp_path) -> None:
-    database = _open_db(tmp_path / "update-missing.db")
-    try:
-        dao, _ = _daos(database)
-        assert _run(dao.update(999, display_name="X")) == 0
-    finally:
-        _run(database.close())
-
-
-def test_set_active_missing_child_returns_zero(tmp_path) -> None:
-    database = _open_db(tmp_path / "set-active-missing.db")
-    try:
-        dao, _ = _daos(database)
-        assert _run(dao.set_active(999, False)) == 0
-    finally:
-        _run(database.close())
-
-
-def test_reorder_assigns_positions_in_order(tmp_path) -> None:
-    database = _open_db(tmp_path / "reorder.db")
-    try:
-        dao, _ = _daos(database)
-        a = _make_child(dao, "Ada")
-        b = _make_child(dao, "Bo")
-        c = _make_child(dao, "Cy")
-        _run(dao.reorder([c.id, a.id, b.id]))
-        children = _run(dao.list_all())
-        assert [x.display_name for x in children] == ["Cy", "Ada", "Bo"]
-        assert [x.sort_order for x in children] == [0, 1, 2]
-    finally:
-        _run(database.close())
-
-
-def test_reorder_is_transactional_and_idempotent(tmp_path) -> None:
-    database = _open_db(tmp_path / "reorder-idempotent.db")
-    try:
-        dao, _ = _daos(database)
-        a = _make_child(dao, "Ada")
-        b = _make_child(dao, "Bo")
-        _run(dao.reorder([b.id, a.id]))
-        _run(dao.reorder([b.id, a.id]))
-        children = _run(dao.list_all())
-        assert [(x.display_name, x.sort_order) for x in children] == [
-            ("Bo", 0),
-            ("Ada", 1),
-        ]
-    finally:
-        _run(database.close())
-
-
-def test_reorder_empty_list_is_noop(tmp_path) -> None:
-    database = _open_db(tmp_path / "reorder-empty.db")
-    try:
-        dao, _ = _daos(database)
-        _make_child(dao, "Ada")
-        _run(dao.reorder([]))
-        children = _run(dao.list_all())
-        assert children[0].sort_order == 0
-    finally:
-        _run(database.close())
-
-
-def test_reorder_unknown_id_leaves_it_untouched(tmp_path) -> None:
-    database = _open_db(tmp_path / "reorder-unknown.db")
-    try:
-        dao, _ = _daos(database)
-        a = _make_child(dao, "Ada")
-        _run(dao.reorder([a.id, 999]))
-        children = _run(dao.list_all())
-        assert children[0].sort_order == 0
-    finally:
-        _run(database.close())
-
-
-def test_reorder_rolls_back_to_original_order_on_failure(tmp_path) -> None:
-    """A failing finalize batch rolls the whole reorder back.
-
-    The two-phase staging is only meaningful if a crash between the
-    batches leaves the original order intact: monkeypatch execute_many
-    so the finalize (non-negative) batch raises, then assert every
-    sort_order is unchanged.
-    """
-    database = _open_db(tmp_path / "reorder-rollback.db")
-    try:
-        dao, _ = _daos(database)
-        a = _make_child(dao, "Ada", sort_order=0)
-        b = _make_child(dao, "Bo", sort_order=1)
-
-        original_execute_many = database.execute_many
-
-        async def _failing_execute_many(sql, parameters):
-            # The staging batch writes negative positions; the finalize
-            # batch writes 0..n-1.  Fail the finalize batch.
-            if all(position >= 0 for position, _ in parameters):
-                raise sqlite3.OperationalError("boom")
-            return await original_execute_many(sql, parameters)
-
-        database.execute_many = _failing_execute_many
-        with pytest.raises(sqlite3.OperationalError, match="boom"):
-            _run(dao.reorder([b.id, a.id]))
-        children = _run(dao.list_all())
-        assert [(c.display_name, c.sort_order) for c in children] == [
-            ("Ada", 0),
-            ("Bo", 1),
-        ], "failed reorder must leave original sort orders intact"
-    finally:
-        _run(database.close())
-
-
-def test_reorder_rejects_duplicate_ids(tmp_path) -> None:
-    database = _open_db(tmp_path / "reorder-duplicate.db")
-    try:
-        dao, _ = _daos(database)
-        a = _make_child(dao, "Ada")
-        with pytest.raises(ValueError, match="duplicate"):
-            _run(dao.reorder([a.id, a.id]))
-        fetched = _run(dao.get(a.id))
-        assert fetched is not None and fetched.sort_order == 0
-    finally:
-        _run(database.close())
-
-
-def test_reorder_concurrent_calls_serialize(tmp_path) -> None:
-    """Concurrent reorders from DIFFERENT DAO instances queue safely.
-
-    Two ChildrenDao objects over one connection race two reorders: the
-    connection-scoped lock makes the second wait, then run against the
-    first call's final state.  Without the lock the wrapper's
-    transaction() would reject the second concurrent transaction with
-    RuntimeError.
-    """
-    async def _main() -> None:
-        database = NestQuestDatabase(_make_hass_mock())
-        await database.open(tmp_path / "reorder-concurrent.db")
-        try:
-            await apply_migrations(database)
-            dao_a, _ = _daos(database)
-            a = await dao_a.create("Ada", NOW)
-            b = await dao_a.create("Bo", NOW)
-            dao_b, _ = _daos(database)  # second instance, same connection
-            task_1 = asyncio.ensure_future(dao_a.reorder([b.id, a.id]))
-            await asyncio.sleep(0)
-            task_2 = asyncio.ensure_future(dao_b.reorder([a.id, b.id]))
-            await asyncio.gather(task_1, task_2)
-            children = await dao_a.list_all()
-            orders = {c.display_name: c.sort_order for c in children}
-            assert sorted(orders.values()) == [0, 1]
-        finally:
-            await database.close()
-
-    _run(_main())
-
-
-# ---------------------------------------------------------------------------
-# admin_users: add, remove, list, exists
-# ---------------------------------------------------------------------------
-
-
-def test_admin_add_then_exists(tmp_path) -> None:
-    database = _open_db(tmp_path / "admin-add.db")
-    try:
-        _, dao = _daos(database)
-        assert _run(dao.add("user-1", NOW)) is True
-        assert _run(dao.exists("user-1")) is True
-        assert _run(dao.exists("user-2")) is False
-    finally:
-        _run(database.close())
-
-
-def test_admin_add_is_idempotent(tmp_path) -> None:
-    database = _open_db(tmp_path / "admin-idempotent.db")
-    try:
-        _, dao = _daos(database)
-        assert _run(dao.add("user-1", NOW)) is True
-        assert _run(dao.add("user-1", NOW)) is False
-        records = _run(dao.list())
-        assert len(records) == 1
-        assert records[0].added_at == NOW
-    finally:
-        _run(database.close())
-
-
-def test_admin_add_concurrent_calls_are_idempotent(tmp_path) -> None:
-    """Concurrent add() calls of the same user: one inserts, rest False.
-
-    The single-statement ON CONFLICT DO NOTHING makes the decision and
-    the write atomic per statement, so racing coroutines cannot both
-    'see no row' and one of them raise IntegrityError.
-    """
-    async def _main() -> None:
-        database = NestQuestDatabase(_make_hass_mock())
-        await database.open(tmp_path / "admin-race.db")
-        try:
-            await apply_migrations(database)
-            _, dao = _daos(database)
-            tasks = [
-                asyncio.ensure_future(dao.add("user-1", NOW))
-                for _ in range(5)
-            ]
-            await asyncio.sleep(0)
-            results = list(await asyncio.gather(*tasks))
-            assert sorted(results) == [False, False, False, False, True]
-            records = await dao.list()
-            assert len(records) == 1
-            assert records[0].added_at == NOW
-        finally:
-            await database.close()
-
-    _run(_main())
-
-
-def test_admin_add_preserves_original_added_at(tmp_path) -> None:
-    database = _open_db(tmp_path / "admin-added-at.db")
-    try:
-        _, dao = _daos(database)
-        _run(dao.add("user-1", NOW))
-        _run(dao.add("user-1", "2026-09-15T00:00:00+00:00"))
-        records = _run(dao.list())
-        assert records[0].added_at == NOW
-    finally:
-        _run(database.close())
-
-
-def test_admin_remove_returns_true_then_false(tmp_path) -> None:
-    database = _open_db(tmp_path / "admin-remove.db")
-    try:
-        _, dao = _daos(database)
-        _run(dao.add("user-1", NOW))
-        assert _run(dao.remove("user-1")) is True
-        assert _run(dao.remove("user-1")) is False
-        assert _run(dao.exists("user-1")) is False
-    finally:
-        _run(database.close())
-
-
-def test_admin_list_returns_typed_records_ordered(tmp_path) -> None:
-    database = _open_db(tmp_path / "admin-list.db")
-    try:
-        _, dao = _daos(database)
-        _run(dao.add("user-2", "2026-09-14T10:00:00+00:00"))
-        _run(dao.add("user-1", "2026-09-14T09:00:00+00:00"))
-        records = _run(dao.list())
-        assert isinstance(records[0], AdminUserRecord)
-        assert [r.ha_user_id for r in records] == ["user-1", "user-2"]
-        assert records[0].added_at == "2026-09-14T09:00:00+00:00"
-    finally:
-        _run(database.close())
-
-
-def test_admin_exists_empty_allowlist_fails_closed(tmp_path) -> None:
-    database = _open_db(tmp_path / "admin-empty.db")
-    try:
-        _, dao = _daos(database)
-        assert _run(dao.exists("user-1")) is False
-        assert _run(dao.list()) == []
-    finally:
-        _run(database.close())
-
-
-def test_admin_records_are_typed_not_raw_rows(tmp_path) -> None:
-    database = _open_db(tmp_path / "admin-typed.db")
-    try:
-        _, dao = _daos(database)
-        _run(dao.add("user-1", NOW))
-        records = _run(dao.list())
-        assert records == [AdminUserRecord("user-1", NOW)]
-    finally:
-        _run(database.close())
-
-
-# ---------------------------------------------------------------------------
-# No SQL for these tables outside the DAO module
-# ---------------------------------------------------------------------------
-
-
-def test_children_and_admin_sql_lives_only_in_dao_module() -> None:
-    """Guardrail: children/admin_users SQL may appear only in the DAO
-    (and the schema DDL declarations).  Scans the integration package
-    AND the repo's test files RECURSIVELY, matching FROM/INTO/UPDATE/
-    DELETE FROM/JOIN against either table — including DELETE FROM
-    children, the hard-delete path the guardrail forbids.
-
-    Exclusions are exact repo-relative paths, narrowly justified:
-    schema.py declares the tables' DDL; migrations.py applies that DDL;
-    test_schema.py and test_migrations.py test exactly those
-    DDL/migration layers.  None of them touch the tables' data paths —
-    that is the DAO's job.
-    """
-    import re
-    from pathlib import Path
-
-    package = Path(
-        __import__(
-            "custom_components.nestquest", fromlist=["__file__"]
-        ).__file__
-    ).parent
-    repo_root = package.parent.parent
-    scan_roots = [package, repo_root / "tests"]
-
-    allowed = {
-        "custom_components/nestquest/dao_children.py",  # the DAO itself
-        "custom_components/nestquest/dao_rules.py",  # validates child
-        # activeness on assignment (FK to children, done-condition
-        # 'validates that the assigned child is active')
-        "custom_components/nestquest/dao_presence.py",  # validates the
-        # schedule/override child exists before writing (same FK shape
-        # as dao_rules: one existence SELECT per write)
-        "custom_components/nestquest/dao_instances.py",  # validates the
-        # instance/event child exists before writing (same FK shape)
-        "custom_components/nestquest/schema.py",  # declares the DDL
-        "custom_components/nestquest/migrations.py",  # applies the DDL
-        "tests/test_schema.py",  # tests the DDL
-        "tests/test_migrations.py",  # tests migration application
-        "tests/test_dao_children.py",  # this file, scanned separately
-        "tests/test_dao_rules.py",  # rules/definitions guard, own scope
-        "tests/test_dao_presence.py",  # presence guard, own scope
-    }
-    sql_pattern = re.compile(
-        r"(FROM|INTO|UPDATE|DELETE\s+FROM|JOIN)\s+"
-        r'["\`]*(children|admin_users)["\`]*\b',
-        re.IGNORECASE,
-    )
-    offenders: list[str] = []
-    for root in scan_roots:
-        for py in sorted(root.rglob("*.py")):
-            relative = py.relative_to(repo_root).as_posix()
-            if relative in allowed:
-                continue
-            if sql_pattern.search(py.read_text()):
-                offenders.append(relative)
-    assert offenders == [], (
-        f"SQL touching children/admin_users leaked into: {offenders}"
-    )
-
-
-def test_dao_test_file_uses_dao_not_raw_table_sql() -> None:
-    """This test module must exercise the DAO, not raw SQL, for these
-    tables.  The two guard functions in this file necessarily mention
-    the table names inside their regex patterns; their source spans are
-    removed BEFORE the scan, and the remaining lines are then scanned
-    as ONE combined blob (not line-by-line), so SQL split across
-    physical lines — e.g. an implicitly concatenated string ending in
-    FROM children — is still caught.  The guard regexes themselves
-    cannot match the SQL keyword pattern, so removing the spans only
-    spares regex text, not executable SQL.
-    """
-    import ast
-    import re
-    from pathlib import Path
-
-    path = Path(__file__)
-    text = path.read_text()
-    lines = text.splitlines(keepends=True)
-    tree = ast.parse(text)
-    guard_names = {
-        "test_children_and_admin_sql_lives_only_in_dao_module",
-        "test_dao_test_file_uses_dao_not_raw_table_sql",
-    }
-    excluded: set[int] = set()
-    for node in ast.walk(tree):
-        if (
-            isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
-            and node.name in guard_names
-        ):
-            excluded.update(
-                range(node.lineno, (node.end_lineno or node.lineno) + 1)
-            )
-
-    # Scan the source minus excluded lines as ONE blob so SQL split
-    # across physical lines cannot evade the pattern.
-    remaining = "".join(
-        line
-        for number, line in enumerate(lines, start=1)
-        if number not in excluded
-    )
-    sql_pattern = re.compile(
-        r"(SELECT\s[^\"']*?FROM|INSERT\s+INTO|UPDATE|"
-        r"DELETE\s+FROM|FROM|JOIN)\s+[`'\"]*(\[)?"
-        r"(children|admin_users)\b",
-        re.IGNORECASE,
-    )
-    assert sql_pattern.search(remaining) is None, (
-        "tests must go through the DAO, not raw SQL, for these tables"
-    )

tests/test_dao_presence.py

@@ -1,622 +0,0 @@
-"""Tests for dao_presence.py: presence schedules and overrides DAO."""
-from __future__ import annotations
-
-import asyncio
-import sqlite3
-
-import pytest
-
-from custom_components.nestquest.dao_children import ChildrenDao
-from custom_components.nestquest.dao_presence import (
-    PresenceOverrideRecord,
-    PresenceOverridesDao,
-    PresenceScheduleRecord,
-    PresenceSchedulesDao,
-)
-from custom_components.nestquest.db import NestQuestDatabase
-from custom_components.nestquest.migrations import apply_migrations
-
-
-def _run(coro):
-    return asyncio.new_event_loop().run_until_complete(coro)
-
-
-def _make_hass_mock():
-    from unittest.mock import AsyncMock, MagicMock
-
-    hass = MagicMock()
-    hass.async_add_executor_job = AsyncMock(side_effect=(lambda fn, *a: fn(*a)))
-    return hass
-
-
-NOW = "2026-09-14T12:00:00+00:00"
-
-
-async def _prepare(path) -> tuple:
-    database = NestQuestDatabase(_make_hass_mock())
-    await database.open(path)
-    await apply_migrations(database)
-    schedules = PresenceSchedulesDao(database)
-    overrides = PresenceOverridesDao(database)
-    children = ChildrenDao(database)
-    child = await children.create("Ada", NOW)
-    return database, schedules, overrides, children, child
-
-
-def _with_db(tmp_path, name):
-    def _run_test(body):
-        async def _main():
-            database, schedules, overrides, children, child = await _prepare(
-                tmp_path / name
-            )
-            try:
-                return await body(
-                    database, schedules, overrides, children, child
-                )
-            finally:
-                await database.close()
-
-        return _run(_main())
-
-    return _run_test
-
-
-# ---------------------------------------------------------------------------
-# presence_schedules: upsert by child
-# ---------------------------------------------------------------------------
-
-
-def test_upsert_creates_then_updates_same_row(tmp_path) -> None:
-    """Second upsert for the same child UPDATES, not raises."""
-    async def _body(database, schedules, overrides, children, child):
-        first = await schedules.upsert_by_child(
-            child.id, 2, "2026-09-07", "0,2,4|1,3"
-        )
-        assert isinstance(first, PresenceScheduleRecord)
-        assert first.child_id == child.id
-        second = await schedules.upsert_by_child(
-            child.id, 2, "2026-09-14", "1,3|0,2,4"
-        )
-        assert second.id == first.id, "upsert must reuse the existing row"
-        fetched = await schedules.get_by_child(child.id)
-        assert fetched.anchor_date == "2026-09-14"
-        assert fetched.pattern == "1,3|0,2,4"
-        rows = await database.fetch_one(
-            "SELECT COUNT(*) FROM presence_schedules"
-        )
-        assert rows == (1,)
-        return second
-
-    _with_db(tmp_path, "upsert.db")(_body)
-
-
-def test_upsert_typed_record_fields(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        record = await schedules.upsert_by_child(
-            child.id, 4, "2026-09-07", "0|1|2|3"
-        )
-        assert record.id == 1
-        assert record.child_id == child.id
-        assert record.cycle_length_weeks == 4
-        assert record.anchor_date == "2026-09-07"
-        assert record.pattern == "0|1|2|3"
-        return record
-
-    _with_db(tmp_path, "upsert-fields.db")(_body)
-
-
-def test_upsert_unknown_child_raises_value_error(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        with pytest.raises(ValueError, match="does not exist"):
-            await schedules.upsert_by_child(
-                999, 2, "2026-09-07", "0,2|1,3"
-            )
-        return None
-
-    _with_db(tmp_path, "upsert-bad-child.db")(_body)
-
-
-def test_upsert_malformed_anchor_date_raises(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        for bad in ("not-a-date", "2026-9-7", "2026-13-01", ""):
-            with pytest.raises(ValueError, match="YYYY-MM-DD"):
-                await schedules.upsert_by_child(child.id, 2, bad, "0|1")
-        return None
-
-    _with_db(tmp_path, "upsert-bad-date.db")(_body)
-
-
-def test_upsert_malformed_pattern_rejected_by_schema(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        with pytest.raises(sqlite3.IntegrityError, match="CHECK"):
-            await schedules.upsert_by_child(
-                child.id, 2, "2026-09-07", "0,2"
-            )
-        return None
-
-    _with_db(tmp_path, "upsert-bad-pattern.db")(_body)
-
-
-def test_upsert_two_children_have_distinct_rows(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        other = await children.create("Bo", NOW)
-        await schedules.upsert_by_child(child.id, 2, "2026-09-07", "0,2|1,3")
-        await schedules.upsert_by_child(other.id, 2, "2026-09-07", "1,3|0,2")
-        mine = await schedules.get_by_child(child.id)
-        theirs = await schedules.get_by_child(other.id)
-        assert mine.id != theirs.id
-        assert mine.pattern == "0,2|1,3"
-        assert theirs.pattern == "1,3|0,2"
-        return mine
-
-    _with_db(tmp_path, "upsert-two-children.db")(_body)
-
-
-def test_upsert_concurrent_same_child_serializes(tmp_path) -> None:
-    """Racing upserts for one child both succeed; exactly one row.
-
-    Deterministic interleaving: a controllable executor gates task A's
-    job AFTER it has acquired the connection lock and begun its
-    transaction, so task B is created while A provably owns the
-    transaction and must queue on the lock.  Both upserts land, and
-    the table holds exactly one row (the ON CONFLICT upsert, not two
-    plain INSERTs, is what avoids a UNIQUE violation).
-    """
-    async def _main():
-        from unittest.mock import MagicMock
-
-        hass = MagicMock()
-        # Gate exactly ONE job: the first _fetch_one issued after
-        # arming, which is task A's child-existence SELECT inside its
-        # transaction.  The transaction's BEGIN runs first and is NOT
-        # gated, so when the gated fetch signals, BEGIN has executed
-        # and SQLite is inside the open transaction (A holds the
-        # connection lock from BEGIN until commit).  Everything before
-        # arming (open, migrations, child create)
-        # and everything after (B's jobs, A's remaining jobs, reads)
-        # pass straight through.
-        armed = {"active": False, "gated": False}
-        gate_open = asyncio.Event()
-        a_started = asyncio.Event()
-
-        async def _gated_executor(fn, *args):
-            # Gate the SECOND gated-window job: the first is the
-            # transaction's BEGIN (submitted and awaited by
-            # transaction() before upsert_by_child's child-SELECT
-            # runs).  Pausing the child-existence SELECT proves the
-            # BEGIN has EXECUTED — SQLite is actually inside the open
-            # transaction, with A holding the connection lock — when
-            # task B gets scheduled and must queue.
-            if armed["active"]:
-                name = getattr(fn, "__name__", "")
-                if name == "_fetch_one" and not armed["gated"]:
-                    armed["gated"] = True
-                    a_started.set()
-                    await gate_open.wait()
-            return fn(*args)
-
-        hass.async_add_executor_job = _gated_executor
-        database = NestQuestDatabase(hass)
-        await database.open(tmp_path / "upsert-race.db")
-        try:
-            await apply_migrations(database)
-            children = ChildrenDao(database)
-            schedules = PresenceSchedulesDao(database)
-            child = await children.create("Ada", NOW)
-
-            armed["active"] = True
-            task_a = asyncio.ensure_future(
-                schedules.upsert_by_child(
-                    child.id, 2, "2026-09-07", "0,2|1,3"
-                )
-            )
-            # Wait until task A's child-existence SELECT (inside its
-            # open transaction, BEGIN already executed) is paused, then
-            # schedule task B so it must queue behind the open
-            # transaction.
-            await a_started.wait()
-            armed["active"] = False
-            task_b = asyncio.ensure_future(
-                schedules.upsert_by_child(
-                    child.id, 2, "2026-09-14", "1,3|0,2"
-                )
-            )
-            await asyncio.sleep(0)
-            # Release A; B's upsert must wait for A's commit and then
-            # land as the ON CONFLICT update path.
-            gate_open.set()
-            record_a, record_b = await asyncio.gather(task_a, task_b)
-            assert record_a.id == record_b.id
-            fetched = await schedules.get_by_child(child.id)
-            assert fetched is not None
-            rows = await database.fetch_one(
-                "SELECT COUNT(*) FROM presence_schedules"
-            )
-            assert rows == (1,)
-            return fetched
-        finally:
-            await database.close()
-
-    fetched = _run(_main())
-    assert fetched.pattern in {"0,2|1,3", "1,3|0,2"}
-
-
-# ---------------------------------------------------------------------------
-# presence_schedules: get / delete
-# ---------------------------------------------------------------------------
-
-
-def test_get_by_child_missing_schedule_returns_none(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        return await schedules.get_by_child(child.id)
-
-    assert _with_db(tmp_path, "get-none.db")(_body) is None
-
-
-def test_get_by_child_unknown_child_raises(tmp_path) -> None:
-    """None must mean ONLY 'no schedule row': an unknown child id is a
-    caller bug, and silently reading a nonexistent child as 'present
-    every day' would be wrong — so get raises instead.
-    """
-    async def _body(database, schedules, overrides, children, child):
-        with pytest.raises(ValueError, match="does not exist"):
-            await schedules.get_by_child(999)
-        return None
-
-    _with_db(tmp_path, "get-unknown.db")(_body)
-
-
-def test_delete_removes_and_returns_true_then_false(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        await schedules.upsert_by_child(child.id, 2, "2026-09-07", "0,2|1,3")
-        assert await schedules.delete(child.id) is True
-        assert await schedules.get_by_child(child.id) is None
-        assert await schedules.delete(child.id) is False
-        return None
-
-    _with_db(tmp_path, "delete.db")(_body)
-
-
-def test_delete_child_without_schedule_returns_false(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        return await schedules.delete(child.id)
-
-    assert _with_db(tmp_path, "delete-none.db")(_body) is False
-
-
-def test_delete_then_upsert_creates_fresh_row(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        first = await schedules.upsert_by_child(
-            child.id, 2, "2026-09-07", "0,2|1,3"
-        )
-        await schedules.delete(child.id)
-        second = await schedules.upsert_by_child(
-            child.id, 2, "2026-09-07", "0,2|1,3"
-        )
-        assert second.id != first.id
-        return second
-
-    _with_db(tmp_path, "delete-recreate.db")(_body)
-
-
-# ---------------------------------------------------------------------------
-# presence_overrides: create / list / delete
-# ---------------------------------------------------------------------------
-
-
-def test_override_create_returns_typed_record(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        record = await overrides.create(
-            child.id, "2026-12-21", "2027-01-04", False,
-            note="Holiday abroad",
-        )
-        assert isinstance(record, PresenceOverrideRecord)
-        assert record.child_id == child.id
-        assert record.start_date == "2026-12-21"
-        assert record.end_date == "2027-01-04"
-        assert record.is_present is False
-        assert record.note == "Holiday abroad"
-        return record
-
-    _with_db(tmp_path, "override-create.db")(_body)
-
-
-def test_override_create_single_day_same_start_and_end(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        record = await overrides.create(
-            child.id, "2026-09-14", "2026-09-14", True
-        )
-        assert record.start_date == record.end_date
-        assert record.is_present is True
-        assert record.note is None
-        return record
-
-    _with_db(tmp_path, "override-single-day.db")(_body)
-
-
-def test_override_create_unknown_child_raises(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        with pytest.raises(ValueError, match="does not exist"):
-            await overrides.create(
-                999, "2026-09-14", "2026-09-14", True
-            )
-        return None
-
-    _with_db(tmp_path, "override-bad-child.db")(_body)
-
-
-def test_override_create_malformed_dates_raise(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        for bad in ("not-a-date", "2026-9-14", ""):
-            with pytest.raises(ValueError, match="YYYY-MM-DD"):
-                await overrides.create(child.id, bad, "2026-09-14", True)
-            with pytest.raises(ValueError, match="YYYY-MM-DD"):
-                await overrides.create(child.id, "2026-09-14", bad, True)
-        return None
-
-    _with_db(tmp_path, "override-bad-dates.db")(_body)
-
-
-def test_override_end_before_start_rejected_by_schema(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        with pytest.raises(sqlite3.IntegrityError, match="CHECK"):
-            await overrides.create(
-                child.id, "2026-09-14", "2026-09-13", True
-            )
-        return None
-
-    _with_db(tmp_path, "override-end-before-start.db")(_body)
-
-
-def test_override_list_by_child_and_range_filters_correctly(
-    tmp_path,
-) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        await overrides.create(
-            child.id, "2026-09-01", "2026-09-05", False, note="before"
-        )
-        inside = await overrides.create(
-            child.id, "2026-09-10", "2026-09-12", False, note="inside"
-        )
-        overlapping = await overrides.create(
-            child.id, "2026-09-20", "2026-09-25", True, note="overlap"
-        )
-        after = await overrides.create(
-            child.id, "2026-10-01", "2026-10-02", False, note="after"
-        )
-        found = await overrides.list_by_child_and_range(
-            child.id, "2026-09-09", "2026-09-22"
-        )
-        assert [r.id for r in found] == [inside.id, overlapping.id]
-        # Inclusive boundaries: a range touching the override's edges
-        # still matches.
-        edge = await overrides.list_by_child_and_range(
-            child.id, "2026-09-20", "2026-09-20"
-        )
-        assert [r.id for r in edge] == [overlapping.id]
-        return found
-
-    _with_db(tmp_path, "override-list-range.db")(_body)
-
-
-def test_override_list_orders_by_start_date(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        late = await overrides.create(
-            child.id, "2026-09-20", "2026-09-21", True
-        )
-        early = await overrides.create(
-            child.id, "2026-09-10", "2026-09-11", False
-        )
-        found = await overrides.list_by_child_and_range(
-            child.id, "2026-09-01", "2026-09-30"
-        )
-        assert [r.id for r in found] == [early.id, late.id]
-        return found
-
-    _with_db(tmp_path, "override-list-order.db")(_body)
-
-
-def test_override_list_per_child_isolation(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        other = await children.create("Bo", NOW)
-        await overrides.create(child.id, "2026-09-10", "2026-09-11", True)
-        await overrides.create(other.id, "2026-09-10", "2026-09-11", False)
-        mine = await overrides.list_by_child_and_range(
-            child.id, "2026-09-01", "2026-09-30"
-        )
-        assert len(mine) == 1
-        assert mine[0].is_present is True
-        return mine
-
-    _with_db(tmp_path, "override-isolation.db")(_body)
-
-
-def test_override_list_malformed_range_raises(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        with pytest.raises(ValueError, match="YYYY-MM-DD"):
-            await overrides.list_by_child_and_range(
-                child.id, "oops", "2026-09-30"
-            )
-        with pytest.raises(ValueError, match="on or after"):
-            await overrides.list_by_child_and_range(
-                child.id, "2026-09-30", "2026-09-01"
-            )
-        return None
-
-    _with_db(tmp_path, "override-list-bad-range.db")(_body)
-
-
-def test_override_list_unknown_child_returns_empty(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        return await overrides.list_by_child_and_range(
-            999, "2026-09-01", "2026-09-30"
-        )
-
-    assert _with_db(tmp_path, "override-list-unknown.db")(_body) == []
-
-
-def test_override_delete_round_trip(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        record = await overrides.create(
-            child.id, "2026-09-10", "2026-09-11", True
-        )
-        assert await overrides.delete(record.id) is True
-        found = await overrides.list_by_child_and_range(
-            child.id, "2026-09-01", "2026-09-30"
-        )
-        assert found == []
-        assert await overrides.delete(record.id) is False
-        return None
-
-    _with_db(tmp_path, "override-delete.db")(_body)
-
-
-def test_override_delete_missing_returns_false(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        return await overrides.delete(999)
-
-    assert _with_db(tmp_path, "override-delete-missing.db")(_body) is False
-
-
-def test_override_delete_leaves_other_overrides(tmp_path) -> None:
-    async def _body(database, schedules, overrides, children, child):
-        first = await overrides.create(
-            child.id, "2026-09-10", "2026-09-11", True
-        )
-        second = await overrides.create(
-            child.id, "2026-09-20", "2026-09-21", False
-        )
-        assert await overrides.delete(first.id) is True
-        found = await overrides.list_by_child_and_range(
-            child.id, "2026-09-01", "2026-09-30"
-        )
-        assert [r.id for r in found] == [second.id]
-        return found
-
-    _with_db(tmp_path, "override-delete-others.db")(_body)
-
-
-def test_schedule_and_override_independent_for_same_child(tmp_path) -> None:
-    """Deleting the schedule does not touch overrides and vice versa."""
-    async def _body(database, schedules, overrides, children, child):
-        await schedules.upsert_by_child(child.id, 2, "2026-09-07", "0,2|1,3")
-        override = await overrides.create(
-            child.id, "2026-09-10", "2026-09-11", True
-        )
-        assert await schedules.delete(child.id) is True
-        found = await overrides.list_by_child_and_range(
-            child.id, "2026-09-01", "2026-09-30"
-        )
-        assert [r.id for r in found] == [override.id]
-        return found
-
-    _with_db(tmp_path, "independent.db")(_body)
-
-
-# ---------------------------------------------------------------------------
-# No SQL for these tables outside the DAO module
-# ---------------------------------------------------------------------------
-
-
-def test_presence_sql_lives_only_in_dao_module() -> None:
-    """Guardrail: presence_schedules/presence_overrides SQL may appear
-    only in the DAO module (and the schema DDL declarations).
-    RECURSIVE scan of package and tests, FROM/INTO/UPDATE/DELETE FROM/
-    JOIN pattern, with exact repo-relative exclusions justified by
-    role: schema.py declares the DDL, migrations.py applies it, and
-    the test files for exactly those layers verify DDL, not data
-    paths.
-    """
-    import re
-    from pathlib import Path
-
-    package = Path(
-        __import__(
-            "custom_components.nestquest", fromlist=["__file__"]
-        ).__file__
-    ).parent
-    repo_root = package.parent.parent
-    scan_roots = [package, repo_root / "tests"]
-
-    allowed = {
-        "custom_components/nestquest/dao_presence.py",  # this DAO
-        "custom_components/nestquest/schema.py",  # declares the DDL
-        "custom_components/nestquest/migrations.py",  # applies the DDL
-        "tests/test_schema.py",  # tests the DDL
-        "tests/test_migrations.py",  # tests migration application
-        "tests/test_dao_presence.py",  # this file, scanned separately
-    }
-    sql_pattern = re.compile(
-        r"(FROM|INTO|UPDATE|DELETE\s+FROM|JOIN)\s+[`'\"]*(\[)?"
-        r"(presence_schedules|presence_overrides)\b",
-        re.IGNORECASE,
-    )
-    offenders: list[str] = []
-    for root in scan_roots:
-        for py in sorted(root.rglob("*.py")):
-            relative = py.relative_to(repo_root).as_posix()
-            if relative in allowed:
-                continue
-            if sql_pattern.search(py.read_text()):
-                offenders.append(relative)
-    assert offenders == [], (
-        f"SQL touching presence_schedules/presence_overrides leaked "
-        f"into: {offenders}"
-    )
-
-
-def test_dao_presence_test_file_uses_dao_not_raw_table_sql() -> None:
-    """This test module must exercise the DAO, not raw SQL, for these
-    tables.  Exemptions are EXACT lines, not whole-function spans: the
-    two single-statement COUNT(*) row probes (the only honest way to
-    prove 'exactly one row exists' without a listing method) and the
-    guard functions' own regex spans.  Any other raw SQL added anywhere
-    in this file fails the guard.
-    """
-    import ast
-    import re
-    from pathlib import Path
-
-    path = Path(__file__)
-    text = path.read_text()
-    lines = text.splitlines(keepends=True)
-    tree = ast.parse(text)
-    guard_names = {
-        "test_presence_sql_lives_only_in_dao_module",
-        "test_dao_presence_test_file_uses_dao_not_raw_table_sql",
-    }
-    excluded: set[int] = set()
-    for node in ast.walk(tree):
-        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            continue
-        if node.name in guard_names:
-            excluded.update(
-                range(node.lineno, (node.end_lineno or node.lineno) + 1)
-            )
-            continue
-        # Narrow probe exemption: only the string-literal line holding
-        # the sanctioned COUNT(*) query, not the enclosing function.
-        for sub in ast.walk(node):
-            if (
-                isinstance(sub, ast.Constant)
-                and isinstance(sub.value, str)
-                and sub.value.strip()
-                == "SELECT COUNT(*) FROM presence_schedules"
-                and sub.lineno is not None
-            ):
-                excluded.add(sub.lineno)
-
-    remaining = "".join(
-        line
-        for number, line in enumerate(lines, start=1)
-        if number not in excluded
-    )
-    sql_pattern = re.compile(
-        r"(SELECT\s[^\"']*?FROM|INSERT\s+INTO|UPDATE|DELETE\s+FROM|"
-        r"FROM|JOIN)\s+[`'\"]*(\[)?(presence_schedules|presence_overrides)"
-        r"\b",
-        re.IGNORECASE,
-    )
-    assert sql_pattern.search(remaining) is None, (
-        "tests must go through the DAO, not raw SQL, for these tables"
-    )

tests/test_dao_rules.py

@@ -1,906 +0,0 @@
-"""Tests for dao_rules.py: typed DAO for schedule_rules and task_definitions."""
-from __future__ import annotations
-
-import asyncio
-import sqlite3
-
-import pytest
-
-from custom_components.nestquest.dao_children import ChildrenDao
-from custom_components.nestquest.dao_rules import (
-    ScheduleRuleRecord,
-    ScheduleRulesDao,
-    TaskDefinitionRecord,
-    TaskDefinitionsDao,
-)
-from custom_components.nestquest.db import NestQuestDatabase
-from custom_components.nestquest.migrations import apply_migrations
-
-
-def _run(coro):
-    return asyncio.new_event_loop().run_until_complete(coro)
-
-
-def _make_hass_mock():
-    from unittest.mock import AsyncMock, MagicMock
-
-    hass = MagicMock()
-    hass.async_add_executor_job = AsyncMock(side_effect=(lambda fn, *a: fn(*a)))
-    return hass
-
-
-NOW = "2026-09-14T12:00:00+00:00"
-
-
-async def _prepare(path) -> tuple:
-    database = NestQuestDatabase(_make_hass_mock())
-    await database.open(path)
-    await apply_migrations(database)
-    rules = ScheduleRulesDao(database)
-    definitions = TaskDefinitionsDao(database)
-    children = ChildrenDao(database)
-    child = await children.create("Ada", NOW)
-    return database, rules, definitions, children, child
-
-
-def _with_db(tmp_path, name):
-    """Run an async body against a prepared database, closing it after."""
-
-    def _run_test(body):
-        async def _main():
-            database, rules, definitions, children, child = await _prepare(
-                tmp_path / name
-            )
-            try:
-                return await body(database, rules, definitions, children, child)
-            finally:
-                await database.close()
-
-        return _run(_main())
-
-    return _run_test
-
-
-# ---------------------------------------------------------------------------
-# schedule_rules: create / get
-# ---------------------------------------------------------------------------
-
-
-def test_rule_create_returns_typed_record(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create(
-            "weekly", "2026-09-14", weekday_set="0,2,4", interval=2
-        )
-        assert isinstance(rule, ScheduleRuleRecord)
-        assert rule.id == 1
-        assert rule.rule_type == "weekly"
-        assert rule.interval == 2
-        assert rule.weekday_set == "0,2,4"
-        assert rule.day_of_month is None
-        assert rule.nth_weekday is None
-        assert rule.month is None
-        assert rule.start_date == "2026-09-14"
-        assert rule.end_date is None
-        return rule
-
-    _with_db(tmp_path, "rule-create.db")(_body)
-
-
-def test_rule_create_monthly_with_day_of_month(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create(
-            "monthly", "2026-09-14", day_of_month=15, weekday_set=None
-        )
-        assert rule.day_of_month == 15
-        assert rule.weekday_set is None
-        return rule
-
-    _with_db(tmp_path, "rule-monthly.db")(_body)
-
-
-def test_rule_get_missing_returns_none(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        return await rules.get(999)
-
-    assert _with_db(tmp_path, "rule-get-missing.db")(_body) is None
-
-
-def test_rule_create_coherence_enforced_by_schema(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        with pytest.raises(sqlite3.IntegrityError, match="CHECK"):
-            await rules.create("weekly", "2026-09-14", weekday_set=None)
-        return None
-
-    _with_db(tmp_path, "rule-coherence.db")(_body)
-
-
-def test_rule_create_rejects_malformed_dates(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        for bad in (
-            "not-a-date",
-            "2026-9-4",
-            "2026-13-01",
-            "2026-02-30",
-            "09-14",
-            "",
-        ):
-            with pytest.raises(ValueError, match="YYYY-MM-DD"):
-                await rules.create("daily", bad)
-            with pytest.raises(ValueError, match="YYYY-MM-DD"):
-                await rules.create("daily", "2026-09-14", end_date=bad)
-        return None
-
-    _with_db(tmp_path, "rule-create-dates.db")(_body)
-
-
-def test_rule_create_end_before_start_rejected(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        with pytest.raises(sqlite3.IntegrityError, match="CHECK"):
-            await rules.create(
-                "daily", "2026-09-14", end_date="2026-09-13"
-            )
-        return None
-
-    _with_db(tmp_path, "rule-dates.db")(_body)
-
-
-# ---------------------------------------------------------------------------
-# schedule_rules: update
-# ---------------------------------------------------------------------------
-
-
-def test_rule_update_fields_round_trip(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("weekly", "2026-09-14", weekday_set="0,2")
-        updated = await rules.update(
-            rule.id, weekday_set="1,3", interval=3, end_date="2026-12-31"
-        )
-        assert updated == 1
-        fetched = await rules.get(rule.id)
-        assert fetched.weekday_set == "1,3"
-        assert fetched.interval == 3
-        assert fetched.end_date == "2026-12-31"
-        assert fetched.rule_type == "weekly"
-        return fetched
-
-    _with_db(tmp_path, "rule-update.db")(_body)
-
-
-def test_rule_update_omitted_fields_untouched(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("weekly", "2026-09-14", weekday_set="0,2")
-        await rules.update(rule.id, interval=2)
-        fetched = await rules.get(rule.id)
-        assert fetched.weekday_set == "0,2"
-        assert fetched.start_date == "2026-09-14"
-        return fetched
-
-    _with_db(tmp_path, "rule-update-partial.db")(_body)
-
-
-def test_rule_update_no_fields_returns_zero(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("daily", "2026-09-14")
-        return await rules.update(rule.id)
-
-    assert _with_db(tmp_path, "rule-update-empty.db")(_body) == 0
-
-
-def test_rule_update_missing_rule_returns_zero(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        return await rules.update(999, interval=2)
-
-    assert _with_db(tmp_path, "rule-update-missing.db")(_body) == 0
-
-
-def test_rule_update_bad_type_rejected_by_check(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("daily", "2026-09-14")
-        with pytest.raises(sqlite3.IntegrityError, match="CHECK"):
-            await rules.update(rule.id, rule_type="sometimes")
-        return None
-
-    _with_db(tmp_path, "rule-update-bad-type.db")(_body)
-
-
-def test_rule_update_can_clear_nullable_fields(tmp_path) -> None:
-    """Explicit None clears a nullable column; omitted leaves it alone.
-
-    A caller must be able to reopen an ended rule (end_date back to
-    NULL) and clear rule-shape fields; the _UNSET sentinel keeps
-    'omitted' distinct from 'write NULL'.
-    """
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create(
-            "weekly",
-            "2026-09-14",
-            weekday_set="0,2",
-            end_date="2026-12-31",
-            month=3,
-        )
-        # Omitted: nothing changes.
-        await rules.update(rule.id, interval=2)
-        kept = await rules.get(rule.id)
-        assert kept.end_date == "2026-12-31"
-        assert kept.month == 3
-        # Explicit None: clears both.
-        await rules.update(rule.id, end_date=None, month=None)
-        cleared = await rules.get(rule.id)
-        assert cleared.end_date is None
-        assert cleared.month is None
-        assert cleared.interval == 2
-        return cleared
-
-    _with_db(tmp_path, "rule-update-clear.db")(_body)
-
-
-def test_rule_update_validates_date_shape(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("daily", "2026-09-14")
-        for bad in ("not-a-date", "2026-9-4", "2026-13-01", "09-14"):
-            with pytest.raises(ValueError, match="YYYY-MM-DD"):
-                await rules.update(rule.id, start_date=bad)
-            with pytest.raises(ValueError, match="YYYY-MM-DD"):
-                await rules.update(rule.id, end_date=bad)
-        # None is still allowed (clears the column) without validation.
-        await rules.update(rule.id, end_date=None)
-        return None
-
-    _with_db(tmp_path, "rule-update-dates.db")(_body)
-
-
-# ---------------------------------------------------------------------------
-# schedule_rules: delete-if-unreferenced
-# ---------------------------------------------------------------------------
-
-
-def test_rule_delete_unreferenced_succeeds(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("daily", "2026-09-14")
-        assert await rules.delete_if_unreferenced(rule.id) is True
-        return await rules.get(rule.id)
-
-    assert _with_db(tmp_path, "rule-delete-ok.db")(_body) is None
-
-
-def test_rule_delete_referenced_is_rejected(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("daily", "2026-09-14")
-        await definitions.create("Brush teeth", child.id, rule.id, NOW)
-        assert await rules.delete_if_unreferenced(rule.id) is False
-        fetched = await rules.get(rule.id)
-        assert fetched is not None, (
-            "referenced rule must survive the delete attempt"
-        )
-        return fetched
-
-    _with_db(tmp_path, "rule-delete-referenced.db")(_body)
-
-
-def test_rule_delete_missing_returns_false(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        return await rules.delete_if_unreferenced(999)
-
-    assert _with_db(tmp_path, "rule-delete-missing.db")(_body) is False
-
-
-def test_rule_delete_after_last_reference_removed_succeeds(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("daily", "2026-09-14")
-        definition = await definitions.create(
-            "Brush teeth", child.id, rule.id, NOW
-        )
-        assert await rules.delete_if_unreferenced(rule.id) is False
-        await definitions.set_active(definition.id, False)
-        # Deactivation is NOT deletion: the definition still references
-        # the rule, so the delete must still be rejected.
-        assert await rules.delete_if_unreferenced(rule.id) is False
-        return None
-
-    _with_db(tmp_path, "rule-delete-inactive-ref.db")(_body)
-
-
-def test_rule_delete_concurrent_with_definition_create_is_safe(
-    tmp_path,
-) -> None:
-    """A racing definition creation cannot produce a dangling reference.
-
-    Both operations queue on the connection lock, so exactly one of two
-    safe outcomes happens: the create wins and the delete is rejected
-    (definition exists, rule exists), or the delete wins and the create
-    fails cleanly with ValueError (rule gone).  A definition row
-    pointing at a deleted rule is impossible in either case.
-
-    BOTH orderings are forced: delete-first by starting the delete and
-    yielding; create-first by hooking ScheduleRulesDao.get so the
-    create's validation pauses mid-flight before the delete starts.
-    """
-    async def _main(order: str):
-        database = NestQuestDatabase(_make_hass_mock())
-        await database.open(tmp_path / f"rule-delete-race-{order}.db")
-        try:
-            await apply_migrations(database)
-            children = ChildrenDao(database)
-            rules = ScheduleRulesDao(database)
-            definitions = TaskDefinitionsDao(database)
-            child = await children.create("Ada", NOW)
-            rule_a = await rules.create("daily", "2026-09-14")
-
-            if order == "create-first":
-                # Pause the create inside its rule validation: the hook
-                # blocks after the rule-lookup statement until the
-                # delete task has been scheduled, so the create holds
-                # the connection lock while the delete queues behind
-                # it — then the create proceeds and wins.
-                import custom_components.nestquest.dao_rules as dao_rules
-
-                original_validate = (
-                    dao_rules.TaskDefinitionsDao._validate_assignable
-                )
-                release = asyncio.Event()
-                started = asyncio.Event()
-
-                async def _pausing_validate(self, child_id, rule_id):
-                    # Run the real validation FIRST (this is the
-                    # time-of-check), THEN pause: the delete task gets
-                    # scheduled while the create sits between its
-                    # passed validation and its INSERT.  The serialized
-                    # transaction must keep the delete queued until the
-                    # insert commits, so the create must win the race
-                    # and the delete must be rejected as referenced.
-                    await original_validate(self, child_id, rule_id)
-                    if rule_id == rule_a.id and not started.is_set():
-                        started.set()
-                        await release.wait()
-
-                dao_rules.TaskDefinitionsDao._validate_assignable = (
-                    _pausing_validate
-                )
-                try:
-                    create_task = asyncio.ensure_future(
-                        definitions.create(
-                            "Brush teeth", child.id, rule_a.id, NOW
-                        )
-                    )
-                    await started.wait()
-                    delete_task = asyncio.ensure_future(
-                        rules.delete_if_unreferenced(rule_a.id)
-                    )
-                    await asyncio.sleep(0)
-                    started.clear()
-                    release.set()
-                    deleted, creation = await asyncio.gather(
-                        delete_task, create_task, return_exceptions=True
-                    )
-                finally:
-                    dao_rules.TaskDefinitionsDao._validate_assignable = (
-                        original_validate
-                    )
-            else:
-                async def _delete():
-                    return await rules.delete_if_unreferenced(rule_a.id)
-
-                async def _create():
-                    return await definitions.create(
-                        "Brush teeth", child.id, rule_a.id, NOW
-                    )
-
-                delete_task = asyncio.ensure_future(_delete())
-                await asyncio.sleep(0)
-                create_task = asyncio.ensure_future(_create())
-                deleted, creation = await asyncio.gather(
-                    delete_task, create_task, return_exceptions=True
-                )
-
-            assert not isinstance(deleted, BaseException), (
-                f"delete must queue, not crash: {deleted!r}"
-            )
-            rule_row = await rules.get(rule_a.id)
-            if deleted:
-                # Delete won: the create must have failed cleanly.
-                assert isinstance(creation, ValueError), (
-                    f"creating against a deleted rule must raise "
-                    f"ValueError, got {creation!r}"
-                )
-                assert rule_row is None
-            else:
-                # Create won: the delete was rejected, both rows exist.
-                assert isinstance(creation, TaskDefinitionRecord), (
-                    f"create must succeed, got {creation!r}"
-                )
-                assert rule_row is not None
-            return deleted
-        finally:
-            await database.close()
-
-    delete_won = _run(_main("delete-first"))
-    create_won = _run(_main("create-first"))
-    # delete-first: the delete acquires the lock before the create can
-    # validate, so the rule is gone and the create fails cleanly.
-    assert delete_won is True
-    # create-first: validation passed, the create holds the lock across
-    # its INSERT, so the queued delete must find the definition and be
-    # rejected — the create must NOT lose its rule after validating it.
-    assert create_won is False
-
-
-# ---------------------------------------------------------------------------
-# task_definitions: create / get
-# ---------------------------------------------------------------------------
-
-
-def test_definition_create_returns_typed_record(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("weekly", "2026-09-14", weekday_set="0,2")
-        definition = await definitions.create(
-            "Brush teeth",
-            child.id,
-            rule.id,
-            NOW,
-            description="Morning and night",
-            icon="mdi:tooth",
-            due_time="08:00",
-        )
-        assert isinstance(definition, TaskDefinitionRecord)
-        assert definition.title == "Brush teeth"
-        assert definition.child_id == child.id
-        assert definition.schedule_rule_id == rule.id
-        assert definition.due_time == "08:00"
-        assert definition.is_active is True
-        assert definition.created_at == NOW
-        return definition
-
-    _with_db(tmp_path, "definition-create.db")(_body)
-
-
-def test_definition_get_missing_returns_none(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        return await definitions.get(999)
-
-    assert _with_db(tmp_path, "definition-get-missing.db")(_body) is None
-
-
-def test_definition_create_unknown_child_raises_value_error(
-    tmp_path,
-) -> None:
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("daily", "2026-09-14")
-        with pytest.raises(ValueError, match="does not exist"):
-            await definitions.create("X", 999, rule.id, NOW)
-        return None
-
-    _with_db(tmp_path, "definition-bad-child.db")(_body)
-
-
-def test_definition_create_inactive_child_raises_value_error(
-    tmp_path,
-) -> None:
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("daily", "2026-09-14")
-        await children.set_active(child.id, False)
-        with pytest.raises(ValueError, match="inactive"):
-            await definitions.create("X", child.id, rule.id, NOW)
-        return None
-
-    _with_db(tmp_path, "definition-inactive-child.db")(_body)
-
-
-def test_definition_create_unknown_rule_raises_value_error(
-    tmp_path,
-) -> None:
-    async def _body(database, rules, definitions, children, child):
-        with pytest.raises(ValueError, match="does not exist"):
-            await definitions.create("X", child.id, 999, NOW)
-        return None
-
-    _with_db(tmp_path, "definition-bad-rule.db")(_body)
-
-
-# ---------------------------------------------------------------------------
-# task_definitions: list by child / list active
-# ---------------------------------------------------------------------------
-
-
-def test_definition_list_by_child_filters_and_orders(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("daily", "2026-09-14")
-        other_child = await children.create("Bo", NOW)
-        await definitions.create("A", child.id, rule.id, NOW)
-        await definitions.create("B", child.id, rule.id, NOW)
-        await definitions.create("C", other_child.id, rule.id, NOW)
-        mine = await definitions.list_by_child(child.id)
-        assert [d.title for d in mine] == ["B", "A"]
-        return mine
-
-    _with_db(tmp_path, "definition-list-by-child.db")(_body)
-
-
-def test_definition_list_by_child_missing_child_returns_empty(
-    tmp_path,
-) -> None:
-    async def _body(database, rules, definitions, children, child):
-        return await definitions.list_by_child(999)
-
-    assert _with_db(tmp_path, "definition-list-missing.db")(_body) == []
-
-
-def test_definition_list_active_excludes_inactive(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("daily", "2026-09-14")
-        first = await definitions.create("A", child.id, rule.id, NOW)
-        await definitions.create("B", child.id, rule.id, NOW)
-        await definitions.set_active(first.id, False)
-        active = await definitions.list_active()
-        assert [d.title for d in active] == ["B"]
-        assert all(d.is_active for d in active)
-        return active
-
-    _with_db(tmp_path, "definition-list-active.db")(_body)
-
-
-# ---------------------------------------------------------------------------
-# task_definitions: update / set_active / set_assignee
-# ---------------------------------------------------------------------------
-
-
-def test_definition_update_fields_round_trip(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("daily", "2026-09-14")
-        definition = await definitions.create(
-            "A", child.id, rule.id, NOW, due_time="08:00"
-        )
-        assert await definitions.update(
-            definition.id,
-            title="A2",
-            description="New",
-            icon="mdi:star",
-            due_time="09:00",
-        ) == 1
-        fetched = await definitions.get(definition.id)
-        assert fetched.title == "A2"
-        assert fetched.description == "New"
-        assert fetched.icon == "mdi:star"
-        assert fetched.due_time == "09:00"
-        return fetched
-
-    _with_db(tmp_path, "definition-update.db")(_body)
-
-
-def test_definition_update_cannot_change_assignee_or_active(
-    tmp_path,
-) -> None:
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("daily", "2026-09-14")
-        other = await children.create("Bo", NOW)
-        definition = await definitions.create("A", child.id, rule.id, NOW)
-        # title= / child_id= / is_active= are NOT update() parameters;
-        # this asserts the API shape: reassignment and activation have
-        # their own explicit methods.
-        import inspect
-
-        parameters = inspect.signature(definitions.update).parameters
-        assert set(parameters) == {
-            "definition_id",
-            "title",
-            "description",
-            "icon",
-            "due_time",
-        }
-        assert await definitions.update(
-            definition.id, title="A2"
-        ) == 1
-        fetched = await definitions.get(definition.id)
-        assert fetched.child_id == child.id
-        assert fetched.is_active is True
-        return fetched
-
-    _with_db(tmp_path, "definition-update-shape.db")(_body)
-
-
-def test_definition_update_no_fields_returns_zero(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("daily", "2026-09-14")
-        definition = await definitions.create("A", child.id, rule.id, NOW)
-        return await definitions.update(definition.id)
-
-    assert _with_db(tmp_path, "definition-update-empty.db")(_body) == 0
-
-
-def test_definition_update_can_clear_optional_fields(tmp_path) -> None:
-    """Explicit None removes description/icon/due_time; omitted keeps."""
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("daily", "2026-09-14")
-        definition = await definitions.create(
-            "A",
-            child.id,
-            rule.id,
-            NOW,
-            description="d",
-            icon="mdi:x",
-            due_time="08:00",
-        )
-        await definitions.update(definition.id, title="A2")
-        kept = await definitions.get(definition.id)
-        assert kept.description == "d"
-        assert kept.icon == "mdi:x"
-        await definitions.update(
-            definition.id, description=None, icon=None, due_time=None
-        )
-        cleared = await definitions.get(definition.id)
-        assert cleared.description is None
-        assert cleared.icon is None
-        assert cleared.due_time is None
-        assert cleared.title == "A2"
-        return cleared
-
-    _with_db(tmp_path, "definition-update-clear.db")(_body)
-
-
-def test_definition_update_missing_returns_zero(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        return await definitions.update(999, title="X")
-
-    assert _with_db(tmp_path, "definition-update-missing.db")(_body) == 0
-
-
-def test_definition_set_active_round_trip(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("daily", "2026-09-14")
-        definition = await definitions.create("A", child.id, rule.id, NOW)
-        assert await definitions.set_active(definition.id, False) == 1
-        fetched = await definitions.get(definition.id)
-        assert fetched.is_active is False
-        assert await definitions.set_active(definition.id, True) == 1
-        fetched = await definitions.get(definition.id)
-        assert fetched.is_active is True
-        return fetched
-
-    _with_db(tmp_path, "definition-set-active.db")(_body)
-
-
-def test_definition_set_active_missing_returns_zero(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        return await definitions.set_active(999, False)
-
-    assert _with_db(tmp_path, "definition-set-active-missing.db")(_body) == 0
-
-
-def test_definition_no_delete_method_exists(tmp_path) -> None:
-    """Guardrail: definitions are deactivated, never hard-deleted."""
-    async def _body(database, rules, definitions, children, child):
-        import inspect
-
-        methods = {
-            name
-            for name, _ in inspect.getmembers(
-                TaskDefinitionsDao, inspect.isfunction
-            )
-        }
-        assert "delete" not in methods
-        assert not any(name.startswith("delete") for name in methods)
-        return methods
-
-    _with_db(tmp_path, "definition-no-delete.db")(_body)
-
-
-def test_definition_set_assignee_round_trip(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("daily", "2026-09-14")
-        other = await children.create("Bo", NOW)
-        definition = await definitions.create("A", child.id, rule.id, NOW)
-        assert await definitions.set_assignee(definition.id, other.id) == 1
-        fetched = await definitions.get(definition.id)
-        assert fetched.child_id == other.id
-        return fetched
-
-    _with_db(tmp_path, "definition-set-assignee.db")(_body)
-
-
-def test_definition_set_assignee_inactive_child_raises(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("daily", "2026-09-14")
-        other = await children.create("Bo", NOW)
-        definition = await definitions.create("A", child.id, rule.id, NOW)
-        await children.set_active(other.id, False)
-        with pytest.raises(ValueError, match="inactive"):
-            await definitions.set_assignee(definition.id, other.id)
-        fetched = await definitions.get(definition.id)
-        assert fetched.child_id == child.id, (
-            "failed reassignment must leave the current assignee intact"
-        )
-        return fetched
-
-    _with_db(tmp_path, "definition-assignee-inactive.db")(_body)
-
-
-def test_definition_set_assignee_unknown_child_raises(tmp_path) -> None:
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("daily", "2026-09-14")
-        definition = await definitions.create("A", child.id, rule.id, NOW)
-        with pytest.raises(ValueError, match="does not exist"):
-            await definitions.set_assignee(definition.id, 999)
-        return None
-
-    _with_db(tmp_path, "definition-assignee-unknown.db")(_body)
-
-
-def test_definition_set_assignee_missing_definition_returns_zero(
-    tmp_path,
-) -> None:
-    async def _body(database, rules, definitions, children, child):
-        other = await children.create("Bo", NOW)
-        return await definitions.set_assignee(999, other.id)
-
-    assert _with_db(tmp_path, "definition-assignee-missing.db")(_body) == 0
-
-
-def test_definition_set_assignee_leaves_history_rows_alone(
-    tmp_path,
-) -> None:
-    """Reassignment writes the definition row only: any instances that
-    already exist keep their generation-time child_id (Feature 06
-    guardrail 'changes future instances only').
-    """
-    async def _body(database, rules, definitions, children, child):
-        rule = await rules.create("daily", "2026-09-14")
-        other = await children.create("Bo", NOW)
-        definition = await definitions.create("A", child.id, rule.id, NOW)
-        # Simulate an already-generated instance (materialization owns
-        # this table, but its row shape proves reassignment isolation).
-        await database.execute(
-            "INSERT INTO task_instances (definition_id, child_id, "
-            "due_date, generated_at) VALUES (?, ?, ?, ?)",
-            (definition.id, child.id, "2026-09-15", NOW),
-        )
-        await definitions.set_assignee(definition.id, other.id)
-        row = await database.fetch_one(
-            "SELECT child_id FROM task_instances WHERE definition_id = ?",
-            (definition.id,),
-        )
-        assert row == (child.id,)
-        return None
-
-    _with_db(tmp_path, "definition-assignee-history.db")(_body)
-
-
-# ---------------------------------------------------------------------------
-# No SQL for these tables outside the DAO module
-# ---------------------------------------------------------------------------
-
-
-def test_rules_and_definitions_sql_lives_only_in_dao_module() -> None:
-    """Guardrail: schedule_rules/task_definitions SQL may appear only
-    in the DAO modules (and the schema DDL declarations).  RECURSIVE
-    scan of package and tests, FROM/INTO/UPDATE/DELETE FROM/JOIN
-    pattern, with exact repo-relative exclusions justified by role:
-    schema.py declares the DDL, migrations.py applies it, and the
-    test files for exactly those layers verify DDL, not data paths.
-    """
-    import re
-    from pathlib import Path
-
-    package = Path(
-        __import__(
-            "custom_components.nestquest", fromlist=["__file__"]
-        ).__file__
-    ).parent
-    repo_root = package.parent.parent
-    scan_roots = [package, repo_root / "tests"]
-
-    allowed = {
-        "custom_components/nestquest/dao_rules.py",  # this DAO
-        "custom_components/nestquest/dao_instances.py",  # validates the
-        # definition exists + fetches its assignee before generating an
-        # instance (the instance must snapshot the definition's child)
-        "custom_components/nestquest/schema.py",  # declares the DDL
-        "custom_components/nestquest/migrations.py",  # applies the DDL
-        "tests/test_schema.py",  # tests the DDL
-        "tests/test_migrations.py",  # tests migration application
-        "tests/test_dao_rules.py",  # this file, scanned separately
-        "tests/test_dao_instances.py",  # instances guard, own scope
-    }
-    sql_pattern = re.compile(
-        r"(FROM|INTO|UPDATE|DELETE\s+FROM|JOIN)\s+[`'\"]*(\[)?"
-        r"(schedule_rules|task_definitions)\b",
-        re.IGNORECASE,
-    )
-    offenders: list[str] = []
-    for root in scan_roots:
-        for py in sorted(root.rglob("*.py")):
-            relative = py.relative_to(repo_root).as_posix()
-            if relative in allowed:
-                continue
-            if sql_pattern.search(py.read_text()):
-                offenders.append(relative)
-    assert offenders == [], (
-        f"SQL touching schedule_rules/task_definitions leaked into: "
-        f"{offenders}"
-    )
-
-
-def test_dao_instances_test_file_uses_dao_not_raw_rules_sql() -> None:
-    """Compensating self-scan for the test_dao_instances.py exemption:
-    that file may query task_instances/completion_events raw (its own
-    guard's scope) but must go through the DAO for schedule_rules and
-    task_definitions, except its single sanctioned definition-create
-    helper usage and guard spans.
-    """
-    import ast
-    import re
-    from pathlib import Path
-
-    instances_test = Path(__file__).parent / "test_dao_instances.py"
-    text = instances_test.read_text()
-    lines = text.splitlines(keepends=True)
-    tree = ast.parse(text)
-    guard_names = {
-        "test_rules_and_definitions_sql_lives_only_in_dao_module",
-        "test_no_mutation_sql_for_completion_events_anywhere",
-    }
-    excluded: set[int] = set()
-    for node in ast.walk(tree):
-        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            continue
-        if node.name in guard_names:
-            excluded.update(
-                range(node.lineno, (node.end_lineno or node.lineno) + 1)
-            )
-
-    remaining = "".join(
-        line
-        for number, line in enumerate(lines, start=1)
-        if number not in excluded
-    )
-    sql_pattern = re.compile(
-        r"(SELECT\s[^\"']*?FROM|INSERT\s+INTO|UPDATE|DELETE\s+FROM|"
-        r"FROM|JOIN)\s+[`'\"]*(\[)?(schedule_rules|task_definitions)\b",
-        re.IGNORECASE,
-    )
-    assert sql_pattern.search(remaining) is None, (
-        "test_dao_instances.py must go through the DAO, not raw SQL, "
-        "for schedule_rules/task_definitions"
-    )
-
-
-def test_dao_rules_test_file_uses_dao_not_raw_table_sql() -> None:
-    """This test module must exercise the DAO, not raw SQL, for these
-    tables.  Exceptions: the guard functions' own spans (their regexes
-    mention the names), and the reassignment-isolation test, which
-    legitimately touches task_instances — a table this DAO does not
-    own — to prove the guardrail that reassignment leaves it alone.
-    """
-    import ast
-    import re
-    from pathlib import Path
-
-    path = Path(__file__)
-    text = path.read_text()
-    lines = text.splitlines(keepends=True)
-    tree = ast.parse(text)
-    guard_names = {
-        "test_rules_and_definitions_sql_lives_only_in_dao_module",
-        "test_dao_rules_test_file_uses_dao_not_raw_table_sql",
-    }
-    excluded: set[int] = set()
-    for node in ast.walk(tree):
-        if (
-            isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
-            and node.name in guard_names
-        ):
-            excluded.update(
-                range(node.lineno, (node.end_lineno or node.lineno) + 1)
-            )
-
-    remaining = "".join(
-        line
-        for number, line in enumerate(lines, start=1)
-        if number not in excluded
-    )
-    sql_pattern = re.compile(
-        r"(SELECT\s[^\"']*?FROM|INSERT\s+INTO|UPDATE|DELETE\s+FROM|"
-        r"FROM|JOIN)\s+[`'\"]*(\[)?(schedule_rules|task_definitions)\b",
-        re.IGNORECASE,
-    )
-    assert sql_pattern.search(remaining) is None, (
-        "tests must go through the DAO, not raw SQL, for these tables"
-    )

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_harness.py

@@ -1,86 +0,0 @@
-"""Contract test for the mock-only homeassistant harness in conftest.py."""
-
-from __future__ import annotations
-
-import asyncio
-import importlib.metadata
-import inspect
-import sys
-from unittest.mock import MagicMock
-
-import pytest
-
-import conftest
-
-from conftest import _HA_MODULES, _ensure_mock_only
-
-
-def test_mock_only_harness_contract(monkeypatch):
-    """The harness is mock-only: shaped mocks everywhere, fail-fast on real HA."""
-    # Every required homeassistant module in sys.modules is a mock stand-in
-    # with the shaped surface, and parent-package attributes point at them.
-    for name in _HA_MODULES:
-        assert isinstance(sys.modules[name], MagicMock), f"{name} is not a mock"
-
-    config_entries = sys.modules["homeassistant.config_entries"]
-    assert config_entries.ConfigFlow is conftest._ConfigFlowBase
-    assert config_entries.OptionsFlowWithConfigEntry is (
-        conftest._OptionsFlowWithConfigEntryBase
-    )
-    assert sys.modules["homeassistant"].config_entries is config_entries
-    assert sys.modules["homeassistant.core"].callback is conftest._callback_decorator
-    assert sys.modules["homeassistant.data_entry_flow"].RESULT_TYPE_FORM == "form"
-
-    # No homeassistant distribution is installed in this suite's own venv.
-    with pytest.raises(importlib.metadata.PackageNotFoundError):
-        importlib.metadata.version("homeassistant")
-
-    # Fail-fast paths: a findable real HA module, or one preloaded in
-    # sys.modules, both abort collection with a UsageError.
-    real_spec = MagicMock(origin="/fake/site-packages/homeassistant/__init__.py")
-    monkeypatch.setattr(conftest, "_find_spec", lambda name: real_spec)
-    with pytest.raises(pytest.UsageError, match="mock-only"):
-        _ensure_mock_only()
-
-    monkeypatch.setattr(conftest, "_find_spec", lambda name: None)
-    monkeypatch.setitem(sys.modules, "homeassistant", MagicMock(name="real-module"))
-    with pytest.raises(pytest.UsageError, match="mock-only"):
-        _ensure_mock_only()
-
-
-async def test_hass_and_registry_run_on_the_running_test_loop(hass, make_entry):
-    """hass.loop is the test's own loop and the registry spins no private loop."""
-    # hass.loop is the very loop the async test runs on (HA running-loop
-    # contract): code scheduling on hass.loop lands on the test loop itself.
-    assert hass.loop is asyncio.get_running_loop()
-    ran = []
-
-    async def _scheduled():
-        ran.append(True)
-
-    await hass.loop.create_task(_scheduled())
-    assert ran == [True]
-
-    # ListenerRegistry never spins its own event loop (no resource leak) and
-    # dispatch is a plain coroutine: sync listeners run inline, async awaited.
-    registry = hass.registry
-    assert not hasattr(registry, "_loop")
-    assert inspect.iscoroutinefunction(registry.dispatch_options_update)
-
-    calls = []
-
-    def _sync_listener(h, entry):
-        calls.append(("sync", entry.entry_id, h is hass))
-
-    entry = make_entry(entry_id="disp")
-    registry.add("disp", _sync_listener)
-    await registry.dispatch_options_update(entry)
-    assert calls == [("sync", "disp", True)]
-
-    async def _async_listener(h, entry):
-        calls.append(("async", entry.entry_id))
-
-    registry.add("disp", _async_listener)
-    calls.clear()
-    await registry.async_dispatch_options_update(entry)
-    assert calls == [("sync", "disp", True), ("async", "disp")]

tests/test_lifecycle.py

@@ -2,257 +2,249 @@
 from __future__ import annotations
 
 import asyncio
+import inspect
+import sys
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+# Mock homeassistant modules if not installed in environment
+for _mod in (
+    "homeassistant",
+    "homeassistant.core",
+    "homeassistant.config_entries",
+):
+    sys.modules.setdefault(_mod, MagicMock())
+
+# Wire parent package attributes to the actual module mocks so that
+# "from homeassistant import config_entries" resolves to the mocked module.
+sys.modules["homeassistant"].config_entries = sys.modules["homeassistant.config_entries"]
 
 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
 from custom_components.nestquest.const import DOMAIN as DOMAIN_CONST
 
 
-def _wire(entry, registry):
-    return wire_entry_to_registry(entry, registry)
+def _run(coro):
+    return asyncio.new_event_loop().run_until_complete(coro)
 
 
-async def test_setup_stores_runtime_data_in_hass_data(hass, make_entry) -> None:
-    entry = _wire(make_entry(), hass.registry)
-    assert await async_setup_entry(hass, entry) is True
+class _ListenerRegistry:
+    """Models HA's update-listener bookkeeping: appends to a list per entry, with per-listener removers."""
+
+    def __init__(self, hass=None):
+        self._hass = hass
+        self._listeners: dict[str, list[object]] = {}
+        self.reloaded: list[str] = []
+        self._loop = asyncio.new_event_loop()
+
+    def add(self, entry_id: str, listener) -> object:
+        def _remove():
+            self._listeners.get(entry_id, []).remove(listener)
+
+        self._listeners.setdefault(entry_id, []).append(listener)
+        return _remove
+
+    def dispatch_options_update(self, entry) -> None:
+        for listener in list(self._listeners.get(entry.entry_id, [])):
+            result = listener(self._hass, entry)
+            if inspect.isawaitable(result):
+                self._loop.run_until_complete(result)
+
+    @property
+    def size(self) -> int:
+        return sum(len(listeners) for listeners in self._listeners.values())
+
+
+def _make_hass():
+    hass = SimpleNamespace(
+        data={},
+        config_entries=SimpleNamespace(
+            async_reload=None,
+        ),
+    )
+    registry = _ListenerRegistry(hass)
+    async def _async_reload(entry_id: str) -> None:
+        registry.reloaded.append(entry_id)
+
+    hass.config_entries.async_reload = MagicMock(side_effect=_async_reload)
+    return hass, registry
+
+
+def _make_entry(entry_id: str = "test_entry", options: dict | None = None):
+    entry = SimpleNamespace(entry_id=entry_id, options=dict(options or {}))
+    entry.add_update_listener = None
+    return entry
+
+
+def _wire_entry(entry, registry: _ListenerRegistry):
+    entry.add_update_listener = lambda listener: registry.add(entry.entry_id, listener)
+    return entry
+
+
+def test_setup_stores_runtime_data_in_hass_data() -> None:
+    hass, _ = _make_hass()
+    entry = _wire_entry(_make_entry(), _ListenerRegistry())
+    assert _run(async_setup_entry(hass, entry)) is True
     assert entry.entry_id in hass.data[DOMAIN]
     assert hass.data[DOMAIN][entry.entry_id] is entry.runtime_data
 
 
-async def test_setup_runtime_data_has_entry_id_and_options(hass, make_entry) -> None:
-    entry = _wire(make_entry(options={"horizon_days": 7}), hass.registry)
-    await async_setup_entry(hass, entry)
+def test_setup_runtime_data_has_entry_id_and_options() -> None:
+    hass, _ = _make_hass()
+    entry = _wire_entry(_make_entry(options={"horizon_days": 7}), _ListenerRegistry())
+    _run(async_setup_entry(hass, entry))
     runtime = entry.runtime_data
     assert runtime.entry_id == entry.entry_id
     assert runtime.options == {"horizon_days": 7}
     assert callable(runtime.remove_update_listener)
 
 
-async def test_unload_returns_true_and_removes_hass_data(hass, make_entry) -> None:
-    registry = hass.registry
-    entry = _wire(make_entry(), registry)
-    assert await async_setup_entry(hass, entry) is True
-    assert registry.size == 1
-    assert await async_unload_entry(hass, entry) is True
-    assert hass.data == {}
-    assert DOMAIN not in hass.data
-    assert entry.runtime_data is None
-    assert registry.size == 0
+def test_unload_returns_true_and_removes_hass_data() -> None:
+    hass, _ = _make_hass()
+    registry = _ListenerRegistry()
+    entry = _wire_entry(_make_entry(), registry)
+    _run(async_setup_entry(hass, entry))
+    assert _run(async_unload_entry(hass, entry)) is True
+    assert entry.entry_id not in hass.data[DOMAIN]
 
 
-async def test_unload_of_one_entry_keeps_domain_while_other_remains(
-    hass, make_entry
-) -> None:
-    """Unloading one of two entries keeps DOMAIN alive with the other entry."""
-    registry = hass.registry
-    entry_a = _wire(make_entry(entry_id="entry_a"), registry)
-    entry_b = _wire(make_entry(entry_id="entry_b"), registry)
-    assert await async_setup_entry(hass, entry_a) is True
-    assert await async_setup_entry(hass, entry_b) is True
-    assert set(hass.data[DOMAIN]) == {"entry_a", "entry_b"}
-
-    assert await async_unload_entry(hass, entry_a) is True
-    assert DOMAIN in hass.data
-    assert set(hass.data[DOMAIN]) == {"entry_b"}
-    assert hass.data[DOMAIN]["entry_b"] is entry_b.runtime_data
-    assert entry_a.runtime_data is None
-    assert entry_b.runtime_data is not None
-    assert registry.size == 1
-
-    assert await async_unload_entry(hass, entry_b) is True
-    assert DOMAIN not in hass.data
-    assert hass.data == {}
-    assert entry_b.runtime_data is None
-    assert registry.size == 0
+def test_unload_is_idempotent() -> None:
+    hass, _ = _make_hass()
+    registry = _ListenerRegistry()
+    entry = _wire_entry(_make_entry(), registry)
+    _run(async_setup_entry(hass, entry))
+    assert _run(async_unload_entry(hass, entry)) is True
+    assert _run(async_unload_entry(hass, entry)) is True
+    assert entry.entry_id not in hass.data[DOMAIN]
 
 
-async def test_unload_is_idempotent(hass, make_entry) -> None:
-    entry = _wire(make_entry(), hass.registry)
-    assert await async_setup_entry(hass, entry) is True
-    assert await async_unload_entry(hass, entry) is True
-    assert await async_unload_entry(hass, entry) is True
-    assert DOMAIN not in hass.data
-    assert hass.data == {}
+def test_unload_without_setup_returns_true() -> None:
+    hass, _ = _make_hass()
+    entry = _make_entry()
+    assert _run(async_unload_entry(hass, entry)) is True
+    assert DOMAIN not in hass.data or entry.entry_id not in hass.data[DOMAIN]
 
 
-async def test_unload_without_setup_returns_true(hass, make_entry) -> None:
-    entry = _wire(make_entry(), hass.registry)
-    assert await async_unload_entry(hass, entry) is True
-    assert DOMAIN not in hass.data
-    assert hass.data == {}
-
-
-async def test_unload_clears_entry_runtime_data(hass, make_entry) -> None:
-    entry = _wire(make_entry(), hass.registry)
-    await async_setup_entry(hass, entry)
-    await async_unload_entry(hass, entry)
+def test_unload_clears_entry_runtime_data() -> None:
+    hass, _ = _make_hass()
+    registry = _ListenerRegistry()
+    entry = _wire_entry(_make_entry(), registry)
+    _run(async_setup_entry(hass, entry))
+    _run(async_unload_entry(hass, entry))
     assert entry.runtime_data is None
 
 
-async def test_unload_removes_update_listener(hass, make_entry) -> None:
-    registry = hass.registry
-    entry = _wire(make_entry(), registry)
-    await async_setup_entry(hass, entry)
+def test_unload_removes_update_listener() -> None:
+    hass, _ = _make_hass()
+    registry = _ListenerRegistry()
+    entry = _wire_entry(_make_entry(), registry)
+    _run(async_setup_entry(hass, entry))
     assert registry.size == 1
-    await async_unload_entry(hass, entry)
+    _run(async_unload_entry(hass, entry))
     assert registry.size == 0
 
 
-async def test_options_update_triggers_reload_once(hass, make_entry) -> None:
-    registry = hass.registry
-    entry = _wire(make_entry(), registry)
-    await async_setup_entry(hass, entry)
+def test_options_update_triggers_reload_once() -> None:
+    hass, registry = _make_hass()
+    entry = _wire_entry(_make_entry(), registry)
+    _run(async_setup_entry(hass, entry))
     entry.options = {"horizon_days": 30}
-    await registry.async_dispatch_options_update(entry)
+    registry.dispatch_options_update(entry)
     assert hass.config_entries.async_reload.call_count == 1
     assert registry.reloaded == [entry.entry_id]
 
 
-async def test_no_reload_after_unload(hass, make_entry) -> None:
-    registry = hass.registry
-    entry = _wire(make_entry(), registry)
-    await async_setup_entry(hass, entry)
-    await async_unload_entry(hass, entry)
-    await registry.async_dispatch_options_update(entry)
+def test_no_reload_after_unload() -> None:
+    hass, registry = _make_hass()
+    entry = _wire_entry(_make_entry(), registry)
+    _run(async_setup_entry(hass, entry))
+    _run(async_unload_entry(hass, entry))
+    registry.dispatch_options_update(entry)
     assert hass.config_entries.async_reload.call_count == 0
 
 
-async def test_three_reload_cycles_keep_single_listener(hass, make_entry) -> None:
-    registry = hass.registry
-    entry = _wire(make_entry(), registry)
+def test_three_reload_cycles_keep_single_listener() -> None:
+    hass, registry = _make_hass()
+    entry = _wire_entry(_make_entry(), registry)
     for _ in range(3):
-        assert await async_setup_entry(hass, entry) is True
+        assert _run(async_setup_entry(hass, entry)) is True
         assert registry.size == 1
-        assert await async_unload_entry(hass, entry) is True
+        assert _run(async_unload_entry(hass, entry)) is True
         assert registry.size == 0
     assert hass.config_entries.async_reload.call_count == 0
 
 
-async def test_three_setup_unload_cycles_leave_no_listeners(hass, make_entry) -> None:
+def test_three_setup_unload_cycles_leave_no_listeners() -> None:
     """Listeners accumulate per entry (HA semantics); unload must remove them all."""
-    registry = hass.registry
-    entry = _wire(make_entry(), registry)
+    hass, registry = _make_hass()
+    entry = _wire_entry(_make_entry(), registry)
     for _ in range(3):
-        await async_setup_entry(hass, entry)
-        await async_unload_entry(hass, entry)
+        _run(async_setup_entry(hass, entry))
+        _run(async_unload_entry(hass, entry))
     assert registry._listeners.get(entry.entry_id, []) == []
     assert registry.size == 0
 
 
-async def test_options_update_after_each_setup_invokes_exactly_one_listener(
-    hass, make_entry
-) -> None:
+def test_options_update_after_each_setup_invokes_exactly_one_listener() -> None:
     """After each setup, an options update dispatches to exactly one listener."""
-    registry = hass.registry
-    entry = _wire(make_entry(), registry)
+    hass, registry = _make_hass()
+    entry = _wire_entry(_make_entry(), registry)
     for _ in range(3):
-        await async_setup_entry(hass, entry)
-        await registry.async_dispatch_options_update(entry)
+        _run(async_setup_entry(hass, entry))
+        registry.dispatch_options_update(entry)
         assert hass.config_entries.async_reload.call_count == 1
         assert registry.reloaded == [entry.entry_id]
-        await async_unload_entry(hass, entry)
+        _run(async_unload_entry(hass, entry))
         hass.config_entries.async_reload.reset_mock()
         registry.reloaded.clear()
 
 
-async def test_reload_setup_cycles_dispatch_reload_each_time(hass, make_entry) -> None:
-    registry = hass.registry
-    entry = _wire(make_entry(), registry)
+def test_reload_setup_cycles_dispatch_reload_each_time() -> None:
+    hass, registry = _make_hass()
+    entry = _wire_entry(_make_entry(), registry)
     for _ in range(3):
-        await async_setup_entry(hass, entry)
-        await registry.async_dispatch_options_update(entry)
-        await async_unload_entry(hass, entry)
+        _run(async_setup_entry(hass, entry))
+        registry.dispatch_options_update(entry)
+        _run(async_unload_entry(hass, entry))
     assert hass.config_entries.async_reload.call_count == 3
     assert registry.size == 0
 
 
-async def test_no_orphaned_tasks_after_unload(hass, make_entry) -> None:
-    entry = _wire(make_entry(), hass.registry)
-    await async_setup_entry(hass, entry)
-    await async_unload_entry(hass, entry)
-    pending = [task for task in asyncio.all_tasks() if task is not asyncio.current_task()]
-    assert pending == []
+def test_no_orphaned_tasks_after_unload() -> None:
+    async def _scenario():
+        hass, registry = _make_hass()
+        entry = _wire_entry(_make_entry(), registry)
+        await async_setup_entry(hass, entry)
+        await async_unload_entry(hass, entry)
+        pending = [task for task in asyncio.all_tasks() if task is not asyncio.current_task()]
+        assert pending == []
+
+    _run(_scenario())
 
 
-async def test_setup_entry_uses_domain_constant(hass, make_entry) -> None:
-    entry = _wire(make_entry(), hass.registry)
-    await async_setup_entry(hass, entry)
+def test_setup_entry_uses_domain_constant() -> None:
+    hass, _ = _make_hass()
+    entry = _wire_entry(_make_entry(), _ListenerRegistry())
+    _run(async_setup_entry(hass, entry))
     assert set(hass.data) == {DOMAIN_CONST}
 
 
-async def test_setup_awaitable_listener_removal_supported() -> None:
+def test_setup_awaitable_listener_removal_supported() -> None:
     """A coroutine-returning remover is awaited during unload."""
-    removed = []
 
-    async def _remover():
-        removed.append(True)
+    async def _scenario():
+        removed = []
 
-    entry = make_config_entry(entry_id="awaitable")
-    entry.add_update_listener = lambda listener: _remover
-    hass, _registry = make_hass()
-    await async_setup_entry(hass, entry)
-    result = await async_unload_entry(hass, entry)
-    assert result is True
-    assert removed == [True]
-    assert hass.data == {}
-    assert entry.runtime_data is None
+        async def _remover():
+            removed.append(True)
 
-
-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):
+        entry = SimpleNamespace(entry_id="awaitable", options={})
+        entry.add_update_listener = lambda listener: _remover
+        hass = SimpleNamespace(data={}, config_entries=SimpleNamespace(async_reload=None))
         await async_setup_entry(hass, entry)
-    assert hass.data.get(DOMAIN, {}) == {}
-    assert not hasattr(entry, "runtime_data")
+        result = await async_unload_entry(hass, entry)
+        assert result is True
+        assert removed == [True]
 
-
-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
-
-
-async def test_setup_applies_all_v1_tables(hass, make_entry) -> None:
-    """Setup applies the full v1 DDL: all four v1 tables exist afterwards."""
-    entry = _wire(make_entry(), hass.registry)
-    assert await async_setup_entry(hass, entry) is True
-    database = entry.runtime_data.database
-    rows = await database.fetch_all(
-        "SELECT name FROM sqlite_master WHERE type = 'table' "
-        "AND name IN ('children', 'admin_users', 'schedule_rules', "
-        "'task_definitions') ORDER BY name"
-    )
-    assert [row[0] for row in rows] == [
-        "admin_users",
-        "children",
-        "schedule_rules",
-        "task_definitions",
-    ]
-    await async_unload_entry(hass, entry)
+    _run(_scenario())

tests/test_manifest.py

@@ -3,6 +3,12 @@ from __future__ import annotations
 
 import json
 from pathlib import Path
+import sys
+from unittest.mock import MagicMock
+
+# Mock homeassistant modules if not installed in environment
+for _mod in ("homeassistant", "homeassistant.core", "homeassistant.config_entries"):
+    sys.modules.setdefault(_mod, MagicMock())
 
 import pytest
 

tests/test_migrations.py

@@ -1,677 +0,0 @@
-"""Tests for migrations.py: the versioned schema migration runner."""
-from __future__ import annotations
-
-import asyncio
-import hashlib
-import logging
-import sqlite3
-from unittest.mock import AsyncMock
-
-import pytest
-
-from custom_components.nestquest.db import NestQuestDatabase
-from custom_components.nestquest.migrations import (
-    MIGRATIONS,
-    VERSION_TABLE,
-    VERSION_TABLE_DDL,
-    apply_migrations,
-    read_schema_version,
-)
-from custom_components.nestquest.schema import SCHEMA_V1_STATEMENTS
-
-
-def _run(coro):
-    return asyncio.new_event_loop().run_until_complete(coro)
-
-
-def _make_hass_mock():
-    from unittest.mock import AsyncMock, MagicMock
-
-    hass = MagicMock()
-    hass.async_add_executor_job = AsyncMock(side_effect=(lambda fn, *a: fn(*a)))
-    return hass
-
-
-def _open_db(path) -> NestQuestDatabase:
-    database = NestQuestDatabase(_make_hass_mock())
-    _run(database.open(path))
-    return database
-
-
-def _migrate(database, migrations=MIGRATIONS):
-    return _run(apply_migrations(database, migrations))
-
-
-def _version(database) -> int:
-    return _run(read_schema_version(database))
-
-
-def _tables(database) -> set[str]:
-    rows = _run(
-        database.fetch_all(
-            "SELECT name FROM sqlite_master WHERE type = 'table' "
-            "AND name NOT LIKE 'sqlite_%'"
-        )
-    )
-    return {row[0] for row in rows}
-
-
-def _counts(database) -> dict[str, int]:
-    """Row counts for every v1 data table plus the version table."""
-    tables = (
-        "children",
-        "admin_users",
-        "schedule_rules",
-        "task_definitions",
-        "presence_schedules",
-        "presence_overrides",
-        "task_instances",
-        "completion_events",
-    )
-    counts = {}
-    for table in tables:
-        row = _run(database.fetch_one(f"SELECT COUNT(*) FROM {table}"))
-        counts[table] = row[0]
-    return counts
-
-
-# ---------------------------------------------------------------------------
-# Fresh file: version 0 -> version 1
-# ---------------------------------------------------------------------------
-
-
-def test_fresh_file_migrates_to_version_1(tmp_path) -> None:
-    database = _open_db(tmp_path / "fresh.db")
-    try:
-        final = _migrate(database)
-        assert final == 1
-        assert _version(database) == 1
-    finally:
-        _run(database.close())
-
-
-def test_fresh_file_migration_creates_all_v1_tables(tmp_path) -> None:
-    database = _open_db(tmp_path / "fresh-tables.db")
-    try:
-        _migrate(database)
-        expected = {
-            "children",
-            "admin_users",
-            "schedule_rules",
-            "task_definitions",
-            "presence_schedules",
-            "presence_overrides",
-            "task_instances",
-            "completion_events",
-            VERSION_TABLE,
-        }
-        assert _tables(database) == expected
-    finally:
-        _run(database.close())
-
-
-def test_missing_version_table_raises_on_direct_read(tmp_path) -> None:
-    database = _open_db(tmp_path / "no-table.db")
-    try:
-        with pytest.raises(sqlite3.OperationalError, match="no such table"):
-            _run(read_schema_version(database))
-        row = _run(
-            database.fetch_one(
-                "SELECT name FROM sqlite_master WHERE type = 'table' "
-                f"AND name = '{VERSION_TABLE}'"
-            )
-        )
-        assert row is None, "read_schema_version must not create the table"
-    finally:
-        _run(database.close())
-
-
-def test_empty_version_table_reads_as_version_0(tmp_path) -> None:
-    database = _open_db(tmp_path / "empty-table.db")
-    try:
-        _run(database.execute(VERSION_TABLE_DDL))
-        assert _version(database) == 0
-    finally:
-        _run(database.close())
-
-
-def test_migration_1_is_the_full_v1_ddl() -> None:
-    assert MIGRATIONS[0] == SCHEMA_V1_STATEMENTS
-    assert len(MIGRATIONS) == 1
-
-
-# ---------------------------------------------------------------------------
-# Idempotence: second start is a no-op
-# ---------------------------------------------------------------------------
-
-
-def test_second_run_applies_nothing_and_keeps_rows(tmp_path) -> None:
-    database = _open_db(tmp_path / "idempotent.db")
-    try:
-        _migrate(database)
-        _run(
-            database.execute(
-                "INSERT INTO children (display_name, created_at) VALUES (?, ?)",
-                ("Ada", "2026-09-13T00:00:00+00:00"),
-            )
-        )
-        _run(
-            database.execute(
-                "INSERT INTO admin_users (ha_user_id, added_at) VALUES (?, ?)",
-                ("user-1", "2026-09-13T00:00:00+00:00"),
-            )
-        )
-        final = _migrate(database)
-        assert final == 1
-        assert _version(database) == 1
-        assert _counts(database)["children"] == 1
-        assert _counts(database)["admin_users"] == 1
-    finally:
-        _run(database.close())
-
-
-def test_second_run_writes_nothing_to_the_file(tmp_path, caplog) -> None:
-    database = _open_db(tmp_path / "noop.db")
-    try:
-        _migrate(database)
-        _run(database.execute("PRAGMA wal_checkpoint(TRUNCATE)"))
-        db_file = tmp_path / "noop.db"
-        wal_file = tmp_path / "noop.db-wal"
-        digest_before = hashlib.sha256(db_file.read_bytes()).hexdigest()
-        mtime_before = db_file.stat().st_mtime_ns
-        wal_digest_before = (
-            hashlib.sha256(wal_file.read_bytes()).hexdigest()
-            if wal_file.exists()
-            else None
-        )
-
-        _migrate(database)
-
-        # A no-op run must not open a write transaction: the main
-        # database file is byte-identical (content hash, not just size)
-        # and untouched (mtime too), and the WAL gained no frames.
-        assert db_file.stat().st_mtime_ns == mtime_before
-        assert (
-            hashlib.sha256(db_file.read_bytes()).hexdigest() == digest_before
-        )
-        if wal_digest_before is None:
-            assert not wal_file.exists()
-        else:
-            assert (
-                hashlib.sha256(wal_file.read_bytes()).hexdigest()
-                == wal_digest_before
-            )
-    finally:
-        _run(database.close())
-
-
-def test_noop_run_logs_no_migration(caplog, tmp_path) -> None:
-    database = _open_db(tmp_path / "noop-log.db")
-    try:
-        _migrate(database)
-        caplog.clear()
-        with caplog.at_level(logging.INFO, logger="custom_components.nestquest.migrations"):
-            _migrate(database)
-        migrated = [
-            r for r in caplog.records if "migrated" in r.getMessage().lower()
-        ]
-        assert migrated == []
-    finally:
-        _run(database.close())
-
-
-def test_noop_run_is_logged_at_debug_level(caplog, tmp_path) -> None:
-    database = _open_db(tmp_path / "noop-debug.db")
-    try:
-        _migrate(database)
-        caplog.clear()
-        with caplog.at_level(logging.DEBUG, logger="custom_components.nestquest.migrations"):
-            _migrate(database)
-        assert any(
-            "already at version 1" in r.getMessage()
-            for r in caplog.records
-        )
-    finally:
-        _run(database.close())
-
-
-# ---------------------------------------------------------------------------
-# Failure atomicity: a failing migration leaves the prior version intact
-# ---------------------------------------------------------------------------
-
-
-def _failing_migrations(prior_statements: list[str]) -> list[list[str]]:
-    """Two-migration list where migration 2 fails mid-application."""
-    return [
-        prior_statements,
-        [
-            "CREATE TABLE IF NOT EXISTS later_table (id INTEGER PRIMARY KEY)",
-            "CREATE TABLE broken (",
-        ],
-    ]
-
-
-def test_failing_migration_rolls_back_to_prior_version(tmp_path) -> None:
-    database = _open_db(tmp_path / "rollback.db")
-    try:
-        # Manually simulate a database at version 1: apply migration 1's
-        # statements directly and stamp version 1 through the runner.
-        _migrate(database)
-        version_row = _run(
-            database.fetch_one(f"SELECT version FROM {VERSION_TABLE}")
-        )
-        assert version_row == (1,)
-
-        with pytest.raises(sqlite3.OperationalError):
-            _migrate(database, _failing_migrations(SCHEMA_V1_STATEMENTS))
-
-        # Version stamp unchanged, statements from the failed migration
-        # absent, and the v1 tables untouched.
-        assert _version(database) == 1
-        assert "later_table" not in _tables(database)
-        assert _counts(database)["children"] == 0
-        assert _counts(database)["completion_events"] == 0
-    finally:
-        _run(database.close())
-
-
-def test_failing_migration_on_fresh_file_leaves_version_0(tmp_path) -> None:
-    database = _open_db(tmp_path / "fresh-rollback.db")
-    try:
-        # The fresh file still reaches migration 2 (the failing one):
-        # migration 1 commits, stamping version 1, before migration 2
-        # fails and rolls back.  The run aborts at version 1 — the last
-        # fully-applied migration — not at version 0.
-        with pytest.raises(sqlite3.OperationalError):
-            _migrate(database, _failing_migrations(SCHEMA_V1_STATEMENTS))
-        assert _version(database) == 1
-        # Migration 2's tables must not survive the failed attempt.
-        assert "later_table" not in _tables(database)
-        # Migration 1's tables do: it committed before the failure.
-        assert "children" in _tables(database)
-        assert "task_instances" in _tables(database)
-    finally:
-        _run(database.close())
-
-
-def test_failed_migration_can_be_retried_after_fix(tmp_path) -> None:
-    database = _open_db(tmp_path / "retry.db")
-    try:
-        _migrate(database)
-        broken = _failing_migrations(SCHEMA_V1_STATEMENTS)
-        with pytest.raises(sqlite3.OperationalError):
-            _migrate(database, broken)
-        # "Fix" the migration and retry: it now applies cleanly.
-        broken[1] = [
-            "CREATE TABLE IF NOT EXISTS later_table (id INTEGER PRIMARY KEY)"
-        ]
-        final = _migrate(database, broken)
-        assert final == 2
-        assert _version(database) == 2
-        assert "later_table" in _tables(database)
-    finally:
-        _run(database.close())
-
-
-def test_failing_migration_error_is_preserved(tmp_path) -> None:
-    database = _open_db(tmp_path / "error-preserved.db")
-    try:
-        with pytest.raises(sqlite3.OperationalError, match="incomplete input"):
-            _migrate(database, _failing_migrations(SCHEMA_V1_STATEMENTS))
-    finally:
-        _run(database.close())
-
-
-# ---------------------------------------------------------------------------
-# Version guard rails
-# ---------------------------------------------------------------------------
-
-
-def test_future_version_is_rejected(tmp_path) -> None:
-    database = _open_db(tmp_path / "future.db")
-    try:
-        _migrate(database)
-        _run(
-            database.execute(
-                f"UPDATE {VERSION_TABLE} SET version = ?", (99,)
-            )
-        )
-        with pytest.raises(RuntimeError, match="newer than"):
-            _migrate(database)
-        # Nothing was modified by the rejected run.
-        assert _version(database) == 99
-    finally:
-        _run(database.close())
-
-
-def test_non_integer_version_raises_runtime_error(tmp_path) -> None:
-    database = _open_db(tmp_path / "string-version.db")
-    try:
-        _run(database.execute(VERSION_TABLE_DDL))
-        # The CHECK enforces version >= 1 but SQLite's loose typing
-        # stores TEXT under an INTEGER-affinity column when it cannot
-        # be losslessly coerced; guard the read path against it.
-        _run(
-            database.execute(
-                f"INSERT INTO {VERSION_TABLE} (id, version) VALUES (1, ?)",
-                ("one",),
-            )
-        )
-        with pytest.raises(RuntimeError, match="not an integer"):
-            _run(read_schema_version(database))
-    finally:
-        _run(database.close())
-
-
-def test_negative_version_read_guard_rejects_below_one() -> None:
-    """The read path rejects sub-1 versions even if storage missed them.
-
-    The VERSION_TABLE CHECK already makes negative/zero unstorable; this
-    exercises the defense-in-depth guard in read_schema_version itself
-    against a database stub returning such a row (e.g. a future schema
-    relaxing the CHECK, or a hand-edited file).
-    """
-    from unittest.mock import AsyncMock, MagicMock
-
-    for bad in (-1, 0):
-        database = MagicMock()
-        database.fetch_one = AsyncMock(return_value=(bad,))
-        with pytest.raises(RuntimeError, match="must be >= 1"):
-            _run(read_schema_version(database))
-
-
-def test_non_integer_version_read_guard_rejects_text() -> None:
-    from unittest.mock import AsyncMock, MagicMock
-
-    for bad in ("one", 1.5, True):
-        database = MagicMock()
-        database.fetch_one = AsyncMock(return_value=(bad,))
-        with pytest.raises(RuntimeError, match="not an integer"):
-            _run(read_schema_version(database))
-
-
-def test_zero_version_row_is_unstorable(tmp_path) -> None:
-    """The CHECK makes sub-1 versions impossible through SQL.
-
-    PRAGMA writable_schema does not bypass CHECKs on ordinary tables,
-    so the negative/zero read guard above is pure defense-in-depth;
-    here we prove the storage-level rule the normal path relies on.
-    """
-    database = _open_db(tmp_path / "zero-version.db")
-    try:
-        _run(database.execute(VERSION_TABLE_DDL))
-        for bad in (0, -1):
-            with pytest.raises(sqlite3.IntegrityError, match="CHECK"):
-                _run(
-                    database.execute(
-                        f"INSERT INTO {VERSION_TABLE} (id, version) "
-                        "VALUES (1, ?)",
-                        (bad,),
-                    )
-                )
-    finally:
-        _run(database.close())
-
-
-def test_version_table_enforces_singleton_row(tmp_path) -> None:
-    database = _open_db(tmp_path / "singleton.db")
-    try:
-        _run(database.execute(VERSION_TABLE_DDL))
-        _run(
-            database.execute(
-                f"INSERT INTO {VERSION_TABLE} (id, version) VALUES (1, 1)"
-            )
-        )
-        with pytest.raises(sqlite3.IntegrityError, match="CHECK"):
-            _run(
-                database.execute(
-                    f"INSERT INTO {VERSION_TABLE} (id, version) "
-                    "VALUES (2, 1)"
-                )
-            )
-    finally:
-        _run(database.close())
-
-
-def test_version_table_check_rejects_version_zero_and_negative(
-    tmp_path,
-) -> None:
-    database = _open_db(tmp_path / "version-check.db")
-    try:
-        _run(database.execute(VERSION_TABLE_DDL))
-        for bad in (0, -1):
-            with pytest.raises(sqlite3.IntegrityError, match="CHECK"):
-                _run(
-                    database.execute(
-                        f"INSERT INTO {VERSION_TABLE} (id, version) "
-                        "VALUES (1, ?)",
-                        (bad,),
-                    )
-                )
-    finally:
-        _run(database.close())
-
-
-def test_concurrent_runners_serialize_and_apply_once(tmp_path) -> None:
-    """Two concurrent runners on one connection apply each step once.
-
-    Deterministic race: runner B starts while runner A is queued into
-    its migration.  A applies everything and stamps; B then acquires
-    the migration lock, re-reads the already-stamped version, and
-    applies nothing.  Without serialization B's transaction() would
-    raise RuntimeError (the wrapper forbids concurrent transactions),
-    so this also proves the queueing works.
-    """
-    migrations = [
-        ["CREATE TABLE IF NOT EXISTS step_a (id INTEGER PRIMARY KEY)"],
-        ["CREATE TABLE IF NOT EXISTS step_b (id INTEGER PRIMARY KEY)"],
-    ]
-    results: dict[str, int] = {}
-
-    async def _main(tmp_name: str) -> None:
-        database = NestQuestDatabase(_make_hass_mock())
-        await database.open(tmp_name)
-        try:
-            # Start A, yield so it acquires the lock and enters its
-            # first transaction, then start B while A is mid-apply.
-            task_a = asyncio.ensure_future(
-                apply_migrations(database, migrations)
-            )
-            await asyncio.sleep(0)
-            task_b = asyncio.ensure_future(
-                apply_migrations(database, migrations)
-            )
-            results["a"], results["b"] = await asyncio.gather(
-                task_a, task_b
-            )
-
-            tables = {
-                row[0]
-                for row in await database.fetch_all(
-                    "SELECT name FROM sqlite_master WHERE type = 'table' "
-                    "AND name NOT LIKE 'sqlite_%'"
-                )
-            }
-            assert {"step_a", "step_b"} <= tables
-            # Each migration's statements ran exactly once: the CREATE
-            # IF NOT EXISTS would hide double-runs, so count via sqlite
-            # sequence/DDL fingerprint instead — re-check version and
-            # that both runners reported the same final version.
-            row = await database.fetch_one(
-                f"SELECT version FROM {VERSION_TABLE}"
-            )
-            assert row == (2,)
-        finally:
-            await database.close()
-
-    loop = asyncio.new_event_loop()
-    try:
-        loop.run_until_complete(_main(str(tmp_path / "concurrent.db")))
-    finally:
-        loop.close()
-
-    assert results["a"] == 2
-    assert results["b"] == 2
-
-
-def test_multiple_pending_migrations_apply_in_order(tmp_path) -> None:
-    database = _open_db(tmp_path / "multi-step.db")
-    try:
-        migrations = [
-            ["CREATE TABLE IF NOT EXISTS step_a (id INTEGER PRIMARY KEY)"],
-            ["CREATE TABLE IF NOT EXISTS step_b (id INTEGER PRIMARY KEY)"],
-            ["CREATE TABLE IF NOT EXISTS step_c (id INTEGER PRIMARY KEY)"],
-        ]
-        final = _run(apply_migrations(database, migrations))
-        assert final == 3
-        assert _version(database) == 3
-        assert {"step_a", "step_b", "step_c"} <= _tables(database)
-    finally:
-        _run(database.close())
-
-
-def test_partial_pending_migrations_resume_from_current_version(
-    tmp_path,
-) -> None:
-    database = _open_db(tmp_path / "resume.db")
-    try:
-        migrations = [
-            ["CREATE TABLE IF NOT EXISTS step_a (id INTEGER PRIMARY KEY)"],
-            ["CREATE TABLE IF NOT EXISTS step_b (id INTEGER PRIMARY KEY)"],
-        ]
-        # Advance to version 1 only, by applying a truncated list of the
-        # same migrations: patch apply_migrations' latest by passing a
-        # single-migration list first, then the full list.
-        _run(apply_migrations(database, migrations[:1]))
-        assert _version(database) == 1
-        final = _run(apply_migrations(database, migrations))
-        assert final == 2
-        assert _version(database) == 2
-        assert "step_b" in _tables(database)
-    finally:
-        _run(database.close())
-
-
-# ---------------------------------------------------------------------------
-# Startup wiring: setup runs the migration runner, not raw DDL
-# ---------------------------------------------------------------------------
-
-
-async def _setup_entry(hass, entry, registry) -> object:
-    from tests.test_lifecycle import _wire  # reuse the established wiring
-
-    entry = _wire(entry, registry)
-    from custom_components.nestquest import async_setup_entry
-
-    await async_setup_entry(hass, entry)
-    return entry
-
-
-async def test_setup_entry_migrates_fresh_database(hass, make_entry) -> None:
-    import sqlite3 as sqlite3_mod
-
-    from custom_components.nestquest.migrations import read_schema_version
-    from custom_components.nestquest.store import async_get_db_path
-
-    entry = await _setup_entry(hass, make_entry(), hass.registry)
-    database = entry.runtime_data.database
-    assert await read_schema_version(database) == 1
-    # The v1 tables exist because the runner applied migration 1.
-    names = {
-        row[0]
-        for row in await database.fetch_all(
-            "SELECT name FROM sqlite_master WHERE type = 'table' "
-            "AND name NOT LIKE 'sqlite_%'"
-        )
-    }
-    assert "children" in names and "completion_events" in names
-    # The version table exists with its singleton row stamped.
-    columns = await database.fetch_all(f"PRAGMA table_info({VERSION_TABLE})")
-    assert [(row[1], row[3]) for row in columns] == [("id", 1), ("version", 1)]
-    db_path = await async_get_db_path(hass)
-    conn = sqlite3_mod.connect(db_path)
-    try:
-        conn.execute(f"INSERT INTO {VERSION_TABLE} (id, version) VALUES (2, 1)")
-        violated = False
-    except sqlite3_mod.IntegrityError:
-        violated = True
-    finally:
-        conn.close()
-    assert violated, "singleton-row CHECK must be live in the setup-created DB"
-    await database.close()
-
-
-async def test_options_reload_reopens_and_rechecks_version(
-    hass, make_entry
-) -> None:
-    """A listener-triggered reload re-runs setup against the same file.
-
-    Unload then setup is the reload lifecycle: the old connection is
-    closed, apply_migrations runs again on the persisted file, keeps
-    version and rows intact, and the reopened connection is live.
-    """
-    from custom_components.nestquest import async_unload_entry
-    from custom_components.nestquest.migrations import read_schema_version
-
-    entry = await _setup_entry(hass, make_entry(), hass.registry)
-    database_a = entry.runtime_data.database
-    await database_a.execute(
-        "INSERT INTO children (display_name, created_at) VALUES (?, ?)",
-        ("Ada", "2026-09-13T00:00:00+00:00"),
-    )
-    assert await async_unload_entry(hass, entry) is True
-    assert not database_a.connected
-
-    entry_reloaded = await _setup_entry(hass, make_entry(), hass.registry)
-    database_b = entry_reloaded.runtime_data.database
-    assert database_b is not database_a
-    try:
-        assert await read_schema_version(database_b) == 1
-        row = await database_b.fetch_one("SELECT COUNT(*) FROM children")
-        assert row == (1,)
-    finally:
-        await database_b.close()
-
-
-async def test_setup_entry_failure_closes_database(
-    hass, make_entry, monkeypatch
-) -> None:
-    """A failing migration closes the opened connection before re-raising.
-
-    Spies on the real wrapper instance: records whether close() ran and
-    whether the connection is left disconnected, rather than inferring
-    from hass.data (a failed setup never stores a runtime record).
-    """
-    import pytest as pytest_module
-
-    import custom_components.nestquest as nestquest_module
-    from custom_components.nestquest.db import NestQuestDatabase
-    from custom_components.nestquest.migrations import (
-        MIGRATIONS as _MIGRATIONS,
-    )
-
-    async def _failing(database, migrations=_MIGRATIONS):
-        raise RuntimeError("boom")
-
-    monkeypatch.setattr(
-        nestquest_module, "apply_migrations", _failing, raising=True
-    )
-
-    close_calls: list[bool] = []
-    original_close = NestQuestDatabase.close
-
-    async def _spy_close(self):
-        close_calls.append(True)
-        return await original_close(self)
-
-    monkeypatch.setattr(NestQuestDatabase, "close", _spy_close)
-
-    entry = make_entry()
-    with pytest_module.raises(RuntimeError, match="boom"):
-        await _setup_entry(hass, entry, hass.registry)
-
-    assert close_calls == [True], (
-        "failed setup must close the connection it opened"
-    )
-    record = hass.data["nestquest"].get(entry.entry_id)
-    assert record is None, "failed setup must not store runtime data"

tests/test_options_flow.py

@@ -1,376 +0,0 @@
-"""Tests for the options flow of NestQuest."""
-from __future__ import annotations
-
-import ast
-import asyncio
-import json
-from pathlib import Path
-from types import SimpleNamespace
-
-import pytest
-
-from conftest import make_config_entry, make_hass, options_flow_base as _options_flow_base
-
-from custom_components.nestquest import config_flow
-from custom_components.nestquest import options_flow
-from custom_components.nestquest.const import (
-    CONF_DAY_ROLLOVER_TIME,
-    CONF_HORIZON_DAYS,
-    CONF_PANEL_IDLE_TIMEOUT,
-    DEFAULT_DAY_ROLLOVER_TIME,
-    DEFAULT_HORIZON_DAYS,
-    DEFAULT_PANEL_IDLE_TIMEOUT,
-    DOMAIN,
-)
-
-PKG_DIR = Path(options_flow.__file__).parent
-STRINGS_PATH = PKG_DIR / "strings.json"
-TRANSLATIONS_EN_PATH = PKG_DIR / "translations" / "en.json"
-
-VALID_INPUT = {
-    CONF_HORIZON_DAYS: 7,
-    CONF_DAY_ROLLOVER_TIME: "03:30",
-    CONF_PANEL_IDLE_TIMEOUT: 60,
-}
-
-
-def _run(coro):
-    return asyncio.new_event_loop().run_until_complete(coro)
-
-
-def _make_hass():
-    return make_hass()
-
-
-def _make_entry(entry_id: str = "test_entry", options: dict | None = None, data: dict | None = None):
-    return make_config_entry(entry_id=entry_id, options=options, data=data)
-
-
-def _make_flow(entry) -> options_flow.NestQuestOptionsFlow:
-    """Create an options flow instance bound to a stubbed config entry."""
-    flow = options_flow.NestQuestOptionsFlow(config_entry=entry)
-    flow.hass = SimpleNamespace()
-    return flow
-
-
-def _schema_values(schema) -> dict:
-    """Extract the per-field default values from a real voluptuous schema."""
-    return {
-        marker.schema: marker.default()
-        for marker in schema.schema
-        if hasattr(marker, "schema")
-    }
-
-
-def test_options_flow_reachable_via_configure_button() -> None:
-    """The config flow exposes async_get_options_flow returning the options flow."""
-    entry = _make_entry()
-    handler = config_flow.NestQuestConfigFlow.async_get_options_flow(entry)
-    assert isinstance(handler, options_flow.NestQuestOptionsFlow)
-    assert handler.config_entry is entry
-
-
-def test_options_flow_get_options_flow_is_ha_callback() -> None:
-    """async_get_options_flow is wrapped by the homeassistant.core.callback decorator."""
-    assert getattr(
-        config_flow.NestQuestConfigFlow.async_get_options_flow, "__ha_callback__", False
-    ) is True
-
-
-def test_options_flow_constructs_through_2024_6_surface() -> None:
-    """The handler constructs against the mocked 2024.6 base and inherits its contract."""
-    entry = _make_entry(options={CONF_HORIZON_DAYS: 21})
-    flow = options_flow.NestQuestOptionsFlow(config_entry=entry)
-    assert isinstance(flow, _options_flow_base())
-    assert flow.config_entry is entry
-    assert flow.options == {CONF_HORIZON_DAYS: 21}
-
-
-def test_options_flow_submits_through_2024_6_surface() -> None:
-    """The handler can be submitted through the mocked 2024.6-shaped surface."""
-    entry = _make_entry()
-    handler = config_flow.NestQuestConfigFlow.async_get_options_flow(entry)
-    result = _run(handler.async_step_init(dict(VALID_INPUT)))
-    assert result["type"] == "create_entry"
-    assert result["title"] == "NestQuest"
-    assert result["data"] == VALID_INPUT
-
-
-def test_options_flow_shows_form_initially() -> None:
-    """The init step shows a form."""
-    flow = _make_flow(_make_entry())
-    result = _run(flow.async_step_init(None))
-    assert result["type"] == "form"
-    assert result["step_id"] == "init"
-
-
-def test_options_flow_schema_is_voluptuous() -> None:
-    """The form's data_schema is a real voluptuous Schema (no dict fallback)."""
-    flow = _make_flow(_make_entry())
-    result = _run(flow.async_step_init(None))
-    import voluptuous as vol
-
-    assert isinstance(result["data_schema"], vol.Schema)
-
-
-def test_options_flow_prefills_from_defaults() -> None:
-    """Without stored options, the form pre-fills with the constant defaults."""
-    flow = _make_flow(_make_entry())
-    result = _run(flow.async_step_init(None))
-    values = _schema_values(result["data_schema"])
-    assert values[CONF_HORIZON_DAYS] == DEFAULT_HORIZON_DAYS
-    assert values[CONF_DAY_ROLLOVER_TIME] == DEFAULT_DAY_ROLLOVER_TIME
-    assert values[CONF_PANEL_IDLE_TIMEOUT] == DEFAULT_PANEL_IDLE_TIMEOUT
-
-
-def test_options_flow_prefills_from_entry_options() -> None:
-    """Stored entry options win over entry data and defaults."""
-    entry = _make_entry(
-        options={
-            CONF_HORIZON_DAYS: 21,
-            CONF_DAY_ROLLOVER_TIME: "05:45",
-            CONF_PANEL_IDLE_TIMEOUT: 120,
-        },
-        data={
-            CONF_HORIZON_DAYS: 99,
-            CONF_DAY_ROLLOVER_TIME: "23:59",
-            CONF_PANEL_IDLE_TIMEOUT: 999,
-        },
-    )
-    result = _run(_make_flow(entry).async_step_init(None))
-    values = _schema_values(result["data_schema"])
-    assert values[CONF_HORIZON_DAYS] == 21
-    assert values[CONF_DAY_ROLLOVER_TIME] == "05:45"
-    assert values[CONF_PANEL_IDLE_TIMEOUT] == 120
-
-
-def test_options_flow_falls_back_to_entry_data() -> None:
-    """Pre-upgrade entries without options fall back to entry.data."""
-    entry = _make_entry(
-        data={
-            CONF_HORIZON_DAYS: 10,
-            CONF_DAY_ROLLOVER_TIME: "01:15",
-            CONF_PANEL_IDLE_TIMEOUT: 90,
-        }
-    )
-    result = _run(_make_flow(entry).async_step_init(None))
-    values = _schema_values(result["data_schema"])
-    assert values[CONF_HORIZON_DAYS] == 10
-    assert values[CONF_DAY_ROLLOVER_TIME] == "01:15"
-    assert values[CONF_PANEL_IDLE_TIMEOUT] == 90
-
-
-def test_options_flow_schema_applies_stored_defaults() -> None:
-    """A real voluptuous validate({}) fills every field from the stored defaults."""
-    entry = _make_entry(
-        options={
-            CONF_HORIZON_DAYS: 21,
-            CONF_DAY_ROLLOVER_TIME: "05:45",
-            CONF_PANEL_IDLE_TIMEOUT: 120,
-        }
-    )
-    result = _run(_make_flow(entry).async_step_init(None))
-    assert result["data_schema"]({}) == {
-        CONF_HORIZON_DAYS: 21,
-        CONF_DAY_ROLLOVER_TIME: "05:45",
-        CONF_PANEL_IDLE_TIMEOUT: 120,
-    }
-
-
-def test_options_flow_schema_coerces_field_types() -> None:
-    """The schema validates the expected field types via voluptuous."""
-    flow = _make_flow(_make_entry())
-    result = _run(flow.async_step_init(None))
-    schema = result["data_schema"]
-    validators = {marker.schema: validator for marker, validator in schema.schema.items()}
-    assert validators[CONF_HORIZON_DAYS] is int
-    assert validators[CONF_DAY_ROLLOVER_TIME] is str
-    assert validators[CONF_PANEL_IDLE_TIMEOUT] is int
-
-
-@pytest.mark.parametrize("bad_horizon", [0, -5])
-def test_options_flow_rejects_non_positive_horizon(bad_horizon: int) -> None:
-    """Zero or negative horizon values yield a field-level error, no exception."""
-    flow = _make_flow(_make_entry())
-    result = _run(
-        flow.async_step_init({**VALID_INPUT, CONF_HORIZON_DAYS: bad_horizon})
-    )
-    assert result["type"] == "form"
-    assert result["errors"] == {CONF_HORIZON_DAYS: "invalid"}
-
-
-def test_options_flow_rejects_malformed_time_not_a_time() -> None:
-    """Non-HH:MM strings are rejected with invalid_time."""
-    flow = _make_flow(_make_entry())
-    result = _run(
-        flow.async_step_init({**VALID_INPUT, CONF_DAY_ROLLOVER_TIME: "noon"})
-    )
-    assert result["type"] == "form"
-    assert result["errors"] == {CONF_DAY_ROLLOVER_TIME: "invalid_time"}
-
-
-def test_options_flow_rejects_malformed_time_out_of_range() -> None:
-    """Out-of-range HH:MM values are rejected with invalid_time."""
-    flow = _make_flow(_make_entry())
-    result = _run(
-        flow.async_step_init({**VALID_INPUT, CONF_DAY_ROLLOVER_TIME: "25:99"})
-    )
-    assert result["type"] == "form"
-    assert result["errors"] == {CONF_DAY_ROLLOVER_TIME: "invalid_time"}
-
-
-def test_options_flow_rejects_pasted_unicode_superscript_time() -> None:
-    """Pasted Unicode digits like '²²:²²' yield a field-level error, no exception."""
-    flow = _make_flow(_make_entry())
-    result = _run(
-        flow.async_step_init({**VALID_INPUT, CONF_DAY_ROLLOVER_TIME: "²²:²²"})
-    )
-    assert result["type"] == "form"
-    assert result["errors"] == {CONF_DAY_ROLLOVER_TIME: "invalid_time"}
-
-
-@pytest.mark.parametrize("bad_timeout", ["abc", 0, -10, 10])
-def test_options_flow_rejects_invalid_idle_timeout(bad_timeout) -> None:
-    """Non-numeric or too-low idle timeouts yield a field-level error."""
-    flow = _make_flow(_make_entry())
-    result = _run(
-        flow.async_step_init({**VALID_INPUT, CONF_PANEL_IDLE_TIMEOUT: bad_timeout})
-    )
-    assert result["type"] == "form"
-    assert result["errors"] == {CONF_PANEL_IDLE_TIMEOUT: "invalid"}
-
-
-def test_options_flow_creates_entry_with_three_keys() -> None:
-    """A valid submit creates an entry with exactly the three validated keys."""
-    flow = _make_flow(_make_entry())
-    result = _run(flow.async_step_init(dict(VALID_INPUT)))
-    assert result["type"] == "create_entry"
-    assert result["title"] == "NestQuest"
-    assert set(result["data"]) == {
-        CONF_HORIZON_DAYS,
-        CONF_DAY_ROLLOVER_TIME,
-        CONF_PANEL_IDLE_TIMEOUT,
-    }
-    assert result["data"] == VALID_INPUT
-
-
-def test_options_flow_create_entry_data_lands_in_entry_options_and_reloads_once() -> None:
-    """The flow's created data is written to entry.options and reloads exactly once."""
-    hass, registry = _make_hass()
-    entry = _make_entry()
-    entry.add_update_listener = lambda listener: registry.add(entry.entry_id, listener)
-
-    # Simulate setup registering the merged lifecycle update listener.
-    from custom_components.nestquest import async_setup_entry
-
-    _run(async_setup_entry(hass, entry))
-
-    # Run the options flow and apply its created data to entry.options like HA does.
-    flow = _make_flow(entry)
-    result = _run(flow.async_step_init(dict(VALID_INPUT)))
-    assert result["type"] == "create_entry"
-    entry.options = dict(result["data"])
-
-    _run(registry.dispatch_options_update(entry))
-    assert hass.config_entries.async_reload.call_count == 1
-    assert registry.reloaded == [entry.entry_id]
-    assert entry.options == VALID_INPUT
-
-
-def test_options_flow_validation_never_raises() -> None:
-    """Validation returns errors instead of raising for arbitrary junk input."""
-    junk = {CONF_HORIZON_DAYS: None, CONF_DAY_ROLLOVER_TIME: None, CONF_PANEL_IDLE_TIMEOUT: None}
-    flow = _make_flow(_make_entry())
-    result = _run(flow.async_step_init(junk))
-    assert result["type"] == "form"
-    assert result["errors"] == {
-        CONF_HORIZON_DAYS: "invalid",
-        CONF_DAY_ROLLOVER_TIME: "invalid_time",
-        CONF_PANEL_IDLE_TIMEOUT: "invalid",
-    }
-
-
-@pytest.fixture
-def strings() -> dict:
-    """Load and parse strings.json."""
-    assert STRINGS_PATH.exists(), f"strings.json does not exist at {STRINGS_PATH}"
-    with open(STRINGS_PATH, encoding="utf-8") as f:
-        return json.load(f)
-
-
-@pytest.fixture
-def translations_en() -> dict:
-    """Load and parse translations/en.json."""
-    assert TRANSLATIONS_EN_PATH.exists(), (
-        f"translations/en.json does not exist at {TRANSLATIONS_EN_PATH}"
-    )
-    with open(TRANSLATIONS_EN_PATH, encoding="utf-8") as f:
-        return json.load(f)
-
-
-def test_options_strings_present_and_matching(strings: dict, translations_en: dict) -> None:
-    """Both string files carry identical options step/error strings."""
-    assert strings.get("options") == translations_en.get("options")
-    options = strings["options"]
-    init = options["step"]["init"]
-    assert init["title"]
-    assert init["description"]
-    data = init["data"]
-    for key in (CONF_HORIZON_DAYS, CONF_DAY_ROLLOVER_TIME, CONF_PANEL_IDLE_TIMEOUT):
-        assert data.get(key), f"Missing field name for '{key}'"
-    errors = options["errors"]
-    for key in ("invalid", "invalid_time"):
-        assert errors.get(key), f"Missing error string for '{key}'"
-
-
-def test_options_strings_no_raw_keys(strings: dict, translations_en: dict) -> None:
-    """No placeholder/raw keys appear in the options strings."""
-
-    def check(value) -> None:
-        if isinstance(value, dict):
-            for key, val in value.items():
-                assert val, f"Empty string value for key '{key}'"
-                check(val)
-        elif isinstance(value, str):
-            assert value.strip() != ""
-
-    check(strings["options"])
-    check(translations_en["options"])
-
-
-def test_options_flow_no_plain_dict_schema_fallback() -> None:
-    """No try/except ImportError fallback for voluptuous in the options flow module."""
-    py_file = Path(options_flow.__file__)
-    tree = ast.parse(py_file.read_text(encoding="utf-8"), filename=str(py_file))
-    for node in ast.walk(tree):
-        if isinstance(node, ast.Try):
-            handlers = node.handlers or []
-            has_import_error_handler = any(
-                getattr(handler.type, "id", getattr(handler.type, "attr", None))
-                == "ImportError"
-                for handler in handlers
-            )
-            assert not has_import_error_handler, (
-                f"Plain-dict schema fallback (try/except ImportError) found in {py_file.name}:{node.lineno}"
-            )
-
-
-def test_options_flow_subclasses_options_flow_with_config_entry() -> None:
-    """NestQuestOptionsFlow subclasses config_entries.OptionsFlowWithConfigEntry."""
-    base = _options_flow_base()
-    assert issubclass(options_flow.NestQuestOptionsFlow, base)
-    assert options_flow.NestQuestOptionsFlow.__bases__ == (base,)
-
-
-def test_options_flow_no_hardcoded_domain_or_db_filename() -> None:
-    """The options flow module does not hardcode the domain or db filename."""
-    py_file = Path(options_flow.__file__)
-    tree = ast.parse(py_file.read_text(encoding="utf-8"), filename=str(py_file))
-    for node in ast.walk(tree):
-        if isinstance(node, ast.Constant) and isinstance(node.value, str):
-            assert node.value != DOMAIN, (
-                f"Hard-coded domain string in {py_file.name}:{node.lineno}"
-            )
-            assert node.value != "nestquest.db", (
-                f"Hard-coded database filename in {py_file.name}:{node.lineno}"
-            )

tests/test_store.py

@@ -4,8 +4,17 @@ from __future__ import annotations
 import ast
 import asyncio
 from pathlib import Path
+import sys
 from unittest.mock import AsyncMock, MagicMock
 
+# Mock homeassistant modules if not installed in environment
+for _mod in (
+    "homeassistant",
+    "homeassistant.core",
+    "homeassistant.config_entries",
+):
+    sys.modules.setdefault(_mod, MagicMock())
+
 from custom_components.nestquest import store
 from custom_components.nestquest.const import SQLITE_DB_FILENAME
 
@@ -100,14 +109,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):

uv.lock

@@ -1,116 +0,0 @@
-version = 1
-revision = 3
-requires-python = ">=3.11"
-
-[[package]]
-name = "colorama"
-version = "0.4.6"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
-]
-
-[[package]]
-name = "iniconfig"
-version = "2.3.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
-]
-
-[[package]]
-name = "nestquest"
-version = "0.1.0"
-source = { virtual = "." }
-
-[package.dev-dependencies]
-dev = [
-    { name = "pytest" },
-    { name = "pytest-asyncio" },
-    { name = "voluptuous" },
-]
-
-[package.metadata]
-
-[package.metadata.requires-dev]
-dev = [
-    { name = "pytest", specifier = ">=8.0.0" },
-    { name = "pytest-asyncio", specifier = ">=0.24" },
-    { name = "voluptuous", specifier = ">=0.14" },
-]
-
-[[package]]
-name = "packaging"
-version = "26.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" },
-]
-
-[[package]]
-name = "pluggy"
-version = "1.6.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
-]
-
-[[package]]
-name = "pygments"
-version = "2.21.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" },
-]
-
-[[package]]
-name = "pytest"
-version = "9.1.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "colorama", marker = "sys_platform == 'win32'" },
-    { name = "iniconfig" },
-    { name = "packaging" },
-    { name = "pluggy" },
-    { name = "pygments" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" },
-]
-
-[[package]]
-name = "pytest-asyncio"
-version = "1.4.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pytest" },
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/43/7c/d36d04db312ecf4298932ef77e6e4a9e8ad017906e24e34f0b0c361a2473/pytest_asyncio-1.4.0.tar.gz", hash = "sha256:c6c0d2259945122819f171a32ecea2c349ead889ee28176caaf492143424be42", size = 58514, upload-time = "2026-05-26T09:56:04.083Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/03/e2/08a497ef684b88559c9cc5f4ad53a37e7b99e727094a86d6ea32536d5d3c/pytest_asyncio-1.4.0-py3-none-any.whl", hash = "sha256:933ca923a23075a87fb7070c0ec272a6848489824d887c85c812670932835aa1", size = 16930, upload-time = "2026-05-26T09:56:02.576Z" },
-]
-
-[[package]]
-name = "typing-extensions"
-version = "4.16.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" },
-]
-
-[[package]]
-name = "voluptuous"
-version = "0.16.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/92/f4/0738e6849858deae22218be3bbb8207ba83a96e9d0ec7e8e8cd67b30e5ca/voluptuous-0.16.0.tar.gz", hash = "sha256:006535e22fed944aec17bef6e8725472476194743c87bd233e912eb463f8ff05", size = 54238, upload-time = "2025-12-18T23:18:46.08Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d1/00/0e0da784245c93cf346150ab67634177bf277f93b7a162bb56c928c39c04/voluptuous-0.16.0-py3-none-any.whl", hash = "sha256:ee342095263e1b5afbd4d418cb5adc92810eebfd07696bb033a261210df33db4", size = 31931, upload-time = "2025-12-18T23:18:44.694Z" },
-]