Skip to main content
Agent skill

Quarkus Tdd

Test-driven development for Quarkus 3.x LTS using JUnit 5, Mockito, REST Assured, Camel testing, and JaCoCo. Use when adding features, fixing bugs, or refactoring event-driven services.

Get started

Get the complete skill folder, including its scripts and reference files.

·

When to use this skill

Use Quarkus Tdd when an AI agent needs a reusable SKILL.md workflow for this job: Test-driven development for Quarkus 3.x LTS using JUnit 5, Mockito, REST Assured, Camel testing, and JaCoCo. Use when adding features, fixing bugs, or refactoring event-driven services.

When not to use it

Skip Quarkus Tdd when the task is outside the coding category, or when a more specific skill in this directory already covers the same workflow with clearer triggers.

How to install

Where will you use it?

Install scope
Claude Code folder setup
mkdir -p ~/.claude/skills/quarkus-tdd
# Save SKILL.md to ~/.claude/skills/quarkus-tdd/SKILL.md
  1. Claude Code personal install: place the skill and its bundled files at ~/.claude/skills/quarkus-tdd/SKILL.md. For a shared project, commit the folder at .claude/skills/quarkus-tdd/ instead.
  2. Current Claude Code detects SKILL.md changes in watched directories during the session. If you just created a top-level skills directory, run /reload-skills. Check that the skill is listed before testing its trigger.
  3. For Claude chat or Cowork in the Desktop app, manage uploaded skills in Customize > Skills; copying files into a local Claude Code folder is not a Desktop install. Other agents may use different install locations.

Full install guide for Claude, Cursor, and Codex →

Try a starter prompt

After installing the skill, paste this starter prompt into your agent to verify it triggers on a small task.

Starter prompt
Use the Quarkus Tdd skill for this task: New features or REST endpoints. Confirm any required inputs or files before making changes.

What supports this recommendation?

83/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.

Documentation
92/100
Practical detail
92/100
Source evidence
63/100
Source signals
70/100
Model compatibility evidence
  • claudeuntested

    No model-specific signal or recorded compatibility test was found.

  • chatgptuntested

    No model-specific signal or recorded compatibility test was found.

  • geminiuntested

    No model-specific signal or recorded compatibility test was found.

  • copilotuntested

    No model-specific signal or recorded compatibility test was found.

  • llamauntested

    No model-specific signal or recorded compatibility test was found.

  • perplexityuntested

    No model-specific signal or recorded compatibility test was found.

  • mistraluntested

    No model-specific signal or recorded compatibility test was found.

  • grokuntested

    No model-specific signal or recorded compatibility test was found.

Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.

What this skill does

# Quarkus TDD Workflow

TDD guidance for Quarkus 3.x services with 80%+ coverage (unit + integration). Optimized for event-driven architectures with Apache Camel.

## When to Use

- New features or REST endpoints - Bug fixes or refactors - Adding data access logic, security rules, or reactive streams - Testing Apache Camel routes and event handlers - Testing event-driven services with RabbitMQ - Testing conditional flow logic - Validating CompletableFuture async operations - Testing LogContext propagation

## Workflow

1. Write tests first (they should fail) 2. Implement minimal code to pass 3. Refactor with tests green 4. Enforce coverage with JaCoCo (80%+ target)

## Unit Tests with @Nested Organization

Follow this structured approach for comprehensive, readable tests:

