/radar

Multi-Language Testing

Purpose: Language-specific testing defaults for Radar outside the TS/JS baseline. Read this when the repo is Python, Go, Rust, or Java.

Contents:

• language detection
• idiomatic test patterns per language
• async and mocking defaults
• coverage commands and thresholds

Language Detection

Python

Defaults

• Use pytest.mark.parametrize for boundary coverage.
• Use fixtures for setup and cleanup.
• Use pytest-asyncio 1.x (GA May 2025) for async code — major version requires asyncio_mode configuration and drops the legacy auto-detection mode. See pytest-asyncio.readthedocs.io for migration guide.
• Use pytest-mock or unittest.mock for external effects.

@pytest.mark.parametrize("input_val,expected", [
    ("", True),
    ("  ", True),
    (None, True),
    ("hello", False),
])
def test_is_blank(input_val, expected):
    assert is_blank(input_val) == expected

@pytest.fixture
def db_session():
    session = create_test_session()
    yield session
    session.rollback()
    session.close()

Coverage commands:

pytest --cov=src --cov-report=html --cov-report=term
pytest --cov=src --cov-fail-under=80
pytest --cov=src --cov-report=term-missing

Go

Defaults

• Prefer table-driven tests for input matrices.
• Use require for setup checks and assert for multiple follow-up expectations.
• Use httptest for handler tests.
• Generate mocks with gomock or mockery instead of handwritten deep stubs.

func TestAdd_TableDriven(t *testing.T) {
    tests := []struct {
        name string
        a    int
        b    int
        want int
    }{
        {name: "positive", a: 2, b: 3, want: 5},
        {name: "zero", a: 0, b: 3, want: 3},
    }

    for _, tc := range tests {
        t.Run(tc.name, func(t *testing.T) {
            assert.Equal(t, tc.want, Add(tc.a, tc.b))
        })
    }
}

Coverage commands:

go test ./... -cover
go test ./... -coverprofile=coverage.out
go tool cover -html=coverage.out -o coverage.html
go test ./... -cover | grep -E "coverage: [0-7][0-9]\\." && exit 1 || echo "OK"

Rust

Defaults

• Keep unit tests in-module for private behavior and integration tests in tests/ for public API.
• Use parameterized tests for edge matrices.
• Use tokio::test for async code.
• Prefer cargo-nextest in CI for faster, isolated test runs (up to 3x faster than cargo test; per-test process isolation; RustRover 2026.1 adds native nextest IDE integration). Source: nexte.st
• cargo-mutants integrates with nextest: cargo mutants --test-tool nextest for parallel mutant runs.

#[test_case("", true; "empty")]
#[test_case("  ", true; "whitespace")]
#[test_case("hello", false; "valid")]
fn is_blank_cases(input: &str, expected: bool) {
    assert_eq!(is_blank(input), expected);
}

Tooling Selection (2026)

// proptest: invariant over a generated domain
proptest! {
    #[test]
    fn roundtrip_encode_decode(s in ".*") {
        prop_assert_eq!(decode(&encode(&s)), s);
    }
}

// insta: snapshot a complex value (review with `cargo insta review`)
insta::assert_yaml_snapshot!(parse_config(input)?);

// async: tokio::test with explicit flavor + timeout to surface hangs
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn fetches_within_budget() {
    let r = tokio::time::timeout(Duration::from_secs(2), fetch(url)).await;
    assert!(r.is_ok(), "fetch exceeded budget (possible deadlock)");
}

Coverage commands — prefer cargo-llvm-cov (LLVM source-based, the accurate default); tarpaulin is faster but ptrace-based and less precise on branch/async coverage. Note llvm-cov has known limitations on Windows GNU/MSVC targets.

cargo llvm-cov --html --output-dir coverage/   # accurate, source-based (default choice)
cargo llvm-cov --fail-under-lines 80           # CI gate
cargo tarpaulin --out html --output-dir coverage/  # faster, lower precision — Linux-first

Java

Defaults

• Use JUnit 5.12+ or JUnit 6 (GA Sep 2025; requires Java 17+) with @Nested for scenario grouping. JUnit 6 adds @ParameterizedClass, Kotlin suspend fun test support, and unified versioning. See junit.org/junit5/docs/current/user-guide/ and docs.junit.org/6.0.3/release-notes.html.
• Use parameterized tests for boundary matrices.
• Use Mockito only at true collaboration boundaries.

@ParameterizedTest
@CsvSource({
  "'', true",
  "'  ', true",
  "hello, false"
})
void isBlankCases(String input, boolean expected) {
  assertEquals(expected, StringUtils.isBlank(input));
}

JaCoCo threshold example:

<rule>
  <element>BUNDLE</element>
  <limits>
    <limit>
      <counter>LINE</counter>
      <value>COVEREDRATIO</value>
      <minimum>0.80</minimum>
    </limit>
  </limits>
</rule>

Cross-Language Rules

Quick Reference