Tests avec Spring Cloud Function

Cet article fait partie d’une série traitant de Spring Cloud Function:

Introduction à Spring Cloud Function
Tests avec Spring Cloud Function
Spring Cloud Function et Déploiement Web
Spring Cloud Function et Spring Cloud Stream

Introduction

Dans l’introduction à Spring Cloud Function, nous avons fait connaissance avec le projet Spring Cloud Function. Cet article détaille comment écrire des tests lorsque ce framework est utilisé.

Nous allons donc automatiser les tests des exemples précédents.

@FunctionalSpringBootTest

Pour tester nos fonctions, nous devons annoter notre classe de test avec @FunctionalSpringBootTest:

@FunctionalSpringBootTest
class FunctionsTests {
    @Autowired
    private FunctionCatalog catalog;

    // les tests vont ici...
}

Il est possible de récupérer une référence vers l’objet FunctionCatalog et l’utiliser comme nous l’avons dans l’article précédent.

Les tests vont donc être très simples puisqu’il nous suffit simplement d’y déplacer le code que nous avions dans la méthode main.

Basique

@Test
void basic() {
    Function<String, String> hello = catalog.lookup("hello");
    assertThat(hello.apply("world")).isEqualTo("Hello, world");
}

Composition

@Test
void composition() {
    Function<String, String> hello = catalog.lookup("capitalize|hello");
    assertThat(hello.apply("world")).isEqualTo("Hello, World");
}

Conversion de type transparente

@Test
void typeConversion() {
    Function<String, String> hello = catalog.lookup("helloUser");
    var answer = hello.apply("{\n" +
            " \"firstName\": \"Jane\",\n" +
            " \"lastName\": \"Doe\"\n" +
            "}");
    assertThat(answer).isEqualTo("Hello, Jane");

}

POJO

@Test
void pojo() {
    Function<String, String> hello = catalog.lookup("helloPojo");
    assertThat(hello.apply("world")).isEqualTo("Hello, world from POJO");
}

POJO combiné avec un non POJO

@Test
void pojoComposedWithNonPojo() {
    Function<String, String> hello = catalog.lookup("capitalize|helloPojo");
    assertThat(hello.apply("world")).isEqualTo("Hello, World from POJO");
}

Plusieurs inputs

@Test
void multipleInputs() {
    Function<Tuple2<String, String>, String> hello = catalog.lookup("helloFirstNameLastName");
    assertThat(hello.apply(Tuples.of("Jane", "Doe"))).isEqualTo("Hello, Jane Doe");
}

Réactive

Pour cette partie, nous devons ajouter la dépendance suivante pour avoir accès aux classes de test du projet Reactor:

<dependency>
    <groupId>io.projectreactor</groupId>
    <artifactId>reactor-test</artifactId>
    <scope>test</scope>
</dependency>

@Test
void reactive() {
    Function<Flux<String>, Flux<String>> hello = catalog.lookup("helloReactive");
    StepVerifier.create(hello.apply(Flux.just("foo", "bar")))
            .expectNext("Hello, foo", "Hello, bar")
            .verifyComplete();
}

Réactive combiné avec non réactive

@Test
void reactiveComposedWithNonReactive() {
    Function<Flux<String>, Flux<String>> hello = catalog.lookup("capitalize|helloReactive");
    StepVerifier.create(hello.apply(Flux.just("foo", "bar")))
            .expectNext("Hello, Foo", "Hello, Bar")
            .verifyComplete();
}

RoutingFunction.FUNCTION_NAME

Pour ce cas de test, nous devons créer une nouvelle classe et définir la combinaison de fonction que l’on souhaite utiliser à l’aide de la propriété spring.cloud.function.definition.

Heureusement, l’annotation @FunctionalSpringBootTest permet de faire cela:

@FunctionalSpringBootTest("spring.cloud.function.definition=capitalize|hello")
public class RuntimeFunctionTests {
    @Autowired
    public FunctionCatalog catalog;

    @Test
    void hello() {
        Function<String, String> hello = catalog.lookup(RoutingFunction.FUNCTION_NAME);
        assertThat(hello.apply("world")).isEqualTo("Hello, World");
    }
}

Conclusion

Avant de couvrir les différentes façons possibles de déployer des fonctions, il était important de faire un petit aparté sur les tests car c’est super important, mais vous le saviez-déjà, n’est-ce pas ? :-)

Du côté de chez Fouad

Du code et de l'architecture logicielle mais pas que...