test(engine): slice 2 — state proxy, websocket, pwa, stubs, markup

Fans out coverage in four focused files:

- test_state.py — ReactiveProxy / LeafProxy path arithmetic, dict access,
  setattr mutation, primitive dunders (math/eq/hash/bool), _is_complex
  classification boundaries.
- test_websocket.py — connect/disconnect lifecycle events, realtime message
  dispatch to @app.server.realtime (deterministic via ack broadcast),
  reverse-RPC envelope shape, .invoke(client_id) targeting one of two
  concurrent connections.
- test_pwa.py — scope-hashed manifest + sw.js routes, default + custom
  Manifest behavior, Service-Worker-Allowed header, versioned bundle
  asset registered in the SW cache list, unknown-scope 404.
- test_unit.py — ClientFunctionStub server-side RuntimeError, repr
  distinguishes callback vs plain, Element.on rejects non-callbacks,
  has_bindings recursion (data-on-*) and intentional non-coverage of
  data-bind-* (pinned as the current contract).

32 passed, 2 xfailed (carryover from slice 1).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: apiad

tests/test_pwa.py

@@ -0,0 +1,103 @@
+"""
+Tests for PWA route registration, manifest serving, and Service Worker scope.
+"""
+import hashlib
+import json
+
+from fastapi.testclient import TestClient
+
+from violetear import App, Document, Manifest
+
+
+def _scope_hash(path: str) -> str:
+    return hashlib.md5(path.encode()).hexdigest()[:8]
+
+
+def test_pwa_route_registers_manifest_and_service_worker():
+    """@app.view("/foo", pwa=True) exposes manifest + SW under a scope-hashed path."""
+    app = App(title="PWA App", version="pwa1")
+
+    @app.view("/install", pwa=True)
+    def home():
+        return Document(title="PWA")
+
+    h = _scope_hash("/install")
+    client = TestClient(app.api)
+
+    r = client.get(f"/_violetear/pwa/{h}/manifest.json")
+    assert r.status_code == 200
+    assert r.headers["content-type"].startswith("application/json")
+
+    manifest = json.loads(r.text)
+    # Default manifest uses app.title as the name, and backfills scope/start_url
+    # from the route path.
+    assert manifest["name"] == "PWA App"
+    assert manifest["scope"] == "/install"
+    assert manifest["start_url"] == "/install"
+
+    r = client.get(f"/_violetear/pwa/{h}/sw.js")
+    assert r.status_code == 200
+    assert r.headers["content-type"].startswith("application/javascript")
+    # Service-Worker-Allowed is required so a SW served from /_violetear/...
+    # can control pages at the route's scope.
+    assert r.headers["service-worker-allowed"] == "/"
+
+
+def test_pwa_unknown_scope_returns_404():
+    app = App(title="PWA App", version="pwa2")
+
+    @app.view("/")
+    def home():
+        return Document(title="x")
+
+    client = TestClient(app.api)
+
+    assert client.get("/_violetear/pwa/deadbeef/manifest.json").status_code == 404
+    assert client.get("/_violetear/pwa/deadbeef/sw.js").status_code == 404
+
+
+def test_pwa_custom_manifest_object_is_honored():
+    """Passing a Manifest object overrides defaults but inherits scope from the route."""
+    app = App(title="App", version="pwa3")
+
+    custom = Manifest(
+        name="Custom Name",
+        short_name="CN",
+        theme_color="#6b21a8",
+    )
+
+    @app.view("/app", pwa=custom)
+    def home():
+        return Document(title="x")
+
+    h = _scope_hash("/app")
+    client = TestClient(app.api)
+    r = client.get(f"/_violetear/pwa/{h}/manifest.json")
+    assert r.status_code == 200
+
+    manifest = json.loads(r.text)
+    assert manifest["name"] == "Custom Name"
+    assert manifest["short_name"] == "CN"
+    assert manifest["theme_color"] == "#6b21a8"
+    # The route registration backfills scope/start_url from the route path
+    # when the user didn't override them.
+    assert manifest["scope"] == "/app"
+    assert manifest["start_url"] == "/app"
+
+
+def test_pwa_service_worker_caches_versioned_bundle_asset():
+    """The generated SW script references the versioned bundle URL."""
+    app = App(title="App", version="cafef00d")
+
+    @app.view("/", pwa=True)
+    def home():
+        return Document(title="x")
+
+    h = _scope_hash("/")
+    client = TestClient(app.api)
+    sw = client.get(f"/_violetear/pwa/{h}/sw.js").text
+
+    # The cache name embeds the app version (sanity check on substitution).
+    assert "violetear-cafef00d" in sw
+    # The bundle asset is added with the version querystring.
+    assert "/_violetear/bundle.py?v=cafef00d" in sw

tests/test_state.py

