521-frameworks-micronaut-testing-unit-tests
Use when you need to write unit tests for Micronaut applications — Mockito-first with @ExtendWith(MockitoExtension.class), @MicronautTest with @MockBean, HttpClient @Client(/) assertions, @Property overrides, @ParameterizedTest, and *Test vs *IT naming. For framework-agnostic Java use @131-java-testing-unit-testing. This should trigger for requests such as Add or improve unit tests in a Micronaut project; Reduce unnecessary @MicronautTest usage with Mockito-first tests. Part of cursor-rules-java project
77
71%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./skills/521-frameworks-micronaut-testing-unit-tests/SKILL.mdQuality
Discovery
100%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
This is an excellent skill description that is highly specific, includes strong trigger terms, clearly answers both what and when, and explicitly disambiguates from a related skill. The cross-reference to the framework-agnostic Java testing skill is a particularly strong feature that reduces conflict risk. The only minor note is that it uses second-person 'you' in the opening ('Use when you need to'), but this is a borderline case as it's part of a standard 'Use when' clause rather than a 'You can use this' pattern.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions and patterns: Mockito-first with @ExtendWith(MockitoExtension.class), @MicronautTest with @MockBean, HttpClient @Client(/) assertions, @Property overrides, @ParameterizedTest, and *Test vs *IT naming conventions. Very detailed and concrete. | 3 / 3 |
Completeness | Clearly answers both 'what' (Mockito-first testing patterns, @MicronautTest with @MockBean, HttpClient assertions, etc.) and 'when' with explicit 'Use when' clause and example trigger requests like 'Add or improve unit tests in a Micronaut project' and 'Reduce unnecessary @MicronautTest usage'. Also includes disambiguation guidance pointing to an alternative skill for framework-agnostic Java. | 3 / 3 |
Trigger Term Quality | Includes strong natural trigger terms: 'unit tests', 'Micronaut', 'Mockito', '@MicronautTest', '@MockBean', 'HttpClient', '@ParameterizedTest'. Also explicitly differentiates from framework-agnostic Java testing with a cross-reference. Users asking about Micronaut testing would naturally use these terms. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive — clearly scoped to Micronaut-specific unit testing and explicitly differentiates itself from the framework-agnostic Java testing skill (@131-java-testing-unit-testing). The Micronaut-specific annotations and patterns make it very unlikely to conflict with other skills. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
42%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
The skill has good structure and progressive disclosure, correctly deferring detailed patterns to a reference file. However, it critically lacks any concrete code examples or specific patterns in the body itself, making it almost entirely abstract. A developer or Claude reading only this file would not know how to write a Mockito-first Micronaut test without consulting the reference.
Suggestions
Add at least one concrete, executable code example showing a Mockito-first test (the primary pattern) and one showing @MicronautTest with @MockBean, so the skill is actionable without requiring the reference file.
Include a brief good/bad comparison inline (e.g., 'Prefer @ExtendWith(MockitoExtension.class) over @MicronautTest when no DI or HTTP is needed') with actual code snippets.
Integrate the compile/verify commands directly into the numbered workflow steps rather than only in the constraints section, and add an explicit error recovery loop (e.g., 'If tests fail, check X before Y').
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is reasonably concise but includes some unnecessary elements like the 'What is covered in this Skill?' bullet list that largely restates the description and reference content. The constraints section has useful content but some items like 'BEFORE APPLYING: Read the reference' are somewhat redundant given the workflow already says this. | 2 / 3 |
Actionability | The skill contains no concrete code examples, no executable commands beyond generic mvnw invocations, and no specific patterns showing Mockito-first tests, @MockBean usage, or HttpClient assertions. All actionable content is deferred entirely to the reference file, making the skill itself vague and descriptive rather than instructive. | 1 / 3 |
Workflow Clarity | The workflow has a clear 4-step sequence with compilation and verification steps mentioned in constraints. However, the workflow steps themselves are abstract ('Apply framework-aligned changes', 'Gather scope') without concrete validation checkpoints or error recovery loops integrated into the sequence. The constraints section partially compensates with compile-first and stop-on-failure rules. | 2 / 3 |
Progressive Disclosure | The skill provides a clear overview with a single well-signaled reference to the detailed file. Navigation is one level deep, the reference is clearly linked, and the skill appropriately splits overview content from detailed guidance. | 3 / 3 |
Total | 8 / 12 Passed |
Validation
100%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 11 / 11 Passed
Validation for skill structure
No warnings or errors.
- Repository
- jabrena/cursor-rules-java
- Commit
899d988
- Reviewed
Table of Contents
Is this your skill?
If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.