Utilisation de conditions avec AssertJ Assertions

1. Vue d'ensemble

Dans ce didacticiel, nous allons examinerthe AssertJ library, en particulier pour définir et utiliser des conditions pour créer des tests lisibles et maintenables.

Les bases d'AssertJ peuvent être trouvéeshere.

2. Classe sous test

Jetons un œil à la classe cible par rapport à laquelle nous allons écrire des cas de test:

public class Member {
    private String name;
    private int age;

    // constructors and getters
}

3. Créer des conditions

Nous pouvons définir une condition d'assertion en instanciant simplement la classeCondition avec les arguments appropriés.

The most convenient way to create a Condition is to use the constructor that takes a Predicate as a parameter. D'autres constructeurs nous obligent à créer une sous-classe et à remplacer la méthodematches, ce qui est moins pratique.

Lors de la construction d'un objetCondition, nous devons spécifier un argument de type, qui est le type de la valeur par rapport à laquelle la condition est évaluée.

Déclarons une condition pour le champage de notre classeMember:

Condition senior = new Condition<>(
  m -> m.getAge() >= 60, "senior");

La variablesenior fait désormais référence à une instanceCondition qui teste si unPerson est senior en fonction de sesage.

Le deuxième argument du constructeur, leString“senior”, est une brève description qui sera utilisée par AssertJ lui-même pour créer un message d'erreur convivial si la condition échoue.

Une autre condition, vérifier si unPerson a lename «John», ressemble à ceci:

Condition nameJohn = new Condition<>(
  m -> m.getName().equalsIgnoreCase("John"),
  "name John"
);

4. Cas de test

Voyons maintenant comment utiliser les objetsCondition dans notre classe de test. Supposons que les conditionssenior etnameJohn soient disponibles sous forme de champs dans notre classe de test.

4.1. Affirmer des valeurs scalaires

Le test suivant doit réussir car la valeurage est supérieure au seuil d'ancienneté:

Member member = new Member("John", 65);
assertThat(member).is(senior);

Puisque l'assertion avec la méthodeis réussit, une assertion utilisantisNot avec le même argument échouera:

// assertion fails with an error message containing "not to be "
assertThat(member).isNot(senior);

En utilisant la variablenameJohn, nous pouvons écrire deux tests similaires:

Member member = new Member("Jane", 60);
assertThat(member).doesNotHave(nameJohn);

// assertion fails with an error message containing "to have:\n "
assertThat(member).has(nameJohn);

The is and has methods, as well as the isNot and doesNotHave methods have the same semantics. Ce que nous utilisons n’est qu’une question de choix. Néanmoins, il est recommandé de choisir celui qui rend notre code de test plus lisible.

4.2. Affirmation des collections

Les conditions ne fonctionnent pas uniquement avec des valeurs scalaires,but they can also verify the existence or non-existence of elements in a collection. Examinons un cas de test:

List members = new ArrayList<>();
members.add(new Member("Alice", 50));
members.add(new Member("Bob", 60));

assertThat(members).haveExactly(1, senior);
assertThat(members).doNotHave(nameJohn);

La méthodehaveExactly affirme le nombre exact d'éléments répondant auxCondition donnés, tandis que la méthodedoNotHave vérifie l'absence d'éléments.

Les méthodeshaveExactly etdoNotHave ne sont pas les seules à travailler avec des conditions de collecte. Pour une liste complète de ces méthodes, consultezthe AbstractIterableAssert class dans la documentation de l'API.

4.3. Conditions de combinaison

Nous pouvons combiner différentes conditions en utilisant trois méthodes statiques de la classeAssertions:

not – crée une condition qui est remplie si la condition spécifiée n'est pas remplie
allOf – crée une condition qui n'est remplie que si toutes les conditions spécifiées sont remplies
anyOf – crée une condition qui est remplie si au moins une des conditions spécifiées est remplie

Voici comment les méthodesnot etallOf peuvent être utilisées pour combiner des conditions:

Member john = new Member("John", 60);
Member jane = new Member("Jane", 50);

assertThat(john).is(allOf(senior, nameJohn));
assertThat(jane).is(allOf(not(nameJohn), not(senior)));

De même, nous pouvons utiliseranyOf:

Member john = new Member("John", 50);
Member jane = new Member("Jane", 60);

assertThat(john).is(anyOf(senior, nameJohn));
assertThat(jane).is(anyOf(nameJohn, senior));

5. Conclusion

Ce tutoriel donnait un guide sur les conditions AssertJ et leur utilisation pour créer des assertions très lisibles dans votre code de test.

L'implémentation de tous les exemples et extraits de code peut être trouvéeover on GitHub.

TOC

Utilisation de conditions avec AssertJ Assertions