Is the usage of lombok's @RequiredArgsConstructor good or bad in @QuarkusTest integration tests?

[tippfelher]

I wonder if there is a reason that @requiredargsconstructor should be avoided or not. What is best practice and why?

[rameshreddy-adutla]

Great question! The short answer: avoid @RequiredArgsConstructor in @QuarkusTest classes — it works in some cases but can cause subtle issues.

Why it's problematic

Quarkus uses CDI (Contexts and Dependency Injection) under the hood. CDI has specific rules about how beans are instantiated:

1. CDI requires a no-arg constructor (or a constructor annotated with @Inject). Lombok's @RequiredArgsConstructor generates a constructor with parameters but does NOT add @Inject.

2. In @QuarkusTest, the test class is managed by the CDI container. If CDI can't find a no-arg constructor or an @Inject-annotated constructor, injection may silently fail or throw errors.

3. Field injection with @Inject is the standard pattern in Quarkus tests and is what the documentation recommends.

Best practice

@QuarkusTest
class MyServiceTest {

    @Inject
    MyService myService;  // ✅ Standard Quarkus way

    @InjectMock
    ExternalClient client; // ✅ For mocks

    @Test
    void shouldDoSomething() {
        // test code
    }
}

In production code (non-test)

For application beans, constructor injection IS recommended, but use @Inject explicitly:

@ApplicationScoped
public class MyService {

    private final MyRepository repo;

    @Inject // explicit — no Lombok needed
    public MyService(MyRepository repo) {
        this.repo = repo;
    }
}

Or if you really want Lombok, combine it with @Inject:

@ApplicationScoped
@RequiredArgsConstructor(onConstructor_ = @Inject)
public class MyService {
    private final MyRepository repo;
}

But note that Quarkus (unlike Spring) does not auto-detect single-constructor injection — you always need @Inject.

TL;DR: Use @Inject field injection in test classes. Use explicit @Inject constructor in production beans. Lombok's @RequiredArgsConstructor alone is not enough for CDI.

[Martzcode]

To add a bit more nuance to the existing answer: @RequiredArgsConstructor in @QuarkusTest is not just risky — it will silently fail in most CDI-managed scenarios, and the failure mode is particularly tricky to diagnose.

Why it silently fails

Quarkus test classes annotated with @QuarkusTest are CDI-managed. CDI creates instances using either:

1. A no-arg constructor (then field injection via @Inject)
2. A constructor explicitly annotated with @Inject

Lombok's @RequiredArgsConstructor generates a constructor with all final fields as parameters, but without @Inject. CDI sees a class with no eligible constructor for injection, falls back to the no-arg constructor (which doesn't exist either), and the result depends on the CDI implementation — it may throw, or worse, silently inject null into your fields.

The one case where it "works" (and shouldn't be relied on)

If your test class has no @Inject-annotated fields at all and you only use @RequiredArgsConstructor for non-CDI collaborators, it may appear to work. But the moment you add an @Inject field, the behavior becomes undefined.

The correct pattern in @QuarkusTest

@QuarkusTest
class MyServiceTest {
    
    @Inject
    MyService myService;
    
    @InjectMock
    ExternalClient externalClient;
    
    @Test
    void shouldReturnResult() { ... }
}

If you genuinely want constructor injection in tests

Use @QuarkusComponentTest instead (available since Quarkus 3.x) — it creates a lightweight CDI container specifically for unit testing individual components, and constructor injection with @Inject works correctly:

@QuarkusComponentTest
class MyServiceComponentTest {

    @Inject
    MyService myService; // MyService is the component under test

    @Test
    void test() { ... }
}

TL;DR: Avoid @RequiredArgsConstructor in @QuarkusTest — use @Inject field injection. If you want constructor injection, use @QuarkusComponentTest.

[MILLERMARRU]

Both existing answers explain why it breaks — to complete the picture, here is how to actually fix it when you want constructor injection in @QuarkusTest:

Use @Inject on the constructor instead of @RequiredArgsConstructor:

@QuarkusTest
public class MyServiceTest {

    private final MyService myService;

    @Inject
    public MyServiceTest(MyService myService) {
        this.myService = myService;
    }
}

Or switch to field injection for test classes:

@QuarkusTest
public class MyServiceTest {

    @Inject
    MyService myService;  // field injection works perfectly with CDI
}

If you need @RequiredArgsConstructor for production beans, that is fine — just do not use it on the @QuarkusTest class itself. Test classes are CDI-managed by Quarkus, so they follow CDI rules: either a no-arg constructor with @Inject fields, or a constructor explicitly annotated with @Inject.