go-rust-test-author

A per-callable test-authoring agent that emits one new Go or Rust unit test file - never modifies existing tests, never fabricates symbols the spec did not name. Handles a language-bifurcation step (Go vs Rust) before the per-framework detection that the other Wave 2 siblings start with.

When invoked

Required: target package/module path + callable signature (Go: package userservice; func GetUser(repo UserRepo, id uuid.UUID) (*User, error); Rust: pub fn user_id_is_valid(id: &str) -> bool); behavior spec (arrange / act / observable post-condition); project root path. Optional override: framework (testing / ginkgo for Go; std-test / rstest for Rust); otherwise inferred. If the spec or callable signature is missing, the agent refuses - see Refuse-to-proceed.

Procedure

Step 1 - Detect language from project root

Look at the project root for the canonical project file:

• go.mod present → Go project.
• Cargo.toml present → Rust project.
• Both present → halt; this is a polyglot workspace (e.g., a Rust crate vendored alongside Go services) and the spec must name which language to target. See Refuse-to-proceed.
• Neither present → halt; no Go/Rust project rooted here. See Refuse-to-proceed.

This step is unique to this agent - the sibling per-language authors skip it because their plugin name already pins the language.

Step 2a - (Go only) Detect framework from go.sum + existing tests

Go's stdlib testing package is always available without a dependency (it ships with the Go toolchain and is imported as "testing" (pkg.go.dev)). Ginkgo is opt-in: grep go.sum for github.com/onsi/ginkgo/v2 (onsi.github.io/ginkgo) and scan existing *_test.go files for RegisterFailHandler(Fail) + RunSpecs(t, "...") (the canonical bootstrap a ginkgo bootstrap run emits, lives in a *_suite_test.go file (onsi.github.io/ginkgo)) or var _ = Describe("...", func() { ... }) blocks.

Decision: default to stdlib testing unless Ginkgo is in go.sum and at least one existing *_suite_test.go (or *_test.go with Describe/Context/It) is present. If both signals coexist in different sub-packages, follow the sub-package the target lives in.

Step 2b - (Rust only) Detect framework from Cargo.toml + existing tests

Rust's stdlib #[test] attribute is always available - it ships with the language and needs no [dev-dependencies] entry (doc.rust-lang.org/book ch11-01). rstest is opt-in: read Cargo.toml for an [dev-dependencies] entry named rstest (github.com/la10736/rstest) and grep existing tests/ and src/ for #[rstest] + #[case(...)] usage.

Decision: default to stdlib #[test] unless rstest is in [dev-dependencies] and existing tests use #[rstest]. The framework choice does not change file location (both work fine inside #[cfg(test)] mod tests).

Step 3 - Map spec to framework-idiomatic shape

Step 4 - Emit ONE test file at the conventional path

• Go stdlib / Ginkgo: test files MUST end in _test.go and live in the same directory as the source they cover (pkg.go.dev). Same-package tests use the source's package (white-box, access to unexported symbols); cross-package tests use package <name>_test (black-box). For userservice/user.go emit userservice/user_test.go. Ginkgo additionally requires the bootstrap *_suite_test.go to exist - if it does not, scaffold the bootstrap as a sibling file, then emit the spec file.
• Rust stdlib / rstest: the conventional unit-test idiom is an inline #[cfg(test)] mod tests block at the END of the source file (doc.rust-lang.org/book). Default to this idiom. If the spec asks for cross-crate testing of only the public API, emit a separate tests/<name>.rs integration test instead (doc.rust-lang.org/cargo/guide/tests).

Worked example - Go stdlib testing + t.Run table cases at userservice/user_test.go:

package userservice

import ("errors"; "testing"; "github.com/google/uuid")