```java @ExtendWith(MockitoExtension.class) @DisplayName("OrderService Unit Tests") class OrderServiceTest {

@Mock private OrderRepository orderRepository;

@Mock private EventService eventService;

@Mock private FulfillmentPublisher fulfillmentPublisher;

@InjectMocks private OrderService orderService;

private CreateOrderCommand validCommand;

@BeforeEach void setUp() { validCommand = new CreateOrderCommand( "customer-123", List.of(new OrderLine("sku-123", 2)) ); }

@Nested @DisplayName("Tests for createOrder") class CreateOrder {

@Test @DisplayName("Should persist order and publish fulfillment event") void givenValidCommand_whenCreateOrder_thenPersistsAndPublishes() { // ARRANGE doNothing().when(orderRepository).persist(any(Order.class));

// ACT OrderReceipt receipt = orderService.createOrder(validCommand);

// ASSERT assertThat(receipt).isNotNull(); assertThat(receipt.customerId()).isEqualTo("customer-123"); verify(orderRepository).persist(any(Order.class)); verify(fulfillmentPublisher).publishAsync(receipt); verify(eventService).createSuccessEvent(receipt, "ORDER_CREATED"); }

@Test @DisplayName("Should reject missing customer id") void givenMissingCustomerId_whenCreateOrder_thenThrowsBadRequest() { // ARRANGE CreateOrderCommand invalid = new CreateOrderCommand("", validCommand.lines());

// ACT & ASSERT WebApplicationException exception = assertThrows( WebApplicationException.class, () -> orderService.createOrder(invalid) );

assertThat(exception.getResponse().getStatus()).isEqualTo(400); verify(orderRepository, never()).persist(any(Order.class)); verify(fulfillmentPublisher, never()).publishAsync(any()); }

@Test @DisplayName("Should record error event when persistence fails") void givenPersistenceFailure_whenCreateOrder_thenRecordsErrorEvent() { // ARRANGE doThrow(new PersistenceException("database unavailable")) .when(orderRepository).persist(any(Order.class));

// ACT & ASSERT PersistenceException exception = assertThrows( PersistenceException.class, () -> orderService.createOrder(validCommand) );

assertThat(exception.getMessage()).contains("database unavailable"); verify(eventService).createErrorEvent( eq(validCommand), eq("ORDER_CREATE_FAILED"), contains("database unavailable") ); verify(fulfillmentPublisher, never()).publishAsync(any()); }

@Test @DisplayName("Should reject null commands") void givenNullCommand_whenCreateOrder_thenThrowsNullPointerException() { // ACT & ASSERT assertThrows( NullPointerException.class, () -> orderService.createOrder(null) );

verify(orderRepository, never()).persist(any(Order.class)); } } } ```

### Key Testing Patterns

1. **@Nested Classes**: Group tests by method being tested 2. **@DisplayName**: Provide readable test descriptions for test reports 3. **Naming Convention**: `givenX_whenY_thenZ` for clarity 4. **AAA Pattern**: Explicit `// ARRANGE`, `// ACT`, `// ASSERT` comments 5. **@BeforeEach**: Setup common test data to reduce duplication 6. **assertDoesNotThrow**: Test success scenarios without catching exceptions 7. **assertThrows**: Test exception scenarios with message validation using AssertJ 8. **Comprehensive Coverage**: Test happy paths, null inputs, edge cases, exceptions 9. **Verify Interactions**: Use Mockito `verify()` to ensure methods are called correctly 10. **Never Verify**: Use `never()` to ensure methods are NOT called in error scenarios

## Testing Camel Routes

