# C# /.NET Tests

Use writing-csharp for toolchain commands. Follow the project's xUnit, NUnit, or
MSTest style.

- Iterate on the nearest test project; run the containing solution when the change crosses projects or no test project is obvious.
- Async tests return `async Task`; never `async void`.
- ASP.NET Core: use the project's existing host or `WebApplicationFactory` harness before adding one.
- EF-backed code: test through the real persistence seam (SQLite in-memory or a test container) instead of mocking LINQ providers.
- Cover nullability, cancellation, and permission paths when the code handles them.
- Replace sleeps with deterministic synchronization, a controllable `TimeProvider`, or polling with a hard timeout.

# Go Tests

Use writing-go for toolchain commands.

## Patterns

- Table-driven tests with a descriptive `name` and `t.Run(tc.name, ...)`; split large or unrelated matrices.
- With testify, `require` for preconditions that must stop the test, `assert` for independent checks. Check errors before dereferencing results.
- `mock.Anything` only for contexts, loggers, and true don't-care values. Use mockery only if the repo already does.
- Setup that needs many mocks or globals is a design smell to report, not to paper over.

## Speed

- Package-list mode (`go test ./pkg/...`) caches passing results; bare `go test` does not. Avoid `-count=1` unless you are chasing a flake or side effect. `-run`, `-short`, `-parallel`, `-failfast`, `-timeout`, and `-v` stay cacheable.
- Tests that read env vars or module files miss the cache when those change.
- `t.Parallel()` only with isolated state. `t.Setenv` is process-wide and panics under parallel tests or parallel ancestors.
- Tune `-parallel` only after measuring; above CPU count it often slows down.
- Replace sleeps with channels, contexts, fake clocks, or `testing/synctest` when the module's Go version supports it.
- Gate real databases, networks, and containers behind `testing.Short()` or build tags.
- `-race`, coverage profiles, and benchmarks are separate tiers, not the edit loop. Race failures are blocking.

# Java and Kotlin Tests

Use writing-java-kotlin for toolchain commands. Identify the framework (JUnit 5,
JUnit 4, TestNG, Kotest), assertion library, and mock library from nearby tests.

- Filter to one module and class in the edit loop (`:module:test --tests`, `-pl module -Dtest=`); run the full build only at the end or for cross-module changes.
- No full `@SpringBootTest` for pure logic. Use a slice (`@WebMvcTest`, `@DataJpaTest`) or no context.
- Testcontainers, real databases, and browser tests belong in a separate Gradle or Maven profile.
- Coroutines: `runTest` with a test scheduler; not `runBlocking` in new tests.
- Do not mix Mockito and MockK in one test class. `verify` only side effects that matter; no `any()` on business-critical arguments.
- `@ParameterizedTest`/`@MethodSource` or Kotest `forAll` for case matrices; AssertJ-style `assertThat` for clearer failures.
- Shared static caches or singleton state across tests cause flakes; reset or isolate them.

# Python Tests

Use writing-python for toolchain commands. Read `conftest.py` before changing
fixtures.

## Patterns

- `@pytest.mark.parametrize` with readable IDs (`pytest.param(..., id="empty-input")`).
- Fixture scope as narrow as correctness needs. Reuse fixtures to hide noise, not behavior.
- Patch where the object is used, not where it is defined. Use `autospec`/`create_autospec` on important boundaries and `AsyncMock` for async.
- Test async code through its async public behavior with the project's configured async plugin.
- Import errors and collection failures are blocking.

## Speed

