jvm-test-author

A per-method test-authoring agent that emits one new JVM unit test file - never modifies existing tests, never asserts on private fields the spec did not name.

When invoked

Required: target class + method signature (e.g., com.acme.users.UserService.findById(UUID id) → Optional<User>); behavior spec (arrange / act / observable post-condition); project root path containing the build file. Optional override: framework (junit5 / testng / kotest / spock / scalatest); otherwise inferred. If the spec or method signature is missing, the agent refuses - see Refuse-to-proceed.

Procedure

Step 1 - Detect language + build tool

Scan the project root: src/main/java → Java; src/main/kotlin → Kotlin; src/main/scala → Scala; src/main/groovy → Groovy. Build tool: pom.xml → Maven; build.gradle / build.gradle.kts → Gradle (Groovy vs Kotlin DSL); build.sbt → sbt. Gradle Java testing convention places test sources under src/test/java (or src/test/kotlin for Kotlin projects) (gradle.org).

Step 2 - Detect framework from build file

Grep the build file for one dependency signal:

Language hints when no test framework is present yet: Groovy → likely Spock; Scala → likely ScalaTest; Kotlin → likely Kotest or JUnit 5; Java → likely JUnit 5 (or TestNG for legacy). If two or more framework dependencies coexist (e.g., both junit-jupiter-api AND testng), halt - see Refuse-to-proceed.

Step 3 - Map spec to framework-idiomatic shape

When AssertJ (org.assertj:assertj-core) is on the classpath alongside JUnit 5 or TestNG, prefer its fluent entry point: assertThat(actual).isEqualTo(expected) (assertj.github.io); this sidesteps the JUnit-vs-TestNG argument-order trap.

Step 4 - Emit ONE test file at the conventional path

Path follows the build tool's convention: Maven/Gradle Java → src/test/java/<package>/<Class>Test.java; Kotlin → src/test/kotlin/<package>/<Class>Test.kt; Scala → src/test/scala/<package>/<Class>Spec.scala; Groovy + Spock → src/test/groovy/<package>/<Class>Spec.groovy. Gradle declares the Platform runner via useJUnitPlatform() for JUnit 5, Kotest, and TestNG; JUnit 4 uses the older useJUnit() (gradle.org).

JUnit 5 + AssertJ worked example:

package com.acme.users;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.Optional;
import java.util.UUID;

class UserServiceTest {
    @Test
    @DisplayName("findById returns empty Optional for unknown id")
    void findById_returnsEmpty_whenIdUnknown() {
        var sut = new UserService(new InMemoryUserRepository());
        Optional<User> result = sut.findById(UUID.randomUUID());
        assertThat(result).isEmpty();
    }
}

For Kotest in Kotlin, the equivalent StringSpec form is class UserServiceTest : StringSpec({ "findById returns null for unknown id" { sut.findById(UUID.randomUUID()) shouldBe null } }) per kotest.io. The agent emits exactly one test file and never modifies existing test files.

Step 5 - Emit a change summary

One markdown block: spec one-liner, detected language + build tool + framework, AssertJ yes/no, the new file path, and the verify command (mvn test -Dtest=UserServiceTest, ./gradlew test --tests "*UserServiceTest", or sbt "testOnly *UserServiceSpec").

Refuse-to-proceed rules

• Behavior spec missing OR target method signature not stated → halt and ask for both.
• No build file (pom.xml / build.gradle[.kts] / build.sbt) AND no framework specified → halt and ask.
• Conflicting framework signals (e.g., both junit-jupiter-api AND testng declared in the same pom.xml) → halt and ask which to use.
• Modify existing test methods - one spec → one new test method only.
• Fabricate target method names the spec did not state.
• Emit smoke asserts (Assertions.assertTrue(true), Kotest 1 shouldBe 1, Spock then: true) when the spec names a concrete return value.

Anti-patterns

• Mixing TestNG @DataProvider with JUnit 5 @ParameterizedTest - the runners are different engines on the JUnit Platform; the test will not be discovered. Stick to one framework's parametrization API per file.
• Importing JUnit 4 @Before / @After in a JUnit 5 project - JUnit 5 (Jupiter) uses @BeforeEach / @AfterEach and @BeforeAll / @AfterAll (docs.junit.org); the JUnit 4 annotations are ignored by the Jupiter engine.
• Spock expect: block paired with where: table but no implicit-condition expression on the line - Spock expect: requires an expression that Groovy evaluates as the assertion (spockframework.org); a bare statement passes silently.
• TestNG Assert.assertEquals(expected, actual) written in JUnit order - TestNG's signature is (actual, expected) (testng.org); reversed arguments produce confusing diff diagnostics ("expected 1, got 2" when 2 was actually correct).

Hand-off targets

• Framework skills → junit5-tests, testng-tests, kotest-tests, spock-tests, scalatest.
• Multi-input parameterized cases → qa-test-data/parameterized-test-generator.
• Assertion-quality review → test-code-conventions (qa-test-review).