[JAVA] Introduction à Micronaut 2 ~ Test unitaire ~

Aperçu

Introduction à Micronaut 1 ~ Introduction ~ suite Effectuez un test unitaire en étendant légèrement le HelloController créé la dernière fois. Utilisez le module d'extension Micronaut Micronaut Test.

Qu'est-ce que le test Micronaut?

Cadre de test pour Micronaut

Vous pouvez tester avec l'un ou l'autre. Cette fois, nous allons tester avec JUnit 5.

Modification / ajout de classe d'implémentation

Correction du contrôleur

Ajoutez une méthode de test à HelloController.

HelloController.java


import io.micronaut.http.MediaType;
import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;
import my.app.service.HelloService;

@Controller("/hello")
public class HelloController {
    HelloService helloService;

    HelloController(HelloService helloService) {
        this.helloService = helloService;
    }

    @Get(produces = MediaType.TEXT_PLAIN)
    public String index() {
        return "hello world!!";
    }

    //Ajouté pour tester avec plusieurs paramètres
    @Get(uri = "/{path}",processes = MediaType.TEXT_PLAIN)
    public String index(String path) {
        return path;
    }

    //Traitement de classe de service ajouté pour la confirmation simulée
    @Get(uri = "/compute/{number}",processes = MediaType.TEXT_PLAIN)
    public String compute(Integer number) {
        //Définissez la méthode de calcul sur Mock pendant le test.
        return String.valueOf(helloService.compute(number));
    }
}
Ajouter une classe de service

HelloService


public interface HelloService {
    public Integer compute(Integer num);
}

HelloServiceImpl


import javax.inject.Singleton;

@Singleton
public class HelloServiceImpl implements HelloService {
    @Override
    public Integer compute(Integer num) {
        return num * 4;
    }
}

Test de l'unité

Ajouter des bibliothèques dépendantes

build.gradle


dependencies {
・ ・ ・
    testAnnotationProcessor "io.micronaut:micronaut-inject-java"
    testCompile "io.micronaut.test:micronaut-test-junit5"
    testCompile "org.junit.jupiter:junit-jupiter-params"
    testCompile "org.mockito:mockito-core:2.24.5"
    testRuntime "org.junit.jupiter:junit-jupiter-engine"
}
Ajout d'un test unitaire

HelloControllerTest.java


import io.micronaut.http.HttpRequest;
import io.micronaut.http.client.RxHttpClient;
import io.micronaut.http.client.annotation.Client;
import io.micronaut.test.annotation.MicronautTest;
import io.micronaut.test.annotation.MockBean;
import my.app.service.HelloService;
import my.app.service.HelloServiceImpl;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.ValueSource;

import javax.inject.Inject;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.*;

@MicronautTest
public class HelloControllerTest {
    //Tester HelloController avec RxHttpClient
    @Inject
    @Client("/")
    RxHttpClient client;

    @Inject
    HelloService helloService;

    @Test
    void testHelloIndex() {
        final String result = client.toBlocking().retrieve(HttpRequest.GET("/hello"), String.class);
        assertEquals(
                "hello world!!",
                result
        );
    }

    @ParameterizedTest
    //Vous pouvez passer plusieurs paramètres et tester plusieurs fois avec la même source
    @ValueSource(strings = { "racecar", "radar" })
    void testHelloIndexPath(String path) {
        final String result = client.toBlocking().retrieve(HttpRequest.GET("/hello/" + path), String.class);
        assertEquals(
                path,
                result
        );
    }

    @ParameterizedTest
    @CsvSource({"2,4", "3,9"})
    void testComputeNumToSquare(Integer num, Integer square) {

        //Définir le comportement de Mock
        when(helloService.compute(num))
                .then(invocation -> Long.valueOf(Math.round(Math.pow(num, 2))).intValue());

        //Appelez le contrôleur pour obtenir le résultat
        final Integer result = client.toBlocking().retrieve(HttpRequest.GET("/hello/compute/" + num), Integer.class);

        assertEquals(
                square,
                result
        );
        verify(helloService).compute(num);
    }

    //Définition fictive à l'aide de MockBean
    @MockBean(HelloServiceImpl.class)
    HelloService mathService() {
        return mock(HelloService.class);
    }
}

Impressions

Puisqu'il s'agit d'un test unitaire utilisant JUnit, la barrière d'introduction semble faible. Depuis que Micronaut a démarré rapidement, le test était léger et bon.

référence

https://micronaut-projects.github.io/micronaut-test/latest/guide/index.html

Recommended Posts

Introduction à Micronaut 2 ~ Test unitaire ~
Introduction à Micronaut 1 ~ Introduction ~
Comment faire un test unitaire de Spring AOP
Introduction à Ruby 2
Bibliothèque de tests unitaires Java Artery-Easy to use
Introduction à web3j
[Java] Introduction à Java
Introduction à la migration
Introduction à Java
Introduction à Doma
Introduction à Ratpack (8) - Session
Introduction à l'arithmétique des bits
Introduction à Ratpack (6) - Promesse
Introduction à Ratpack (9) --Thymeleaf
Introduction à PlayFramework 2.7 ① Présentation
Introduction à la mise en page Android
Échantillon de bibliothèque de tests unitaires Java
Introduction aux modèles de conception (introduction)
Introduction à la programmation pratique
Introduction à la commande javadoc
Introduction à la commande jar
Introduction à Ratpack (2) -Architecture
Introduction au style lambda
Faites un test unitaire avec Junit.
Introduction à la commande java
Introduction au développement de Keycloak
Introduction à la commande javac
Comment écrire un test unitaire pour Spring Boot 2
Comment faire un test unitaire avec JVM sur une source à l'aide de RxAndroid
Comment écrire dynamiquement des cas de test itératifs à l'aide de test / unit (Test :: Unit)
Introduction aux modèles de conception (Builder)
Introduction au développement d'applications Android
Introduction à Ratpack (5) --Json & Registry
Introduction à la métabase ~ Construction de l'environnement ~
Introduction à Ratpack (7) --Guice & Spring
(Installation par points) Introduction à Java8_Impression
[IntelliJ IDEA] Effectuer un test d'unité
Introduction aux modèles de conception (composite)
Introduction à JUnit (note d'étude)
Introduction à Spring Boot ① ~ DI ~
Test unitaire d'architecture avec ArchUnit
Introduction aux modèles de conception (poids mouche)
[Java] Introduction à l'expression lambda
Introduction à Spring Boot ② ~ AOP ~
Introduction à Apache Beam (2) ~ ParDo ~
Introduction à l'API EHRbase 2-REST
Introduction au prototype de modèles de conception
[Rails] Test d'intégration avec Capybara (de l'introduction à l'exécution simple du test)
[Java] Introduction à l'API Stream
Introduction aux modèles de conception (Iterator)