coop/rose-ash
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
fac97883f9d440979a3ac82e68ca23e04fe746d8
rose-ash/sx/tests/test_demos.py
giles fac97883f9 Spec explorer data endpoint, spec file finder, browser render test (failing) 
- Add spec-explorer-data-by-slug helper with _SPEC_SLUG_MAP
- _find_spec_file searches spec/, web/, shared/sx/ref/ directories
- defpage specs-explore-page uses :data for server-side data fetch
- test_evaluator_renders_in_browser: failing test for client-side rendering
  (client re-evaluates defpage content, find-spec unavailable — pre-existing)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-03-18 17:36:21 +00:00

553 lines
22 KiB
Python
Raw Blame History

"""Automated Playwright tests for SX docs demos.
Covers hypermedia examples, reactive islands, and marshes.
Run against the dev server:
cd sx/tests
pytest test_demos.py -v --headed # visible browser
pytest test_demos.py -v # headless
Requires: pip install pytest-playwright
"""
from __future__ import annotations
import pytest
from playwright.sync_api import Page, expect
import os
BASE = os.environ.get("SX_TEST_BASE", "https://sx.rose-ash.com")
# ---------------------------------------------------------------------------
# Fixtures
# ---------------------------------------------------------------------------
@pytest.fixture(scope="session")
def browser_context_args():
return {"ignore_https_errors": True}
def nav(page: Page, path: str):
"""Navigate to an SX URL and wait for rendered content."""
page.goto(f"{BASE}/sx/{path}", wait_until="networkidle")
# Wait for SX to render — look for any heading or paragraph in main panel
page.wait_for_selector("#main-panel h2, #main-panel p, #main-panel div", timeout=15000)
# ---------------------------------------------------------------------------
# Hypermedia Examples
# ---------------------------------------------------------------------------
class TestClickToLoad:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.click-to-load)))")
expect(page.locator("#main-panel")).to_contain_text("Click to Load")
def test_click_loads_content(self, page: Page):
nav(page, "(geography.(hypermedia.(example.click-to-load)))")
page.click("button:has-text('Load content')")
expect(page.locator("#click-result")).to_contain_text(
"Content loaded", timeout=5000
)
class TestFormSubmission:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.form-submission)))")
expect(page.locator("#main-panel")).to_contain_text("Form Submission")
def test_submit_form(self, page: Page):
nav(page, "(geography.(hypermedia.(example.form-submission)))")
page.fill("input[name='name']", "TestUser")
page.click("button[type='submit']")
expect(page.locator("#form-result")).to_contain_text("TestUser", timeout=5000)
class TestPolling:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.polling)))")
expect(page.locator("#main-panel")).to_contain_text("Polling")
def test_poll_updates(self, page: Page):
nav(page, "(geography.(hypermedia.(example.polling)))")
expect(page.locator("#poll-target")).to_contain_text("Server time", timeout=10000)
class TestDeleteRow:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.delete-row)))")
expect(page.locator("#main-panel")).to_contain_text("Delete Row")
class TestInlineEdit:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.inline-edit)))")
expect(page.locator("#main-panel")).to_contain_text("Inline Edit")
def test_edit_shows_form(self, page: Page):
nav(page, "(geography.(hypermedia.(example.inline-edit)))")
page.click("#edit-target button:has-text('edit')")
expect(page.locator("input[name='value']")).to_be_visible(timeout=5000)
class TestOobSwaps:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.oob-swaps)))")
expect(page.locator("#main-panel")).to_contain_text("OOB")
def test_oob_updates_both_boxes(self, page: Page):
nav(page, "(geography.(hypermedia.(example.oob-swaps)))")
page.click("button:has-text('Update both boxes')")
expect(page.locator("#oob-box-a")).to_contain_text("Box A updated", timeout=5000)
expect(page.locator("#oob-box-b").last).to_contain_text("Box B updated", timeout=5000)
class TestLazyLoading:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.lazy-loading)))")
expect(page.locator("#main-panel")).to_contain_text("Lazy Loading")
def test_content_loads_automatically(self, page: Page):
nav(page, "(geography.(hypermedia.(example.lazy-loading)))")
expect(page.locator("#lazy-target")).to_contain_text("Content loaded", timeout=10000)
class TestInfiniteScroll:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.infinite-scroll)))")
expect(page.locator("#main-panel")).to_contain_text("Infinite Scroll")
class TestProgressBar:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.progress-bar)))")
expect(page.locator("#main-panel")).to_contain_text("Progress Bar")
def test_progress_starts(self, page: Page):
nav(page, "(geography.(hypermedia.(example.progress-bar)))")
page.click("button:has-text('Start job')")
expect(page.locator("#progress-target")).to_contain_text("complete", timeout=10000)
class TestActiveSearch:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.active-search)))")
expect(page.locator("#main-panel")).to_contain_text("Active Search")
def test_search_returns_results(self, page: Page):
nav(page, "(geography.(hypermedia.(example.active-search)))")
page.locator("input[name='q']").type("Py")
expect(page.locator("#search-results")).to_contain_text("Python", timeout=5000)
class TestInlineValidation:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.inline-validation)))")
expect(page.locator("#main-panel")).to_contain_text("Inline Validation")
def test_invalid_email(self, page: Page):
nav(page, "(geography.(hypermedia.(example.inline-validation)))")
page.fill("input[name='email']", "notanemail")
page.locator("input[name='email']").blur()
expect(page.locator("#email-feedback")).to_contain_text("Invalid", timeout=5000)
class TestValueSelect:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.value-select)))")
expect(page.locator("#main-panel")).to_contain_text("Value Select")
def test_select_changes_options(self, page: Page):
nav(page, "(geography.(hypermedia.(example.value-select)))")
page.select_option("select[name='category']", "Languages")
expect(page.locator("#value-items")).to_contain_text("Python", timeout=5000)
class TestResetOnSubmit:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.reset-on-submit)))")
expect(page.locator("#main-panel")).to_contain_text("Reset")
def test_has_form(self, page: Page):
nav(page, "(geography.(hypermedia.(example.reset-on-submit)))")
expect(page.locator("form")).to_be_visible(timeout=5000)
class TestEditRow:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.edit-row)))")
expect(page.locator("#main-panel")).to_contain_text("Edit Row")
class TestBulkUpdate:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.bulk-update)))")
expect(page.locator("#main-panel")).to_contain_text("Bulk Update")
def test_has_checkboxes(self, page: Page):
nav(page, "(geography.(hypermedia.(example.bulk-update)))")
expect(page.locator("input[type='checkbox']").first).to_be_visible(timeout=5000)
class TestSwapPositions:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.swap-positions)))")
expect(page.locator("#main-panel")).to_contain_text("Swap")
class TestSelectFilter:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.select-filter)))")
expect(page.locator("#main-panel")).to_contain_text("Select Filter")
class TestTabs:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.tabs)))")
expect(page.locator("#main-panel")).to_contain_text("Tabs")
class TestAnimations:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.animations)))")
expect(page.locator("#main-panel")).to_contain_text("Animation")
class TestDialogs:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.dialogs)))")
expect(page.locator("#main-panel")).to_contain_text("Dialog")
class TestKeyboardShortcuts:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.keyboard-shortcuts)))")
expect(page.locator("#main-panel")).to_contain_text("Keyboard")
class TestPutPatch:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.put-patch)))")
expect(page.locator("#main-panel")).to_contain_text("PUT")
class TestJsonEncoding:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.json-encoding)))")
expect(page.locator("#main-panel")).to_contain_text("JSON")
class TestValsAndHeaders:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.vals-and-headers)))")
expect(page.locator("#main-panel")).to_contain_text("Vals")
class TestLoadingStates:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.loading-states)))")
expect(page.locator("#main-panel")).to_contain_text("Loading")
class TestSyncReplace:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.sync-replace)))")
expect(page.locator("#main-panel")).to_contain_text("Request Abort")
class TestRetry:
def test_page_loads(self, page: Page):
nav(page, "(geography.(hypermedia.(example.retry)))")
expect(page.locator("#main-panel")).to_contain_text("Retry")
# ---------------------------------------------------------------------------
# Reactive Islands
# ---------------------------------------------------------------------------
class TestReactiveIslandsOverview:
def test_page_loads(self, page: Page):
nav(page, "(geography.(reactive))")
expect(page.locator("#main-panel")).to_contain_text("Reactive Islands")
def test_architecture_table(self, page: Page):
nav(page, "(geography.(reactive))")
expect(page.locator("table").first).to_be_visible()
class TestReactiveExamplesOverview:
def test_page_loads(self, page: Page):
nav(page, "(geography.(reactive.(examples)))")
expect(page.locator("#main-panel")).to_contain_text("Examples")
class TestReactiveCounter:
def test_page_loads(self, page: Page):
nav(page, "(geography.(reactive.(examples.counter)))")
expect(page.locator("#main-panel")).to_contain_text("signal holds a value")
def test_counter_increments(self, page: Page):
nav(page, "(geography.(reactive.(examples.counter)))")
# Find the island's + button
island = page.locator("[data-sx-island*='demo-counter']")
expect(island).to_be_visible(timeout=5000)
# Wait for hydration
page.wait_for_timeout(1000)
initial = island.locator("span.text-2xl").text_content()
island.locator("button", has_text="+").click()
page.wait_for_timeout(500)
updated = island.locator("span.text-2xl").text_content()
assert initial != updated, f"Counter should change: {initial} -> {updated}"
class TestReactiveTemperature:
def test_page_loads(self, page: Page):
nav(page, "(geography.(reactive.(examples.temperature)))")
expect(page.locator("#main-panel")).to_contain_text("Temperature")
def test_temperature_updates(self, page: Page):
nav(page, "(geography.(reactive.(examples.temperature)))")
island = page.locator("[data-sx-island*='demo-temperature']")
expect(island).to_be_visible(timeout=5000)
page.wait_for_timeout(1000)
island.locator("button", has_text="+5").click()
page.wait_for_timeout(500)
# Should show celsius value > 20 (default)
expect(island).to_contain_text("25")
class TestReactiveStopwatch:
def test_page_loads(self, page: Page):
nav(page, "(geography.(reactive.(examples.stopwatch)))")
expect(page.locator("#main-panel")).to_contain_text("Stopwatch")
class TestReactiveImperative:
def test_page_loads(self, page: Page):
nav(page, "(geography.(reactive.(examples.imperative)))")
expect(page.locator("#main-panel")).to_contain_text("Imperative")
class TestReactiveList:
def test_page_loads(self, page: Page):
nav(page, "(geography.(reactive.(examples.reactive-list)))")
expect(page.locator("#main-panel")).to_contain_text("Reactive List")
def test_add_item(self, page: Page):
nav(page, "(geography.(reactive.(examples.reactive-list)))")
island = page.locator("[data-sx-island*='demo-reactive-list']")
expect(island).to_be_visible(timeout=5000)
page.wait_for_timeout(1000)
island.locator("button", has_text="Add Item").click()
page.wait_for_timeout(500)
expect(island).to_contain_text("Item 1")
class TestReactiveInputBinding:
def test_page_loads(self, page: Page):
nav(page, "(geography.(reactive.(examples.input-binding)))")
expect(page.locator("#main-panel")).to_contain_text("Input Binding")
def test_input_binding(self, page: Page):
nav(page, "(geography.(reactive.(examples.input-binding)))")
island = page.locator("[data-sx-island*='demo-input-binding']")
expect(island).to_be_visible(timeout=5000)
page.wait_for_timeout(1000)
island.locator("input[type='text']").fill("World")
page.wait_for_timeout(500)
expect(island).to_contain_text("Hello, World!")
class TestReactivePortal:
def test_page_loads(self, page: Page):
nav(page, "(geography.(reactive.(examples.portal)))")
expect(page.locator("#main-panel")).to_contain_text("Portal")
class TestReactiveErrorBoundary:
def test_page_loads(self, page: Page):
nav(page, "(geography.(reactive.(examples.error-boundary)))")
expect(page.locator("#main-panel")).to_contain_text("Error")
class TestReactiveRefs:
def test_page_loads(self, page: Page):
nav(page, "(geography.(reactive.(examples.refs)))")
expect(page.locator("#main-panel")).to_contain_text("Refs")
class TestReactiveDynamicClass:
def test_page_loads(self, page: Page):
nav(page, "(geography.(reactive.(examples.dynamic-class)))")
expect(page.locator("#main-panel")).to_contain_text("Dynamic")
class TestReactiveResource:
def test_page_loads(self, page: Page):
nav(page, "(geography.(reactive.(examples.resource)))")
expect(page.locator("#main-panel")).to_contain_text("Resource")
class TestReactiveTransition:
def test_page_loads(self, page: Page):
nav(page, "(geography.(reactive.(examples.transition)))")
expect(page.locator("#main-panel")).to_contain_text("Transition")
class TestReactiveStores:
def test_page_loads(self, page: Page):
nav(page, "(geography.(reactive.(examples.stores)))")
expect(page.locator("#main-panel")).to_contain_text("Store")
class TestReactiveEventBridge:
def test_page_loads(self, page: Page):
nav(page, "(geography.(reactive.(examples.event-bridge-demo)))")
expect(page.locator("#main-panel")).to_contain_text("Event Bridge")
class TestReactiveDefisland:
def test_page_loads(self, page: Page):
nav(page, "(geography.(reactive.(examples.defisland)))")
expect(page.locator("#main-panel")).to_contain_text("defisland")
class TestReactiveTests:
def test_page_loads(self, page: Page):
nav(page, "(geography.(reactive.(examples.tests)))")
expect(page.locator("#main-panel")).to_contain_text("test")
class TestReactiveCoverage:
def test_page_loads(self, page: Page):
nav(page, "(geography.(reactive.(examples.coverage)))")
expect(page.locator("#main-panel")).to_contain_text("React")
# ---------------------------------------------------------------------------
# Marshes
# ---------------------------------------------------------------------------
class TestMarshesOverview:
def test_page_loads(self, page: Page):
nav(page, "(geography.(marshes))")
expect(page.locator("#main-panel")).to_contain_text("Marshes")
class TestMarshesHypermediaFeeds:
def test_page_loads(self, page: Page):
nav(page, "(geography.(marshes.hypermedia-feeds))")
expect(page.locator("#main-panel")).to_contain_text("Hypermedia Feeds")
class TestMarshesServerSignals:
def test_page_loads(self, page: Page):
nav(page, "(geography.(marshes.server-signals))")
expect(page.locator("#main-panel")).to_contain_text("Server Writes")
class TestMarshesOnSettle:
def test_page_loads(self, page: Page):
nav(page, "(geography.(marshes.on-settle))")
expect(page.locator("#main-panel")).to_contain_text("sx-on-settle")
class TestMarshesSignalTriggers:
def test_page_loads(self, page: Page):
nav(page, "(geography.(marshes.signal-triggers))")
expect(page.locator("#main-panel")).to_contain_text("Signal-Bound")
class TestMarshesViewTransform:
def test_page_loads(self, page: Page):
nav(page, "(geography.(marshes.view-transform))")
expect(page.locator("#main-panel")).to_contain_text("Reactive View")
# ---------------------------------------------------------------------------
# Spec Explorer
# ---------------------------------------------------------------------------
class TestSpecExplorer:
def test_evaluator_server_renders(self, page: Page):
"""Server returns spec explorer content with evaluator data."""
resp = page.request.get(f"{BASE}/sx/(language.(spec.(explore.evaluator)))")
assert resp.ok, f"Server returned {resp.status}"
body = resp.text()
assert "Evaluator" in body, "Should contain evaluator title"
assert "eval" in body.lower(), "Should contain evaluator content"
def test_parser_server_renders(self, page: Page):
"""Server returns spec explorer content with parser data."""
resp = page.request.get(f"{BASE}/sx/(language.(spec.(explore.parser)))")
assert resp.ok, f"Server returned {resp.status}"
body = resp.text()
assert "Parser" in body, "Should contain parser title"
def test_has_spec_source(self, page: Page):
"""Spec explorer includes actual spec source code."""
resp = page.request.get(f"{BASE}/sx/(language.(spec.(explore.evaluator)))")
body = resp.text()
assert "define" in body, "Should contain define forms from spec"
assert "eval-expr" in body, "Should contain eval-expr from evaluator spec"
def test_evaluator_renders_in_browser(self, page: Page):
"""Spec explorer should render correctly in the browser, not show 'not found'."""
nav(page, "(language.(spec.(explore.evaluator)))")
page.wait_for_timeout(3000)
content = page.locator("#main-panel").text_content() or ""
assert "not found" not in content.lower(), \
f"Page shows 'not found' instead of spec content: {content[:200]}"
expect(page.locator("#main-panel")).to_contain_text("Evaluator", timeout=5000)
# ---------------------------------------------------------------------------
# Key doc pages (smoke tests)
# ---------------------------------------------------------------------------
class TestDocPages:
@pytest.mark.parametrize("path,expected", [
("(geography.(reactive))", "Reactive Islands"),
("(geography.(hypermedia.(reference.attributes)))", "Attributes"),
("(geography.(scopes))", "Scopes"),
("(geography.(provide))", "Provide"),
("(geography.(spreads))", "Spreads"),
("(language.(doc.introduction))", "Introduction"),
("(language.(spec.core))", "Core"),
("(applications.(cssx))", "CSSX"),
("(etc.(essay.why-sexps))", "Why S-Expressions"),
])
def test_page_loads(self, page: Page, path: str, expected: str):
nav(page, path)
expect(page.locator("#main-panel")).to_contain_text(expected, timeout=10000)
# ---------------------------------------------------------------------------
# Navigation tests
# ---------------------------------------------------------------------------
class TestClientNavigation:
def test_navigate_between_reactive_examples(self, page: Page):
"""Navigate from counter to temperature via server fetch."""
nav(page, "(geography.(reactive.(examples.counter)))")
expect(page.locator("#main-panel")).to_contain_text("signal holds a value", timeout=10000)
# Click temperature link in sibling nav — has sx-get for server fetch
temp_link = page.locator("a[sx-push-url]:has-text('Temperature')").first
expect(temp_link).to_be_visible(timeout=5000)
temp_link.click()
page.wait_for_timeout(5000)
expect(page.locator("#main-panel")).to_contain_text("Temperature", timeout=10000)
def test_reactive_island_works_after_navigation(self, page: Page):
"""Island should be functional after client-side navigation."""
nav(page, "(geography.(reactive.(examples.temperature)))")
page.wait_for_timeout(3000) # Wait for hydration
# Click +5 and verify
island = page.locator("[data-sx-island*='demo-temperature']")
expect(island).to_be_visible(timeout=5000)
island.locator("button", has_text="+5").click()
page.wait_for_timeout(500)
expect(island).to_contain_text("25")
Reference in New Issue View Git Blame Copy Permalink