@QuarkusComponentTest fails on nested test classes

[slinstaedt-hlag]

Describe the bug

Given

Quarkus version: 3.17.8
Extensions: quarkus-junit5-component

When

Having a any CDI bean (dummy MyService used in this case) and test class like

@QuarkusComponentTest
class NestedComponentTest {

    @Inject
    private MyService testUnit;

    @Test
    void topLevel() {
    }

    @Nested
    class NonStaticInnerClass {

        @Test
        void nested() {
        }
    }
}

Then

java.lang.IllegalStateException: No component classes to test

Expected behavior

The extension should handle nested test classes, as these are often used to structure more complex test scenarios, for which especially @QuarkusComponentTest is a good candidate to reduce mocking efforts.

Actual behavior

No response

How to Reproduce?

No response

Output of uname -a or ver

No response

Output of java -version

No response

Quarkus version or git rev

No response

Build tool (ie. output of mvnw --version or gradlew --version)

No response

Additional information

No response

[quarkus-bot]

/cc @geoand (testing)

[gsmet]

/cc @mkouba

[RayanArgolo03]

Other problem when we used @nested:

java.lang.IllegalStateException: The injected field [dev.rayan.services.AuthenticationService dev.rayan.services.AuthenticationServiceTest.service] expects a real component; but no matching component was registered

	at io.quarkus.test.component.QuarkusComponentTestExtension$FieldInjector.<init>(QuarkusComponentTestExtension.java:1169)
	at io.quarkus.test.component.QuarkusComponentTestExtension.injectFields(QuarkusComponentTestExtension.java:1055)
	at io.quarkus.test.component.QuarkusComponentTestExtension.startContainer(QuarkusComponentTestExtension.java:501)
	at io.quarkus.test.component.QuarkusComponentTestExtension.beforeEach(QuarkusComponentTestExtension.java:237)
	at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.accept(ForEachOps.java:183)
	at java.base/java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:197)
	at java.base/java.util.stream.ReferencePipeline$2$1.accept(ReferencePipeline.java:179)
	at java.base/java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:197)
	at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.accept(ForEachOps.java:183)
	at java.base/java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:197)
	at java.base/java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:197)
	at java.base/java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:197)
	at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.accept(ForEachOps.java:183)
	at java.base/java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:197)
	at java.base/java.util.Spliterators$ArraySpliterator.forEachRemaining(Spliterators.java:992)
	at java.base/java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:509)
	at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:499)
	at java.base/java.util.stream.ForEachOps$ForEachOp.evaluateSequential(ForEachOps.java:150)
	at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.evaluateSequential(ForEachOps.java:173)
	at java.base/java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
	at java.base/java.util.stream.ReferencePipeline.forEach(ReferencePipeline.java:596)
	at java.base/java.util.stream.ReferencePipeline$7$1.accept(ReferencePipeline.java:276)
	at java.base/java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:197)
	at java.base/java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:197)
	at java.base/java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:197)
	at java.base/java.util.ArrayList$ArrayListSpliterator.forEachRemaining(ArrayList.java:1625)
	at java.base/java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:509)
	at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:499)
	at java.base/java.util.stream.ForEachOps$ForEachOp.evaluateSequential(ForEachOps.java:150)
	at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.evaluateSequential(ForEachOps.java:173)
	at java.base/java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
	at java.base/java.util.stream.ReferencePipeline.forEach(ReferencePipeline.java:596)
	at java.base/java.util.stream.ReferencePipeline$7$1.accept(ReferencePipeline.java:276)
	at java.base/java.util.ArrayList$ArrayListSpliterator.forEachRemaining(ArrayList.java:1625)
	at java.base/java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:509)
	at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:499)
	at java.base/java.util.stream.ForEachOps$ForEachOp.evaluateSequential(ForEachOps.java:150)
	at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.evaluateSequential(ForEachOps.java:173)
	at java.base/java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
	at java.base/java.util.stream.ReferencePipeline.forEach(ReferencePipeline.java:596)
	at java.base/java.util.ArrayList.forEach(ArrayList.java:1511)
	at java.base/java.util.ArrayList.forEach(ArrayList.java:1511)
	at java.base/java.util.ArrayList.forEach(ArrayList.java:1511)