```java @QuarkusTest @DisplayName("Business Rules Camel Route Tests") class BusinessRulesRouteTest {

@Inject CamelContext camelContext;

@Inject ProducerTemplate producerTemplate;

@InjectMock EventService eventService;

@InjectMock DocumentValidator documentValidator;

private BusinessRulesPayload testPayload;

@BeforeEach void setUp() { // ARRANGE - Test data testPayload = new BusinessRulesPayload(); testPayload.setDocumentId(1L); testPayload.setFlowProfile(FlowProfile.BASIC); }

@Nested @DisplayName("Tests for business-rules-publisher route") class BusinessRulesPublisher {

@Test @DisplayName("Should successfully publish message to RabbitMQ") void givenValidPayload_whenPublish_thenMessageSentToQueue() throws Exception { // ARRANGE MockEndpoint mockRabbitMQ = camelContext.getEndpoint("mock:rabbitmq", MockEndpoint.class); mockRabbitMQ.expectedMessageCount(1);

// Replace real endpoint with mock for testing camelContext.getRouteController().stopRoute("business-rules-publisher"); AdviceWith.adviceWith(camelContext, "business-rules-publisher", advice -> { advice.replaceFromWith("direct:business-rules-publisher"); advice.weaveByToString(".*spring-rabbitmq.*").replace().to("mock:rabbitmq"); }); camelContext.getRouteController().startRoute("business-rules-publisher");

// ACT producerTemplate.sendBody("direct:business-rules-publisher", testPayload);

// ASSERT — body is a JSON String after .marshal().json(JsonLibrary.Jackson) mockRabbitMQ.assertIsSatisfied(5000);

assertThat(mockRabbitMQ.getExchanges()).hasSize(1); String body = mockRabbitMQ.getExchanges().get(0).getIn().getBody(String.class); assertThat(body).contains("\"documentId\":1"); }

@Test @DisplayName("Should handle marshalling to JSON") void givenPayload_whenPublish_thenMarshalledToJson() throws Exception { // ARRANGE MockEndpoint mockMarshal = new MockEndpoint("mock:marshal"); camelContext.addEndpoint("mock:marshal", mockMarshal); mockMarshal.expectedMessageCount(1);

camelContext.getRouteController().stopRoute("business-rules-publisher"); AdviceWith.adviceWith(camelContext, "business-rules-publisher", advice -> { advice.weaveAddLast().to("mock:marshal"); }); camelContext.getRouteController().startRoute("business-rules-publisher");

// ACT producerTemplate.sendBody("direct:business-rules-publisher", testPayload);

// ASSERT mockMarshal.assertIsSatisfied(5000);

String body = mockMarshal.getExchanges().get(0).getIn().getBody(String.class); assertThat(body).contains("\"documentId\":1"); assertThat(body).contains("\"flowProfile\":\"BASIC\""); } }

@Nested @DisplayName("Tests for document-processing route") class DocumentProcessing {

@Test @DisplayName("Should route invoice to correct processor") void givenInvoiceType_whenProcess_thenRoutesToInvoiceProcessor() throws Exception { // ARRANGE MockEndpoint mockInvoice = camelContext.getEndpoint("mock:invoice", MockEndpoint.class); mockInvoice.expectedMessageCount(1);

camelContext.getRouteController().stopRoute("document-processing"); AdviceWith.adviceWith(camelContext, "document-processing", advice -> { advice.weaveByToString(".*direct:process-invoice.*").replace().to("mock:invoice"); }); camelContext.getRouteController().startRoute("document-processing");

// ACT producerTemplate.sendBodyAndHeader("direct:process-document", testPayload, "documentType", "INVOICE");

// ASSERT mockInvoice.assertIsSatisfied(5000); }

@Test @DisplayName("Should handle validation errors gracefully") void givenValidationError_whenProcess_thenRoutesToErrorHandler() throws Exception { // ARRANGE MockEndpoint mockError = camelContext.getEndpoint("mock:error", MockEndpoint.class); mockError.expectedMessageCount(1);

camelContext.getRouteController().stopRoute("document-processing"); AdviceWith.adviceWith(camelContext, "document-processing", advice -> { advice.weaveByToString(".*direct:validation-error-handler.*") .replace().to("mock:error"); }); camelContext.getRouteController().startRoute("document-processing");

// Mock validator bean to throw exception when(documentValidator.validate(any())).thenThrow(new ValidationException("Invalid document"));

// ACT producerTemplate.sendBody("direct:process-document", testPayload);

// ASSERT mockError.assertIsSatisfied(5000);

Exception exception = mockError.getExchanges().get(0).getException(); assertThat(exception).isInstanceOf(ValidationException.class); assertThat(exception.getMessage()).contains("Invalid document"); } } } ```

## Testing Event Services

