Add thread notifications, SEO topic pages, and fix quiz auto-advance

Notifications: a new "thread" type notifies every other commenter on a post whenever anyone comments on it, disregarding reply hierarchy - excluding the actor and whoever already got a comment/reply notification for that same event, so no one is double-notified. Implemented via a background-deferred fan-out mirroring the existing mention-notification pattern. SEO: discussion_forum_posting() now embeds up to 20 of a post's comments as nested schema.org Comment entities (not just an aggregate count), and a new /topics hub plus /topics/{topic} pages give the feed's topic filter real, independently crawlable/indexable URLs - /feed?topic=X was never indexable since its canonical strips the query string back to bare /feed. Both are wired end to end (schemas, Devii actions, docs API, sitemap, locustfile load-test coverage). Quiz player: the auto-advance to the next question used to hide the just-answered slide in the same tick as rendering the grade, so on any multi-question quiz the Correct/Not correct feedback was never actually visible before the view moved on. Delayed via setTimeout, with the pending timer cleared on manual navigation and on disconnect so it can't race or fire on a removed component. Also includes other local changes already in progress in this working tree before this session (messaging, push delivery, deepsearch jobs, game economy, quiz builder) - verified by the full suite passing (3467 tests) but not authored or individually reviewed in this session. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01VL9Xn57W5UR3HZbbuuzxdK
2026-09-03 08:47:57 +02:00
parent afb4799869
commit 572e022584
93 changed files with 2788 additions and 331 deletions
@@ -302,6 +302,91 @@ def test_apns_delivery_maps_statuses(monkeypatch):
    assert throttled.status == providers.REJECTED


+def test_apns_dead_reasons_excludes_topic_misconfiguration(monkeypatch):
+    from devplacepy.push import providers
+
+    not_for_topic, _ = _apns_response_status(
+        monkeypatch, 400, {"reason": "DeviceTokenNotForTopic"}
+    )
+    assert not_for_topic.status == providers.REJECTED
+
+    disallowed, _ = _apns_response_status(monkeypatch, 400, {"reason": "TopicDisallowed"})
+    assert disallowed.status == providers.REJECTED
+
+    expired, _ = _apns_response_status(monkeypatch, 410, {"reason": "ExpiredToken"})
+    assert expired.status == providers.DEAD
+
+
+def test_apns_dead_carries_apns_confirmation_timestamp(monkeypatch):
+    from datetime import datetime, timezone
+    from devplacepy.push import providers
+
+    gone, _ = _apns_response_status(
+        monkeypatch, 410, {"reason": "Unregistered", "timestamp": 1700000000000}
+    )
+    assert gone.status == providers.DEAD
+    assert gone.dead_before == datetime.fromtimestamp(
+        1700000000000 / 1000, tz=timezone.utc
+    ).isoformat()
+
+    bad_token, _ = _apns_response_status(monkeypatch, 400, {"reason": "BadDeviceToken"})
+    assert bad_token.status == providers.DEAD
+    assert bad_token.dead_before is None
+
+
+def test_apns_auth_failure_invalidates_cached_token(monkeypatch, local_db):
+    import httpx
+    from tests.conftest import run_async
+    from devplacepy.push import providers
+    from devplacepy.push.providers import apns
+
+    _apns_settings(
+        monkeypatch,
+        **{
+            apns.TEAM_ID_KEY: "TEAMID1234",
+            apns.KEY_ID_KEY: "KEYID12345",
+            apns.AUTH_KEY_KEY: _ec_private_key_pem(),
+            apns.TOPIC_KEY: "nl.molodetz.devplace",
+        },
+    )
+    provider = providers.PROVIDERS["apns"]
+    pem = _ec_private_key_pem()
+    first = apns.provider_token("TEAMID1234", "KEYID12345", pem)
+    assert apns._token_state["current"]["token"] == first
+    assert apns._read_shared_token()["token"] == first
+
+    def handler(request):
+        return httpx.Response(403, json={"reason": "InvalidProviderToken"})
+
+    async def run():
+        transport = httpx.MockTransport(handler)
+        async with httpx.AsyncClient(transport=transport) as client:
+            return await provider.deliver(
+                client, {"token": "a" * 64}, provider.prepare({"message": "hi"})
+            )
+
+    outcome = run_async(run())
+    assert outcome.status == providers.REJECTED
+    assert "current" not in apns._token_state
+    assert apns._read_shared_token() is None
+
+    second = apns.provider_token("TEAMID1234", "KEYID12345", pem)
+    assert second != first
+
+
+def test_apns_provider_token_is_shared_across_workers(monkeypatch, local_db):
+    from devplacepy.push.providers import apns
+
+    _apns_settings(monkeypatch)
+    pem = _ec_private_key_pem()
+    token = apns.provider_token("TEAMID1234", "KEYID12345", pem)
+
+    apns._token_state.clear()
+    reused = apns.provider_token("TEAMID1234", "KEYID12345", pem)
+    assert reused == token
+    assert apns._token_state["current"]["token"] == token
+
+
 def test_apns_delivery_without_configuration_never_raises(monkeypatch):
    import httpx
    from tests.conftest import run_async
