gofasta test

Wraps go test with the gofasta defaults: race detector on, every package under ./..., output streamed straight to the terminal. Equivalent to go test -race ./... but shorter and consistent with the rest of the gofasta CLI (banner, --json mode, etc.).


gofasta test                          # all packages, race detector on
gofasta test ./app/services           # one package
gofasta test ./app/...                # everything under app/
gofasta test ./app/... -- -count=1    # forward extra flags to go test

Usage


gofasta test [path...] [flags] [-- go-test-flags]

Positional args are package paths passed through to go test. Anything after a literal -- is forwarded verbatim to go test so you can use flags gofasta doesn’t shortcut.

Flags

Flag	Short	Default	Description
`--short`	`-s`	`false`	Skip long-running tests (passes `-short` to `go test`).
`--integration`	`-i`	`false`	Run only `Integration`-named tests (passes `-run Integration`).
`--coverage`	`-c`	`false`	Write coverage profile to `coverage.out` and print total %.
`--run`	`-r`	(none)	Run only tests matching the regex pattern (`-run <pattern>`).
`--no-race`		`false`	Skip the race detector (faster, less safe).
`--verbose`	`-v`	`false`	Verbose output (passes `-v` to `go test`).

Global flags:

--json — forwards -json to go test, producing NDJSON events suitable for gotestsum, GitHub Actions test reporters, or your own pipeline. Suppresses the banner and progress line so stdout is a strict JSON stream.

Examples

Run everything, race detector on (the default):


gofasta test

Skip long tests:


gofasta test --short

Run only Integration-prefixed tests:


gofasta test --integration

Coverage profile + total %:


gofasta test --coverage
# → writes coverage.out, prints "coverage: 87.4% of statements"

Filter to one test:


gofasta test --run TestUserCreate
gofasta test --run "TestUser.*"     # regex

Skip the race detector for a faster run:


gofasta test --no-race

Scope to one package:


gofasta test ./app/services

Forward extra go test flags after --:


gofasta test ./app/... -- -count=1 -tags=integration -timeout=5m

CI: NDJSON output for a test reporter:


gofasta test --json | tee test-output.jsonl

How it works

gofasta test builds a single go test command line:


go test -race ./... [-short] [-integration -run Integration] [-coverprofile=coverage.out] [-run=<pattern>] [-v] [-json] [paths...] [-- extra-go-test-flags]

Then runs it with stdout/stderr inherited (so live progress shows up immediately) and exits with the same code go test did.

Two things gofasta adds on top:

Coverage summary. When --coverage is set, after go test finishes gofasta reads coverage.out and prints coverage: X.X% of statements so you see the total without running go tool cover -func separately.
JSON noise suppression. Under --json, the banner + the ▶ go test ... progress line + the coverage summary are suppressed so stdout stays a strict NDJSON stream.

When to use

In a project. Always — it’s shorter than go test -race ./... and the gofasta CLI already knows your project conventions.
In CI. Pair with --json and pipe to gotestsum (or GitHub Actions’ --json-input reporter) for structured test output.
For coverage. gofasta test --coverage is the one-shot way; gofasta verify runs the full preflight suite (lint + race + build + …) when you want a stricter gate.

gofasta init
Initialize a cloned or existing Gofasta project by installing dependencies and running code generators.
gofasta dev
Bring the full local environment up with one command — compose services + migrations + Air hot reload, with interactive restart.
gofasta debug
CLI surface for the devtools /debug/* endpoints — requests, SQL, traces, logs, errors, cache, pprof, EXPLAIN, HAR, plus the composed...
gofasta ai
Install per-agent configuration for Claude Code, Cursor, OpenAI Codex, Aider, and Windsurf — permission allowlists, hooks, project rules, and slash commands.
gofasta verify
Run the full preflight gauntlet — gofmt, vet, golangci-lint, tests, build, Wire drift, routes — in one command.
gofasta status
Report the health of the current project — Wire drift, swagger drift, pending migrations, uncommitted generated files, module freshness.
gofasta inspect
Show the full composition of a resource — model fields, DTOs, service methods, controller methods, routes — as structured output.
gofasta inspect-jobs
Static AST scan of app/jobs/ that lists every registered cron job with its schedule from config.yaml.
gofasta inspect-tasks
Static AST scan of app/tasks/ that lists every async task with its wire name, payload shape, and handler/enqueuer presence.
gofasta impact
Reverse-dependency analysis — given a file or import path, list every package that depends on it (directly + transitively) and every Go source file in those packages.
gofasta xrefs
Type-aware reverse symbol lookup — find every reference to a Go func, type, method, var, or const across the current module.
gofasta do
Run a named development workflow — a pre-defined chain of gofasta commands that together accomplish one higher-level task.
gofasta config
Inspect and validate your project's config.yaml — currently the schema emitter, more subcommands to come.
gofasta serve
Run the project's HTTP server in production mode — no Air, no hot reload.
gofasta refactor
Switch a Gofasta project between layered and feature-package layouts without rewriting code by hand.
gofasta migrate
Run database migrations up or down for your Gofasta project, with static analysis (--explain), safe rollbacks (--steps, --all), and dirty-state repair (migrate repair).
gofasta seed
Run database seeders to populate your database with initial or test data.
gofasta db
Destructive database utilities, kept separate from `gofasta migrate` on purpose.
gofasta deploy
Deploy a Gofasta application to a remote VPS via SSH using Docker or a compiled binary, with a health gate and automatic rollback.
gofasta wire
Regenerate Google Wire dependency injection code for your Gofasta project.
gofasta swagger
Generate OpenAPI/Swagger documentation from the `@Summary`, `@Tags`, `@Router`, and `@Param` annotations the scaffold and `g endpoint` emit.
gofasta routes
Print every registered REST route in the project as a formatted table — method, path, and source file.
gofasta console
Start an interactive Go REPL in your project directory, powered by yaegi, for one-off data inspection and exploring an API surface without writing a throwaway main().
gofasta doctor
Check system prerequisites, project configuration, and database connectivity.
gofasta upgrade
Self-update the Gofasta CLI to the latest GitHub release.
gofasta version
Print the CLI version, the Go toolchain it was compiled with, and the OS/architecture target.
Error codes
Reference for every structured error code the Gofasta CLI emits — the stable machine-readable identifiers in `--json` output, grouped by...