Remove every automatic timezone-setting mechanism (task 7f685179) (#282)

Co-authored-by: Joshua <joshua@cnjmail.com>
Co-committed-by: Joshua <joshua@cnjmail.com>

tests/test_api_admin_settings.py

@@ -13,7 +13,8 @@ proven against the DATABASE the routes wrote, not a parallel copy.
 Proven per the done-condition, everything read back through the API:
 
 - ``GET /api/v1/admin/settings`` returns the current effective settings
-  — the twelve documented fields at their defaults on a fresh database.
+  — the eleven documented fields at their defaults on a fresh database,
+  with no ``timezone_configured`` marker.
 - ``PATCH /api/v1/admin/settings`` PERSISTS the supplied fields and the
   NEXT read reflects them; a later partial update merges onto the
   current effective settings (omitted fields keep their stored value),
@@ -60,7 +61,7 @@ _dao_meta = importlib.import_module("nestquest_core.dao_meta")
 SETTINGS_META_KEY = "settings"
 
 #: The all-defaults effective settings a fresh database reports — the
-#: documented twelve fields, asserted literally so the payload contract is
+#: documented eleven fields, asserted literally so the payload contract is
 #: pinned here, independent of the core constants.
 DEFAULT_SETTINGS = {
     "horizon_days": 14,
@@ -74,7 +75,6 @@ DEFAULT_SETTINGS = {
     "end_of_day_report_enabled": True,
     "celebration_enabled": True,
     "timezone": "",
-    "timezone_configured": False,
 }
 
 
@@ -105,7 +105,7 @@ async def settings_client(temp_db_path: str) -> SimpleNamespace:
 async def test_get_settings_returns_defaults_on_a_fresh_database(
     settings_client: SimpleNamespace,
 ) -> None:
-    """GET returns the twelve documented fields at their defaults."""
+    """GET returns the eleven documented fields at their defaults."""
     response = await settings_client.client.get(
         "/api/v1/admin/settings", headers=_admin_headers()
     )
@@ -223,27 +223,38 @@ async def test_null_resets_a_field_to_its_default(
     assert reread.json()["horizon_days"] == 14
 
 
-async def test_timezone_configured_round_trips_with_an_explicit_empty_zone(
+async def test_default_settings_carry_no_timezone_configured_marker(
     settings_client: SimpleNamespace,
 ) -> None:
-    """An explicit empty (host-local) zone persists as configured.
+    """The removed auto-set marker is absent from the default response."""
+    response = await settings_client.client.get(
+        "/api/v1/admin/settings", headers=_admin_headers()
+    )
+    assert response.status_code == 200
+    assert "timezone_configured" not in response.json()
+    assert response.json()["timezone"] == ""
 
-    The admin clearing the zone PATCHes ``timezone: ""`` together with
-    ``timezone_configured: true``; the NEXT read — a reopened settings
-    screen — sees the marker, so the empty value is a persisted choice
-    rather than a fresh install to auto-set.
-    """
+
+@pytest.mark.parametrize("zone", ["America/New_York", ""])
+async def test_manual_timezone_patch_persists_and_is_returned(
+    settings_client: SimpleNamespace, zone: str
+) -> None:
+    """An admin's timezone PATCH is stored exactly as given and read back."""
     client = settings_client.client
-    fresh = await client.get("/api/v1/admin/settings", headers=_admin_headers())
-    assert fresh.json()["timezone_configured"] is False
+    seeded = await client.patch(
+        "/api/v1/admin/settings",
+        json={"timezone": "Europe/Dublin"},
+        headers=_admin_headers(),
+    )
+    assert seeded.status_code == 200
 
     patched = await client.patch(
         "/api/v1/admin/settings",
-        json={"timezone": "", "timezone_configured": True},
+        json={"timezone": zone},
         headers=_admin_headers(),
     )
     assert patched.status_code == 200
-    expected = {**DEFAULT_SETTINGS, "timezone_configured": True}
+    expected = {**DEFAULT_SETTINGS, "timezone": zone}
     assert patched.json() == expected
 
     reread = await client.get(
@@ -254,7 +265,43 @@ async def test_timezone_configured_round_trips_with_an_explicit_empty_zone(
         SETTINGS_META_KEY
     )
     assert raw is not None
-    assert json.loads(raw)["timezone_configured"] is True
+    stored = json.loads(raw)
+    assert stored["timezone"] == zone
+    assert "timezone_configured" not in stored
+
+
+async def test_timezone_configured_is_an_unknown_field(
+    settings_client: SimpleNamespace,
+) -> None:
+    """The removed marker is rejected like any unknown field; nothing is written."""
+    response = await settings_client.client.patch(
+        "/api/v1/admin/settings",
+        json={"timezone_configured": True},
+        headers=_admin_headers(),
+    )
+    assert response.status_code == 422
+    assert "timezone_configured" in str(response.json()["detail"])
+    raw = await _dao_meta.MetaStateDao(settings_client.database).get(
+        SETTINGS_META_KEY
+    )
+    assert raw is None
+
+
+async def test_stored_legacy_timezone_configured_key_is_ignored(
+    settings_client: SimpleNamespace,
+) -> None:
+    """A document written before the marker was removed still loads."""
+    await _dao_meta.MetaStateDao(settings_client.database).set(
+        SETTINGS_META_KEY,
+        json.dumps(
+            {"timezone": "America/Chicago", "timezone_configured": True}
+        ),
+    )
+    response = await settings_client.client.get(
+        "/api/v1/admin/settings", headers=_admin_headers()
+    )
+    assert response.status_code == 200
+    assert response.json() == {**DEFAULT_SETTINGS, "timezone": "America/Chicago"}
 
 
 # --- validation: rejected values never change the stored settings -------
@@ -273,8 +320,6 @@ async def test_timezone_configured_round_trips_with_an_explicit_empty_zone(
         ({"morning_summary_enabled": "yes"}, "morning_summary_enabled"),
         ({"celebration_enabled": 1}, "celebration_enabled"),
         ({"notify_target": 5}, "notify_target"),
-        ({"timezone_configured": "true"}, "timezone_configured"),
-        ({"timezone_configured": 1}, "timezone_configured"),
     ],
 )
 async def test_invalid_value_is_rejected_and_stored_settings_unchanged(

tests/test_api_client.py

@@ -196,25 +196,27 @@ async def test_complete_instance_posts_body_and_headers() -> None:
     assert call["headers"]["Authorization"] == f"Bearer {TOKEN}"
 
 
-async def test_household_timezone_rides_every_request_header() -> None:
-    """Home Assistant's zone is reported so the API reads the household
-    clock (task 6351b36d); it is sent only when the client has one."""
+async def test_requests_carry_only_the_bearer_header() -> None:
+    """No timezone is reported to the API (task 7f685179): the Bearer
+    credential is the only header on every request."""
     transport = StubTransport(
         StubResponse(200, json.dumps(SNAPSHOT_PAYLOAD)),
         StubResponse(200, '{"status": "done"}'),
     )
-    client = NestQuestApiClient(
-        BASE_URL, TOKEN, transport, household_timezone="America/New_York"
-    )
+    client = make_client(transport)
 
     await client.get_snapshot()
     await client.complete_instance(42, 3)
 
     for call in transport.calls:
-        assert call["headers"] == {
-            "Authorization": f"Bearer {TOKEN}",
-            "X-NestQuest-Timezone": "America/New_York",
-        }
+        assert call["headers"] == {"Authorization": f"Bearer {TOKEN}"}
+
+
+def test_client_takes_no_household_timezone() -> None:
+    with pytest.raises(TypeError):
+        NestQuestApiClient(
+            BASE_URL, TOKEN, StubTransport(), household_timezone="UTC"
+        )
 
 
 async def test_base_url_trailing_slash_is_normalized() -> None:
@@ -413,20 +415,13 @@ def test_client_from_entry_reads_config_and_shared_session(monkeypatch) -> None:
         }
     )
 
-    hass = types.SimpleNamespace(
-        config=types.SimpleNamespace(time_zone="America/New_York")
-    )
-
-    client = api_client.client_from_entry(hass, entry)
+    # A bare object: building the client must not read hass.config.
+    client = api_client.client_from_entry(object(), entry)
 
     assert client._session is shared_session
     assert client._base_url == "http://panel.lan:8443"
     assert client._panel_token == "entry-token"
-    assert client._household_timezone == "America/New_York"
-
-
-#: A minimal hass stand-in carrying the configured time zone.
-_HASS_UTC = types.SimpleNamespace(config=types.SimpleNamespace(time_zone="UTC"))
+    assert client._headers() == {"Authorization": "Bearer entry-token"}
 
 
 def test_client_from_entry_unconfigured_token_raises_at_construction(
@@ -449,12 +444,12 @@ def test_client_from_entry_unconfigured_token_raises_at_construction(
     assert resolve_api_config(entry)[1] == DEFAULT_PANEL_TOKEN == ""
 
     with pytest.raises(ValueError, match="panel_token must be a non-empty"):
-        api_client.client_from_entry(_HASS_UTC, entry)
+        api_client.client_from_entry(object(), entry)
 
     # Same for a whitespace-only stored token: whitespace is not a token.
     entry_ws = make_config_entry(options={CONF_PANEL_TOKEN: "   "})
     with pytest.raises(ValueError, match="panel_token must be a non-empty"):
-        api_client.client_from_entry(_HASS_UTC, entry_ws)
+        api_client.client_from_entry(object(), entry_ws)
 
 
 async def test_client_logs_nothing() -> None:

tests/test_api_household_clock.py

@@ -19,6 +19,8 @@ container's zone) and sets the household zone through the real admin
 
 An unset zone keeps the historical host-local behaviour, and the
 missed-sweep scheduler waits for the rollover in household time.
+Nothing sets the zone automatically: a timezone header on a panel
+request never changes the stored settings (task 7f685179).
 """
 from __future__ import annotations
 
@@ -47,6 +49,7 @@ _settings = importlib.import_module("nestquest_core.settings")
 _settings_store = importlib.import_module("nestquest_core.settings_store")
 _core_db = importlib.import_module("nestquest_core.db")
 _core_migrations = importlib.import_module("nestquest_core.migrations")
+_dao_meta = importlib.import_module("nestquest_core.dao_meta")
 
 #: The panel service token the admin harness app is configured with.
 HARNESS_PANEL_TOKEN = "admin-test-panel-token"
@@ -84,7 +87,12 @@ async def household(temp_db_path: str, monkeypatch) -> SimpleNamespace:
     monkeypatch.setattr(routes_panel, "_local_now", lambda: clock["now"])
     runner = AdminRunner(temp_db_path, jwks_for(ADMIN_KEY, KID))
     async with runner as client:
-        yield SimpleNamespace(client=client, seed=seed, clock=clock)
+        yield SimpleNamespace(
+            client=client,
+            seed=seed,
+            clock=clock,
+            database=runner.app.state.db.database,
+        )
 
 
 async def _set_zone(household: SimpleNamespace, zone: str) -> None:
@@ -237,23 +245,14 @@ def test_from_options_reads_and_resiliently_defaults_timezone() -> None:
     )
 
 
-def test_settings_timezone_configured_defaults_false_and_is_strict() -> None:
-    assert _settings.NestQuestSettings().timezone_configured is False
-    assert _settings.NestQuestSettings.from_options({}).timezone_configured is False
-    assert (
-        _settings.NestQuestSettings.from_options(
-            {"timezone_configured": True}
-        ).timezone_configured
-        is True
-    )
-    for value in ("true", 1, None):
-        with pytest.raises(ValueError, match="timezone_configured"):
-            _settings.NestQuestSettings(timezone_configured=value)
-        if value is not None:
-            with pytest.raises(ValueError):
-                _settings.NestQuestSettings.from_options(
-                    {"timezone_configured": value}
-                )
+def test_settings_have_no_timezone_configured_marker() -> None:
+    assert not hasattr(_settings.NestQuestSettings(), "timezone_configured")
+    with pytest.raises(TypeError):
+        _settings.NestQuestSettings(timezone_configured=True)
+    # A stored document still carrying the removed key loads harmlessly.
+    assert _settings.NestQuestSettings.from_options_resilient(
+        {"timezone": HOUSEHOLD_ZONE, "timezone_configured": True}
+    ) == _settings.NestQuestSettings(timezone=HOUSEHOLD_ZONE)
 
 
 # --- the missed-sweep scheduler ----------------------------------------------
@@ -329,37 +328,29 @@ def test_delay_seconds_is_true_elapsed_time_across_dst(
     assert _delay_seconds(target, now) == expected
 
 
-# --- the Home Assistant-reported zone (task 6351b36d) ------------------------
+# --- nothing sets the zone automatically (task 7f685179) --------------------
 #
-# The deployed household never set ``timezone``, so the UTC API host marked
-# morning quests overdue.  The integration reports Home Assistant's
-# ``time_zone`` on every panel request; while the admin has not chosen a
-# zone the API adopts it (persisted, so the scheduler and the admin plane
-# follow too), and an explicit admin choice still wins.
+# The zone is only ever set by an admin's explicit settings update.  A
+# timezone header on a panel request — the one Home Assistant used to
+# report, or any look-alike — is ignored, and no read writes settings.
+
+#: Timezone-looking request headers a panel request might carry.
+_TIMEZONE_HEADERS = [
+    {"X-NestQuest-Timezone": HOUSEHOLD_ZONE},
+    {"X-NestQuest-Time-Zone": HOUSEHOLD_ZONE},
+    {"X-Timezone": HOUSEHOLD_ZONE},
+    {"Time-Zone": HOUSEHOLD_ZONE},
+]
 
 
-def _reporting_panel_headers(zone: str) -> dict[str, str]:
-    return {**_panel_headers(), "X-NestQuest-Timezone": zone}
-
-
-async def _panel_pack_bag(
-    household: SimpleNamespace, zone: str
-) -> tuple[str, dict]:
-    response = await household.client.get(
-        "/api/v1/panel/snapshot", headers=_reporting_panel_headers(zone)
+async def _stored_document(household: SimpleNamespace) -> str | None:
+    """The raw stored settings document (``None`` when never written)."""
+    return await _dao_meta.MetaStateDao(household.database).get(
+        _settings_store.SETTINGS_META_KEY
     )
-    assert response.status_code == 200
-    body = response.json()
-    ada = next(
-        child
-        for child in body["children"]
-        if child["child_id"] == household.seed.ada.id
-    )
-    (instance,) = ada["instances"]
-    return body["today_iso"], instance
 
 
-async def _stored_settings(household: SimpleNamespace) -> dict:
+async def _admin_settings(household: SimpleNamespace) -> dict:
     response = await household.client.get(
         "/api/v1/admin/settings", headers=_admin_headers()
     )
@@ -367,137 +358,73 @@ async def _stored_settings(household: SimpleNamespace) -> dict:
     return response.json()
 
 
-async def test_unset_zone_adopts_reported_zone_for_overdue(
-    household: SimpleNamespace,
+@pytest.mark.parametrize("extra", _TIMEZONE_HEADERS)
+async def test_panel_timezone_header_never_changes_settings(
+    household: SimpleNamespace, extra: dict[str, str]
 ) -> None:
-    """09:59:59 EDT on a UTC host, zone never set: NOT overdue."""
+    """09:59:59 EDT on a UTC host, zone unset: the header is ignored."""
     household.clock["now"] = _utc(13, 59, 59)
-    today_iso, instance = await _panel_pack_bag(household, HOUSEHOLD_ZONE)
-    assert today_iso == TODAY.isoformat()
-    assert instance["overdue"] is False
-    # Persisted as the automatic (not admin-chosen) household zone, so
-    # the admin plane and the missed-sweep scheduler read it too.
-    stored = await _stored_settings(household)
-    assert stored["timezone"] == HOUSEHOLD_ZONE
-    assert stored["timezone_configured"] is False
-    _today, admin_instance = await _pack_bag(household, "admin")
-    assert admin_instance["overdue"] is False
-
-
-async def test_unset_zone_adopts_reported_zone_for_today(
-    household: SimpleNamespace,
-) -> None:
-    """23:30 EDT is tomorrow in UTC; the household day is still today."""
-    household.clock["now"] = _utc(3, 30, day=27)
-    today_iso, _instance = await _panel_pack_bag(household, HOUSEHOLD_ZONE)
-    assert today_iso == TODAY.isoformat()
-
-
-async def test_reported_zone_completion_is_on_time(
-    household: SimpleNamespace,
-) -> None:
-    """A 09:30 EDT tap with the zone never set is on time."""
-    household.clock["now"] = _utc(13, 30)
+    headers = {**_panel_headers(), **extra}
+    snapshot = await household.client.get(
+        "/api/v1/panel/snapshot", headers=headers
+    )
+    assert snapshot.status_code == 200
     seed = household.seed
-    response = await household.client.post(
+    completed = await household.client.post(
         f"/api/v1/panel/instances/{seed.pack_bag_instance.id}/complete",
-        headers=_reporting_panel_headers(HOUSEHOLD_ZONE),
+        headers=headers,
         json={"actor_child_id": seed.ada.id},
     )
-    assert response.status_code == 200
+    assert completed.status_code == 200
+    # Nothing was written, and the clock stayed host local (UTC): the
+    # 10:00 quest was overdue and the 13:59 UTC completion was late.
+    assert await _stored_document(household) is None
+    assert (await _admin_settings(household))["timezone"] == ""
     _today_iso, instance = await _pack_bag(household, "admin")
-    assert instance["on_time"] is True
+    assert instance["on_time"] is False
 
 
-async def test_reported_zone_follows_home_assistant_changes(
-    household: SimpleNamespace,
+@pytest.mark.parametrize("extra", _TIMEZONE_HEADERS)
+async def test_panel_timezone_header_never_replaces_the_stored_zone(
+    household: SimpleNamespace, extra: dict[str, str]
 ) -> None:
-    """An automatically adopted zone tracks a later Home Assistant change."""
-    await _panel_pack_bag(household, "America/Chicago")
-    await _panel_pack_bag(household, HOUSEHOLD_ZONE)
-    assert (await _stored_settings(household))["timezone"] == HOUSEHOLD_ZONE
-
-
-async def _adopt_new_york(household: SimpleNamespace) -> None:
-    """Prove automatic adoption first, so later assertions can't pass
-    on code that ignores the reported zone altogether."""
-    await _panel_pack_bag(household, HOUSEHOLD_ZONE)
-    stored = await _stored_settings(household)
-    assert stored["timezone"] == HOUSEHOLD_ZONE
-    assert stored["timezone_configured"] is False
-
-
-@pytest.mark.parametrize("chosen", ["America/Los_Angeles", ""])
-async def test_admin_chosen_zone_wins_over_reported_zone(
-    household: SimpleNamespace, chosen: str
-) -> None:
-    await _adopt_new_york(household)
-    response = await household.client.patch(
-        "/api/v1/admin/settings",
-        json={"timezone": chosen, "timezone_configured": True},
-        headers=_admin_headers(),
+    """A stored zone stays exactly as the admin saved it."""
+    await _set_zone(household, "America/Los_Angeles")
+    before = await _stored_document(household)
+    household.clock["now"] = _utc(16, 59, 59)  # 09:59:59 PDT, 12:59:59 EDT
+    response = await household.client.get(
+        "/api/v1/panel/snapshot",
+        headers={**_panel_headers(), **extra},
     )
     assert response.status_code == 200
-    # A conflicting report is no longer adopted.
-    await _panel_pack_bag(household, "America/Chicago")
-    stored = await _stored_settings(household)
-    assert stored["timezone"] == chosen
-    assert stored["timezone_configured"] is True
-
-
-# --- a timezone-only admin update is an explicit choice (task 45243478) ------
-
-
-@pytest.mark.parametrize("chosen", ["America/Los_Angeles", ""])
-async def test_timezone_only_admin_update_is_an_explicit_choice(
-    household: SimpleNamespace, chosen: str
-) -> None:
-    """``PATCH {"timezone": ...}`` alone marks the zone admin-chosen."""
-    await _adopt_new_york(household)
-    response = await household.client.patch(
-        "/api/v1/admin/settings",
-        json={"timezone": chosen},
-        headers=_admin_headers(),
-    )
-    assert response.status_code == 200
-    assert response.json()["timezone_configured"] is True
-    # A conflicting report is no longer adopted.
-    await _panel_pack_bag(household, "America/Chicago")
-    stored = await _stored_settings(household)
-    assert stored["timezone"] == chosen
-    assert stored["timezone_configured"] is True
-
-
-async def test_explicit_timezone_configured_false_is_respected(
-    household: SimpleNamespace,
-) -> None:
-    """A supplied ``timezone_configured`` is persisted exactly as given."""
-    response = await household.client.patch(
-        "/api/v1/admin/settings",
-        json={"timezone": "America/Chicago", "timezone_configured": False},
-        headers=_admin_headers(),
-    )
-    assert response.status_code == 200
-    assert response.json()["timezone_configured"] is False
-    await _panel_pack_bag(household, HOUSEHOLD_ZONE)
-    assert (await _stored_settings(household))["timezone"] == HOUSEHOLD_ZONE
-
-
-async def test_invalid_reported_zone_is_ignored(
-    household: SimpleNamespace,
-) -> None:
-    await _adopt_new_york(household)
-    household.clock["now"] = _utc(13, 59, 59)
-    _today_iso, instance = await _panel_pack_bag(household, "Mars/Olympus_Mons")
-    # Still read in the adopted zone: 09:59:59 EDT is not overdue.
+    assert await _stored_document(household) == before
+    _today_iso, instance = await _pack_bag(household, "panel")
     assert instance["overdue"] is False
-    assert (await _stored_settings(household))["timezone"] == HOUSEHOLD_ZONE
 
 
-# --- the scheduler follows an adopted zone (task 6351b36d) -------------------
+async def test_fresh_install_zone_stays_empty_across_reads(
+    household: SimpleNamespace,
+) -> None:
+    """Repeated panel and admin reads never write the settings document."""
+    for hour in (3, 13, 23):
+        household.clock["now"] = _utc(hour, 0)
+        for extra in _TIMEZONE_HEADERS:
+            response = await household.client.get(
+                "/api/v1/panel/snapshot",
+                headers={**_panel_headers(), **extra},
+            )
+            assert response.status_code == 200
+        await _pack_bag(household, "admin")
+        settings = await _admin_settings(household)
+        assert settings["timezone"] == ""
+        assert "timezone_configured" not in settings
+    assert await _stored_document(household) is None
+
+
+# --- the scheduler follows a changed zone (task 6351b36d) --------------------
 #
 # On a UTC host with no stored zone the scheduler first plans for UTC
-# midnight; a zone adopted while it sleeps must move the sweep to the
+# midnight; a zone stored while it sleeps must move the sweep to the
 # household's midnight rather than sweep at 20:00 EDT.
 
 #: 13:00 UTC (09:00 EDT) to UTC midnight.
@@ -506,11 +433,20 @@ _UTC_MIDNIGHT_DELAY = 11 * 3600
 _NEW_YORK_MIDNIGHT_DELAY = 15 * 3600
 
 
-async def test_scheduler_replans_when_panel_adopts_zone_while_sleeping(
+async def _store_zone(scheduler, database, zone: str) -> None:
+    """Store ``zone`` the way a settings writer must: under the lock."""
+    async with scheduler.settings_lock:
+        settings = await _settings_store.update_settings(
+            database, {"timezone": zone}
+        )
+        scheduler.settings_changed(settings)
+
+
+async def test_scheduler_replans_when_zone_changes_while_sleeping(
     temp_db_path: str,
 ) -> None:
     runner = AdminRunner(temp_db_path, jwks_for(ADMIN_KEY, KID))
-    async with runner as client:
+    async with runner:
         app_state = runner.app.state
         await app_state.sweep_scheduler.stop()
         delays: list[float] = []
@@ -532,11 +468,9 @@ async def test_scheduler_replans_when_panel_adopts_zone_while_sleeping(
                 await asyncio.wait_for(
                     slept.wait_for(lambda: len(delays) == 1), timeout=5
                 )
-            response = await client.get(
-                "/api/v1/panel/snapshot",
-                headers=_reporting_panel_headers(HOUSEHOLD_ZONE),
+            await _store_zone(
+                scheduler, app_state.db.database, HOUSEHOLD_ZONE
             )
-            assert response.status_code == 200
             async with slept:
                 await asyncio.wait_for(
                     slept.wait_for(lambda: len(delays) == 2), timeout=5
@@ -574,8 +508,8 @@ async def test_scheduler_rechecks_settings_before_sweeping(
             if len(delays) == 1:
                 # The UTC rollover "arrives" after the zone was stored
                 # behind the scheduler's back.
-                await _settings_store.adopt_reported_timezone(
-                    database, HOUSEHOLD_ZONE
+                await _settings_store.update_settings(
+                    database, {"timezone": HOUSEHOLD_ZONE}
                 )
                 return
             replanned.set()
@@ -598,12 +532,12 @@ async def test_scheduler_rechecks_settings_before_sweeping(
         await database.close()
 
 
-# --- adoption is serialised with planning and sweeping (TZ-003) --------------
+# --- settings writes are serialised with planning and sweeping (TZ-003) ------
 #
-# An adoption racing the loop's own settings reads must never leave a
+# A zone write racing the loop's own settings reads must never leave a
 # stale plan behind.  Each test holds the loop at one of its reads and
-# issues a real panel adoption there; when the scheduler's settings lock
-# is held at that point the adoption provably cannot commit until the
+# issues a locked zone write there; when the scheduler's settings lock
+# is held at that point the write provably cannot commit until the
 # loop moves on, otherwise it is awaited to commit inside the window.
 
 
@@ -626,24 +560,12 @@ def _hold_scheduler_read(monkeypatch, scheduler, nth: int, during):
     return real_load
 
 
-async def _adopt_via(client, zone: str) -> None:
-    response = await client.get(
-        "/api/v1/panel/snapshot", headers=_reporting_panel_headers(zone)
-    )
-    assert response.status_code == 200
-
-
-async def _adopt_inside_read(client, scheduler, zone: str) -> asyncio.Task:
-    """Start a panel adoption of ``zone``; let it commit unless serialised."""
-    adoption = asyncio.create_task(
-        client.get(
-            "/api/v1/panel/snapshot", headers=_reporting_panel_headers(zone)
-        )
-    )
-    lock = getattr(scheduler, "settings_lock", None)
-    if lock is None or not lock.locked():
-        await adoption
-    return adoption
+async def _store_inside_read(scheduler, database, zone: str) -> asyncio.Task:
+    """Start a locked write of ``zone``; let it commit unless serialised."""
+    write = asyncio.create_task(_store_zone(scheduler, database, zone))
+    if not scheduler.settings_lock.locked():
+        await write
+    return write
 
 
 async def test_scheduler_follows_successive_zone_changes(
@@ -651,8 +573,9 @@ async def test_scheduler_follows_successive_zone_changes(
 ) -> None:
     """New York -> UTC -> New York while the re-plan read is in flight."""
     runner = AdminRunner(temp_db_path, jwks_for(ADMIN_KEY, KID))
-    async with runner as client:
+    async with runner:
         app_state = runner.app.state
+        database = app_state.db.database
         await app_state.sweep_scheduler.stop()
         delays: list[float] = []
         slept = asyncio.Condition()
@@ -664,15 +587,15 @@ async def test_scheduler_follows_successive_zone_changes(
             await asyncio.Event().wait()
 
         scheduler = MissedSweepScheduler(
-            app_state.db.database, clock=lambda: _utc(13, 0), sleep=sleep_stub
+            database, clock=lambda: _utc(13, 0), sleep=sleep_stub
         )
         app_state.sweep_scheduler = scheduler
-        await _adopt_via(client, HOUSEHOLD_ZONE)
-        adoptions: list[asyncio.Task] = []
+        await _store_zone(scheduler, database, HOUSEHOLD_ZONE)
+        writes: list[asyncio.Task] = []
 
         async def back_to_new_york(_settings) -> None:
-            adoptions.append(
-                await _adopt_inside_read(client, scheduler, HOUSEHOLD_ZONE)
+            writes.append(
+                await _store_inside_read(scheduler, database, HOUSEHOLD_ZONE)
             )
 
         # Read 1 plans New York; read 2 is the re-plan after UTC.
@@ -683,16 +606,16 @@ async def test_scheduler_follows_successive_zone_changes(
                 await asyncio.wait_for(
                     slept.wait_for(lambda: len(delays) == 1), timeout=5
                 )
-            await _adopt_via(client, "UTC")
+            await _store_zone(scheduler, database, "UTC")
             async with slept:
                 await asyncio.wait_for(
                     slept.wait_for(lambda: len(delays) == 3), timeout=5
                 )
-            (adoption,) = adoptions
-            assert (await adoption).status_code == 200
+            (write,) = writes
+            await write
         finally:
             await scheduler.stop()
-    # The in-flight read planned UTC; the New York adoption that followed
+    # The in-flight read planned UTC; the New York write that followed
     # it woke the wait, so the scheduler sleeps on New York midnight.
     assert delays == [
         pytest.approx(_NEW_YORK_MIDNIGHT_DELAY),
@@ -701,12 +624,12 @@ async def test_scheduler_follows_successive_zone_changes(
     ]
 
 
-async def test_adoption_after_presweep_check_cannot_precede_the_sweep(
+async def test_zone_write_after_presweep_check_cannot_precede_the_sweep(
     temp_db_path: str, monkeypatch
 ) -> None:
-    """No sweep runs once an adoption has replaced its plan."""
+    """No sweep runs once a zone write has replaced its plan."""
     runner = AdminRunner(temp_db_path, jwks_for(ADMIN_KEY, KID))
-    async with runner as client:
+    async with runner:
         app_state = runner.app.state
         await app_state.sweep_scheduler.stop()
         delays: list[float] = []
@@ -723,16 +646,18 @@ async def test_adoption_after_presweep_check_cannot_precede_the_sweep(
             app_state.db.database, clock=lambda: _utc(13, 0), sleep=sleep_stub
         )
         app_state.sweep_scheduler = scheduler
-        adoptions: list[asyncio.Task] = []
+        writes: list[asyncio.Task] = []
 
-        async def adopt_new_york(_settings) -> None:
-            adoptions.append(
-                await _adopt_inside_read(client, scheduler, HOUSEHOLD_ZONE)
+        async def store_new_york(_settings) -> None:
+            writes.append(
+                await _store_inside_read(
+                    scheduler, app_state.db.database, HOUSEHOLD_ZONE
+                )
             )
 
         # Read 1 plans UTC; read 2 is the pre-sweep re-check.
         real_load = _hold_scheduler_read(
-            monkeypatch, scheduler, 2, adopt_new_york
+            monkeypatch, scheduler, 2, store_new_york
         )
         swept_under: list[str] = []
 
@@ -746,12 +671,12 @@ async def test_adoption_after_presweep_check_cannot_precede_the_sweep(
         scheduler.start()
         try:
             await asyncio.wait_for(replanned.wait(), timeout=5)
-            (adoption,) = adoptions
-            assert (await adoption).status_code == 200
+            (write,) = writes
+            await write
         finally:
             await scheduler.stop()
     # The sweep ran for the UTC plan with UTC still stored, never after
-    # New York had been adopted; the next plan is New York midnight.
+    # New York had been stored; the next plan is New York midnight.
     assert swept_under == [""]
     assert delays == [
         pytest.approx(_UTC_MIDNIGHT_DELAY),

tests/test_coordinator.py

@@ -686,8 +686,8 @@ async def test_coordinator_configured_token_builds_real_client(
         hass, entry, session_factory=_session_factory
     )
     assert isinstance(real_client, NestQuestApiClient)
-    # Home Assistant's zone is reported to the API (task 6351b36d).
-    assert real_client._household_timezone == hass.config.time_zone
+    # Home Assistant's zone is not reported to the API (task 7f685179).
+    assert real_client._headers() == {"Authorization": "Bearer tok"}
 
     set_coordinator_client(entry, real_client)
     assert await async_setup_entry(hass, entry) is True

tests/test_sse_subscription.py

@@ -351,24 +351,6 @@ async def test_stream_events_yields_documented_frames_and_sends_bearer() -> None
     assert call["json"] is None
 
 
-async def test_stream_events_reports_household_timezone() -> None:
-    """The SSE GET carries Home Assistant's zone beside the Bearer token
-    (task 6351b36d), like the snapshot and completion requests."""
-    frame = _frame_text(*DOCUMENTED_FRAMES[0])
-    transport = _StreamTransport(_StreamingResponse(200, [frame]))
-    client = NestQuestApiClient(
-        BASE_URL, TOKEN, transport, household_timezone="America/New_York"
-    )
-
-    frames = [frame async for frame in client.stream_events()]
-
-    assert frames == [DOCUMENTED_FRAMES[0]]
-    assert transport.calls[0]["headers"] == {
-        "Authorization": f"Bearer {TOKEN}",
-        "X-NestQuest-Timezone": "America/New_York",
-    }
-
-
 async def test_stream_events_buffers_lines_across_chunks_and_joins_data() -> None:
     """Chunk-split lines parse, and multi-line data joins per SSE rules."""
     first_type, first_payload = DOCUMENTED_FRAMES[0]