test: full test-suite refactor sweep (#61)

* chore(test): start test-suite refactor sweep

* test(ltl): pin exact multi-obligation residual AST

* test(ltl): table-test finalize Kleene connective combinations

* test(ltl): pin reduce over pending inner for bound, Or, Not

* test(ltl): marshal bounded Always steps/duration/deadline

* test(verifier): cover LTL combinator verdict transitions and within unit panic

* test(verifier): table-test DecodeAction kinds and lastAction field exposure

* test(verifier): assert WithPlatform(ios) reaches the picker host and key pool

* test(verifier): widen weighted-selection assertion to a 5x skew margin

* test(verifier): un-skip ax-find round trip with a committed tree fixture

* test(runner): pin isWDADrop to sidecar reconnect-failed message origin

* test(runner): assert PressKey/Wait trace encoding records kind-specific fields

* test(runner): cover RenderSummary unsupported-verbs surfacing branch

* test(trace): set Hierarchy in round-trip and lock lossy Tree contract

Also add a -race concurrent WriteStep test that asserts N well-formed JSONL lines, catching torn lines if the writer mutex is dropped.

* test(trace): round-trip witnesses/changes/metrics/exceptions, pin step-0 witness

* test(trace): document ViolationsAreGreppable grep contract and lock-free WriteScreenshot

* test(hierarchy): cover invalid-JSON and malformed-bounds parser paths

* test(trace): guard writer mutex via WriteStep/Close race on w.file

* test(replay): drop unfailable assets and devproxy assertions

* test(replay): cache reuses on equal mtime, reparses after append

* test(replay): violation marker falls back to detection step when attributed missing

* test(replay): corrupt meta/trace dirs return 500 with error body

* test(replay): SSE client receives runs.changed after a broadcast

* test(replay): Run coalesces creates, ignores write/chmod, closes subs on cancel

* fix(sidecar): synchronize health fixture writes and exercise healthError

* test(sidecar): cover swipe/longpress/doubletap/erase/presskey/metrics/logs translations

* test(sidecar): cover DoubleTapSelector composition and mid-gesture cancel

* test(sidecar): assert gRPC error status surfaces from action RPC

* fix(chrome): route action methods through runCtx so caller cancellation aborts CDP

* fix(chrome): route hierarchy/screenshot/waitidle/metrics through runCtx

* refactor(ios): extract pure simctl JSON parsers

* refactor(ios): add command-runner seams for EnsureSimulator

* test(ios): table-test simctl parsers and EnsureSimulator seams

* test(sidecarassets): cover placeholder build path

* test(sidecarassets): assert reuse via sentinel bytes not mtime

* test(bundler): cover properties-only spec registration

* refactor(testrun): extract prepareBundleInputs from Execute

* test(testrun): cover prepareBundleInputs aliases and missing-runtime error

* test(testrun): table-test resolveRuntimeSibling search edges

* test(testrun): exact-output tests for progressHandler line format

* fix(cmd): point bundle-check aliases at pkg/spec/src

* test(cmd): smoke-test bundle-check resolves spec aliases

* test(cmd): table-test hier-check parse and FindAll on fixture

* test(cmd): unit-test buildBrowseURL deep-link vs root

* test(cmd): drop flaky TestRun_Doctor that launched real Chromium

* test(cmd): pin pipeline error to bundle resolution on web platform

* test(replay-ui): add bun test script

* ci(replay-ui): run bun test via make web-test target

* ci(replay-ui): point bun cache key at replay-ui/bun.lock

* test(replay-ui): exercise real URL encoding and non-ok throw in getJson

* refactor(replay-ui): extract snapshot flatten/getAtPath into lib module

* test(replay-ui): pin snapshot flatten/getAtPath path round-trip

* refactor(replay-ui): extract action selector/format into lib module

* test(replay-ui): pin action selector parse and row formatting

* refactor(replay-ui): share one statusFor between panels

* refactor(replay-ui): extract run-history derivation into lib module

* test(replay-ui): pin shared statusFor precedence and ordering

* test(replay-ui): pin run-history derivation alignment

* refactor(replay-ui): export clampIndex for testing

* refactor(replay-ui): extract keyboard-nav dispatch into pure module

* refactor(replay-ui): extract metrics formatters into lib module

* test(replay-ui): pin clampIndex step boundaries

* test(replay-ui): pin keyboard-nav ownership and key routing

* test(replay-ui): pin metrics formatters and path gap handling

* refactor(sidecar): expose device-output parsers as internal for testing

* test(sidecar): table-test device-output parsers against malformed input

* test(sidecar): cover logcat parsing year inference and line skipping

* test(sidecar): pin pressKey keycode mapping and unknown-key rejection

* test(sidecar): metrics bundleId falls back to launched app and honors override

* test(sidecar): loosen deadline upper bound to tolerate slow CI scheduling

* test(web-runtime): export selector builders for unit tests

* test(web-runtime): guard sanitize cycle, function, and depth limits

* test(web-runtime): table-test selector builder quoting and escaping

* test(sidecar): collapse scalar-forwarding RPC tests into a table

* test(replay-ui): dedup step/summary fixtures into shared module

* test(ios): collapse pickSimulator point-tests into a table

cmd/internal-tools/bundle-check/main.go

@@ -9,6 +9,17 @@ import (
 	"github.com/priyanshujain/sanderling/internal/bundler"
 )
 
+func bundleSpec(specSrc, entryFile string) (bundler.Result, error) {
+	return bundler.Bundle(bundler.Options{
+		EntryFile: entryFile,
+		Aliases: map[string]string{
+			"@sanderling/spec":                     filepath.Join(specSrc, "index.ts"),
+			"@sanderling/spec/defaults":            filepath.Join(specSrc, "defaults/index.ts"),
+			"@sanderling/spec/defaults/properties": filepath.Join(specSrc, "defaults/properties.ts"),
+		},
+	})
+}
+
 func main() {
 	if len(os.Args) < 2 {
 		fmt.Fprintln(os.Stderr, "usage: bundle-check <spec.ts>")
@@ -26,16 +37,8 @@ func main() {
 		fmt.Fprintf(os.Stderr, "getwd: %v\n", err)
 		os.Exit(1)
 	}
-	specApiPath := filepath.Join(repoRoot, "pkg/spec-api/src/index.ts")
-	defaultPropertiesPath := filepath.Join(repoRoot, "pkg/spec-api/src/defaults/properties.ts")
 
-	result, err := bundler.Bundle(bundler.Options{
-		EntryFile: entryFile,
-		Aliases: map[string]string{
-			"@sanderling/spec":                    specApiPath,
-			"@sanderling/spec/defaults/properties": defaultPropertiesPath,
-		},
-	})
+	result, err := bundleSpec(filepath.Join(repoRoot, "pkg/spec/src"), entryFile)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "bundle: %v\n", err)
 		os.Exit(1)

cmd/internal-tools/bundle-check/main_test.go

@@ -0,0 +1,57 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// repoSpecSrc walks up from the test's working directory to the repo root and
+// returns pkg/spec/src. The bundle-check aliases once pointed at the
+// non-existent pkg/spec-api/src, so esbuild resolved nothing and the tool
+// silently emitted an empty bundle.
+func repoSpecSrc(t *testing.T) string {
+	t.Helper()
+	dir, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	for {
+		candidate := filepath.Join(dir, "pkg/spec/src")
+		if _, err := os.Stat(filepath.Join(candidate, "index.ts")); err == nil {
+			return candidate
+		}
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			t.Fatal("pkg/spec/src/index.ts not found above test dir")
+		}
+		dir = parent
+	}
+}
+
+func TestBundleSpec_ResolvesSpecAliases(t *testing.T) {
+	specSrc := repoSpecSrc(t)
+	entry, err := filepath.Abs(filepath.Join("testdata", "spec.ts"))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	result, err := bundleSpec(specSrc, entry)
+	if err != nil {
+		t.Fatalf("bundle: %v", err)
+	}
+	if len(result.JavaScript) == 0 {
+		t.Fatal("empty bundle: aliases resolved to nothing")
+	}
+	if result.SHA256 == "" {
+		t.Fatal("missing bundle hash")
+	}
+
+	second, err := bundleSpec(specSrc, entry)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.SHA256 != second.SHA256 {
+		t.Errorf("unstable bundle hash: %s vs %s", result.SHA256, second.SHA256)
+	}
+}

cmd/internal-tools/bundle-check/testdata/spec.ts

@@ -0,0 +1,12 @@
+import { Tap, actions } from "@sanderling/spec";
+import { noUncaughtExceptions } from "@sanderling/spec/defaults/properties";
+import * as defaults from "@sanderling/spec/defaults";
+
+const tapPrimary = actions((state) => {
+  const button = state.ax.find("desc:primary");
+  return button ? [Tap({ on: button })] : [];
+});
+
+export const properties = { noUncaughtExceptions };
+export const actionsRoot = tapPrimary;
+export const defaultsKeys = Object.keys(defaults);

cmd/internal-tools/hier-check/main_test.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/priyanshujain/sanderling/internal/hierarchy"
+)
+
+func TestHierCheck_ParseAndFind(t *testing.T) {
+	content, err := os.ReadFile(filepath.Join("testdata", "dump.json"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	tree, err := hierarchy.Parse(string(content))
+	if err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+	if got := len(tree.Elements); got != 4 {
+		t.Fatalf("element count: got %d, want 4", got)
+	}
+
+	cases := []struct {
+		selector string
+		want     int
+	}{
+		{"desc:row", 2},
+		{"id:title", 1},
+		{"text:Bob", 1},
+		{"id:missing", 0},
+	}
+	for _, c := range cases {
+		if got := len(tree.FindAll(c.selector)); got != c.want {
+			t.Errorf("%s: got %d matches, want %d", c.selector, got, c.want)
+		}
+	}
+}
+
+func TestHierCheck_MalformedReturnsError(t *testing.T) {
+	if _, err := hierarchy.Parse(`{"attributes": {`); err == nil {
+		t.Fatal("expected error for malformed hierarchy, got nil")
+	}
+}

cmd/internal-tools/hier-check/testdata/dump.json

@@ -0,0 +1,17 @@
+{
+  "attributes": {"class": "android.widget.LinearLayout", "package": "app", "bounds": "[0,0,1080,2340]"},
+  "children": [
+    {
+      "attributes": {"resource-id": "app:id/title", "text": "Hello", "bounds": "[10,20,200,60]"},
+      "children": []
+    },
+    {
+      "attributes": {"resource-id": "app:id/row", "text": "Alice", "content-desc": "row", "bounds": "[0,100,1080,200]"},
+      "children": []
+    },
+    {
+      "attributes": {"resource-id": "app:id/row", "text": "Bob", "content-desc": "row", "bounds": "[0,200,1080,300]"},
+      "children": []
+    }
+  ]
+}

cmd/sanderling/main_test.go

@@ -152,17 +152,6 @@ func TestRun_UnknownCommand(t *testing.T) {
 	}
 }
 
-func TestRun_Doctor(t *testing.T) {
-	var stdout bytes.Buffer
-	// Doctor may pass or fail depending on host environment; we just want to
-	// confirm it runs and emits per-check lines.
-	_ = run([]string{"sanderling", "doctor"}, &stdout, io.Discard)
-	output := stdout.String()
-	if !strings.Contains(output, "OK") && !strings.Contains(output, "FAIL") {
-		t.Errorf("doctor output missing OK/FAIL lines: %q", output)
-	}
-}
-
 func TestParseTestArgs_AcceptsIosPlatform(t *testing.T) {
 	options, err := parseTestArgs([]string{
 		"--spec", "s.ts",
@@ -193,24 +182,20 @@ func TestParseTestArgs_IosDeviceFlag(t *testing.T) {
 }
 
 func TestRun_TestSubcommand_PipelineErrors(t *testing.T) {
-	// Without a real spec, a real device, or a bootable AVD the pipeline
-	// must surface a specific error rather than panicking — proves the flag
-	// wiring reaches the runner.
+	// Web skips host-dependent device boot and bundles first, so a missing spec
+	// deterministically surfaces a bundle-resolution error. This proves the
+	// flag wiring reaches the bundler rather than panicking on the way.
 	err := run([]string{
 		"sanderling", "test",
 		"--spec", "definitely-missing-spec.ts",
-		"--bundle-id", "com.example",
-		"--avd", "definitely-missing-avd",
+		"--bundle-id", "http://localhost:3000",
+		"--platform", "web",
 	}, io.Discard, io.Discard)
 	if err == nil {
 		t.Fatal("expected error, got nil")
 	}
 	message := err.Error()
-	ok := strings.Contains(message, "bundle") ||
-		strings.Contains(message, "device") ||
-		strings.Contains(message, "AVD") ||
-		strings.Contains(message, "emulator")
-	if !ok {
-		t.Errorf("expected pipeline error (bundle/device/AVD/emulator), got %v", err)
+	if !strings.HasPrefix(message, "bundle spec:") || !strings.Contains(message, "definitely-missing-spec.ts") {
+		t.Errorf("expected bundle-resolution error for the missing spec, got %v", err)
 	}
 }

cmd/sanderling/replay_test.go

@@ -3,6 +3,7 @@ package main
 import (
 	"bytes"
 	"io"
+	"net"
 	"strings"
 	"testing"
 )
@@ -34,6 +35,25 @@ func TestParseReplayArgs_RejectsTooManyPositional(t *testing.T) {
 	}
 }
 
+func TestBuildBrowseURL(t *testing.T) {
+	address := &net.TCPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 8080}
+	cases := []struct {
+		name       string
+		deepLinkID string
+		want       string
+	}{
+		{"root", "", "http://127.0.0.1:8080/"},
+		{"deep link", "20240101-120000", "http://127.0.0.1:8080/runs/20240101-120000"},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			if got := buildBrowseURL(address, c.deepLinkID); got != c.want {
+				t.Errorf("buildBrowseURL(%q) = %q, want %q", c.deepLinkID, got, c.want)
+			}
+		})
+	}
+}
+
 func TestRun_HelpListsReplayCommand(t *testing.T) {
 	var stdout bytes.Buffer
 	if err := run([]string{"sanderling"}, &stdout, io.Discard); err != nil {