Link: https://github.com/caspianb/dropwizard-testing
https://central.sonatype.com/artifact/com.logicalbias/dropwizard-testing

I recently (first half of this year) started at a company which uses DropWizard for a lot of their services. I had never used DropWizard before, but I have many years of Spring Boot experience; including writing auto-configuration libraries for things like multi-tenant security, database access, kafka, and so on at previous company.

There are many things that I find I like about DropWizard, but I also find that I miss some of the niceties that the Spring Boot world provides. Especially when it comes to writing "integration" tests - and by integration tests, I mean unit tests where I would define the unit as the API of the service. So you might still use an embedded database or kafka while mocking out things like web clients which call other services.

In SpringBoot, you can spin up the application, start up an embedded database, embedded kafka, and mock out services just by popping a few annotations on the test class. I looked into the DropwizardAppExtension and have done much the same thing against DropWizard testing.

Here's a (working) example of a test in a sandbox project using custom annotations I have created (these annotations can also be placed on an interface or parent class and will be inherited).

@Slf4j
@DropwizardTest(value = DropwizardApplication.class, configFile = "config.yml", properties = "dynamo.embedded=false")
@MockBean(UserService.class)
@Import(OrderResourceTest.TestOrderService.class)
@DynamoDbTest(environment = DynamoDbTest.Environment.DOCKER)
@KafkaTest(properties = {
        "kafka.consumer.bootstrapServers=${bootstrapServers}",
        "kafka.producer.bootstrapServers=${bootstrapServers}"
})
class OrderResourceTest {
    private final TestClient client;
    private final UserService userService;
    private final ObjectMapper objectMapper;
    private final OutboxService outboxService;
    private final Consumer<String, String> consumer;

    OrderResourceTest(
            TestClient client,
            UserService userService,
            ObjectMapper objectMapper,
            ConsumerFactory consumerFactory,
            OutboxService outboxService) {
        this.client = client;
        this.userService = userService; // This is a Mockito mock and can be configured accordingly

        this.objectMapper = objectMapper;
        this.outboxService = outboxService;

        this.consumer = consumerFactory.createConsumer("test-group");
        consumer.subscribe(List.of(TestOrderService.ORDER_UPDATED_EVENT_TOPIC));
    }

    // ... Example of TestClient usage which is included as part of my base dropwizard test library
    OrderDto createOrder(String item, int quantity) {
        var orderDto = OrderDto.builder()
                .item(item)
                .quantity(quantity)
                .build();

        return client.post("orders")
                .body(orderDto)
                .expectStatus(Response.Status.CREATED)
                .invoke(OrderDto.class);
    }

   // rest of the test

The first thing to notice is @DropwizardTest which, at its core, is just an annotation wrapper around the dropwizard-testing DropwizardAppExtension class. It uses an annotation based approach to create it and inject it into the test. It also provides a @MockBean and @Import annotation which will inject mocks (Mockito) or test classes into the HK2 context. Assuming the service uses HK2 instead of manually 'newing' the dependencies, this means the running test application will execute against these imported or mocked classes allowing the test to target mock specific spots inside the running application.

Building off that, I also created a dynamo testing module which uses the above hook points to inject database clients into the running application which target an embedded or dockerized container (the same could be done for JDBC, Mongo, or whatever other 3rd party dependencies you might want to mock/containerize out in the test application -- such as Kafka as the @KafkaTest annotation shows above to start up an embedded kafka service and inject the connection properties back into the test application).

I do wonder if the base @DropwizardTest annotation, @MockBean, @Import are something that might be considered for dropwizard-testing or should I look at releasing my own standalone testing library built on top of it? Would there be any interest in such a tool?