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
2026-10-02 19:17:10 +00:00 · 2026-06-06 13:59:08 +05:30
1 parent 410602d2e1
commit 94d9511312
@@ -104,6 +104,48 @@ func TestDescribe(t *testing.T) {
 	}
 }

+// TestEventuallyWithinSteps_NextInnerHitsBoundFirstStep pins the boundary: a
+// 1-step Eventually whose inner is a Next defers the inner to step 2, but the
+// window closes at step 1, so the obligation is unmet and violates. Bug class:
+// off-by-one at the step bound treating the deferred inner as still in-window.
+func TestEventuallyWithinSteps_NextInnerHitsBoundFirstStep(t *testing.T) {
+	evaluator := NewEvaluator(EventuallyWithinSteps(Next(ThunkNamed("p", func() (bool, error) { return true, nil })), 1))
+	if got := evaluator.ObserveAt(time.Unix(0, 0)); got != VerdictViolated {
+		t.Errorf("EventuallyWithinSteps(Next(p), 1) step 1: got %v, want violated", got)
+	}
+}
+
+// TestOr_ViolatedDisjunctDoesNotViolateWhileOtherPending guards the Or-reduce
+// path where one disjunct fails (Pure(false)) while the other is still pending
+// (Next(p)). The disjunction must stay pending on the failing step, never
+// violate. Bug class: Or-reduction dropping the still-pending branch and
+// latching violated on a single failed disjunct.
+func TestOr_ViolatedDisjunctDoesNotViolateWhileOtherPending(t *testing.T) {
+	evaluator := NewEvaluator(Always(Or(Pure(false), Next(ThunkNamed("p", func() (bool, error) { return true, nil })))))
+	if got := evaluator.ObserveAt(time.Unix(0, 0)); got != VerdictPending {
+		t.Errorf("step 1: got %v, want pending (Pure(false) disjunct must not violate)", got)
+	}
+	if got := evaluator.ObserveAt(time.Unix(1, 0)); got != VerdictPending {
+		t.Errorf("step 2: got %v, want pending", got)
+	}
+}
+
+// TestNot_OverPendingStaysPendingThenResolves pins Not over a pending inner: it
+// must carry a Not-wrapped residual rather than collapse to a definite verdict
+// at the step the inner is still deferred. Bug class: negation of a pending
+// verdict resolving early to holds/violated.
+func TestNot_OverPendingStaysPendingThenResolves(t *testing.T) {
+	// Next(p) is deferred at step 1, so Not(Next(p)) is pending, not definite.
+	// At step 2 the inner Next holds, so Not violates.
+	evaluator := NewEvaluator(Always(Not(Next(ThunkNamed("p", func() (bool, error) { return true, nil })))))
+	if got := evaluator.ObserveAt(time.Unix(0, 0)); got != VerdictPending {
+		t.Errorf("step 1: got %v, want pending", got)
+	}
+	if got := evaluator.ObserveAt(time.Unix(1, 0)); got != VerdictViolated {
+		t.Errorf("step 2: got %v, want violated (Not over a held inner)", got)
+	}
+}
+
 func TestObserve_PanicsOnUnknownFormulaType(t *testing.T) {
 	type unsupportedFormula struct{ Formula }
 	defer func() {
@@ -146,6 +146,49 @@ func TestViolationLatchIsMonotonic(t *testing.T) {
 	}
 }

+// TestFinalize_KleeneConnectives locks the soundness guarantee in finalize's
+// doc comment: an indefinite (pending) operand must never let a connective
+// manufacture a definite verdict. Bug class: a pending side collapsing to
+// holds/violated at run end, making sanderling lie about pass/fail.
+func TestFinalize_KleeneConnectives(t *testing.T) {
+	pure := func(v bool) Formula { return PureFormula{Value: v} }
+	pendingThunk := ThunkFormula{Name: "t", Func: func() (bool, error) { return true, nil }}
+	eventuallyViolated := EventuallyFormula{Inner: PureFormula{Value: false}}
+	nextPending := NextFormula{Inner: PureFormula{Value: true}}
+	alwaysHolds := AlwaysFormula{Inner: PureFormula{Value: true}}
+
+	cases := []struct {
+		name    string
+		formula Formula
+		want    residualStatus
+	}{
+		{"and-pending-violated", AndFormula{Left: pendingThunk, Right: eventuallyViolated}, statusViolated},
+		{"and-violated-pending", AndFormula{Left: nextPending, Right: eventuallyViolated}, statusViolated},
+		{"and-pending-holds", AndFormula{Left: pendingThunk, Right: alwaysHolds}, statusPending},
+		{"and-holds-holds", AndFormula{Left: pure(true), Right: alwaysHolds}, statusHolds},
+
+		{"or-pending-violated", OrFormula{Left: pendingThunk, Right: eventuallyViolated}, statusPending},
+		{"or-pending-holds", OrFormula{Left: pendingThunk, Right: alwaysHolds}, statusHolds},
+		{"or-violated-violated", OrFormula{Left: pure(false), Right: eventuallyViolated}, statusViolated},
+
+		{"not-pending", NotFormula{Inner: pendingThunk}, statusPending},
+		{"not-violated", NotFormula{Inner: eventuallyViolated}, statusHolds},
+		{"not-holds", NotFormula{Inner: alwaysHolds}, statusViolated},
+
+		{"implies-pending-violated", ImpliesFormula{Antecedent: pendingThunk, Consequent: eventuallyViolated}, statusPending},
+		{"implies-holds-violated", ImpliesFormula{Antecedent: alwaysHolds, Consequent: eventuallyViolated}, statusViolated},
+		{"implies-violated-pending", ImpliesFormula{Antecedent: eventuallyViolated, Consequent: nextPending}, statusHolds},
+
+		{"now-violated", NowFormula{Inner: eventuallyViolated}, statusViolated},
+		{"now-pending", NowFormula{Inner: nextPending}, statusPending},
+	}
+	for _, tc := range cases {
+		if got := finalize(tc.formula); got != tc.want {
+			t.Errorf("%s: finalize = %v, want %v", tc.name, got, tc.want)
+		}
+	}
+}
+
 func TestCollapse_IdenticalObligationsMerge(t *testing.T) {
 	merged := collapse([]obligation{
 		{formula: Next(Pure(true)), origin: 1},
@@ -220,6 +220,30 @@ func TestMarshalJSON_EventuallyMillisecondsAndDeadline(t *testing.T) {
 	}
 }

+// TestMarshalJSON_AlwaysStepsMillisecondsDeadline mirrors the Eventually
+// marshal test for bounded Always: the within node must carry the right unit
+// and amount for each bound flavor. Bug class: a bounded Always serializing the
+// wrong bound (unit/amount) into the trace AST the replay UI consumes.
+func TestMarshalJSON_AlwaysStepsMillisecondsDeadline(t *testing.T) {
+	steps := AlwaysFormula{Inner: Pure(true), StepBound: 4, HasStepBound: true}
+	body, _ := json.Marshal(steps)
+	if !strings.Contains(string(body), `"unit":"steps"`) || !strings.Contains(string(body), `"amount":4`) {
+		t.Errorf("always steps within wrong: %s", body)
+	}
+
+	duration := AlwaysFormula{Inner: Pure(true), Duration: 250 * time.Millisecond}
+	body, _ = json.Marshal(duration)
+	if !strings.Contains(string(body), `"unit":"milliseconds"`) || !strings.Contains(string(body), `"amount":250`) {
+		t.Errorf("always milliseconds within wrong: %s", body)
+	}
+
+	deadline := AlwaysFormula{Inner: Pure(true), Deadline: time.UnixMilli(1700000000000), HasDeadline: true}
+	body, _ = json.Marshal(deadline)
+	if !strings.Contains(string(body), `"unit":"deadline"`) || !strings.Contains(string(body), `"amount":1700000000000`) {
+		t.Errorf("always deadline within wrong: %s", body)
+	}
+}
+
 func TestMarshalJSON_NextAndThunkAndError(t *testing.T) {
 	body, _ := json.Marshal(Next(Pure(true)))
 	if string(body) != `{"op":"next","arg":{"op":"true"}}` {
@@ -248,13 +272,19 @@ func TestResidual_HoldsViolatedPending(t *testing.T) {
 		t.Errorf("violated residual = %v, want false", got)
 	}

-	pendingEval := NewEvaluator(Always(Next(Pure(true))))
+	// A genuinely multi-obligation residual: both Next inners survive to the
+	// next step folded under And, in registration order. A residual that
+	// dropped or transposed an obligation would change this exact AST.
+	predP := ThunkNamed("p", func() (bool, error) { return true, nil })
+	predQ := ThunkNamed("q", func() (bool, error) { return true, nil })
+	pendingEval := NewEvaluator(Always(And(Next(predP), Next(predQ))))
 	pendingEval.Observe()
 	body, err := json.Marshal(pendingEval.Residual())
 	if err != nil {
 		t.Fatal(err)
 	}
-	if !strings.Contains(string(body), `"op":"and"`) && !strings.Contains(string(body), `"op":"true"`) {
-		t.Errorf("pending residual unexpected: %s", body)
+	want := `{"op":"and","left":{"op":"predicate","name":"p"},"right":{"op":"predicate","name":"q"}}`
+	if string(body) != want {
+		t.Errorf("pending residual:\n got: %s\nwant: %s", body, want)
 	}
 }