@@ -345,3 +430,271 @@ def test_delivery_timeout_is_clamped(monkeypatch):

    monkeypatch.setattr(delivery, "get_int_setting", lambda key, default: 100000)
    assert delivery.timeout_seconds() == float(delivery.MAX_TIMEOUT_SECONDS)
+
+
+def test_apns_parse_registration_accepts_client_id_and_normalizes_token():
+    from devplacepy.push import providers
+
+    apns = providers.PROVIDERS["apns"]
+    token = "A1B2C3D4" * 8
+    assert apns.parse_registration(
+        {"token": f"<{token[:8]} {token[8:]}>", "client_id": " device-1 "}
+    ) == {"token": token.lower(), "client_id": "device-1"}
+    assert apns.parse_registration({"token": token, "client_id": ""}) == {
+        "token": token.lower()
+    }
+    assert apns.parse_registration({"token": token, "client_id": {"uid": "x"}}) is None
+    assert apns.parse_registration({"token": token, "client_id": "x" * 200}) is None
+    assert apns.parse_registration({"client_id": "device-1"}) is None
+
+
+def test_apns_client_config_advertises_environment(monkeypatch):
+    from devplacepy.push import providers
+    from devplacepy.push.providers import apns
+
+    _apns_settings(monkeypatch, **{apns.ENVIRONMENT_KEY: "sandbox"})
+    assert providers.PROVIDERS["apns"].client_config() == {"environment": "sandbox"}
+    _apns_settings(monkeypatch, **{apns.ENVIRONMENT_KEY: "nonsense"})
+    assert providers.PROVIDERS["apns"].client_config() == {"environment": "production"}
+
+
+def test_apns_stamp_registration_sets_environment(monkeypatch):
+    from devplacepy.push import providers
+    from devplacepy.push.providers import apns
+
+    _apns_settings(monkeypatch, **{apns.ENVIRONMENT_KEY: "sandbox"})
+    stamped = providers.PROVIDERS["apns"].stamp_registration({"token": "a" * 64})
+    assert stamped["environment"] == "sandbox"
+
+
+def test_apns_delivery_uses_registration_environment(monkeypatch):
+    from devplacepy.push import providers
+    from devplacepy.push.providers import apns
+
+    _apns_settings(
+        monkeypatch,
+        **{
+            apns.TEAM_ID_KEY: "TEAMID1234",
+            apns.KEY_ID_KEY: "KEYID12345",
+            apns.AUTH_KEY_KEY: _ec_private_key_pem(),
+            apns.TOPIC_KEY: "nl.molodetz.devplace",
+            apns.ENVIRONMENT_KEY: "production",
+        },
+    )
+    seen = {}
+
+    def handler(request):
+        seen["url"] = str(request.url)
+        return __import__("httpx").Response(200, json={})
+
+    async def run():
+        import httpx
+
+        transport = httpx.MockTransport(handler)
+        async with httpx.AsyncClient(transport=transport) as client:
+            return await providers.PROVIDERS["apns"].deliver(
+                client,
+                {"token": "a" * 64, "environment": "sandbox"},
+                "{}",
+            )
+
+    from tests.conftest import run_async
+
+    outcome = run_async(run())
+    assert outcome.status == providers.ACCEPTED
+    assert seen["url"].startswith("https://api.sandbox.push.apple.com/3/device/")
+
+
+def test_apns_delivery_client_is_plain_http2():
+    import httpx
+    from devplacepy.curl_transport import CurlTransport
+    from devplacepy.push.providers import apns
+    from tests.conftest import run_async
+
+    client = apns.gateway_client(5.0)
+    assert isinstance(client, httpx.AsyncClient)
+    assert not isinstance(client._transport, CurlTransport)
+    run_async(client.aclose())
+
+
+def test_apns_delivery_client_persists_across_calls():
+    from devplacepy.push import providers
+    from devplacepy.push.providers import apns
+    from tests.conftest import run_async
+
+    provider = providers.PROVIDERS["apns"]
+    assert provider.closes_delivery_client() is False
+    run_async(apns.close_client())
+    try:
+        first = provider.delivery_client(5.0)
+        second = provider.delivery_client(5.0)
+        assert first is second
+        assert not first.is_closed
+        run_async(apns.close_client())
+        assert first.is_closed
+        third = provider.delivery_client(5.0)
+        assert third is not first
+    finally:
+        run_async(apns.close_client())
+
+
+def test_webpush_closes_delivery_client_by_default():
+    from devplacepy.push import providers
+
+    provider = providers.PROVIDERS["webpush"]
+    assert provider.closes_delivery_client() is True
+
+
+def test_store_upserts_by_client_id_and_revives_dead_tokens(local_db):
+    from devplacepy.push import store
+
+    user_uid = "user-apns-1"
+    token = "a" * 64
+    write = store.register(user_uid, "apns", {"token": token, "client_id": "phone"})
+    assert write.created is True
+    assert write.revived is False
+    assert write.probe is True
+
+    same = store.register(user_uid, "apns", {"token": token, "client_id": "phone"})
+    assert same.created is False
+    assert same.revived is False
+    assert same.record["uid"] == write.record["uid"]
+
+    store.mark_dead(write.record["id"])
+    revived = store.register(user_uid, "apns", {"token": token, "client_id": "phone"})
+    assert revived.created is False
+    assert revived.revived is True
+    assert revived.record["deleted_at"] is None
+    assert len(store.active_for_user(user_uid)) == 1
+
+    rotated = store.register(
+        user_uid, "apns", {"token": "b" * 64, "client_id": "phone"}
+    )
+    assert rotated.created is False
+    assert rotated.record["token"] == "b" * 64
+    assert rotated.record["uid"] == write.record["uid"]
+    assert len(store.active_for_user(user_uid)) == 1
+
+
+def test_store_revives_token_only_registration(local_db):
+    from devplacepy.push import store
+
+    user_uid = "user-apns-2"
+    token = "c" * 64
+    write = store.register(user_uid, "apns", {"token": token})
+    store.mark_dead(write.record["id"])
+    revived = store.register(user_uid, "apns", {"token": token, "client_id": "phone-2"})
+    assert revived.revived is True
+    assert revived.record["client_id"] == "phone-2"
+    assert len(store.active_for_user(user_uid)) == 1
+
+
+def test_store_attaches_client_id_to_existing_token_row(local_db):
+    from devplacepy.push import store
+
+    user_uid = "user-apns-3"
+    token = "d" * 64
+    first = store.register(user_uid, "apns", {"token": token})
+    second = store.register(user_uid, "apns", {"token": token, "client_id": "phone-3"})
+    assert second.created is False
+    assert second.record["uid"] == first.record["uid"]
+    assert second.record["client_id"] == "phone-3"
+
+
+def test_store_mark_dead_skips_a_registration_revived_after_confirmation(local_db):
+    from datetime import datetime, timedelta, timezone
+    from devplacepy.push import store
+
+    user_uid = "user-apns-4"
+    token = "f" * 64
+    write = store.register(user_uid, "apns", {"token": token})
+    registered_at = write.record["registered_at"]
+    assert registered_at
+
+    stale_confirmation = (
+        datetime.fromisoformat(registered_at) - timedelta(minutes=5)
+    ).isoformat()
+    store.mark_dead(write.record["id"], stale_confirmation)
+    assert len(store.active_for_user(user_uid)) == 1
+
+    fresh_confirmation = (
+        datetime.now(timezone.utc) + timedelta(minutes=5)
+    ).isoformat()
+    store.mark_dead(write.record["id"], fresh_confirmation)
+    assert store.active_for_user(user_uid) == []
+
+
+def test_dead_delivery_logs_the_reason(monkeypatch, caplog):
+    import logging
+    import httpx
+    from tests.conftest import run_async
+    from devplacepy.push import providers
+    from devplacepy.push.delivery import _deliver_one
+
+    class _FakeStore:
+        def __init__(self):
+            self.dead = []
+
+        def mark_dead(self, registration_id, dead_before=None):
+            self.dead.append(registration_id)
+
+    fake = _FakeStore()
+    monkeypatch.setattr("devplacepy.push.delivery.store", fake)
+
+    async def dead_deliver(client, registration, prepared):
+        return providers.Delivery(providers.DEAD, "400 BadDeviceToken")
+
+    provider = providers.PROVIDERS["apns"]
+    monkeypatch.setattr(provider, "deliver", dead_deliver)
+
+    async def run():
+        async with httpx.AsyncClient() as client:
+            return await _deliver_one(
+                provider, client, {"id": 9, "token": "a" * 64}, "{}", "user-x"
+            )
+
+    with caplog.at_level(logging.WARNING):
+        outcome = run_async(run())
+    assert outcome.status == providers.DEAD
+    assert fake.dead == [9]
+    assert "400 BadDeviceToken" in caplog.text
+
+
+def test_notify_user_opens_apns_gateway_not_stealth(monkeypatch, local_db):
+    import httpx
+    from tests.conftest import run_async
+    from devplacepy.push import store
+    from devplacepy.push.delivery import notify_user
+    from devplacepy.push.providers import apns
+
+    _apns_settings(
+        monkeypatch,
+        **{
+            apns.TEAM_ID_KEY: "TEAMID1234",
+            apns.KEY_ID_KEY: "KEYID12345",
+            apns.AUTH_KEY_KEY: _ec_private_key_pem(),
+            apns.TOPIC_KEY: "nl.molodetz.devplace",
+        },
+    )
+    store.register("user-gw", "apns", {"token": "e" * 64, "environment": "production"})
+    opened = []
+
+    def fake_gateway(timeout):
+        opened.append(timeout)
+        return httpx.AsyncClient(
+            transport=httpx.MockTransport(lambda request: httpx.Response(200, json={}))
+        )
+
+    def fail_stealth(**kwargs):
+        raise AssertionError("APNs must not use stealth")
+
+    monkeypatch.setattr(apns, "gateway_client", fake_gateway)
+    monkeypatch.setattr(
+        "devplacepy.stealth.stealth_async_client", fail_stealth
+    )
+    run_async(apns.close_client())
+    try:
+        run_async(notify_user("user-gw", {"title": "t", "message": "m"}))
+    finally:
+        run_async(apns.close_client())
+    assert opened