tempest-cli 0.5.1__tar.gz → 0.6.0__tar.gz

{tempest_cli-0.5.1 → tempest_cli-0.6.0}/CHANGELOG.md

@@ -5,6 +5,28 @@ All notable changes to **tempest-cli** are listed below.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [0.6.0] — 2026-10-20
+
+### Changed
+
+- **`test` and `check` run the suite in parallel by default.** The
+  pytest-xdist run that needed `--fast` (`-n auto -p no:cacheprovider`) is
+  now what a bare `tempest-cli test` does; `--serial` opts out (for
+  `--lf` / `--ff`, or a debugger), and `--workers` tunes the default
+  without a flag. Measured on a FastAPI service suite of 1136 tests on a
+  12-CPU machine: 262 s serially, 37.6 s in parallel, same outcome.
+- **Without pytest-xdist the default degrades instead of failing.** When
+  the environment pytest runs in cannot import it, a bare `test` / `check`
+  prints a one-line notice naming the install command and runs the suite
+  serially (exit code is pytest's); an explicit `--fast` keeps the old
+  behavior — the fix is printed and the exit code is 127, nothing runs.
+  `run_pytest` / `run_full_check` take `require_xdist=` (default `True`,
+  the old library behavior) to pick between the two.
+- `--workers` with `--serial` is a usage error (exit 2), as `--workers`
+  without `--fast` used to be.
+
 ## [0.5.1] — 2026-10-15
 
 ### Fixed

{tempest_cli-0.5.1 → tempest_cli-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tempest-cli
-Version: 0.5.1
+Version: 0.6.0
 Summary: Framework-agnostic quality gate for Python projects: ruff + mypy + pytest behind one command, with a typing-strictness dial and a PR-description prompt generator.
 Project-URL: Homepage, https://github.com/mauriciobenjamin700/tempest-cli
 Project-URL: Repository, https://github.com/mauriciobenjamin700/tempest-cli
@@ -74,8 +74,8 @@ remembered to pass.
 | `tempest-cli format` | `ruff format` (writes) |
 | `tempest-cli fmt-check` | `ruff format --check` (read-only) |
 | `tempest-cli type` | `mypy` |
-| `tempest-cli test` | `pytest` (`--fast` spreads it across cores with pytest-xdist: `-n auto -p no:cacheprovider`, `-w N` to choose) |
-| `tempest-cli check` | all four, in order, stopping at the first failure (`--fast` runs the test step in parallel; a host CLI can add steps between `mypy` and `pytest`) |
+| `tempest-cli test` | `pytest`, in parallel by default with pytest-xdist (`-n auto -p no:cacheprovider`, `-w N` to choose; serial with a notice when it is not installed; `--serial` opts out) |
+| `tempest-cli check` | all four, in order, stopping at the first failure (the test step in parallel as in `test`; a host CLI can add steps between `mypy` and `pytest`) |
 | `tempest-cli pr-prompt` | builds the prompt that makes an AI write this branch's PR description |
 
 Every command takes an optional path (`tempest-cli lint src/`) and
@@ -188,7 +188,8 @@ your suite. Add them yourself, or take the bundle:
 uv add --dev "tempest-cli[tools]"   # mypy + pytest + pytest-xdist
 ```
 
-`pytest-xdist` is what `test --fast` runs the suite with; its
+`pytest-xdist` is what `test` runs the suite in parallel with, by
+default (without it the suite runs serially, with a notice); its
 `requires-dist` (`execnet>=2.1`, `pytest>=7.0.0`) carries no upper bound.
 
 Whatever you pin wins over the bundled ruff. The lookup runs in this

{tempest_cli-0.5.1 → tempest_cli-0.6.0}/README.md

@@ -42,8 +42,8 @@ remembered to pass.
 | `tempest-cli format` | `ruff format` (writes) |
 | `tempest-cli fmt-check` | `ruff format --check` (read-only) |
 | `tempest-cli type` | `mypy` |
-| `tempest-cli test` | `pytest` (`--fast` spreads it across cores with pytest-xdist: `-n auto -p no:cacheprovider`, `-w N` to choose) |
-| `tempest-cli check` | all four, in order, stopping at the first failure (`--fast` runs the test step in parallel; a host CLI can add steps between `mypy` and `pytest`) |
+| `tempest-cli test` | `pytest`, in parallel by default with pytest-xdist (`-n auto -p no:cacheprovider`, `-w N` to choose; serial with a notice when it is not installed; `--serial` opts out) |
+| `tempest-cli check` | all four, in order, stopping at the first failure (the test step in parallel as in `test`; a host CLI can add steps between `mypy` and `pytest`) |
 | `tempest-cli pr-prompt` | builds the prompt that makes an AI write this branch's PR description |
 
 Every command takes an optional path (`tempest-cli lint src/`) and
@@ -156,7 +156,8 @@ your suite. Add them yourself, or take the bundle:
 uv add --dev "tempest-cli[tools]"   # mypy + pytest + pytest-xdist
 ```
 
-`pytest-xdist` is what `test --fast` runs the suite with; its
+`pytest-xdist` is what `test` runs the suite in parallel with, by
+default (without it the suite runs serially, with a notice); its
 `requires-dist` (`execnet>=2.1`, `pytest>=7.0.0`) carries no upper bound.
 
 Whatever you pin wins over the bundled ruff. The lookup runs in this

{tempest_cli-0.5.1 → tempest_cli-0.6.0}/docs/changelog.en.md

@@ -3,6 +3,21 @@
 The full history lives in the repository's
 [`CHANGELOG.md`](https://github.com/mauriciobenjamin700/tempest-cli/blob/main/CHANGELOG.md).
 
+## [0.6.0] — 2026-10-20
+
+### Changed
+
+- **`test` and `check` run the suite in parallel by default.** The
+  pytest-xdist `-n auto` run that needed `--fast` is now what a bare
+  `test` does; `--serial` opts out (for `--lf` / `--ff`, or a debugger).
+  Measured on a FastAPI suite of 1136 tests on 12 CPUs: 262 s serially,
+  37.6 s in parallel, same outcome.
+  [Details](commands.md#the-suite-in-parallel-the-default).
+- **Without pytest-xdist the default degrades to serial instead of
+  failing**, with a notice naming the install command; only an explicit
+  `--fast` still requires the plugin (exit code 127).
+- `--workers` with `--serial` is a usage error (exit code 2).
+
 ## [0.5.1] — 2026-10-15
 
 ### Fixed
@@ -46,7 +61,7 @@ The full history lives in the repository's
   the default — or `logical`) and is a usage error without `--fast`. The
   target is forwarded and pytest's exit code comes back untranslated. It
   is a flag, not a subcommand, because `test fast` keeps meaning the
-  `fast/` folder. [Details](commands.md#the-suite-in-parallel-fast).
+  `fast/` folder. [Details](commands.md#the-suite-in-parallel-the-default).
 - **A missing pytest-xdist is a sentence, not `unrecognized arguments:
   -n`.** `--fast` asks the interpreter that will run pytest whether it
   can import `xdist`; when it cannot, the message names the package and

{tempest_cli-0.5.1 → tempest_cli-0.6.0}/docs/changelog.md

@@ -4,6 +4,21 @@ O histórico completo vive no
 [`CHANGELOG.md`](https://github.com/mauriciobenjamin700/tempest-cli/blob/main/CHANGELOG.md)
 do repositório.
 
+## [0.6.0] — 2026-10-20
+
+### Alterado
+
+- **O `test` e o `check` rodam a suíte em paralelo por padrão.** O
+  `-n auto` do pytest-xdist, que pedia `--fast`, agora é o que um
+  `test` puro faz; `--serial` desliga (para `--lf` / `--ff` ou depurador).
+  Medido numa suíte FastAPI de 1136 testes em 12 CPUs: 262 s em série,
+  37,6 s em paralelo, mesmo resultado.
+  [Detalhes](commands.md#a-suite-em-paralelo-o-padrao).
+- **Sem o pytest-xdist, o padrão cai para série em vez de falhar**, com um
+  aviso de como instalar; só o `--fast` explícito continua exigindo o
+  plugin (código de saída 127).
+- `--workers` com `--serial` é erro de uso (código de saída 2).
+
 ## [0.5.1] — 2026-10-15
 
 ### Corrigido
@@ -45,7 +60,7 @@ do repositório.
   o padrão — ou `logical`) e é erro de uso sem `--fast`. O alvo é
   repassado e o código de saída do pytest volta sem tradução. É flag, e
   não subcomando, porque `test fast` continua significando a pasta
-  `fast/`. [Detalhes](commands.md#a-suite-em-paralelo-fast).
+  `fast/`. [Detalhes](commands.md#a-suite-em-paralelo-o-padrao).
 - **pytest-xdist ausente vira frase, não `unrecognized arguments: -n`.**
   O `--fast` pergunta ao interpretador que vai rodar o pytest se ele
   importa o `xdist`; faltando, a mensagem nomeia o pacote e os extras

{tempest_cli-0.5.1 → tempest_cli-0.6.0}/docs/commands.en.md

@@ -181,76 +181,93 @@ tempest-cli test tests/unit
 `test` forwards the path to pytest as a filter; with no argument it runs
 the whole suite.
 
-## The suite in parallel: `--fast`
+## The suite in parallel (the default)
 
 A suite whose tests are already isolated (a database per test, no global
-state) pays the serial time and buys nothing for it. `--fast` spreads the
-suite across the cores with
-[pytest-xdist](https://pytest-xdist.readthedocs.io/):
+state) pays the serial time and buys nothing for it. That is why `test`
+and `check` spread the suite across cores with
+[pytest-xdist](https://pytest-xdist.readthedocs.io/) **without being
+asked**:
 
 ```bash
-tempest-cli test --fast              # -n auto: one worker per core
-tempest-cli test --fast -w 4         # four workers
-tempest-cli test tests/unit --fast   # the target is still forwarded
-tempest-cli check --fast             # the full gate, with the test step in parallel
+tempest-cli test                     # -n auto: one worker per core
+tempest-cli test -w 4                # four workers
+tempest-cli test tests/unit          # the target is still forwarded
+tempest-cli check                    # the full gate, with the test step in parallel
+tempest-cli test --serial            # a single process (for --lf / --ff, or a debugger)
 ```
 
 Underneath it becomes `pytest -n <workers> -p no:cacheprovider [target]`.
 `-p no:cacheprovider` is there because several workers writing
 `.pytest_cache` at once is a race that buys nothing — and that cache is
-what `--lf` / `--ff` read, so those two remain a serial-run affair.
+what `--lf` / `--ff` read, so those two are a `--serial` affair.
+
+On a FastAPI service suite of 1136 tests (an in-memory SQLite database
+per test), on a 12-CPU machine: **262 s** serially, **37.6 s** with
+`-n auto` — same outcome, 1136 passed.
 
 `--workers` (`-w`) takes what `pytest -n` takes: an integer, `auto` (the
-default) or `logical`. Without `--fast` it is a usage error (exit 2)
+default) or `logical`. With `--serial` it is a usage error (exit 2)
 instead of being silently ignored.
 
 !!! info "`auto` counts physical cores when `psutil` is installed"
     pytest-xdist decides: with `psutil` importable, `auto` is the number of
-    **physical** cores; without it, the number of logical CPUs. On a machine
-    with 6 cores and 12 threads, with `psutil` in the environment, `auto`
-    started `created: 6/6 workers`. Want the 12 threads? `-w logical` or
+    **physical** cores; without it, the number of logical CPUs. On a
+    6-core, 12-thread machine with `psutil` in the environment, `auto`
+    reported `created: 6/6 workers`. Want the 12 threads? `-w logical` or
     `-w 12`.
 
-!!! note "Why a flag, not `tempest-cli test fast`"
-    `test` already takes a positional path. `test fast` keeps meaning
-    "run pytest on the `fast/` folder" — a subcommand by that name would
-    break anyone who has one.
+!!! note "Why a flag, and not `tempest-cli test serial`"
+    `test` already takes a positional path. `test fast` keeps meaning "run
+    pytest on the `fast/` folder" — a subcommand by that name would break
+    anyone who has that folder.
 
 ### Without pytest-xdist
 
 Before running anything, the CLI asks **the very interpreter that will
 run pytest** whether it can import `xdist` — not the CLI's own
-interpreter, which under `uv tool install` or pipx lives in a different
-environment. When it is missing, the message names what to install and
-the exit code is **127**, with no traceback:
-
-```console
-$ tempest-cli test --fast
-error: --fast needs pytest-xdist, which is not installed in the environment pytest runs in (.venv/bin/pytest). Install it with 'uv add --dev pytest-xdist' — or a bundle that carries it, 'uv add --dev "tempest-cli[tools]"' or 'uv add --dev "tempest-fastapi-sdk[tests]"' — and retry, or drop --fast to run the suite serially.
-$ echo $?
-127
-```
+interpreter, which under `uv tool install` or pipx lives in another
+environment. When it is missing, it depends on who asked for parallel:
+
+- **Nobody (the default):** the suite runs serially, with a notice on
+  stderr naming what to install. `tempest-cli test` keeps working in a
+  project that never installed pytest-xdist — it is just slower.
+
+    ```console
+    $ tempest-cli test
+    note: pytest-xdist is not installed in the environment pytest runs in (.venv/bin/pytest), so the suite runs serially. Install it with 'uv add --dev pytest-xdist' — or a bundle that carries it, 'uv add --dev "tempest-cli[tools]"' or 'uv add --dev "tempest-fastapi-sdk[tests]"' — to run it in parallel.
+    ```
+
+- **`--fast` by name:** parallel becomes a requirement. The message names
+  what to install and the exit code is **127**, with nothing run:
+
+    ```console
+    $ tempest-cli test --fast
+    error: --fast needs pytest-xdist, which is not installed in the environment pytest runs in (.venv/bin/pytest). Install it with 'uv add --dev pytest-xdist' — or a bundle that carries it, 'uv add --dev "tempest-cli[tools]"' or 'uv add --dev "tempest-fastapi-sdk[tests]"' — and retry, or pass --serial to run the suite serially.
+    $ echo $?
+    127
+    ```
 
-Under `check --fast` the check happens **before** the first step: there
-is no point waiting for lint and mypy to finish to learn the tests will
-not run.
+Under `check` the probe happens **before** the first step: with `--fast`
+there is no point waiting for lint and mypy to finish only to learn the
+tests will not run.
 
 ### A test that fails only in parallel
 
-Parallelism exposes tests that depend on order or on an idle machine:
-two tests writing the same file, the same port, a module-level global, a
-fixed `sleep` waiting for something that takes longer once every core is
+Parallelism exposes tests that depend on order or on an idle machine: two
+tests writing the same file, the same port, a module-level global, a
+fixed `sleep` waiting for something that takes longer with every core
 busy. Before treating the failure as a regression, run the test **alone
 and serially**:
 
 ```bash
-tempest-cli test "tests/test_scheduler.py::test_lease_expires"
+tempest-cli test --serial "tests/test_scheduler.py::test_lease_expires"
 ```
 
-- **It passes alone**: the defect is the test's isolation, not the change
+- **Passes alone**: the defect is the test's isolation, not the change
   under review. Fix the test (a file under `tmp_path`, a free port, wait
-  on a condition instead of a `sleep`).
-- **It fails alone too**: it is a real regression.
+  on a condition instead of `sleep`).
+- **Fails alone too**: it is a real regression.
 
 ## What each returns
 
@@ -265,8 +282,9 @@ of the places the CLI looks — the run's environment, `PATH`, `uv run
 --with` — and the message then names what was missing and how to install
 it. The lookup order is in
 [Installation](installation.md#where-ruff-mypy-and-pytest-come-from).
-The same 127 comes out of `--fast` when pytest-xdist is not in pytest's
-environment.
+The same 127 comes out of an explicit `--fast` when pytest-xdist is not in
+pytest's environment; without the flag, its absence only makes the suite
+serial.
 
 ## Recap
 
@@ -276,8 +294,10 @@ environment.
 - Long comments and strings `fix` shortens on its own, with the AST
   proven equal. An E501 left after it has no mechanical rewrite: `fix`
   names the token and the action — change the code's shape.
-- `test --fast` / `check --fast` run the suite with pytest-xdist
-  (`-n auto`, `-w N` to choose); a test that fails only in parallel is
-  checked by running it alone.
+- `test` and `check` run the suite in parallel by default, with
+  pytest-xdist (`-n auto`, `-w N` to choose); `--serial` turns it off.
+  Without pytest-xdist the default falls back to serial with a notice,
+  and an explicit `--fast` becomes exit 127. A test that fails only in
+  parallel is checked by running it alone, with `--serial`.
 - Exit codes are the tools'; 127 means a missing tool (or the
-  pytest-xdist `--fast` needs).
+  pytest-xdist an explicit `--fast` requires).

{tempest_cli-0.5.1 → tempest_cli-0.6.0}/docs/commands.md

@@ -181,28 +181,33 @@ tempest-cli test tests/unit
 `test` repassa o caminho ao pytest como filtro; sem argumento, roda a
 suíte inteira.
 
-## A suíte em paralelo: `--fast`
+## A suíte em paralelo (o padrão)
 
 Suíte cujos testes já são isolados (banco por teste, nada de estado
-global) paga o tempo serial sem comprar nada. `--fast` espalha a suíte
-pelos núcleos com o [pytest-xdist](https://pytest-xdist.readthedocs.io/):
+global) paga o tempo serial sem comprar nada. Por isso `test` e `check`
+espalham a suíte pelos núcleos com o
+[pytest-xdist](https://pytest-xdist.readthedocs.io/) **sem você pedir**:
 
 ```bash
-tempest-cli test --fast              # -n auto: um worker por núcleo
-tempest-cli test --fast -w 4         # quatro workers
-tempest-cli test tests/unit --fast   # o alvo continua sendo repassado
-tempest-cli check --fast             # o gate completo, com o passo de teste em paralelo
+tempest-cli test                     # -n auto: um worker por núcleo
+tempest-cli test -w 4                # quatro workers
+tempest-cli test tests/unit          # o alvo continua sendo repassado
+tempest-cli check                    # o gate completo, com o passo de teste em paralelo
+tempest-cli test --serial            # um processo só (para --lf / --ff, ou depurar)
 ```
 
 Por baixo, vira `pytest -n <workers> -p no:cacheprovider [alvo]`. O
 `-p no:cacheprovider` existe porque vários workers escrevendo
 `.pytest_cache` ao mesmo tempo é corrida à toa — e é esse cache que o
-`--lf` / `--ff` leem, então esses dois continuam sendo coisa de execução
-serial.
+`--lf` / `--ff` leem, então esses dois são coisa de `--serial`.
+
+Numa suíte de serviço FastAPI com 1136 testes (banco SQLite in-memory por
+teste), numa máquina de 12 CPUs: **262 s** em série, **37,6 s** com
+`-n auto` — o mesmo resultado, 1136 passed.
 
 `--workers` (`-w`) aceita o que o `pytest -n` aceita: um inteiro, `auto`
-(o padrão) ou `logical`. Sem `--fast` ele é erro de uso (saída 2), em vez
-de ser ignorado em silêncio.
+(o padrão) ou `logical`. Com `--serial` ele é erro de uso (saída 2), em
+vez de ser ignorado em silêncio.
 
 !!! info "`auto` conta núcleo físico quando o `psutil` está instalado"
     É o pytest-xdist que decide: com `psutil` importável, `auto` é o número
@@ -210,7 +215,7 @@ de ser ignorado em silêncio.
     núcleos e 12 threads, com `psutil` no ambiente, `auto` subiu
     `created: 6/6 workers`. Quer as 12 threads? `-w logical` ou `-w 12`.
 
-!!! note "Por que flag, e não `tempest-cli test fast`"
+!!! note "Por que flag, e não `tempest-cli test serial`"
     `test` já recebe um caminho posicional. `test fast` continua
     significando "rode o pytest na pasta `fast/`" — um subcomando com esse
     nome quebraria quem tem essa pasta.
@@ -220,18 +225,30 @@ de ser ignorado em silêncio.
 Antes de rodar qualquer coisa, a CLI pergunta ao **mesmo interpretador
 que vai rodar o pytest** se ele importa o `xdist` — não ao interpretador
 da própria CLI, que sob `uv tool install` ou pipx mora em outro ambiente.
-Faltou, a mensagem diz o que instalar e a saída é **127**, sem traceback:
+Faltou, depende de quem pediu o paralelismo:
 
-```console
-$ tempest-cli test --fast
-error: --fast needs pytest-xdist, which is not installed in the environment pytest runs in (.venv/bin/pytest). Install it with 'uv add --dev pytest-xdist' — or a bundle that carries it, 'uv add --dev "tempest-cli[tools]"' or 'uv add --dev "tempest-fastapi-sdk[tests]"' — and retry, or drop --fast to run the suite serially.
-$ echo $?
-127
-```
+- **Ninguém pediu (o padrão):** a suíte roda em série, com um aviso no
+  stderr dizendo o que instalar. `tempest-cli test` continua funcionando
+  em projeto que nunca instalou o pytest-xdist — só fica mais lento.
+
+    ```console
+    $ tempest-cli test
+    note: pytest-xdist is not installed in the environment pytest runs in (.venv/bin/pytest), so the suite runs serially. Install it with 'uv add --dev pytest-xdist' — or a bundle that carries it, 'uv add --dev "tempest-cli[tools]"' or 'uv add --dev "tempest-fastapi-sdk[tests]"' — to run it in parallel.
+    ```
+
+- **`--fast` explícito:** o paralelismo vira exigência. A mensagem diz o
+  que instalar e a saída é **127**, sem rodar nada:
+
+    ```console
+    $ tempest-cli test --fast
+    error: --fast needs pytest-xdist, which is not installed in the environment pytest runs in (.venv/bin/pytest). Install it with 'uv add --dev pytest-xdist' — or a bundle that carries it, 'uv add --dev "tempest-cli[tools]"' or 'uv add --dev "tempest-fastapi-sdk[tests]"' — and retry, or pass --serial to run the suite serially.
+    $ echo $?
+    127
+    ```
 
-No `check --fast` essa checagem acontece **antes** do primeiro passo:
-não adianta esperar lint e mypy terminarem para descobrir que o teste
-não vai rodar.
+No `check` essa checagem acontece **antes** do primeiro passo: com
+`--fast`, não adianta esperar lint e mypy terminarem para descobrir que o
+teste não vai rodar.
 
 ### Teste que só falha em paralelo
 
@@ -242,7 +259,7 @@ demora mais. Antes de tratar a falha como regressão, rode o teste
 **sozinho e em série**:
 
 ```bash
-tempest-cli test "tests/test_scheduler.py::test_lease_expires"
+tempest-cli test --serial "tests/test_scheduler.py::test_lease_expires"
 ```
 
 - **Passou sozinho**: o defeito é o isolamento do teste, não a mudança
@@ -262,8 +279,8 @@ Só há um código próprio: **127**, quando a ferramenta não está em nenhum
 dos lugares onde a CLI procura — ambiente da execução, `PATH`, `uv run
 --with` — e aí a mensagem diz qual faltou e como instalá-la. A ordem de
 busca está em [Instalação](installation.md#de-onde-vem-o-ruff-o-mypy-e-o-pytest).
-O mesmo 127 sai do `--fast` quando o pytest-xdist não está no ambiente do
-pytest.
+O mesmo 127 sai do `--fast` explícito quando o pytest-xdist não está no
+ambiente do pytest; sem a flag, a falta dele só deixa a suíte em série.
 
 ## Recap
 
@@ -273,8 +290,10 @@ pytest.
 - Comentário e string longos o `fix` encurta sozinho, com a AST provada
   igual. O E501 que sobra é linha sem reescrita mecânica: o `fix` diz o
   token e a ação — mude a forma do código.
-- `test --fast` / `check --fast` rodam a suíte com pytest-xdist
-  (`-n auto`, `-w N` para escolher); teste que só falha em paralelo se
-  confere rodando-o sozinho.
+- `test` e `check` rodam a suíte em paralelo por padrão, com pytest-xdist
+  (`-n auto`, `-w N` para escolher); `--serial` desliga. Sem o
+  pytest-xdist, o padrão cai para série com um aviso, e o `--fast`
+  explícito vira erro 127. Teste que só falha em paralelo se confere
+  rodando-o sozinho, com `--serial`.
 - Código de saída é o da ferramenta; 127 significa ferramenta (ou o
-  pytest-xdist do `--fast`) ausente.
+  pytest-xdist que o `--fast` exige) ausente.

{tempest_cli-0.5.1 → tempest_cli-0.6.0}/docs/installation.en.md

@@ -45,8 +45,9 @@ take the bundle:
 uv add --dev "tempest-cli[tools]"   # mypy + pytest + pytest-xdist
 ```
 
-`pytest-xdist` is what [`test --fast`](commands.md#the-suite-in-parallel-fast)
-uses to run the suite in parallel. Its `requires-dist` (`execnet>=2.1`,
+`pytest-xdist` is what [`test`](commands.md#the-suite-in-parallel-the-default)
+uses to run the suite in parallel, the default; without it the suite runs
+serially, with a notice. Its `requires-dist` (`execnet>=2.1`,
 `pytest>=7.0.0`) carries no upper bound, so it tightens nobody's
 resolution.
 

{tempest_cli-0.5.1 → tempest_cli-0.6.0}/docs/installation.md

@@ -46,8 +46,9 @@ mesmo, ou pegue o pacote pronto:
 uv add --dev "tempest-cli[tools]"   # mypy + pytest + pytest-xdist
 ```
 
-O `pytest-xdist` é o que o [`test --fast`](commands.md#a-suite-em-paralelo-fast)
-usa para rodar a suíte em paralelo. O `requires-dist` dele
+O `pytest-xdist` é o que o [`test`](commands.md#a-suite-em-paralelo-o-padrao)
+usa para rodar a suíte em paralelo, o padrão; sem ele a suíte roda em
+série, com um aviso. O `requires-dist` dele
 (`execnet>=2.1`, `pytest>=7.0.0`) não tem teto nenhum, então ele não
 aperta a resolução de ninguém.
 

{tempest_cli-0.5.1 → tempest_cli-0.6.0}/docs/library.en.md

@@ -30,7 +30,8 @@ run_ruff_fix("src", unsafe=False, config=strict)
 run_ruff_format("src", check=True)        # --check: writes nothing
 run_mypy("src", config=strict)
 run_pytest("tests/unit")
-run_pytest("tests/unit", fast=True, workers="4")   # pytest-xdist: -n 4
+run_pytest("tests/unit", fast=True, workers="4")   # pytest-xdist: -n 4; without it, 127
+run_pytest("tests", fast=True, require_xdist=False)  # without pytest-xdist: serial, with a notice
 ```
 
 `load_tempest_config(start)` walks up from `start` (the cwd by default)
@@ -135,7 +136,7 @@ The order is `ruff check` → `ruff format --check` → `mypy` → the extra
 steps, in list order → `pytest`. An extra step is a static check: it
 sits before the suite so it fails in a second, not after it. The
 contract is the built-in steps' — the first non-zero code stops the gate
-and becomes `check`'s exit code, with or without `--fast`.
+and becomes `check`'s exit code, in parallel or with `--serial`.
 
 !!! tip "The message is yours"
     `check` only echoes the name. What the step prints is what the user

{tempest_cli-0.5.1 → tempest_cli-0.6.0}/docs/library.md

@@ -31,7 +31,8 @@ run_ruff_fix("src", unsafe=False, config=strict)
 run_ruff_format("src", check=True)        # --check: não escreve
 run_mypy("src", config=strict)
 run_pytest("tests/unit")
-run_pytest("tests/unit", fast=True, workers="4")   # pytest-xdist: -n 4
+run_pytest("tests/unit", fast=True, workers="4")   # pytest-xdist: -n 4; sem ele, 127
+run_pytest("tests", fast=True, require_xdist=False)  # sem pytest-xdist: série, com aviso
 ```
 
 `load_tempest_config(start)` procura o `pyproject.toml` mais próximo
@@ -136,7 +137,7 @@ A ordem é `ruff check` → `ruff format --check` → `mypy` → os passos
 extras, na ordem da lista → `pytest`. Passo extra é checagem estática:
 fica antes da suíte para falhar em um segundo, não depois dela. O
 contrato é o dos passos embutidos — o primeiro código diferente de `0`
-para o gate e vira o código de saída do `check`, com ou sem `--fast`.
+para o gate e vira o código de saída do `check`, em paralelo ou com `--serial`.
 
 !!! tip "A mensagem é sua"
     O `check` só ecoa o nome. O que o passo imprime é o que o usuário lê,

{tempest_cli-0.5.1 → tempest_cli-0.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tempest-cli"
-version = "0.5.1"
+version = "0.6.0"
 description = "Framework-agnostic quality gate for Python projects: ruff + mypy + pytest behind one command, with a typing-strictness dial and a PR-description prompt generator."
 readme = "README.md"
 requires-python = ">=3.11"

{tempest_cli-0.5.1 → tempest_cli-0.6.0}/tempest_cli/__init__.py

@@ -57,7 +57,7 @@ from tempest_cli.pr_prompt import PromptLanguage as PromptLanguage
 from tempest_cli.pr_prompt import generate_pr_prompt as generate_pr_prompt
 from tempest_cli.steps import CheckStep as CheckStep
 
-__version__: str = "0.5.1"
+__version__: str = "0.6.0"
 """Installed package version."""
 
 __all__: list[str] = [

{tempest_cli-0.5.1 → tempest_cli-0.6.0}/tempest_cli/lint.py

@@ -8,6 +8,7 @@ import subprocess
 import sys
 from collections.abc import Callable, Sequence
 from pathlib import Path
+from typing import Literal
 
 import typer
 
@@ -494,41 +495,86 @@ def _module_available(interpreter: list[str], module: str) -> bool | None:
     return None
 
 
-def _missing_xdist_code() -> int:
-    """Check that the environment pytest runs in can import pytest-xdist.
+ParallelDecision = Literal["parallel", "serial", "stop"]
+"""How a requested parallel run proceeds once pytest-xdist was looked for."""
+
+XDIST_INSTALL_HINT = (
+    "'uv add --dev pytest-xdist' — or a bundle that carries it, "
+    "'uv add --dev \"tempest-cli[tools]\"' or "
+    "'uv add --dev \"tempest-fastapi-sdk[tests]\"'"
+)
+"""How to get pytest-xdist, quoted by both the error and the fallback notice."""
+
+
+def _xdist_missing() -> list[str] | None:
+    """Tell whether the environment pytest runs in lacks pytest-xdist.
 
     Without the plugin, ``pytest -n auto`` stops at argument parsing with
     ``unrecognized arguments: -n`` — true, but it names neither the
     missing package nor the way to get it. This preflight answers first,
-    in words.
+    so the caller can say it in words.
 
-    An unknown answer is not a failure: when pytest cannot be resolved
+    An unknown answer is not "missing": when pytest cannot be resolved
     (:func:`_execute` reports that with its own message) or its
     interpreter cannot be told, the run proceeds and pytest speaks.
 
     Returns:
-        int: ``0`` when the plugin is present or its presence cannot be
-        told; :data:`MISSING_TOOL_EXIT_CODE` after printing the fix when
-        it is absent.
+        list[str] | None: The pytest argv prefix when the plugin is
+        known to be absent; ``None`` when it is present or its presence
+        cannot be told.
     """
     argv = resolve_tool("pytest")
     if argv is None:
-        return 0
+        return None
     interpreter = _pytest_interpreter(argv)
     if interpreter is None:
-        return 0
+        return None
     if _module_available(interpreter, XDIST_MODULE) is not False:
-        return 0
+        return None
+    return argv
+
+
+def _parallel_allowed(*, require_xdist: bool) -> ParallelDecision:
+    """Decide how a parallel run proceeds, given whether xdist is present.
+
+    Two policies, picked by ``require_xdist``:
+
+    - **required** (the parallel run was asked for by name, ``--fast``):
+      a missing plugin is an error — the fix is printed and
+      :data:`MISSING_TOOL_EXIT_CODE` comes back, so nothing runs;
+    - **preferred** (parallel is only the default): a missing plugin
+      degrades the run to serial, with a one-line notice on stderr
+      naming the install command. ``tempest test`` keeps working in a
+      project that never installed pytest-xdist, it is just slower.
+
+    Args:
+        require_xdist (bool): Whether a missing plugin is an error.
+
+    Returns:
+        ParallelDecision: ``"parallel"`` when the plugin is there (or its
+        presence cannot be told), ``"serial"`` to fall back, ``"stop"``
+        after printing the fix.
+    """
+    argv = _xdist_missing()
+    if argv is None:
+        return "parallel"
+    where = " ".join(argv)
+    if require_xdist:
+        typer.echo(
+            "error: --fast needs pytest-xdist, which is not installed in the "
+            f"environment pytest runs in ({where}). Install it with "
+            f"{XDIST_INSTALL_HINT} — and retry, or pass --serial to run the "
+            "suite serially.",
+            err=True,
+        )
+        return "stop"
     typer.echo(
-        "error: --fast needs pytest-xdist, which is not installed in the "
-        f"environment pytest runs in ({' '.join(argv)}). Install it with "
-        "'uv add --dev pytest-xdist' — or a bundle that carries it, "
-        "'uv add --dev \"tempest-cli[tools]\"' or "
-        "'uv add --dev \"tempest-fastapi-sdk[tests]\"' — and retry, "
-        "or drop --fast to run the suite serially.",
+        "note: pytest-xdist is not installed in the environment pytest runs "
+        f"in ({where}), so the suite runs serially. Install it with "
+        f"{XDIST_INSTALL_HINT} — to run it in parallel.",
         err=True,
     )
-    return MISSING_TOOL_EXIT_CODE
+    return "serial"
 
 
 def _pytest_args(target: str | None, *, fast: bool, workers: str) -> list[str]:
@@ -555,6 +601,7 @@ def run_pytest(
     *,
     fast: bool = False,
     workers: str = DEFAULT_FAST_WORKERS,
+    require_xdist: bool = True,
 ) -> int:
     """Invoke ``pytest`` with an optional target.
 
@@ -563,8 +610,8 @@ def run_pytest(
     writing ``.pytest_cache`` at once is a race that buys nothing. The
     cache is what ``--lf`` / ``--ff`` read, so those belong to serial
     runs. Before spawning, the interpreter pytest runs under is asked
-    whether it can import pytest-xdist; when it cannot, the fix is
-    printed and nothing runs.
+    whether it can import pytest-xdist; what happens when it cannot is
+    ``require_xdist``'s call (:func:`_parallel_allowed`).
 
     Args:
         target (str | None): Optional pytest path filter. ``None`` runs
@@ -574,16 +621,21 @@ def run_pytest(
         workers (str): Worker count for ``fast`` — an integer, ``auto``
             (one per CPU core: physical when ``psutil`` is importable) or
             ``logical``, exactly as ``pytest -n`` takes it. Ignored when
-            ``fast`` is False.
+            the run is serial.
+        require_xdist (bool): With ``fast``, whether a missing
+            pytest-xdist stops the run (``True``, the default) or degrades
+            it to serial with a notice (``False``, what the CLI passes
+            when parallel is only its default).
 
     Returns:
         int: The pytest exit code, or :data:`MISSING_TOOL_EXIT_CODE` when
-        pytest — or, with ``fast``, pytest-xdist — is absent.
+        pytest — or a required pytest-xdist — is absent.
     """
     if fast:
-        code = _missing_xdist_code()
-        if code != 0:
-            return code
+        decision = _parallel_allowed(require_xdist=require_xdist)
+        if decision == "stop":
+            return MISSING_TOOL_EXIT_CODE
+        fast = decision == "parallel"
     return _execute("pytest", _pytest_args(target, fast=fast, workers=workers))
 
 
@@ -622,6 +674,7 @@ def run_full_check(
     fast: bool = False,
     workers: str = DEFAULT_FAST_WORKERS,
     extra_steps: Sequence[CheckStep] = (),
+    require_xdist: bool = True,
 ) -> int:
     """Run the entire quality gate sequentially.
 
@@ -635,8 +688,9 @@ def run_full_check(
 
     With ``fast=True`` the pytest step runs the way :func:`run_pytest`
     runs it with ``fast=True``. The pytest-xdist preflight happens
-    *before* the first step, so a missing plugin fails in a second
-    instead of after lint and mypy have already run.
+    *before* the first step, so a required plugin that is missing fails
+    in a second instead of after lint and mypy have already run, and a
+    merely preferred one degrades the pytest step to serial up front.
 
     Args:
         target (str): The path inspected by ruff/mypy and handed to every
@@ -651,15 +705,19 @@ def run_full_check(
         extra_steps (Sequence[CheckStep]): Caller-supplied steps run
             after ``mypy`` and before ``pytest``. Empty by default, which
             leaves the gate exactly as it was without them.
+        require_xdist (bool): With ``fast``, whether a missing
+            pytest-xdist stops the gate or degrades the pytest step to
+            serial — as in :func:`run_pytest`.
 
     Returns:
         int: The first non-zero exit code — a tool's or an extra step's —
         or ``0`` when every gate passed.
     """
     if fast:
-        code = _missing_xdist_code()
-        if code != 0:
-            return code
+        decision = _parallel_allowed(require_xdist=require_xdist)
+        if decision == "stop":
+            return MISSING_TOOL_EXIT_CODE
+        fast = decision == "parallel"
     resolved = config or TempestConfig()
     steps: list[tuple[str, Callable[[], int]]] = [
         _tool_step("ruff", ["check", *_ruff_ann_args(resolved), target]),
@@ -679,6 +737,7 @@ def run_full_check(
 __all__: list[str] = [
     "DEFAULT_FAST_WORKERS",
     "MISSING_TOOL_EXIT_CODE",
+    "XDIST_INSTALL_HINT",
     "XDIST_MODULE",
     "resolve_tool",
     "run_full_check",

{tempest_cli-0.5.1 → tempest_cli-0.6.0}/tempest_cli/main.py

@@ -77,7 +77,11 @@ WORKER_KEYWORDS: frozenset[str] = frozenset({"auto", "logical"})
 
 
 def _fast_option() -> typer.models.OptionInfo:
-    """Build a fresh ``--fast`` option.
+    """Build a fresh ``--fast/--serial`` option.
+
+    Parallel is the default. ``--fast`` asks for it by name, which turns a
+    missing pytest-xdist into an error; ``--serial`` opts out (for
+    ``--lf`` / ``--ff``, or a debugger).
 
     Returns:
         typer.models.OptionInfo: The configured option.
@@ -85,11 +89,12 @@ def _fast_option() -> typer.models.OptionInfo:
     return cast(
         "typer.models.OptionInfo",
         typer.Option(
-            "--fast",
+            "--fast/--serial",
             help=(
-                "Run the suite in parallel with pytest-xdist: -n <workers> "
-                "-p no:cacheprovider. Needs pytest-xdist in the environment "
-                "pytest runs in."
+                "Parallel (the default) runs the suite with pytest-xdist: "
+                "-n <workers> -p no:cacheprovider. Without pytest-xdist the "
+                "default falls back to a serial run with a notice; --fast "
+                "makes that an error instead. --serial runs one process."
             ),
         ),
     )
@@ -107,9 +112,9 @@ def _workers_option() -> typer.models.OptionInfo:
             "--workers",
             "-w",
             help=(
-                "Worker count for --fast: a number, 'auto' (the default: one "
-                "per physical core when psutil is installed, per logical CPU "
-                "otherwise) or 'logical'. Requires --fast."
+                "Worker count for a parallel run: a number, 'auto' (the "
+                "default: one per physical core when psutil is installed, per "
+                "logical CPU otherwise) or 'logical'. Not with --serial."
             ),
         ),
     )
@@ -121,19 +126,20 @@ def _resolve_workers(
     fast: bool,
     workers: str,
 ) -> str:
-    """Validate ``--workers`` against ``--fast`` and pytest-xdist's grammar.
+    """Validate ``--workers`` against ``--serial`` and pytest-xdist's grammar.
 
     Args:
         ctx (typer.Context): The command context, used to tell an
             explicit ``--workers`` from its default.
-        fast (bool): The ``--fast`` flag value.
+        fast (bool): The ``--fast/--serial`` value (``False`` is
+            ``--serial``).
         workers (str): The ``--workers`` value.
 
     Returns:
         str: The value to hand to ``pytest -n``.
 
     Raises:
-        typer.BadParameter: When ``--workers`` is given without ``--fast``,
+        typer.BadParameter: When ``--workers`` is given with ``--serial``,
             or is neither a non-negative integer nor ``auto``/``logical``.
     """
     explicit = getattr(ctx.get_parameter_source("workers"), "name", "") == (
@@ -141,7 +147,7 @@ def _resolve_workers(
     )
     if explicit and not fast:
         raise typer.BadParameter(
-            "--workers only applies to a parallel run; add --fast.",
+            "--workers only applies to a parallel run; drop --serial.",
             param_hint="--workers",
         )
     if workers in WORKER_KEYWORDS or workers.isdigit():
@@ -154,6 +160,21 @@ def _resolve_workers(
     )
 
 
+def _require_xdist(ctx: typer.Context) -> bool:
+    """Tell whether the parallel run was asked for by name.
+
+    ``--fast`` on the command line makes a missing pytest-xdist an error;
+    the default (no flag) only prefers parallel and degrades to serial.
+
+    Args:
+        ctx (typer.Context): The command context.
+
+    Returns:
+        bool: ``True`` when ``--fast`` was typed.
+    """
+    return getattr(ctx.get_parameter_source("fast"), "name", "") == "COMMANDLINE"
+
+
 def register_commands(
     app: typer.Typer,
     *,
@@ -166,7 +187,7 @@ def register_commands(
             help text are left untouched; only commands are added.
         extra_steps (Sequence[CheckStep]): Steps the ``check`` command
             runs after ``mypy`` and before ``pytest``, in every variant
-            (``--fast`` included). This is how a framework adds its own
+            (parallel or ``--serial``). This is how a framework adds its own
             rules to the gate without this package knowing about it.
             Empty by default.
 
@@ -286,27 +307,33 @@ def register_commands(
             str | None,
             typer.Argument(help="Optional pytest path filter."),
         ] = None,
-        fast: Annotated[bool, _fast_option()] = False,
+        fast: Annotated[bool, _fast_option()] = True,
         workers: Annotated[str, _workers_option()] = lint_module.DEFAULT_FAST_WORKERS,
     ) -> None:
         """Run ``pytest`` (forwarding the optional path argument).
 
-        --fast spreads the suite across pytest-xdist workers (-n auto
-        unless --workers says otherwise) and turns the cache plugin off,
-        so --lf / --ff belong to serial runs. Without pytest-xdist in the
-        environment pytest runs in, it stops with the install command and
-        exit code 127.
+        The suite runs in parallel by default: pytest-xdist workers (-n
+        auto unless --workers says otherwise), with the cache plugin off,
+        so --lf / --ff belong to --serial runs. Without pytest-xdist in the
+        environment pytest runs in, the default falls back to a serial run
+        and says how to install it; --fast makes that an error (exit code
+        127) instead.
 
-        A test that fails only under --fast shares state with another
+        A test that fails only in parallel shares state with another
         one: a file, a port, a module-level global, a fixed sleep racing
         a busy machine. Before treating it as a regression, rerun it
         alone, serially, with its node id as the target
-        (test tests/test_x.py::test_name). Passing alone means the defect
-        is the test's isolation, not the change under review.
+        (test --serial tests/test_x.py::test_name). Passing alone means the
+        defect is the test's isolation, not the change under review.
         """
         resolved_workers = _resolve_workers(ctx, fast=fast, workers=workers)
         raise typer.Exit(
-            lint_module.run_pytest(target, fast=fast, workers=resolved_workers)
+            lint_module.run_pytest(
+                target,
+                fast=fast,
+                workers=resolved_workers,
+                require_xdist=_require_xdist(ctx),
+            )
         )
 
     @app.command("check")
@@ -317,14 +344,14 @@ def register_commands(
             typer.Argument(help="Path to inspect. Defaults to the current directory."),
         ] = ".",
         strictness: Annotated[str | None, _strictness_option()] = None,
-        fast: Annotated[bool, _fast_option()] = False,
+        fast: Annotated[bool, _fast_option()] = True,
         workers: Annotated[str, _workers_option()] = lint_module.DEFAULT_FAST_WORKERS,
     ) -> None:
         """Run the full quality gate (lint + fmt-check + type + test).
 
-        ``--fast`` runs the test step as ``test --fast`` does, with the
-        pytest-xdist check made before the first step. Steps the host CLI
-        registered run after type and before test.
+        The test step runs as ``test`` does — in parallel unless
+        ``--serial`` — with the pytest-xdist check made before the first
+        step. Steps the host CLI registered run after type and before test.
         """
         config = _resolve_config(target, strictness)
         resolved_workers = _resolve_workers(ctx, fast=fast, workers=workers)
@@ -335,6 +362,7 @@ def register_commands(
                 fast=fast,
                 workers=resolved_workers,
                 extra_steps=extra_steps,
+                require_xdist=_require_xdist(ctx),
             )
         )
 

{tempest_cli-0.5.1 → tempest_cli-0.6.0}/tests/test_extra_steps.py

@@ -59,7 +59,7 @@ def log(monkeypatch: pytest.MonkeyPatch) -> list[str]:
 
     monkeypatch.setattr(subprocess, "call", fake_call)
     monkeypatch.setattr(shutil, "which", _on_path_only)
-    monkeypatch.setattr(lint, "_missing_xdist_code", lambda: 0)
+    monkeypatch.setattr(lint, "_xdist_missing", lambda: None)
     return entries
 
 

{tempest_cli-0.5.1 → tempest_cli-0.6.0}/tests/test_fast.py

@@ -1,4 +1,4 @@
-"""Tests for ``test --fast`` / ``check --fast``: the parallel pytest run.
+"""Tests for the parallel pytest run of ``test`` / ``check`` (the default).
 
 Three things matter: the argv handed to pytest, the preflight that asks
 *pytest's* interpreter whether pytest-xdist is importable, and the exit
@@ -163,6 +163,40 @@ def test_missing_xdist_names_the_fix_and_reports_127(
     assert "Traceback" not in err
 
 
+def test_preferred_parallel_without_xdist_runs_serially_and_says_so(
+    monkeypatch: pytest.MonkeyPatch,
+    calls: list[list[str]],
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    """The default only prefers parallel: no plugin is a slower run, not an error."""
+    monkeypatch.setattr(subprocess, "run", _probe_answering(1))
+    assert lint.run_pytest("tests", fast=True, require_xdist=False) == 0
+    assert calls[0][1:] == ["tests"]
+    err = capsys.readouterr().err
+    assert "runs serially" in err
+    assert "pytest-xdist" in err
+    assert "tempest-cli[tools]" in err
+
+
+def test_preferred_parallel_with_xdist_still_spreads(calls: list[list[str]]) -> None:
+    assert lint.run_pytest(None, fast=True, require_xdist=False) == 0
+    assert calls[0][1:] == ["-n", "auto", "-p", "no:cacheprovider"]
+
+
+def test_full_check_preferred_parallel_falls_back_without_stopping(
+    monkeypatch: pytest.MonkeyPatch,
+    calls: list[list[str]],
+) -> None:
+    """The gate runs every step and the pytest one serially."""
+    monkeypatch.setattr(subprocess, "run", _probe_answering(1))
+    code = lint.run_full_check(
+        "src", config=TempestConfig(), fast=True, require_xdist=False
+    )
+    assert code == 0
+    assert len(calls) == 4
+    assert "-n" not in calls[-1]
+
+
 def test_an_unanswerable_probe_lets_pytest_speak(
     monkeypatch: pytest.MonkeyPatch,
     fake_pytest: Path,
@@ -311,13 +345,31 @@ def test_cli_test_fast_forwards_workers_and_target(
         main_module.app, ["test", "tests/unit", "--fast", "--workers", "4"]
     )
     assert result.exit_code == 0, result.output
-    assert seen == [(("tests/unit",), {"fast": True, "workers": "4"})]
+    assert seen == [
+        (("tests/unit",), {"fast": True, "workers": "4", "require_xdist": True})
+    ]
 
 
-def test_cli_fast_defaults_to_auto(monkeypatch: pytest.MonkeyPatch) -> None:
+def test_cli_runs_in_parallel_by_default(monkeypatch: pytest.MonkeyPatch) -> None:
+    """No flag: parallel on auto workers, degrading to serial without xdist."""
+    seen = _capture_runner(monkeypatch, "run_pytest")
+    runner.invoke(main_module.app, ["test"])
+    assert seen == [
+        ((None,), {"fast": True, "workers": "auto", "require_xdist": False})
+    ]
+
+
+def test_cli_fast_by_name_requires_xdist(monkeypatch: pytest.MonkeyPatch) -> None:
     seen = _capture_runner(monkeypatch, "run_pytest")
     runner.invoke(main_module.app, ["test", "--fast"])
-    assert seen == [((None,), {"fast": True, "workers": "auto"})]
+    assert seen == [((None,), {"fast": True, "workers": "auto", "require_xdist": True})]
+
+
+def test_cli_serial_opts_out(monkeypatch: pytest.MonkeyPatch) -> None:
+    seen = _capture_runner(monkeypatch, "run_pytest")
+    runner.invoke(main_module.app, ["test", "--serial", "tests/unit"])
+    assert seen[0][0] == ("tests/unit",)
+    assert seen[0][1]["fast"] is False
 
 
 def test_a_folder_named_fast_is_still_a_target(
@@ -326,18 +378,29 @@ def test_a_folder_named_fast_is_still_a_target(
     """Why ``--fast`` is a flag: ``tempest test fast`` keeps its meaning."""
     seen = _capture_runner(monkeypatch, "run_pytest")
     runner.invoke(main_module.app, ["test", "fast"])
-    assert seen == [(("fast",), {"fast": False, "workers": "auto"})]
+    assert seen == [
+        (("fast",), {"fast": True, "workers": "auto", "require_xdist": False})
+    ]
 
 
-def test_cli_workers_without_fast_is_a_usage_error(
+def test_cli_workers_with_serial_is_a_usage_error(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     seen = _capture_runner(monkeypatch, "run_pytest")
-    result = runner.invoke(main_module.app, ["test", "--workers", "4"])
+    result = runner.invoke(main_module.app, ["test", "--serial", "--workers", "4"])
     assert result.exit_code == 2
     assert seen == []
 
 
+def test_cli_workers_without_a_flag_tunes_the_default(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    seen = _capture_runner(monkeypatch, "run_pytest")
+    result = runner.invoke(main_module.app, ["test", "--workers", "4"])
+    assert result.exit_code == 0, result.output
+    assert seen[0][1]["workers"] == "4"
+
+
 @pytest.mark.parametrize("workers", ["many", "-1", "2.5", ""])
 def test_cli_rejects_a_worker_count_xdist_would_refuse(
     monkeypatch: pytest.MonkeyPatch,
@@ -368,6 +431,16 @@ def test_cli_check_fast_reaches_the_gate(monkeypatch: pytest.MonkeyPatch) -> Non
     assert args == ("src",)
     assert kwargs["fast"] is True
     assert kwargs["workers"] == "3"
+    assert kwargs["require_xdist"] is True
+
+
+def test_cli_check_is_parallel_by_default(monkeypatch: pytest.MonkeyPatch) -> None:
+    seen = _capture_runner(monkeypatch, "run_full_check")
+    result = runner.invoke(main_module.app, ["check", "src"])
+    assert result.exit_code == 0, result.output
+    kwargs = seen[0][1]
+    assert kwargs["fast"] is True
+    assert kwargs["require_xdist"] is False
 
 
 def test_cli_propagates_the_runner_exit_code(
@@ -384,5 +457,5 @@ def test_test_help_explains_the_parallel_only_failure() -> None:
     )
     assert command.callback is not None
     doc = command.callback.__doc__ or ""
-    assert "fails only under --fast" in doc
-    assert "tests/test_x.py::test_name" in doc
+    assert "fails only in parallel" in doc
+    assert "test --serial tests/test_x.py::test_name" in doc

{tempest_cli-0.5.1 → tempest_cli-0.6.0}/uv.lock

@@ -1148,7 +1148,7 @@ wheels = [
 
 [[package]]
 name = "tempest-cli"
-version = "0.5.1"
+version = "0.6.0"
 source = { editable = "." }
 dependencies = [
     { name = "ruff" },