Image:

My code:

@QuarkusComponentTest
@DisplayName("--- Authentication service tests ---")
public class AuthenticationServiceTest {

@Inject
AuthenticationService service;

@InjectMock
CredentialRepository credentialRepository;

@InjectMock
ForgotPasswordRepository forgotPasswordRepository;

@InjectMock
CredentialMapper credentialMapper = Mappers.getMapper(CredentialMapper.class);

@InjectMock
ForgotPasswordMapper forgotPasswordMapper = Mappers.getMapper(ForgotPasswordMapper.class);

Validator hibernateValidator = Validation.buildDefaultValidatorFactory().getValidator();

@Nested
@DisplayName("--- CredentialRequest tests ")
class CredentialRequestTests {

    @Test
    @DisplayName("Must have one violation when email is null")
    void givenPersistCredential_whenEmailIsNull_thenThrowConstraintViolationException() {

        final String password = "#Rayan12";
        final CredentialRequest request = new CredentialRequest(new EmailRequest(null), password);


        final Set<ConstraintViolation<CredentialRequest>> violations = hibernateValidator.validate(request);

        final String message = violations.iterator().next().getMessage(),
                expectedMessage = "Email required!";

        final int size = violations.size(),
                expectedSize = 1;

        assertEquals(expectedSize, violations.size());
        assertEquals(expectedMessage, message);

    }

    @ParameterizedTest
    @ValueSource(strings = {
            "", " ", "plainaddress", "@missingusername.com", "username@.com", "username@.com.", "username@domain..com",
            "username@domain.c", "username@domain.toolong", "username@domain,com", "username@domain@domain.com",
            "username@domain..com", "username@domain.com (Joe Smith)", "username@domain.com.", "username@domain.com-",
            "username@domain.com_", "username@domain.com+", "username@domain.com%", "username@domain.com#",
            "username@domain.com$", "username@domain.com!", "username@domain.com^", "username@domain.com&",
            "username@domain.com*", "username@domain.com(", "username@domain.com)", "username@domain.com=",
            "username@domain.com{", "username@domain.com}", "username@domain.com[", "username@domain.com]"
    })
    @DisplayName("Must have one violation when email is invalid in pattern xxx@domain.com")
    void givenPersistCredential_whenEmailIsInvalid_thenThrowConstraintViolationException(@SkipInject final String email) {

        final String password = "#Rayan12";
        final CredentialRequest request = new CredentialRequest(new EmailRequest(email), password);

        final Set<ConstraintViolation<CredentialRequest>> violations = hibernateValidator.validate(request);

        final String message = violations.iterator().next().getMessage(),
                expectedMessage = "Invalid email! Pattern required: xxx@domain.com";

        final int size = violations.size(),
                expectedSize = 1;

        assertEquals(expectedSize, size);
        assertEquals(expectedMessage, message);

    }

    @Test
    @DisplayName("Must have one violation when password is null")
    void givenPersistCredential_whenPasswordIsNull_thenThrowConstraintViolationException() {

        final String email = "admin@gmail.com";
        final CredentialRequest request = new CredentialRequest(new EmailRequest(email), null);

        final Set<ConstraintViolation<CredentialRequest>> violations = hibernateValidator.validate(request);

        final String message = violations.iterator().next().getMessage(),
                expectedMessage = "Password required!";

        final int size = violations.size(),
                expectedSize = 1;

        assertEquals(expectedSize, size);
        assertEquals(expectedMessage, message);
    }

