# How to run the tests

This guide shows how to run and read Turbo Rust's test suite. It assumes you have a checkout and Go 1.26 or later.

## The whole suite

```bash
make test
```

That is the single documented command. It runs `cargo test` across every package.

## Variants

**See each test by name:**

```bash
make test-verbose
```

**Measure coverage per package:**

```bash
make cover
```

**One package only:**

```bash
go test ./internal/buffer/
```

**Without starting a language server.** One test in `internal/lsp` starts a real `rust-analyzer` when it finds one. To skip it:

```bash
go test -short ./...
```

**With the race detector.** The LSP client is concurrent, so this is worth running before touching it:

```bash
go test -race ./internal/lsp/
```

**Everything a commit should pass:**

```bash
make check
```

This runs `go fmt`, `go vet` and the tests, in that order.

## What the suite covers

No test needs a real terminal. The widgets and the editor are drawn onto tcell's `SimulationScreen` — a real `Screen` that draws into memory — so the assertions are made on the picture a terminal would actually show. The LSP client is driven against a language server running in the same process, over an in-memory pipe.

The one exception is `TestAgainstRealGopls`, which starts the real thing. It **skips itself** when `rust-analyzer` is not installed, so a checkout without one still has a green suite.

## Testing against an unreleased turbo-core

Most of Turbo Rust is turbo-core, and this repository depends on it by version, from the module proxy:

```
require rickub.com/turbo-editors/turbo-core v0.2.0
```

A change made in a turbo-core checkout beside this one is therefore invisible here until it is published. To test it before that, make a workspace:

```bash
go work init . ../turbo-core
make test
```

Every import of the library now resolves to that checkout. Nothing in `go.mod` or `go.sum` changes, so there is no edit to undo. Check it took effect — this is the mistake worth guarding against, because everything still builds and still passes if it did not:

```bash
go list -f '{{.Dir}}' rickub.com/turbo-editors/turbo-core/app
```

The answer should be your checkout, not a path under `pkg/mod`. When you are done, `rm go.work go.work.sum`; it is gitignored, so it cannot be committed by accident.

## Code quality

The test suite is not the whole gate. Quality is measured separately:

```bash
python3 ~/.claude/skills/quality/scripts/quality_report.py --workspace .
```

It writes a report under `.quality/` and exits non-zero if the gate fails.

## See also

- Why the tests are shaped this way: [Architecture](../explanation/architecture.md)
- Every make target: [command line reference](../reference/cli.md)