To add real tests for an untested Quarkus module in 2026, Atlas reads your existing codebase, identifies public symbols, and then generates new JUnit 5 (@QuarkusTest) test cases that adhere to your project's Maven and Spotless conventions, ensuring immediate integration and execution.
How Atlas Identifies Untested Quarkus Code for Test Generation
Atlas begins by thoroughly understanding your Quarkus project's structure and identifying all public symbols within an untested module. In 2026, Atlas uses its `lsp` tool with the `documentSymbol` operation to enumerate every exported function and class, ensuring no public API is overlooked during test generation.
Atlas leverages its advanced code indexing capabilities, built on AST declarations using tree-sitter, to precisely map out the target Quarkus module. This is not a blind line-window scan; instead, Atlas understands the semantic structure of your Java code. By employing the `lsp` tool's `documentSymbol` operation, Atlas can accurately list all public methods, fields, and classes that require test coverage. This initial `read` and `lsp` phase is crucial for ensuring comprehensive test generation, as it guarantees that Atlas will attempt to cover every accessible part of the module, aligning with the goal of adding real tests for a module that has none. This process also respects Quarkus's build-time augmentation, allowing Atlas to correctly interpret the project's structure and identify CDI beans or JAX-RS resources.
Generating Quarkus JUnit 5 (@QuarkusTest) Tests with Existing Conventions
Atlas generates new `JUnit 5 (@QuarkusTest)` test files by first analyzing your existing Quarkus repository for established testing conventions. This ensures that any new test code, like those for a module in 2026, direct integrates, matching the `Maven` project structure and `Spotless` formatting rules already in place.
After identifying the symbols to test, Atlas uses its `grep` tool to locate an existing test file within your Quarkus project. This step is vital for understanding the repository's specific framework, import style, and naming conventions. For instance, Atlas will identify how existing `@QuarkusTest` annotations are used, how `RestAssured` is configured for integration tests, and the typical structure of a `src/test/java/com/example/MyResourceTest.java` file. With this context, Atlas then employs the `write` tool to draft the new test spec file. This intelligent approach means Atlas doesn't invent new conventions but rather extends your project's established practices, ensuring the generated tests are immediately recognizable and maintainable by any Quarkus developer. The `pom.xml` configuration, including `quarkus-bom` and `maven-surefire-plugin` settings, is implicitly respected.
Executing and Iterating on Quarkus Tests with Maven
Once Atlas drafts the new `JUnit 5 (@QuarkusTest)` test suite, it immediately executes them using the `bash` tool and the standard `Maven` command, `./mvnw test`. This crucial step ensures that the generated tests are not just syntactically correct but functionally valid, providing immediate feedback on any 0 failures or unexpected behavior.
The true measure of a test is its execution. Atlas understands this, and after generating the test file, it uses the `bash` tool to run the entire test suite. For a Quarkus project, this means executing `./mvnw test`, which invokes `Maven` and the `JUnit 5` runner. Atlas monitors the output, and while it truncates logs over 2000 lines or 50 KB, the full log is always saved to a file for detailed review. If tests fail, Atlas switches to an `edit` and `todowrite` iteration cycle. The `edit` tool allows Atlas to modify the test code based on the failures, while `todowrite` helps manage progress for larger modules. This iterative process, driven by real test execution, continues until the entire suite is green, ensuring the new tests are robust and accurate for your Quarkus application.
Reviewing and Committing Quarkus Test Changes with Atlas Safety Features
Atlas prioritizes developer control and safety throughout the test generation process for Quarkus applications. Before any changes are written to disk, Atlas presents a unified diff for every file edit, allowing you to review and approve the exact modifications. This ensures 100% transparency and prevents unintended alterations to your `pom.xml` or test files.
Every action Atlas takes that modifies your Quarkus codebase is permission-gated. When Atlas uses the `write` tool to create or modify a test file, or when it suggests changes to replace runtime reflection with build-time-friendly patterns, it first computes a unified diff. This diff is surfaced for your approval, giving you complete control over what changes are applied. After the tests are green, Atlas can also apply `Spotless` formatting to ensure the new code adheres to your project's style guidelines before committing. Atlas reads git branches, status, and diffs, and can stage and create commits on your behalf, but always with your explicit permission. This robust review mechanism, combined with the ability to snapshot file changes as git patches, provides a secure and auditable workflow for integrating new `JUnit 5 (@QuarkusTest)` cases into your Quarkus project.
Step by step
- 01Identify Untested Quarkus Symbols: Use Atlas's `read` tool to analyze your target Quarkus module, then employ the `lsp` tool with `documentSymbol` to enumerate all public methods and classes requiring `JUnit 5 (@QuarkusTest)` coverage.
- 02Discover Quarkus Test Conventions: Instruct Atlas to `grep` your existing Quarkus project for an example `JUnit 5 (@QuarkusTest)` file, such as `src/test/java/com/example/MyResourceTest.java`, to learn the repo's framework, import style, and naming conventions for `Maven` projects.
- 03Draft New Quarkus Test Spec: Utilize Atlas's `write` tool to generate the new `JUnit 5 (@QuarkusTest)` spec file, incorporating `RestAssured` if applicable, and review the unified diff presented for approval before writing to disk.
- 04Execute Quarkus Tests with Maven: Run the newly drafted `JUnit 5 (@QuarkusTest)` suite using Atlas's `bash` tool with the command `./mvnw test`, monitoring the output for failures and saving the full log for review.
- 05Iterate and Refine Quarkus Tests: If tests fail, use Atlas's `edit` tool to modify the test code, leveraging `todowrite` for larger modules, and repeat the `./mvnw test` execution until all `JUnit 5 (@QuarkusTest)` cases pass.
- 06Apply Spotless Formatting: Once tests are green, instruct Atlas to apply `Spotless` formatting to the new test files, ensuring adherence to your Quarkus project's code style before committing.
- 07Review and Commit Changes: Review the final diff of all changes, including `Spotless` applications, and use Atlas to stage and create a git commit for the new `JUnit 5 (@QuarkusTest)` files.
Frequently asked questions
- How does Atlas ensure new Quarkus tests match my existing project style?
- Atlas uses its `grep` tool to analyze your existing `JUnit 5 (@QuarkusTest)` files, learning your project's specific import styles, naming conventions, and `Maven` project structure before generating new tests.
- Can Atlas help with `RestAssured` tests in Quarkus?
- Yes, Atlas can add `@QuarkusTest` cases that utilize `RestAssured` for integration testing, following the patterns it discovers in your existing Quarkus codebase.
- What if my Quarkus module uses runtime reflection?
- Atlas can identify runtime reflection patterns in your Quarkus code and suggest replacing them with build-time-friendly alternatives, ensuring compatibility with native-image compilation.
- How does Atlas run the generated Quarkus tests?
- Atlas uses its `bash` tool to execute the standard `Maven` command `./mvnw test`, running your `JUnit 5 (@QuarkusTest)` suite and providing real-time feedback on test outcomes.
- Is Atlas compatible with Quarkus's `pom.xml` and `quarkus-bom`?
- Yes, Atlas is designed to operate within a Quarkus project that uses `Maven` and pulls in `quarkus-bom`, understanding the project's dependencies and build configuration.
- How does Atlas handle code formatting for new Quarkus tests?
- After generating and validating tests, Atlas can apply `Spotless` formatting to the new `JUnit 5 (@QuarkusTest)` files, ensuring they conform to your Quarkus project's established code style.
- How do I review changes Atlas makes to my Quarkus project?
- Atlas presents a unified diff for every file edit, including new `JUnit 5 (@QuarkusTest)` files or modifications to `application.properties`, allowing you to review and approve changes before they are written to disk.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Write Unit Tests for Untested Code with Atlas in 2026
How to write unit tests for untested code with Atlas in 2026: the lsp tool enumerates exported symbols, grep copies repo conventions, and bash actually runs the suite.
Atlas for Quarkus in 2026
Atlas is a terminal-native AI coding agent for Quarkus in 2026. It reads CDI beans and JAX-RS resources, then runs ./mvnw test behind a permission prompt.
Refactor a legacy module in Quarkus with Atlas in 2026
Streamline Quarkus module refactoring in 2026 with Atlas. Safely restructure old code, maintain behavior, and prevent breaking callers using Maven, JUnit 5, and Spotless.
Locate where a behavior is implemented in Quarkus with Atlas in 2026
Pinpoint Quarkus behavior implementation with Atlas in 2026. Use semantic search, grep, and LSP to find exact files and symbols in your Maven project, ensuring build-time compatibility and code quality.
Trace a runtime bug from a stack trace in Quarkus with Atlas in 2026
Pinpoint and fix Quarkus runtime bugs from production stack traces using Atlas, the terminal-native AI agent. Leverage Maven, JUnit 5, and Spotless for rapid resolution.
Debug a Single Failing Test in Quarkus with Atlas in 2026
Pinpoint and fix failing Quarkus tests efficiently with Atlas. Leverage JUnit 5, Maven, and Spotless for a streamlined debugging workflow in 2026.
Upgrade a Quarkus Dependency and Fix Breakage with Atlas in 2026
In 2026, Atlas helps Quarkus developers upgrade major dependencies, fixing compile and test failures. It drives Maven, reads compiler output, and repairs code with LSP, ensuring JUnit 5 and Spotless compliance.
Extract a Shared Helper from Duplicated Quarkus Code with Atlas in 2026
Streamline your Quarkus applications in 2026 by extracting duplicated logic into shared, tested helpers using Atlas. Find semantic duplicates, refactor with confidence, and ensure code quality with Maven and JUnit 5.