```java @ExtendWith(MockitoExtension.class) @DisplayName("EventService Unit Tests") class EventServiceTest {

@Mock private EventRepository eventRepository;

@Mock private ObjectMapper objectMapper;

@InjectMocks private EventService eventService;

private BusinessRulesPayload testPayload;

@BeforeEach void setUp() { // ARRANGE testPayload = new BusinessRulesPayload(); testPayload.setDocumentId(1L); }

@Nested @DisplayName("Tests for createSuccessEvent") class CreateSuccessEvent {

@Test @DisplayName("Should create success event with correct attributes") void givenValidPayload_whenCreateSuccessEvent_thenEventPersisted() throws Exception { // ARRANGE when(objectMapper.writeValueAsString(testPayload)).thenReturn("{\"documentId\":1}");

// ACT assertDoesNotThrow(() -> eventService.createSuccessEvent(testPayload, "DOCUMENT_PROCESSED"));

// ASSERT verify(eventRepository).persist(argThat(event -> event.getType().equals("DOCUMENT_PROCESSED") && event.getStatus() == EventStatus.SUCCESS && event.getPayload().equals("{\"documentId\":1}") && event.getTimestamp() != null )); }

@Test @DisplayName("Should throw exception when payload is null") void givenNullPayload_whenCreateSuccessEvent_thenThrowsException() { // ARRANGE Object nullPayload = null;

// ACT & ASSERT NullPointerException exception = assertThrows( NullPointerException.class, () -> eventService.createSuccessEvent(nullPayload, "EVENT_TYPE") );

assertThat(exception.getMessage()).isEqualTo("Payload cannot be null"); verify(eventRepository, never()).persist(any()); } }

@Nested @DisplayName("Tests for createErrorEvent") class CreateErrorEvent {

@Test @DisplayName("Should create error event with error message") void givenError_whenCreateErrorEvent_thenEventPersistedWithMessage() throws Exception { // ARRANGE String errorMessage = "Processing failed"; when(objectMapper.writeValueAsString(testPayload)).thenReturn("{\"documentId\":1}");

// ACT assertDoesNotThrow(() -> eventService.createErrorEvent(testPayload, "PROCESSING_ERROR", errorMessage));

// ASSERT verify(eventRepository).persist(argThat(event -> event.getType().equals("PROCESSING_ERROR") && event.getStatus() == EventStatus.ERROR && event.getErrorMessage().equals(errorMessage) && event.getPayload().equals("{\"documentId\":1}") )); }

@ParameterizedTest @DisplayName("Should reject invalid error messages") @ValueSource(strings = {"", " "}) void givenBlankErrorMessage_whenCreateErrorEvent_thenThrowsException(String blankMessage) { // ACT & ASSERT IllegalArgumentException exception = assertThrows( IllegalArgumentException.class, () -> eventService.createErrorEvent(testPayload, "ERROR", blankMessage) );

assertThat(exception.getMessage()).contains("Error message cannot be blank"); } } } ```

## Testing CompletableFuture

```java @ExtendWith(MockitoExtension.class) @DisplayName("FileStorageService Unit Tests") class FileStorageServiceTest {

@Mock private S3Client s3Client;

@Mock private ExecutorService executorService;

@InjectMocks private FileStorageService fileStorageService;

private InputStream testInputStream; private LogContext testLogContext;

@BeforeEach void setUp() { // ARRANGE testInputStream = new ByteArrayInputStream("test content".getBytes()); testLogContext = new LogContext(); testLogContext.put("traceId", "trace-123"); }

@Nested @DisplayName("Tests for uploadOriginalFile") class UploadOriginalFile {

@Test @DisplayName("Should successfully upload file and return document info") void givenValidFile_whenUpload_thenReturnsDocumentInfo() throws Exception { // ARRANGE doAnswer(invocation -> { ((Runnable) invocation.getArgument(0)).run(); return null; }).when(executorService).execute(any(Runnable.class));

when(s3Client.putObject(any(PutObjectRequest.class), any(RequestBody.class))) .thenReturn(PutObjectResponse.builder().build());

// ACT CompletableFuture<StoredDocumentInfo> future = fileStorageService.uploadOriginalFile(testInputStream, 1024L, testLogContext, InvoiceFormat.UBL);

StoredDocumentInfo result = future.join();

// ASSERT assertThat(result).isNotNull(); assertThat(result.getPath()).isNotBlank(); assertThat(result.getSize()).isEqualTo(1024L); assertThat(result.getUploadedAt()).isNotNull();

verify(s3Client).putObject(any(PutObjectRequest.class), any(RequestBody.class)); }

@Test @DisplayName("Should handle S3 upload failure") void givenS3Failure_whenUpload_thenCompletableFutureFails() { // ARRANGE — run synchronously so exception propagates through the future doAnswer(invocation -> { ((Runnable) invocation.getArgument(0)).run(); return null; }).when(executorService).execute(any(Runnable.class));

when(s3Client.putObject(any(PutObjectRequest.class), any(RequestBody.class))) .thenThrow(new StorageException("S3 unavailable"));

// ACT CompletableFuture<StoredDocumentInfo> future = fileStorageService.uploadOriginalFile(testInputStream, 1024L, testLogContext, InvoiceFormat.UBL);

// ASSERT assertThatThrownBy(() -> future.join()) .isInstanceOf(CompletionException.class) .hasCauseInstanceOf(StorageException.class) .hasMessageContaining("S3 unavailable"); }

@Test @DisplayName("Should propagate LogContext to async operation") void givenLogContext_whenUpload_thenContextPropagated() throws Exception { // ARRANGE AtomicReference<LogContext> capturedContext = new AtomicReference<>();

doAnswer(invocation -> { capturedContext.set(CustomLog.getCurrentContext()); ((Runnable) invocation.getArgument(0)).run(); return null; }).when(executorService).execute(any(Runnable.class));

// ACT fileStorageService.uploadOriginalFile(testInputStream, 1024L, testLogContext, InvoiceFormat.UBL).join();

// ASSERT assertThat(capturedContext.get()).isNotNull(); assertThat(capturedContext.get().get("traceId")).isEqualTo("trace-123"); } } } ```

