Matchers de base commune Hamcrest

1. Vue d'ensemble

Dans ce tutoriel, nous allons explorer la CoreMatchers classe du cadre Hamcrest populaire pour écrire des scénarios de test simples et plus expressifs.

L'idée est de faire lire les déclarations d'assert comme un langage naturel.

2. Configuration de Hamcrest

Nous pouvons utiliser Hamcrest avec Maven en ajoutant la dépendance suivante à notre fichier pom.xml :

 org.hamcrest java-hamcrest 2.0.0.0 test 

La dernière version de cette bibliothèque est toujours disponible ici.

3. Matchers de base communs

3.1. est (T) et est (Matcher)

Le is (T) prend un objet comme paramètre pour vérifier l'égalité et is (Matcher) prend un autre matcher permettant à la déclaration d'égalité d'être plus expressive.

Nous pouvons l'utiliser avec presque toutes les méthodes :

String testString = "hamcrest core"; assertThat(testString, is("hamcrest core")); assertThat(testString, is(equalTo("hamcrest core")));

3.2. égal à (T)

L' equalTo (T) prend un objet comme paramètre et vérifie son égalité avec un autre objet. Ceci est fréquemment utilisé avec is (Matcher) :

String actualString = "equalTo match"; List actualList = Lists.newArrayList("equalTo", "match"); assertThat(actualString, is(equalTo("equalTo match"))); assertThat(actualList, is(equalTo(Lists.newArrayList("equalTo", "match"))));

Nous pouvons également utiliser equalToObject (Object operand) - qui vérifie l'égalité et n'impose pas que deux objets soient du même type statique:

Object original = 100; assertThat(original, equalToObject(100));

3.3. pas (T) et pas (Matcher)

Les not (T) et not (Matcher) sont utilisés pour vérifier la non-égalité des objets donnés. Le premier prend un objet comme argument et le second prend un autre matcher:

String testString = "troy kingdom"; assertThat(testString, not("german kingdom")); assertThat(testString, is(not(equalTo("german kingdom")))); assertThat(testString, is(not(instanceOf(Integer.class))));

3.4. nullValue () et nullValue (classe)

La valeur nullValue () vérifie la valeur nulle par rapport à l'objet examiné. La valeur nullValue (Class) vérifie la nullité d'un objet de type de classe donné:

Integer nullObject = null; assertThat(nullObject, is(nullValue())); assertThat(nullObject, is(nullValue(Integer.class)));

3.5. notNullValue () et notNullValue (classe)

Il s'agit d'un raccourci vers is (not (nullValue)) fréquemment utilisé . Ceux-ci vérifient l'égalité non nulle d'un objet ou avec le type de classe:

Integer testNumber = 123; assertThat(testNumber, is(notNullValue())); assertThat(testNumber, is(notNullValue(Integer.class)));

3.6. instanceOf (classe)

L' instanceOf (Class) correspond si l'objet examiné est une instance de la classe spécifiéetype.

Pour vérifier, cette méthode appelle en interne la classe isIntance (Object) de Class :

assertThat("instanceOf example", is(instanceOf(String.class)));

3.7. isA (type de classe)

Le isA (type de classe) est un raccourci vers l' instanceOf (classe) ci-dessus . Il prend exactement le même type d'argument qu'un instanceOf (Class) :

assertThat("Drogon is biggest dragon", isA(String.class));

3.8. sameInstance ()

Le sameInstance () correspond si deux variables de référence pointent vers le même objet dans un tas:

String string1 = "Viseron"; String string2 = string1; assertThat(string1, is(sameInstance(string2)));

3.9. any (Classe)

Le any (Class) vérifie si la classe est du même type que l'objet réel:

assertThat("test string", is(any(String.class))); assertThat("test string", is(any(Object.class)));

3.10. allOf (Matcher…) et anyOf (Matcher…)

Nous pouvons utiliser allOf (Matcher…) pour affirmer si l'objet réel correspond à toutes les conditions spécifiées:

String testString = "Achilles is powerful"; assertThat(testString, allOf(startsWith("Achi"), endsWith("ul"), containsString("Achilles")));

Le ANYOF (matcher ...) se comporte comme allof (matcher ...) mais correspond si l'objet examiné correspond à une des conditions spécifiées:

String testString = "Hector killed Achilles"; assertThat(testString, anyOf(startsWith("Hec"), containsString("baeldung")));

3.11. hasItem (T) et hasItem (Matcher)

Celles-ci correspondent si la collection Iterable examinée correspond à un objet ou un matcher donné dans hasItem () ou hasItem (Matcher) .

Comprenons comment cela fonctionne:

List list = Lists.newArrayList("java", "spring", "baeldung"); assertThat(list, hasItem("java")); assertThat(list, hasItem(isA(String.class)));

De même, nous pouvons également affirmer contre plus d'un éléments en utilisant hasItems (T…) et hasItems (Matcher…) :

List list = Lists.newArrayList("java", "spring", "baeldung"); assertThat(list, hasItems("java", "baeldung")); assertThat(list, hasItems(isA(String.class), endsWith("ing")));

3.12. à la fois (Matcher) et soit (Matcher)

Comme son nom l'indique, les deux (Matcher) correspondent lorsque les deux conditions spécifiées correspondent à l'objet examiné:

String testString = "daenerys targaryen"; assertThat(testString, both(startsWith("daene")).and(containsString("yen")));

et soit (Matcher) correspond lorsque l'une des conditions spécifiées correspond à l'objet examiné:

String testString = "daenerys targaryen"; assertThat(testString, either(startsWith("tar")).or(containsString("targaryen")));

4. Comparaison des chaînes

Nous pouvons utiliser containsString (String) ou containsStringIgnoringCase (String) pour affirmer si la chaîne réelle contient une chaîne de test:

String testString = "Rhaegar Targaryen"; assertThat(testString, containsString("aegar")); assertThat(testString, containsStringIgnoringCase("AEGAR"));

Ou startsWith (String) et startsWithIgnoringCase (String) pour affirmer si la chaîne réelle commence par la chaîne de test:

assertThat(testString, startsWith("Rhae")); assertThat(testString, startsWithIgnoringCase("rhae"));

Nous pouvons également utiliser endsWith (String) ou endsWithIgnoringCase (String) pour affirmer si la chaîne réelle se termine par une chaîne de test:

assertThat(testString, endsWith("aryen")); assertThat(testString, endsWithIgnoringCase("ARYEN"));

5. Conclusion

Dans cet article, nous avons discuté de différentes méthodes de CoreMatchers classe dans Hamcrest bibliothèque.

Et, comme toujours, le code source des exemples est disponible sur GitHub.