writing-tests

Refactor-proof tests assert on user-observable state like selection or return values rather than mock invocation details. You drive tests through user-facing surfaces and check the resulting state a user would notice, preventing mock-based drift during code changes.

Tests break during refactors when they assert on mock internals or what was called instead of actual behavior. By verifying observable state such as glyph contours, viewport pan, or emitted payloads, tests remain stable across implementation changes while catching real regressions.

Bridge tests validate interactions with the real Editor or Rust engine boundaries, while pure module tests verify isolated logic. Choosing the right test category ensures the harness matches the behavior’s boundaries, driving through user-facing surfaces like TestEditor and NativeBridge.

Global stubs and vi.fn calls should be avoided in tool behavior tests. Instead of asserting on mock invocations, you should drive tests through pointer and keyboard actions, command history, and then assert on the resulting tool state or emitted payloads.

Testing command undo and redo contracts requires driving actions through command history and asserting on user-observable state. This approach avoids brittle mock-heavy assertions, ensuring the test verifies the actual contract behavior rather than internal mock call sequences.

Native bridge validation works by interacting with real Editor or Rust engine boundaries. You drive tests through the NativeBridge surface and assert on observable state or emitted payloads, avoiding global stubs and parallel-world harnesses for accurate boundary verification.