qa-unit-tests-go-rust
Go + Rust unit testing per-framework wrappers: 5 skills (cargo-test, ginkgo-tests, go-rust-mocking, go-test, rstest-tests) and 2 agents (go-rust-framework-selector, go-rust-test-author).
Install this plugin
/plugin install qa-unit-tests-go-rust@testland-qaPart of role bundle: qa-role-sdet
qa-unit-tests-go-rust
Go + Rust unit testing per-framework wrappers. Combined plugin since each language has a small test surface (stdlib + 1 community library).
Per-framework lifecycle scope. Does not duplicate qa-test-review (test code hygiene).
Components
| Type | Name | Description |
|---|---|---|
| Skill | go-test | Go stdlib testing package; table-driven idiom; benchmarks; fuzzing (Go 1.18+); examples |
| Skill | ginkgo-tests | Go BDD framework (Kubernetes-ecosystem standard); Describe/Context/It; Gomega matchers |
| Skill | cargo-test | Rust cargo test; unit + integration + doc tests; Result<>-return for ?; Criterion for benchmarks |
| Skill | rstest-tests | Rust parametrize + fixtures; #[case]/#[fixture]; matrix tests; async fixture support |
| Agent | go-rust-test-author | Detects language (go.mod vs Cargo.toml) + framework (Go: testing or Ginkgo; Rust: #[test] or rstest), emits one unit test file per spec |
| Agent | go-rust-framework-selector | Detects Go vs Rust and recommends one test framework (stdlib/Ginkgo for Go, cargo-test/rstest for Rust). |
| Skill | go-rust-mocking | Test-double patterns for Go (gomock, testify/mock) and Rust (mockall). |
Install
/plugin marketplace add testland/qa
/plugin install qa-unit-tests-go-rust@testland-qaSkills
cargo-test
Configures and runs Rust's built-in `cargo test` - `#[test]` + `#[should_panic]` + `Result<(), E>` returns; integration tests in `tests/`; doc-tests embedded in `///` comments; `--lib` / `--bins` / `--all-targets` / `--workspace` selection; `cargo bench` (nightly) + Criterion (stable); `cargo test -- --test-threads=1` for serial; `cargo test -- --nocapture` to see println output. Use for any Rust project - testing is built into Cargo, no install needed.
ginkgo-tests
Configures and runs Ginkgo - Go BDD test framework with `Describe` / `Context` / `It` nesting; `BeforeEach` / `AfterEach` / `JustBeforeEach` / `JustAfterEach` lifecycle; Gomega matchers DSL (`Expect(actual).To(Equal(expected))`); parallel execution via `-p`; focus (`F` prefix) + skip (`P` prefix); `DescribeTable` + `Entry` for parametrized tests; `ginkgo` CLI tool. Use when working with Go on a BDD-style test suite (Kubernetes-ecosystem standard).
go-rust-mocking
Isolates dependencies in Go and Rust unit tests using test-double generation - Go: `go.uber.org/mock` (gomock + mockgen codegen) and `github.com/stretchr/testify/mock` (hand-written stubs); Rust: `mockall` crate with `#[automock]` for traits and `mock!` macro for structs and external traits. Use when a unit test reaches a database, HTTP client, file system, or any interface boundary that must be replaced with a controlled fake to keep tests fast, deterministic, and isolated.
go-test
Configures and runs Go's stdlib `testing` package - `func TestXxx(t *testing.T)` convention; table-driven tests via slice + range; `t.Run` for subtests with hierarchical names; `t.Parallel()` for parallel execution; benchmarks (`func BenchmarkXxx(b *testing.B)`); examples (`func ExampleXxx()`); fuzzing (`func FuzzXxx(f *testing.F)`); coverage via `go test -cover`/`-coverprofile`; build tags for selective compilation. Use for any Go project - testing is a stdlib feature, no install needed.
rstest-tests
Configures and runs rstest - Rust parametrized + fixture-based testing crate; `#[rstest]` attribute + `#[case(...)]` for parametrize; `#[fixture]` for reusable test setup; matrix tests via multiple `#[case]` × N (cartesian product); async test support via `#[async_std::test]` / `#[tokio::test]` + `#[rstest]`; `#[future]` for async fixtures. Use when working with Rust and needing parametrize/fixture patterns beyond stdlib `#[test]`.
Agents
go-rust-framework-selector
Read-only agent that reads a Go or Rust project root (`go.mod` / `Cargo.toml` plus existing test files) and emits one concrete test-framework recommendation with rationale and a preloaded skill to read next. Distinct from `go-rust-test-author` (action-taker that writes test files, assumes framework already chosen) and `qa-process/framework-choice-advisor` (language-agnostic e2e/load catalog with no file reads). Use when starting a new Go or Rust test project and the team has not yet committed to a framework.
go-rust-test-author
Action-taking agent that authors one Go or Rust unit test file per spec - first detects language from project root (`go.mod` → Go; `Cargo.toml` → Rust), then detects framework (Go: stdlib `testing` or Ginkgo BDD; Rust: stdlib `#[test]` or `rstest` parameterized) from dependencies + existing test files. Distinct from `qa-shift-left/spec-to-suite-orchestrator` (language-agnostic multi-stage project-skeleton workflow) - narrower scope, single-file output, Go/Rust only. Sibling of the per-language authors in `qa-unit-tests-{net,js,jvm,python}` and `qa-desktop/desktop-test-author`. Use when adding a single new Go or Rust unit test to an existing test project.