package engine import ( "context" "fmt" "net/http" "net/http/httptest" "strings" "testing" ) // --------------------------------------------------------------------------- // Realistic page templates simulating common website structures. // These tests verify the lite engine produces correct accessibility snapshots // comparable to what Chrome's CDP accessibility tree would return. // --------------------------------------------------------------------------- const wikipediaStylePage = ` Go (programming language) - Wikipedia

Go (programming language)

Go, also known as Golang, is a statically typed, compiled programming language designed at Google.

History

Go was designed at Google in 2007 by Robert Griesemer, Rob Pike, and Ken Thompson.

Syntax

Go's syntax is similar to C but with memory safety, garbage collection, and CSP-style concurrency.

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

Concurrency

Go has built-in support for concurrent programming via goroutines and channels.

Feature	Go	Rust
GC	Yes	No
Generics	Yes (1.18+)	Yes

` const hackerNewsStylePage = ` Hacker News

1. Show HN: A new Go framework johndoe | 142 comments
2. Why Rust is great for CLI tools janedoe | 89 comments
3. The future of WebAssembly alice | 203 comments

` const ecommerceStylePage = ` Product - Online Store

Wireless Bluetooth Headphones

Premium noise-canceling headphones with 30-hour battery life.

Price: $79.99

Customer Reviews

4.5 out of 5 stars (128 reviews)

Great sound quality! - Alice
Battery lasts forever - Bob
Comfortable for long sessions - Charlie

` const formHeavyPage = ` Registration Form

Create Your Account

` const ariaHeavyPage = ` Dashboard

Key Metrics

Last updated: 5 minutes ago

Revenue

$45,230

Active Users

1,234

Date	Revenue	Users
Jan 1	$1,200	89
Jan 2	$1,450	102

` const deeplyNestedPage = ` Nested

Deeply nested paragraph with a link inside.

` const specialCharsPage = ` Special & Characters

Café & Restaurant

Price: <$50 for dégustation menu

Japanese: 日本語

Réserver

Emoji: 😀 🚀 ❤