## Resource Layer Tests (REST Assured)

```java @QuarkusTest @DisplayName("DocumentResource API Tests") class DocumentResourceTest {

@InjectMock DocumentService documentService;

@Nested @DisplayName("Tests for GET /api/documents") class ListDocuments {

@Test @DisplayName("Should return list of documents") void givenDocumentsExist_whenList_thenReturnsOk() { // ARRANGE List<Document> documents = List.of(createDocument(1L, "DOC-001")); when(documentService.list(0, 20)).thenReturn(documents);

// ACT & ASSERT given() .when().get("/api/documents") .then() .statusCode(200) .body("$.size()", is(1)) .body("[0].referenceNumber", equalTo("DOC-001")); } }

@Nested @DisplayName("Tests for POST /api/documents") class CreateDocument {

@Test @DisplayName("Should create document and return 201") void givenValidRequest_whenCreate_thenReturns201() { // ARRANGE Document document = createDocument(1L, "DOC-001"); when(documentService.create(any())).thenReturn(document);

// ACT & ASSERT given() .contentType(ContentType.JSON) .body(""" { "referenceNumber": "DOC-001", "description": "Test document", "validUntil": "2030-01-01T00:00:00Z", "categories": ["test"] } """) .when().post("/api/documents") .then() .statusCode(201) .header("Location", containsString("/api/documents/1")) .body("referenceNumber", equalTo("DOC-001")); }

@Test @DisplayName("Should return 400 for invalid input") void givenInvalidRequest_whenCreate_thenReturns400() { // ACT & ASSERT given() .contentType(ContentType.JSON) .body(""" { "referenceNumber": "", "description": "Test" } """) .when().post("/api/documents") .then() .statusCode(400); } }

private Document createDocument(Long id, String referenceNumber) { Document document = new Document(); document.setId(id); document.setReferenceNumber(referenceNumber); document.setStatus(DocumentStatus.PENDING); return document; } } ```

## Integration Tests with Real Database

```java @QuarkusTest @TestProfile(IntegrationTestProfile.class) @DisplayName("Document Integration Tests") class DocumentIntegrationTest {

@Test @Transactional @DisplayName("Should create and retrieve document via API") void givenNewDocument_whenCreateAndRetrieve_thenSuccessful() { // ACT - Create via API Long id = given() .contentType(ContentType.JSON) .body(""" { "referenceNumber": "INT-001", "description": "Integration test", "validUntil": "2030-01-01T00:00:00Z", "categories": ["test"] } """) .when().post("/api/documents") .then() .statusCode(201) .extract().path("id");

// ASSERT - Retrieve via API given() .when().get("/api/documents/" + id) .then() .statusCode(200) .body("referenceNumber", equalTo("INT-001")); } } ```

## Coverage with JaCoCo

### Maven Configuration (Complete)

```xml <plugin> <groupId>org.jacoco</groupId> <artifactId>jacoco-maven-plugin</artifactId> <version>0.8.13</version> <executions> <!-- Prepare agent for test execution --> <execution> <id>prepare-agent</id> <goals> <goal>prepare-agent</goal> </goals> </execution>

<!-- Generate coverage report --> <execution> <id>report</id> <phase>verify</phase> <goals> <goal>report</goal> </goals> </execution>

<!-- Enforce coverage thresholds --> <execution> <id>check</id> <goals> <goal>check</goal> </goals> <configuration> <rules> <rule> <element>BUNDLE</element> <limits> <limit> <counter>LINE</counter> <value>COVEREDRATIO</value> <minimum>0.80</minimum> </limit> <limit> <counter>BRANCH</counter> <value>COVEREDRATIO</value> <minimum>0.70</minimum> </limit> </limits> </rule> </rules> </configuration> </execution> </executions> </plugin> ```

Run tests with coverage: ```bash mvn clean test mvn jacoco:report mvn jacoco:check

# Report at: target/site/jacoco/index.html ```

## Test Dependencies