    @ParameterizedTest
    @ValueSource(strings = {
            "abcde", "ABCDE", "12345", "abc123", "ABC123", "abc!@#", "123!@#", "abcABC", "abcABC123",
            "abcABC!@#", "123ABC!@#", "abc123!@#", "abcABC123!@#", "abcdE", "abcdE1",
            "abcdE1!@#", "abcdE1!@#2", "abcdE1!@#23", "abcdE1!@#234", "abcdE1!@#2345", "abcdE1!@#23456", "abcdE1!@#234567",
            "abcdE1!@#2345678", "abcdE1!@#23456789", "abcdE1!@#234567890", "abcdE1!@#2345678901"
    })
    @DisplayName("Must have one violation when password is invalid in pattern '5 and 8 characters, at least 1 special character and a capital letter'")
    void givenPersistCredential_whenPasswordIsInvalid_thenThrowConstraintViolationException(@SkipInject final String password) {

        final String email = "admin@gmail.com";
        final CredentialRequest request = new CredentialRequest(new EmailRequest(email), password);

        final Set<ConstraintViolation<CredentialRequest>> violations = hibernateValidator.validate(request);

        final String message = violations.iterator().next().getMessage(),
                expectedMessage = "Invalid password! Between 5 and 8 characters, at least 1 special character and a capital letter!";

        final int size = violations.size(),
                expectedSize = 1;

        assertEquals(expectedSize, size);
        assertEquals(expectedMessage, message);

    }
}


@Nested
@DisplayName("---- Persist credential tests ----")
class PersistCredentialTests {

    CredentialRequest request;

    @BeforeEach
    void setUp() {
        request = new CredentialRequest(new EmailRequest("admin@gmail.com"), "#Admin12");
    }

    @Test
    @DisplayName("Should be throw WebApplicationException with status code 409 Conflict when email already exists")
    void givenPersistCredential_whenRequestEmailIsPresent_thenThrowWebApplicationException() {

        final Credential credential = new Credential();

        when(credentialRepository.findCredentialByEmail(request.emailRequest().email()))
                .thenReturn(Optional.of(credential));

        final WebApplicationException e = assertThrows(WebApplicationException.class,
                () -> service.persistCredential(request));

        final String expectedMessage = format("Client with email %s already exists!", request.emailRequest().email());
        final Response.Status expectedStatusCode = CONFLICT;

        assertEquals(expectedMessage, e.getMessage());
        assertEquals(expectedStatusCode, e.getResponse().getStatusInfo().toEnum());

        verify(credentialRepository, times(1)).findCredentialByEmail(request.emailRequest().email());
    }

    @Test
    @DisplayName("Should persist and return CredentialResponse when request is valid")
    void givenPersistCredential_whenRequestIsValid_thenPersistAndReturnCredentialResponse() {

        final Credential credential = Credential.builder()
                .id(UUID.randomUUID())
                .email(request.emailRequest().email())
                .password(CryptographyUtils.encrypt(request.password()))
                .build();

        final CredentialResponse expectedResponse = CredentialResponse.builder()
                .id(credential.getId())
                .email(credential.getEmail())
                .password(credential.getPassword())
                .createdAt(credential.getCreatedAt())
                .keycloakUserId(null)
                .build();

        when(credentialRepository.findCredentialByEmail(request.emailRequest().email()))
                .thenReturn(Optional.empty());

        when(credentialMapper.requestToCredential(request)).thenReturn(credential);
        doNothing().when(credentialRepository).persist(credential);
        when(credentialMapper.credentialToResponse(credential)).thenReturn(expectedResponse);

        final CredentialResponse response = service.persistCredential(request);

        assertEquals(response, expectedResponse);

        verify(credentialRepository).findCredentialByEmail(request.emailRequest().email());
        verify(credentialMapper).requestToCredential(request);
        verify(credentialRepository).persist(credential);
        verify(credentialMapper).credentialToResponse(credential);
    }
}