Hamcrest Common Core Matchers

1. Visão geral

Neste tutorial rápido, vamos explorar oCoreMatchers class da popular estruturaHamcrest para escrever casos de teste simples e mais expressivos.

A idéia é fazer com que as declarações de asserção sejam lidas como linguagem natural.

2. Configuração do Hamcrest

Podemos usar o Hamcrest com Maven adicionando a seguinte dependência ao nosso arquivopom.xml:


    org.hamcrest
    java-hamcrest
    2.0.0.0
    test

A versão mais recente desta biblioteca pode sempre ser encontradahere.

3. Correspondentes principais comuns

**3.1. is(T) eis(Matcher<T>)**

Ois(T) usa um objeto como parâmetro para verificar a igualdade eis(Matcher<T>) usa outro matcher permitindo que a declaração de igualdade seja mais expressiva.

We can use this with almost all of the methods:

String testString = "hamcrest core";

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

3.2. equalTo(T)

OequalTo(T) pega um objeto como parâmetro e verifica sua igualdade em relação a outro objeto. This is frequently used with is(Matcher<T>):

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

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

Também podemos usarequalToObject(Object operand) – que verifica a igualdade e não impõe que dois objetos sejam do mesmo tipo estático:

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

**3.3. not(T)areianot(Matcher<T>)**

Osnot(T)enot(Matcher<T>) são usados para verificar a não igualdade de objetos dados. Primeiro pega um objeto como argumento e depois pega outro 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() enullValue(Class<T>)**

OnullValue() verifica o valornull em relação ao objeto examinado. OnullValue(Class<T>) verifica a nulidade de determinado objeto de tipo de classe:

Integer nullObject = null;

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

**3.5. notNullValue() enotNullValue(Class<T>)**

These are a shortcut to frequently used is(not(nullValue)). Estes verificam a igualdade não nula de um objeto ou com o tipo de classe:

Integer testNumber = 123;

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

3.6. instanceOf(Class<?>)

OinstanceOf(Class<?>) corresponde se o objeto examinado for uma instância do tipoClass especificado.

To verify, this method internally calls theisIntance(Object) of Class class:

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

3.7. isA(Class<T> type)

OisA(Class<T> type) é um atalho para oinstanceOf(Class<?>) acima. It takes the exact same type of argument as an instanceOf(Class<?>):

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

3.8. sameInstance()

OsameInstance() corresponde se duas variáveis de referência apontam para o mesmo objeto em um heap:

String string1 = "Viseron";
String string2 = string1;

assertThat(string1, is(sameInstance(string2)));

3.9. any(Class<T>)

Oany(Class<T>)verifica se a classe é do mesmo tipo que o objeto real:

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

3.10. allOf(Matcher<? extends T>…) and anyOf(Matcher<? extends T>…)

Podemos usarallOf(Matcher<? extends T>…) para afirmar se o objeto real corresponde a todas as condições especificadas:

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

OanyOf(Matcher<? extends T>…) se comporta comoallOf(Matcher<? extends T>… ), mas corresponde se o objeto examinado corresponder a qualquer uma das condições especificadas:

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

**3.11. hasItem(T) ehasItem(Matcher<? extends T>)**

Eles correspondem se a coleçãoIterable examinada corresponder a determinado objeto ou correspondência dentro dehasItem() ouhasItem(Matcher<? extends T>).

Vamos entender como isso funciona:

List list = Lists.newArrayList("java", "spring", "example");

assertThat(list, hasItem("java"));
assertThat(list, hasItem(isA(String.class)));

Similarly, we can also assert against more than one items using hasItems(T…)and hasItems(Matcher<? extends T>…):

List list = Lists.newArrayList("java", "spring", "example");

assertThat(list, hasItems("java", "example"));
assertThat(list, hasItems(isA(String.class), endsWith("ing")));

3.12. both(Matcher<? extends T>) and either(Matcher<? extends T>)

Como o nome sugere,both(Matcher<? extends T>) coincide quando ambas as condições especificadas correspondem ao objeto examinado:

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

eeither(Matcher<? extends T>)corresponde quando uma das condições especificadas corresponde ao objeto examinado:

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

4. Corda Comparação

Podemos usarcontainsString(String) oucontainsStringIgnoringCase(String) para afirmar se a string real contém a string de teste:

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

OustartsWith(String)estartsWithIgnoringCase(String) para afirmar se a string real começa com a string de teste:

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

Também podemos usarendsWith(String) orendsWithIgnoringCase(String) para afirmar se a string real termina com a string de teste:

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

5. Conclusão

Neste artigo, discutimos diferentes métodos deCoreMatchers class na bibliotecaHamcrest .

E, como sempre, o código-fonte dos exemplos pode ser encontradoover on GitHub.

TOC

Hamcrest Common Core Matchers