```xml <dependencies> <!-- Quarkus Testing --> <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-junit5</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-junit5-mockito</artifactId> <scope>test</scope> </dependency>

<!-- Mockito --> <dependency> <groupId>org.mockito</groupId> <artifactId>mockito-core</artifactId> <scope>test</scope> </dependency>

<!-- AssertJ (preferred over JUnit assertions) --> <dependency> <groupId>org.assertj</groupId> <artifactId>assertj-core</artifactId> <version>3.24.2</version> <scope>test</scope> </dependency>

<!-- REST Assured --> <dependency> <groupId>io.rest-assured</groupId> <artifactId>rest-assured</artifactId> <scope>test</scope> </dependency>

<!-- Camel Testing --> <dependency> <groupId>org.apache.camel.quarkus</groupId> <artifactId>camel-quarkus-junit5</artifactId> <scope>test</scope> </dependency> </dependencies> ```

## Best Practices

### Test Organization - Use `@Nested` classes to group tests by method being tested - Use `@DisplayName` for readable test descriptions visible in reports - Follow `givenX_whenY_thenZ` naming convention for test methods - Use `@BeforeEach` for common test data setup to reduce duplication

### Test Structure - Follow AAA pattern with explicit comments (`// ARRANGE`, `// ACT`, `// ASSERT`) - Use `assertDoesNotThrow` for success scenarios - Use `assertThrows` for exception scenarios with message validation - Verify exception messages match expected values using AssertJ `contains()` or `isEqualTo()`

### Test Coverage - Test happy paths for all public methods - Test null input handling - Test edge cases (empty collections, boundary values, negative IDs, blank strings) - Test exception scenarios comprehensively - Mock all external dependencies (repositories, services, Camel endpoints) - Aim for 80%+ line coverage, 70%+ branch coverage

### Assertions - **Prefer AssertJ** (`assertThat`) over JUnit assertions for value checks - Use fluent AssertJ API for readability: `assertThat(list).hasSize(3).contains(item)` - For exceptions: use JUnit `assertThrows` to capture, then AssertJ to validate the message - For non-throwing success paths: use JUnit `assertDoesNotThrow` - For collections: `extracting()`, `filteredOn()`, `containsExactly()`

### Testing Integration - Use `@QuarkusTest` for integration tests - Use `@InjectMock` to mock dependencies in Quarkus tests - Prefer REST Assured for API testing - Use `@TestProfile` for test-specific configuration

### Event-Driven Testing - Test Camel routes with `AdviceWith` and `MockEndpoint` - Use `@CamelQuarkusTest` annotation (if using standalone Camel tests) - Verify message content, headers, and routing logic - Test error handling routes separately - Mock external systems (RabbitMQ, S3, databases) in unit tests

### Camel Route Testing - Use `MockEndpoint` for asserting message flow - Use `AdviceWith` to modify routes for testing (replace endpoints with mocks) - Test message transformation and marshalling - Test exception handling and dead letter queues

### Testing Async Operations - Test CompletableFuture success and failure scenarios - Use `.join()` in tests to wait for async completion - Test exception propagation from CompletableFuture - Verify LogContext propagation to async operations

### Performance - Keep tests fast and isolated - Run tests in continuous mode: `mvn quarkus:test` - Use parameterized tests (`@ParameterizedTest`) for input variations - Build reusable test data builders or factory methods

### Quarkus-Specific - Stay on latest LTS version (Quarkus 3.x) - Test native compilation compatibility periodically - Use Quarkus test profiles for different scenarios - Leverage Quarkus dev services for local testing - Use `@InjectMock` instead of `@MockBean` (Quarkus-specific)

### Verification Best Practices - Always verify interactions on mocked dependencies - Use `verify(mock, never())` to ensure methods are NOT called in error scenarios - Use `argThat()` for complex argument matching - Verify the order of calls when it matters: `InOrder` from Mockito

Intended uses

  • New features or REST endpoints
  • Bug fixes or refactors
  • Adding data access logic, security rules, or reactive streams
  • Testing Apache Camel routes and event handlers
  • Testing event-driven services with RabbitMQ
  • Testing conditional flow logic
  • Validating CompletableFuture async operations
  • Testing LogContext propagation
  • Write tests first (they should fail)
  • Implement minimal code to pass
  • Refactor with tests green
  • Enforce coverage with JaCoCo (80%+ target)

Implementation notes

  • Review the source instructions and adapt inputs before running the workflow.

Try it, then tell us how it went

A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.