- Find the bottleneck with `--durations=20 --durations-min=0.5`; when collection dominates, `python -X importtime -m pytest --collect-only`.
- `pytest-cov` instruments every line; run it only for coverage work.
- `pytest-xdist` only if configured or approved. Start with `-n auto --dist worksteal` for uneven durations; `loadscope`/`loadfile`/`loadgroup` only when grouped fixtures save more than the imbalance costs. More workers do not fix time spent waiting on sleeps or I/O.
- Key shared real resources (ports, databases, tmux sessions, fixed filenames, queues) by `PYTEST_XDIST_WORKER`.
- Replace `time.sleep`/`asyncio.sleep` with poll-until-condition helpers (small interval, hard timeout), or freeze time with the project's clock tool. Lower test-only timeouts so failure paths are fast too.
- Session or module fixtures only for immutable setup; for costly mutable artifacts (git repos, populated databases), build once and copy per test.
- Move heavy import-time work into fixtures. New pytest config: explicit `testpaths` and `--import-mode=importlib`.
- Stub expensive autouse behavior in unit tests; opt in to the real thing where it is under test.
- Mark slow tiers (`integration`, `e2e`, `live`, `llm`) and keep the default command on the fast tier. Use `--last-failed` in the edit loop.
- Mature suites can add a hook that fails non-slow tests above an env-tunable wall-time ceiling.

# Rust Tests

Use writing-rust for toolchain commands.

- Unit tests in `#[cfg(test)] mod tests` for private logic worth covering; `tests/*.rs` for public crate or CLI behavior; doctests for copyable public examples.
- nextest (when the project uses it) does not run doctests; add `cargo test --doc`.
- Filter by package and test name in the edit loop; keep full workspace runs, coverage, Miri, and benchmarks as separate tiers. Never `cargo clean` as a routine step.
- Assert error variants or messages only when callers depend on them.
- Prefer small fakes behind local traits over mock frameworks. Add crates such as `assert_cmd`, `tempfile`, `insta`, `proptest`, `mockall`, or `wiremock` only when already used or justified.
- Async tests use the project's macro (`#[tokio::test]`); no blocking mutex guard across `.await`; channels, barriers, or paused time instead of sleeps.
- Normalize volatile snapshot output (paths, timestamps, ordering).
- For unsafe or concurrency-sensitive code, run configured Miri, loom, or sanitizers and report when unavailable.

# TypeScript and JavaScript Tests

Use writing-typescript for toolchain commands and the project's runner.

## Patterns

- `it.each`/`test.each` with object cases for multi-field inputs.
- React: test user-visible behavior with Testing Library. Query by role, then label, then text; test ID last. Prefer `user-event`; use async queries for async state. Cover loading, error, empty, and permission states that matter.
- Snapshots only for complex, stable output.
- Network: MSW or the project's HTTP fakes. Type mocks (`vi.mocked()`) so contract drift fails to compile. Restore mocks per project convention.

## Speed

- Use the runner's related or changed-file mode in the edit loop.
- Coverage and Jest `--detectOpenHandles` (which forces serial execution) are diagnostics, not the default loop.
- Tune worker count by measurement: transform cost, memory, DOM environments, and database limits often make fewer workers faster.
- Disable per-file isolation only when tests clean their globals. Never trade determinism for speed.
- When the runner reports transform, import, setup, or environment time, cut the largest bucket first. Keep global setup and preloads minimal; they run for every focused test.
- Explicit test roots and ignores, so discovery skips build output, fixtures, vendor trees, and e2e suites.
- Pure logic runs in the Node environment, not a DOM one. Scope DOM environments to the files that need them; do not swap DOM implementations unless the project accepts the fidelity loss.
- Fake timers or poll-until-condition helpers instead of sleeps. Reset only the timers, mocks, and modules a test changed; blanket resets dominate tiny tests.

# Browser and HTMX Tests

Use browser-automation for running flows interactively. If Playwright is not
configured, say so instead of guessing.

- `playwright test --list` is safe discovery; run browser tests only when needed. An empty list means no coverage, not unknown coverage.
- Locators: `getByRole`, then `getByLabel`, then `getByText`; `getByTestId` only when semantics cannot express it. No XPath, deep CSS, or generated IDs.
- Playwright auto-waits: assert with `expect(locator).toBeVisible()` instead of fixed timeouts.
- One user-visible flow per test. Delete page-load smoke tests once flow tests cover the page.
- HTMX: assert the swapped, added, or removed element, not internal events.
- Route-mock external services instead of calling them.
- Classify failures as locator, timing, app behavior, test logic, or environment.