` const emptyAndMinimalPage = ` Empty ` // --------------------------------------------------------------------------- // Test runner // --------------------------------------------------------------------------- type realworldTestCase struct { name string html string checks []realworldCheck } type realworldCheck struct { desc string fn func(t *testing.T, lite *LiteEngine) } func runRealworldSuite(t *testing.T, tc realworldTestCase) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/html; charset=utf-8") _, _ = w.Write([]byte(tc.html)) })) defer ts.Close() lite := NewLiteEngine() defer func() { _ = lite.Close() }() _, err := lite.Navigate(context.Background(), ts.URL) if err != nil { t.Fatalf("Navigate failed: %v", err) } for _, c := range tc.checks { t.Run(c.desc, func(t *testing.T) { c.fn(t, lite) }) } } // --------------------------------------------------------------------------- // Helpers // --------------------------------------------------------------------------- func snapshotNodes(t *testing.T, lite *LiteEngine, filter string) []SnapshotNode { t.Helper() nodes, err := lite.Snapshot(context.Background(), "", filter) if err != nil { t.Fatalf("Snapshot(%q): %v", filter, err) } return nodes } func getText(t *testing.T, lite *LiteEngine) string { t.Helper() text, err := lite.Text(context.Background(), "") if err != nil { t.Fatalf("Text: %v", err) } return text } func requireRole(t *testing.T, nodes []SnapshotNode, role string, minCount int) { t.Helper() count := 0 for _, n := range nodes { if n.Role == role { count++ } } if count < minCount { t.Errorf("expected >= %d nodes with role=%q, got %d", minCount, role, count) } } func requireRoleWithName(t *testing.T, nodes []SnapshotNode, role, nameSub string) { t.Helper() for _, n := range nodes { if n.Role == role && strings.Contains(n.Name, nameSub) { return } } t.Errorf("no node with role=%q containing name=%q", role, nameSub) } func requireTextContains(t *testing.T, text string, subs ...string) { t.Helper() for _, s := range subs { if !strings.Contains(text, s) { t.Errorf("expected text to contain %q (len=%d)", s, len(text)) } } } func requireTextNotContains(t *testing.T, text string, subs ...string) { t.Helper() for _, s := range subs { if strings.Contains(text, s) { t.Errorf("text should NOT contain %q", s) } } } // --------------------------------------------------------------------------- // Test cases // --------------------------------------------------------------------------- func TestRealworld_WikipediaStyle(t *testing.T) { runRealworldSuite(t, realworldTestCase{ name: "Wikipedia-style article", html: wikipediaStylePage, checks: []realworldCheck{ {"scripts stripped from text", func(t *testing.T, lite *LiteEngine) { text := getText(t, lite) requireTextNotContains(t, text, "addEventListener", "console.log", "DOMContentLoaded") }}, {"heading hierarchy", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") requireRole(t, nodes, "heading", 4) // h1 + 3x h2 }}, {"navigation landmarks", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") requireRole(t, nodes, "navigation", 2) // top-nav + toc }}, {"sections with aria-label become regions", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") requireRoleWithName(t, nodes, "region", "History") requireRoleWithName(t, nodes, "region", "Syntax") requireRoleWithName(t, nodes, "region", "Concurrency") }}, {"table structure", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") requireRole(t, nodes, "table", 1) requireRole(t, nodes, "row", 3) requireRole(t, nodes, "columnheader", 3) requireRole(t, nodes, "cell", 4) }}, {"links detected as interactive", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "interactive") requireRole(t, nodes, "link", 1) // at minimum the logo link and toc links // All should be interactive for _, n := range nodes { if !n.Interactive { t.Errorf("interactive filter returned non-interactive: %+v", n) } } }}, {"search form elements", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "interactive") requireRoleWithName(t, nodes, "textbox", "Search") requireRole(t, nodes, "button", 1) }}, {"text content completeness", func(t *testing.T, lite *LiteEngine) { text := getText(t, lite) requireTextContains(t, text, "Go (programming language)", "statically typed", "Robert Griesemer", "goroutines and channels", "Privacy policy", ) }}, {"banner and contentinfo landmarks", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") requireRole(t, nodes, "banner", 1) requireRole(t, nodes, "contentinfo", 1) }}, }, }) } func TestRealworld_HackerNewsStyle(t *testing.T) { runRealworldSuite(t, realworldTestCase{ name: "Hacker News style", html: hackerNewsStylePage, checks: []realworldCheck{ {"all story links detected", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") requireRole(t, nodes, "link", 5) // at minimum the story links }}, {"list structure", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") requireRole(t, nodes, "list", 1) requireRole(t, nodes, "listitem", 3) }}, {"text has all headlines", func(t *testing.T, lite *LiteEngine) { text := getText(t, lite) requireTextContains(t, text, "Show HN: A new Go framework", "Why Rust is great", "future of WebAssembly", ) }}, {"interactive elements include nav links", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "interactive") var names []string for _, n := range nodes { if n.Name != "" { names = append(names, n.Name) } } found := false for _, name := range names { if strings.Contains(name, "new") || strings.Contains(name, "login") { found = true break } } if !found { t.Errorf("expected nav links in interactive, got names: %v", names) } }}, }, }) } func TestRealworld_EcommerceStyle(t *testing.T) { runRealworldSuite(t, realworldTestCase{ name: "E-commerce product page", html: ecommerceStylePage, checks: []realworldCheck{ {"product heading", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") requireRoleWithName(t, nodes, "heading", "") }}, {"image with alt text", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") requireRoleWithName(t, nodes, "img", "Black wireless headphones") }}, {"color select dropdown", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "interactive") requireRole(t, nodes, "combobox", 1) }}, {"number input for quantity", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "interactive") requireRole(t, nodes, "textbox", 1) // number input → textbox }}, {"add to cart button", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "interactive") requireRoleWithName(t, nodes, "button", "Add to Cart") }}, {"details/summary as group/button", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") requireRole(t, nodes, "group", 1) // summary → interactive button interNodes := snapshotNodes(t, lite, "interactive") foundSummary := false for _, n := range interNodes { if strings.Contains(n.Name, "4.5 out of 5") { foundSummary = true break } } if !foundSummary { t.Error("expected details summary to be interactive") } }}, {"review section landmark", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") requireRoleWithName(t, nodes, "region", "Reviews") }}, {"article structure", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") requireRole(t, nodes, "article", 1) }}, {"scripts from CDN stripped", func(t *testing.T, lite *LiteEngine) { text := getText(t, lite) requireTextNotContains(t, text, "analytics.js", "cdn.example.com") }}, }, }) } func TestRealworld_FormHeavy(t *testing.T) { runRealworldSuite(t, realworldTestCase{ name: "Registration form", html: formHeavyPage, checks: []realworldCheck{ {"all text inputs detected", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "interactive") textboxCount := 0 for _, n := range nodes { if n.Role == "textbox" { textboxCount++ } } // firstname, lastname, email, password, bio (textarea) if textboxCount < 5 { t.Errorf("expected >= 5 textboxes, got %d", textboxCount) } }}, {"radio buttons", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "interactive") requireRole(t, nodes, "radio", 2) }}, {"checkbox", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "interactive") requireRole(t, nodes, "checkbox", 1) }}, {"select dropdown", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "interactive") requireRole(t, nodes, "combobox", 1) }}, {"submit and reset buttons", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "interactive") btnNames := make(map[string]bool) for _, n := range nodes { if n.Role == "button" { btnNames[n.Name] = true } } if !btnNames["Register"] { t.Error("expected Register button") } if !btnNames["Clear Form"] { t.Error("expected Clear Form button") } }}, {"form landmark", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") requireRole(t, nodes, "form", 1) }}, {"type into input and verify", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "interactive") var firstInput string for _, n := range nodes { if n.Role == "textbox" { firstInput = n.Ref break } } if firstInput == "" { t.Fatal("no textbox found") } err := lite.Type(context.Background(), "", firstInput, "TestUser") if err != nil { t.Errorf("Type: %v", err) } }}, }, }) } func TestRealworld_AriaHeavy(t *testing.T) { runRealworldSuite(t, realworldTestCase{ name: "ARIA-heavy dashboard", html: ariaHeavyPage, checks: []realworldCheck{ {"banner role from div[role=banner]", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") requireRole(t, nodes, "banner", 1) }}, {"navigation with aria-label", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") requireRoleWithName(t, nodes, "navigation", "Main") }}, {"main role", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") requireRole(t, nodes, "main", 1) }}, {"tablist with tab buttons", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") requireRole(t, nodes, "tablist", 1) requireRole(t, nodes, "tab", 3) }}, {"tabs are interactive", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "interactive") tabCount := 0 for _, n := range nodes { if n.Role == "tab" { tabCount++ } } if tabCount < 3 { t.Errorf("expected 3 interactive tabs, got %d", tabCount) } }}, {"status role detected", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") requireRole(t, nodes, "status", 1) }}, {"region roles with aria-label", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") requireRoleWithName(t, nodes, "region", "Revenue") requireRoleWithName(t, nodes, "region", "Users") }}, {"dialog detected", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") requireRoleWithName(t, nodes, "dialog", "Welcome") }}, {"tabpanel role", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") requireRole(t, nodes, "tabpanel", 1) }}, {"contentinfo footer", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") requireRole(t, nodes, "contentinfo", 1) }}, {"table inside tabpanel", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") requireRole(t, nodes, "table", 1) requireRole(t, nodes, "row", 3) }}, }, }) } func TestRealworld_DeeplyNested(t *testing.T) { runRealworldSuite(t, realworldTestCase{ name: "Deeply nested DOM", html: deeplyNestedPage, checks: []realworldCheck{ {"links found through nesting", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "interactive") requireRole(t, nodes, "link", 3) // Link A, Link B, link inside p }}, {"deep input and button found", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "interactive") requireRole(t, nodes, "textbox", 1) requireRole(t, nodes, "button", 1) }}, {"text extraction through nesting", func(t *testing.T, lite *LiteEngine) { text := getText(t, lite) requireTextContains(t, text, "Level 5 Link A", "Deeply nested paragraph") }}, {"depth values increase with nesting", func(t *testing.T, lite *LiteEngine) { nodes := snapshotNodes(t, lite, "") maxDepth := 0 for _, n := range nodes { if n.Depth > maxDepth { maxDepth = n.Depth } } if maxDepth < 5 { t.Errorf("expected maxDepth >= 5 for deeply nested page, got %d", maxDepth) } }}, }, }) } func TestRealworld_SpecialCharacters(t *testing.T) { runRealworldSuite(t, realworldTestCase{ name: "Special characters & Unicode", html: specialCharsPage, checks: []realworldCheck{ {"HTML entities decoded in text", func(t *testing.T, lite *LiteEngine) { text := getText(t, lite) // & should be decoded to & requireTextContains(t, text, "&") // < should be decoded requireTextContains(t, text, "<$50") }}, {"accented characters", func(t *testing.T, lite *LiteEngine) { text := getText(t, lite) requireTextContains(t, text, "Caf") }}, {"unicode CJK characters", func(t *testing.T, lite *LiteEngine) { text := getText(t, lite) requireTextContains(t, text, "日本語") }}, }, }) } func TestRealworld_EmptyPage(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/html; charset=utf-8") _, _ = w.Write([]byte(emptyAndMinimalPage)) })) defer ts.Close() lite := NewLiteEngine() defer func() { _ = lite.Close() }() _, err := lite.Navigate(context.Background(), ts.URL) if err != nil { t.Fatalf("Navigate: %v", err) } nodes, err := lite.Snapshot(context.Background(), "", "all") if err != nil { t.Fatalf("Snapshot: %v", err) } // Empty body should yield 0 or very few nodes if len(nodes) > 1 { t.Errorf("expected <= 1 nodes for empty page, got %d", len(nodes)) } text, err := lite.Text(context.Background(), "") if err != nil { t.Fatalf("Text: %v", err) } if strings.TrimSpace(text) != "" { t.Errorf("expected empty text for empty page, got %q", text) } } func TestRealworld_NonHTMLContentType(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"error": "not html"}`)) })) defer ts.Close() lite := NewLiteEngine() defer func() { _ = lite.Close() }() _, err := lite.Navigate(context.Background(), ts.URL) if err == nil { t.Error("expected error for non-HTML content type") } if !strings.Contains(err.Error(), "unsupported content type") { t.Errorf("unexpected error: %v", err) } } func TestRealworld_HTTP404(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(404) _, _ = w.Write([]byte("Not Found")) })) defer ts.Close() lite := NewLiteEngine() defer func() { _ = lite.Close() }() _, err := lite.Navigate(context.Background(), ts.URL) if err == nil { t.Error("expected error for 404") } if !strings.Contains(err.Error(), "HTTP 404") { t.Errorf("unexpected error: %v", err) } } func TestRealworld_LargePagePerformance(t *testing.T) { // Generate a page with many elements to test performance doesn't degrade var b strings.Builder b.WriteString(`Large`) for i := range 200 { _, _ = fmt.Fprintf(&b, `

Section %d

Content %d

Link %d

`, i, i, i, i) } b.WriteString(``) largePage := b.String() ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/html; charset=utf-8") _, _ = w.Write([]byte(largePage)) })) defer ts.Close() lite := NewLiteEngine() defer func() { _ = lite.Close() }() _, err := lite.Navigate(context.Background(), ts.URL) if err != nil { t.Fatalf("Navigate: %v", err) } nodes := snapshotNodes(t, lite, "") if len(nodes) < 600 { // 200 * (div + h3 + p + a) = 800 minimum t.Errorf("expected >= 600 nodes for large page, got %d", len(nodes)) } interNodes := snapshotNodes(t, lite, "interactive") if len(interNodes) < 200 { t.Errorf("expected >= 200 interactive nodes (links), got %d", len(interNodes)) } } func TestRealworld_MultipleScriptTags(t *testing.T) { page := `

Content

Visible paragraph

Styled text

Normal text

Some content here

` ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/html; charset=utf-8") _, _ = w.Write([]byte(page)) })) defer ts.Close() lite := NewLiteEngine() defer func() { _ = lite.Close() }() _, _ = lite.Navigate(context.Background(), ts.URL) nodes := snapshotNodes(t, lite, "interactive") // Click every interactive element — should not error or panic for _, n := range nodes { err := lite.Click(context.Background(), "", n.Ref) if err != nil { t.Errorf("Click(%s role=%s name=%q): %v", n.Ref, n.Role, n.Name, err) } } // Engine should still be usable text, err := lite.Text(context.Background(), "") if err != nil { t.Fatalf("Text after clicks: %v", err) } if !strings.Contains(text, "Some content here") { t.Errorf("unexpected text after clicks: %s", text) } } func TestRealworld_ClickLinkRecovery(t *testing.T) { // Clicking anchor links triggers gost-dom navigation which can panic // (no script engine). Verify we recover gracefully. page := ` Links Go to Page 2 Go to Page 3 ` ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/html; charset=utf-8") _, _ = w.Write([]byte(page)) })) defer ts.Close() lite := NewLiteEngine() defer func() { _ = lite.Close() }() _, _ = lite.Navigate(context.Background(), ts.URL) nodes := snapshotNodes(t, lite, "interactive") for _, n := range nodes { if n.Role == "link" { err := lite.Click(context.Background(), "", n.Ref) // Error is acceptable (recovered panic) — the key is it doesn't crash _ = err } } } func TestRealworld_TypeWorkflow(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/html; charset=utf-8") _, _ = w.Write([]byte(formHeavyPage)) })) defer ts.Close() lite := NewLiteEngine() defer func() { _ = lite.Close() }() _, _ = lite.Navigate(context.Background(), ts.URL) nodes := snapshotNodes(t, lite, "interactive") // Type into all textboxes for _, n := range nodes { if n.Role == "textbox" { err := lite.Type(context.Background(), "", n.Ref, "test-value") if err != nil { t.Errorf("Type(%s name=%q): %v", n.Ref, n.Name, err) } } } }