Why is Quarkus mixing up unit tests with integration tests and service tests?

[HerrDerb]

In quarkus, there are @QuarkusTest and @QuarkusIntegrationTest

As far as I know, quarkus describes @QuarkusTest not as integration tests, which means they are understood as unit tests. Also qaurkus encourages to mainly use @QuarkusTest for unit tests (at least that's what I feel, as e.g. you run into problems with jacoco when mixing up regular junit test with @QuarkusTest ), altought @QuarkusTest start the whole application context with DI and which is definetly way above the scope of a unit test. In other words @QuarkusTest exactly represents what an integration test is. This seems like quarkus is discurraging writing regular plain and fast unit tests, which seems really weird to me and definitly not best practice.

Then we have @QuarkusIntegrationTest, which represent black box service test. Which are actually again, above the scope of an integration test.

I'm am really confused of the whole quarkus test concept and it feels to me like well reasoned principles are just thrown over board for something "new, cool and fancy".

What are the reasons for those decisions? Meybe there is something I didn't understand?

[rr-nagasyamala-appikatla]

I have the same feeling as @HerrDerb. I'm trying to write unit tests but I don't see a way, and I only find tests with @QuarkusTest which are tests(rest client integration tests). Is there a way to write unitTests in quarkus application? Thanks.

[maxandersen]

Hi,

Seems we missed answering this old thread. Lets fix that.

Quarkus allows all the different ways of testing that you are after; it's just that what is which level of testing (unit, integration, service, etc.) varies dependent on the observer. Someone's unit is someone else's integration or service test. Just look at JUnit - it's name is indicating unit tests but it can be used in all the various levels.

Also maven/gradle uses different phases of their execution to do the tests which increases the confusion.

The terms gets overloaded.

Let's try cover the various approaches and it might help grok the situation.

Unit tests - as in small and fast tests using no injection and wiring is all possible. Just use traditional @test annotation. We don't cover it much in the docs since it does not require any use of Quarkus framework to do that testing. Use @QuarkusTest if you want to test where you need to have the framework active and perform the various lifecycle and injections needed. These still runs fast; but just the mere fact we are now starting to test the code at the level where Quarkus framework is involved the nature of the test is higher level than a single class. We refrain from calling it integration tests as it is still mainly just testing a single unit (the rest endpoint) using the api (rest) it exposes.

Integration/service tests - you can still use @test and @QuarkusTest for this but we have @QuarkusIntegration test annotation that is used when wanting to write tests at the level of actually having the full jar or native image built and executed. Which for technical reasons are done in the phase named integration test by maven/gradle.

We do not encourage use of unit tests when it involves native image as it requires multiple slow builds and you end up not testing the real thing. That's why you see our examples use more end point testing as it can be done both in jvm and native image mode.

Hope that helps.

[nithinbandaru1]

Regarding Unit tests

@maxandersen's reply makes total sense about unit tests. I recently had a discussion with my colleague about this. Colleague was suspecting that it's better to use @QuarkusTest for the unit tests by pointing to the documentation Getting Started - Testing.

When I read the documentation there wasn't anywhere explicitly mentioned that you do not need to use @QuarkusTest annotation when you don't have framework dependencies like CDI things.

It would be great if you guys can add that explicitly in the documentation to remove the confusion.

- Regarding @QuarkusTest annotated tests calling unit tests

In general, when we say unit tests it has to just test at class level and not anything above it. If you use @QuarkusTest you are injecting dependencies. So, you are adding that class dependencies and then testing. So, by definition these are not Unit tests. These are integration tests.

Based on my experience I feel that we should look all tests that are not unit tests can be called as integration tests. They can be of multiple flavors covering different scopes of the application.

I feel that you should name these tests (@QuarkusTest) as Component tests which will inject all original in-component dependencies like Beans, but your tests are not making network calls, all are running in same process. Ideally, we will also mocking external dependencies at this level like OAuth server, Database, External queues etc.

@QuarkusIntegrationTest tests can be called as integration tests as they make true network calls. Feels like tested in environment setup.

I also feel that maybe if you go will different naming for annotations like

@QuarkusTest => @QuarkusInject or @QuarkusCDIInject or @QuarkusFrameworkInject
QuarkusIntegrationTest => @QuarkusAppStartBeforeTest

This naming makes things very clear when to use and when not to use and also especially what they do. For example we use @Inject for doing generic injection. Similarly @QuarkusInject will say you are injecting using Quarkus framework.

[kauanmocelin]

I have the same feeling as @HerrDerb. I'm trying to write unit tests but I don't see a way, and I only find tests with @QuarkusTest which are tests(rest client integration tests). Is there a way to write unitTests in quarkus application? Thanks.

Yes, just annotate the method with @test without any annotation at class.