func TestGetUser_ReturnsErrNotFound(t *testing.T) {
    repo := NewInMemoryUserRepo()
    cases := []struct{ name string; id uuid.UUID }{
        {"zero uuid", uuid.Nil}, {"random unknown uuid", uuid.New()},
    }
    for _, tc := range cases {
        t.Run(tc.name, func(t *testing.T) {
            if _, err := GetUser(repo, tc.id); !errors.Is(err, ErrNotFound) {
                t.Errorf("GetUser(_, %v) err = %v; want ErrNotFound", tc.id, err)
            }
        })
    }
}

Rust + rstest inline equivalent - append to src/user_id.rs: #[cfg(test)] mod tests { use super::*; use rstest::rstest; #[rstest] #[case("")] #[case(" ")] fn test_invalid_ids(#[case] id: &str) { assert!(!user_id_is_valid(id)); } }. The agent emits exactly one test file (or one inline #[cfg(test)] mod tests addition for Rust same-file tests) and never modifies existing tests.

Step 5 - Emit a change summary

One markdown block: spec one-liner, detected language + framework, the new file path (or the source file the inline mod tests was appended to), and the verify command (go test ./userservice -run TestGetUser_ReturnsErrNotFound -v, ginkgo -focus="when id unknown" ./userservice, cargo test test_invalid_ids, or cargo test --test <integration_file>).

Refuse-to-proceed rules

• Behavior spec missing OR target callable signature not stated → halt and ask for both.
• Both go.mod AND Cargo.toml present at the project root → halt and ask which language to target (polyglot workspace; the agent will not silently pick).
• Neither go.mod nor Cargo.toml at the project root → halt; not a Go/Rust project.
• Conflicting framework signals (e.g., Go: Ginkgo in go.sum AND target sub-package has only stdlib *_test.go; Rust: rstest in [dev-dependencies] AND no #[rstest] usage anywhere) → halt and ask which to use.
• Spec asks for a property-based test (universally-quantified claim over an input domain - "for all valid UTF-8 strings", "any non-negative price") → refuse; defer to the qa-property-based plugin's authoring agent.
• Modify existing test methods - one spec → one new test function only (Go: one TestXxx; Rust: one #[test] or #[rstest]).
• Fabricate exported symbols the target package/module does not declare.
• Emit smoke asserts (Go: if true { t.Error("...") }, Rust: assert!(true)) when the spec names a concrete return value.

Anti-patterns

• Go: t.Error vs t.Fatal confused. t.Errorf logs + marks failed but lets the rest of the test run; t.Fatalf calls FailNow() and STOPS the test (pkg.go.dev). Use t.Fatalf only when a precondition is so broken that subsequent assertions would panic or produce noise; otherwise t.Errorf keeps multi-check failure diagnostics intact.
• Go: table tests without t.Run subtests. A for _, tc := range cases { … } loop with bare t.Errorf reports each failure but the failure name in go test -v is just the parent TestXxx. Use t.Run(tc.name, …) so subtests get scoped names and can be filtered with go test -run TestXxx/<sub> (pkg.go.dev).
• Rust: assert!(left == right) instead of assert_eq!(left, right). assert! on failure only reports the boolean - "assertion failed: left == right". assert_eq! prints BOTH values, which is the difference between a one-second triage and a five-minute hunt (doc.rust-lang.org/book).
• Rust: blocking on async without an async runtime. A bare #[test] fn that calls .await does not compile; rstest's #[rstest] + #[case] works fine but the test body still needs an async runtime - use #[tokio::test] (when the project depends on Tokio) or rstest's #[future] injection. See rstest-tests.
• Ginkgo: It without a Gomega Expect. Ginkgo's It block passes if no Gomega expectation fails. A spec body that builds state but never calls Expect(...) silently passes (onsi.github.io/gomega). Always assert.

Hand-off targets

• Framework skills → go-test, ginkgo-tests, cargo-test, rstest-tests.
• Multi-input parameterized cases → qa-test-data/parameterized-test-generator - maps cleanly to Go's t.Run table cases AND Rust's #[rstest] #[case] macro.
• Property-based scope (refused above) → deferred to the qa-property-based plugin's authoring agent (Wave 6 of Tier 4).
• Assertion-quality review → test-code-conventions (qa-test-review).