@@ -0,0 +1,123 @@
+"""
+Unit tests for the reactive state proxy (violetear/state.py).
+
+Server-side branches only — IS_BROWSER paths (ReactiveRegistry.notify) are
+skipped here; they need a Pyodide simulator and live in a later slice.
+"""
+from dataclasses import dataclass, field
+
+from violetear.state import LeafProxy, ReactiveProxy, local
+
+
+def test_local_returns_reactive_proxy_with_root_path():
+    @local
+    @dataclass
+    class Ui:
+        theme: str = "light"
+
+    assert isinstance(Ui, ReactiveProxy)
+    assert Ui._path == "Ui"
+    assert Ui.current_value.theme == "light"
+
+
+def test_primitive_attribute_returns_leaf_proxy_with_dotted_path():
+    @local
+    @dataclass
+    class Ui:
+        theme: str = "light"
+        count: int = 5
+
+    theme = Ui.theme
+    assert isinstance(theme, LeafProxy)
+    assert theme._path == "Ui.theme"
+    assert theme.current_value == "light"
+
+    count = Ui.count
+    assert isinstance(count, LeafProxy)
+    assert count._path == "Ui.count"
+    assert count.current_value == 5
+
+
+def test_nested_object_returns_recursive_proxy():
+    @dataclass
+    class Inner:
+        value: str = "x"
+
+    @local
+    @dataclass
+    class Outer:
+        inner: Inner = field(default_factory=Inner)
+
+    inner_proxy = Outer.inner
+    assert isinstance(inner_proxy, ReactiveProxy)
+    assert inner_proxy._path == "Outer.inner"
+
+    value_proxy = Outer.inner.value
+    assert isinstance(value_proxy, LeafProxy)
+    assert value_proxy._path == "Outer.inner.value"
+    assert value_proxy.current_value == "x"
+
+
+def test_dict_access_via_getitem_builds_path():
+    @local
+    @dataclass
+    class Store:
+        users: dict = field(default_factory=lambda: {"alice": "admin"})
+
+    role = Store.users["alice"]
+    assert isinstance(role, LeafProxy)
+    assert role._path == "Store.users.alice"
+    assert role.current_value == "admin"
+
+
+def test_setattr_mutates_underlying_target():
+    @local
+    @dataclass
+    class Ui:
+        theme: str = "light"
+
+    Ui.theme = "dark"
+
+    assert Ui.current_value.theme == "dark"
+    assert Ui.theme.current_value == "dark"
+
+
+def test_leaf_proxy_arithmetic_dunders():
+    proxy = LeafProxy(5, "x.n")
+
+    assert proxy + 1 == 6
+    assert 1 + proxy == 6
+    assert proxy - 2 == 3
+    assert proxy * 3 == 15
+    assert str(proxy) == "5"
+    assert int(proxy) == 5
+    assert float(proxy) == 5.0
+    assert bool(proxy) is True
+
+    zero = LeafProxy(0, "x.n")
+    assert bool(zero) is False
+
+
+def test_leaf_proxy_equality_and_hash():
+    a = LeafProxy("light", "x.theme")
+    b = LeafProxy("light", "y.theme")  # different path, same value
+
+    assert a == b
+    assert a == "light"
+    assert a != "dark"
+    assert hash(a) == hash("light")
+
+
+def test_is_complex_classification():
+    @dataclass
+    class Obj:
+        x: int = 1
+
+    proxy = ReactiveProxy(Obj(), "test")
+
+    assert proxy._is_complex({"a": 1}) is True
+    assert proxy._is_complex([1, 2, 3]) is True
+    assert proxy._is_complex(Obj()) is True
+    assert proxy._is_complex("string") is False
+    assert proxy._is_complex(42) is False
+    assert proxy._is_complex(True) is False

tests/test_unit.py

@@ -0,0 +1,79 @@
+"""
+Unit-level tests for ClientFunctionStub safety semantics and Element helpers.
+"""
+import pytest
+
+from violetear import App
+from violetear.markup import Element
+
+
+def test_client_stub_raises_when_called_from_server():
+    """The stub returned by @app.client.* must refuse to execute server-side."""
+    app = App(version="u1")
+
+    @app.client.callback
+    async def on_click(event):
+        pass
+
+    with pytest.raises(RuntimeError, match="cannot be called from the Server"):
+        on_click(None)
+
+
+def test_client_callback_stub_repr_distinguishes_kind():
+    app = App(version="u2")
+
+    @app.client.callback
+    async def cb(event):
+        pass
+
+    @app.client
+    async def plain():
+        pass
+
+    # Repr should distinguish a DOM-binding callback from a plain client function.
+    assert "callback" in repr(cb)
+    assert "callback" not in repr(plain)
+    assert "client:" in repr(plain)
+
+
+def test_element_on_rejects_non_callback_handler():
+    """Element.on requires the handler to carry the @app.client.callback marker."""
+    app = App(version="u3")  # noqa: F841 — instantiated to keep the test honest
+
+    async def not_a_callback(event):
+        pass
+
+    el = Element("button")
+    with pytest.raises(ValueError, match="@app.client.callback"):
+        el.on("click", not_a_callback)
+
+
+def test_element_has_bindings_recurses_through_children():
+    """has_bindings finds data-on-* on self or any descendant."""
+    app = App(version="u4")
+
+    @app.client.callback
+    async def cb(event):
+        pass
+
+    parent = Element("div")
+    child = Element("button").on("click", cb)
+    grandchild = Element("span")
+
+    child.add(grandchild)
+    parent.add(child)
+
+    assert parent.has_bindings() is True
+    assert child.has_bindings() is True
+    assert grandchild.has_bindings() is False
+
+
+def test_element_has_bindings_ignores_data_bind_attrs():
+    """has_bindings counts only data-on-* (event handlers), not data-bind-* (reactive)."""
+    el = Element("span")
+    el._attrs["data-bind-text"] = "Ui.theme"
+
+    # Pinned: reactive-only elements report no bindings. This is the current
+    # contract; if has_bindings is ever made the gate for Pyodide injection,
+    # this assertion should flip.
+    assert el.has_bindings() is False