TOC

Introdução ao AssertJ

Introdução ao AssertJ

1. Overview

Neste artigo, exploraremosAssertJ - uma biblioteca de código aberto dirigida pela comunidade usada para escrever asserções ricas e fluentes em testes Java.

Este artigo se concentra nas ferramentas disponíveis no módulo básico do AssertJ chamadoAssertJ-core.

2. Maven Dependencies

Para usar o AssertJ, você precisa incluir a seguinte seção em seu arquivopom.xml: 


    org.assertj
    assertj-core
    3.4.1
    test

Essa dependência cobre apenas as asserções Java básicas. Se você deseja usar asserções avançadas, precisará adicionar módulos adicionais separadamente.

Observe que, para Java 7 e versões anteriores, você deve usar o AssertJ core versão 2.x.x.

As versões mais recentes podem ser encontradashere.

3. Introdução

O AssertJ fornece um conjunto de classes e métodos utilitários que permitem escrever facilmente declarações fluentes e bonitas para:

  • Java padrão

  • Java 8

  • Goiaba

  • Hora de Joda

  • Neo4J e

  • Componentes de giro

Uma lista detalhada de todos os módulos está disponível emwebsite do projeto.

Vamos começar com alguns exemplos, direto da documentação do AssertJ: 

assertThat(frodo)
  .isNotEqualTo(sauron)
  .isIn(fellowshipOfTheRing);

assertThat(frodo.getName())
  .startsWith("Fro")
  .endsWith("do")
  .isEqualToIgnoringCase("frodo");

assertThat(fellowshipOfTheRing)
  .hasSize(9)
  .contains(frodo, sam)
  .doesNotContain(sauron);

Os exemplos acima são apenas a ponta do iceberg, mas nos dão uma visão geral de como as declarações de escrita nesta biblioteca podem parecer.

4. AssertJ in Action

Nesta seção, vamos nos concentrar em configurar a AssertJ e explorar suas possibilidades.

4.1. Começando

Com o jar da biblioteca em um caminho de classe, a ativação de asserções é tão fácil quanto adicionar uma única importação estática à sua classe de teste: 

import static org.assertj.core.api.Assertions.*;

4.2. Escrevendo afirmações

Para escrever uma asserção, você sempre precisa começar passando seu objeto para o métodoAssertions.assertThat() e depois seguir com as asserções reais.

É importante lembrar que, ao contrário de outras bibliotecas, o código a seguir ainda não afirma nada enever falhará em um teste: 

assertThat(anyRefenceOrValue);

Se você aproveitar os recursos de autocompletar de código do IDE, escrever asserções AssertJ se torna incrivelmente fácil devido aos seus métodos muito descritivos. É assim que parece no IntelliJ IDEA 16:

IDE’s code completion features

Recursos de preenchimento de código do IDE

 

Como você pode ver, você tem dezenas de métodos contextuais para escolher e eles estão disponíveis apenas para o tipoString. Vamos explorar em detalhes alguns desta API e examinar algumas afirmações específicas.

4.3. Object afirmações

Objects pode ser comparado de várias maneiras para determinar a igualdade de dois objetos ou para examinar os campos de um objeto.

Vejamos duas maneiras de comparar a igualdade de dois objetos. Dados os seguintes dois objetosDogfido efidosClone: 

public class Dog {
    private String name;
    private Float weight;

    // standard getters and setters
}

Dog fido = new Dog("Fido", 5.25);

Dog fidosClone = new Dog("Fido", 5.25);

Podemos comparar a igualdade com a seguinte afirmação: 

assertThat(fido).isEqualTo(fidosClone);

Isso falhará, poisisEqualTo() compara referências de objeto. Se quisermos comparar seu conteúdo, podemos usarisEqualToComparingFieldByFieldRecursively() assim: 

assertThat(fido).isEqualToComparingFieldByFieldRecursively(fidosClone);

FidoefidosClone são iguais ao fazer um campo recursivo por comparação de campo porque cada campo de um objeto é comparado ao campo no outro objeto.

Existem muitos outros métodos de asserção que fornecem maneiras diferentes de comparar e contrair objetos, além de examinar e afirmar em seus campos. Para descobrir todos eles, consulte osAbstractObjectAssertdocumentation oficiais.

4.4. Boolean afirmações

Existem alguns métodos simples para testar a verdade:

  • é verdade()

  • é falso()

Vamos vê-los em ação: 

assertThat("".isEmpty()).isTrue();

4.5. Iterable/Array afirmações

Para umIterable ou umArray, existem várias maneiras de afirmar que seu conteúdo existe. Uma das afirmações mais comuns seria verificar se umIterable ouArray contém um determinado elemento: 

List list = Arrays.asList("1", "2", "3");

assertThat(list).contains("1");

ou se aList não estiver vazio: 

assertThat(list).isNotEmpty();

ou se umList começar com um determinado caractere. Por exemplo "1": 

assertThat(list).startsWith("1");

Lembre-se de que, se você quiser criar mais de uma asserção para o mesmo objeto, poderá juntá-las facilmente.

Aqui está um exemplo de afirmação que verifica se uma lista fornecida não está vazia, contém o elemento "1", não contém nulos e contém a sequência dos elementos "2", "3": 

assertThat(list)
  .isNotEmpty()
  .contains("1")
  .doesNotContainNull()
  .containsSequence("2", "3");

É claro que existem muitas outras afirmações possíveis para esses tipos. Para descobrir todos eles, consulte osAbstractIterableAssertdocumentation oficiais.

4.6. Character afirmações

Asserções para tipos de caracteres geralmente envolvem comparações e até mesmo verificar se um determinado caractere é de uma tabelaUnicode.

Aqui está um exemplo de uma asserção que verifica se um caractere fornecido não é ‘a ', está na tabela Unicode, é maior que ‘b' e está em minúscula: 

assertThat(someCharacter)
  .isNotEqualTo('a')
  .inUnicode()
  .isGreaterThanOrEqualTo('b')
  .isLowerCase();

Para obter uma lista detalhada de todas as afirmações de tipos de caracteres, consulteAbstractCharacterAssertdocumentation.

4.7. Class afirmações

As afirmações para o tipoClass são principalmente sobre a verificação de seus campos, tiposClass, presença de anotações e finalidade da classe.

Se você deseja afirmar que a classeRunnable é uma interface, você precisa simplesmente escrever: 

assertThat(Runnable.class).isInterface();

ou se você deseja verificar se uma classe é atribuível à outra: 

assertThat(Exception.class).isAssignableFrom(NoSuchElementException.class);

Todas as afirmaçõesClass possíveis podem ser visualizadas emAbstractClassAssertdocumentation.

4.8. File afirmações

As asserçõesFile tratam de verificar se uma determinada instânciaFile existe, é um diretório ou arquivo, tem certo conteúdo, é legível ou tem uma extensão fornecida.

Aqui você pode ver um exemplo de asserção que verifica se um determinado arquivo existe, é um arquivo e não um diretório, pode ser legível e gravável: 

 assertThat(someFile)
   .exists()
   .isFile()
   .canRead()
   .canWrite();

Todas as asserções de classe possíveis podem ser visualizadas emAbstractFileAssertdocumentation.

4.9. Double/Float/Integer afirmações

Double/Float/Integer e outros tipos deNumber

As asserções numéricas tratam da comparação de valores numéricos dentro ou sem um determinado deslocamento. Por exemplo, se você deseja verificar se dois valores são iguais de acordo com uma determinada precisão, podemos fazer o seguinte: 

assertThat(5.1).isEqualTo(5, withPrecision(1d));

Observe que estamos usando o método auxiliarwithPrecision(Double offset) já importado para gerar objetosOffset.

Para obter mais afirmações, visite AbstractDoubleAssertdocumentation.

4.10. InputStream afirmações

Há apenas uma afirmação específica deInputStream disponível:

  • hasSameContentAs (InputStream esperado)

e em ação: 

assertThat(given).hasSameContentAs(expected);

4.11. Map afirmações

As asserçõesMap permitem que você verifique se um mapa contém determinada entrada, conjunto de entradas ou chaves / valores separadamente.

E aqui você pode ver um exemplo de uma asserção que verifica se um determinado mapa não está vazio, contém a chave numérica “2”, não contém a chave numérica “10” e contém a entrada:key: 2, value: “a”: 

assertThat(map)
  .isNotEmpty()
  .containsKey(2)
  .doesNotContainKeys(10)
  .contains(entry(2, "a"));

Para obter mais afirmações, consulteAbstractMapAssertdocumentation.

4.12. Throwable afirmações

Throwable asserções permitem, por exemplo: inspecionar mensagens de exceção, rastreamentos de pilha, verificar a causa ou verificar se uma exceção já foi lançada.

Vejamos o exemplo de uma asserção que verifica se uma determinada exceção foi lançada e tem uma mensagem terminando com "c": 

assertThat(ex).hasNoCause().hasMessageEndingWith("c");

Para obter mais afirmações, consulte AbstractThrowableAssertdocumentation.

5. Descrevendo afirmações

Para atingir um nível de verbosidade ainda mais alto, você pode criar descrições personalizadas geradas dinamicamente para suas asserções. A chave para fazer isso é o métodoas(String description, Object… args).

Se você definir sua afirmação assim: 

assertThat(person.getAge())
  .as("%s's age should be equal to 100", person.getName())
  .isEqualTo(100);

isto é o que você obterá ao executar testes: 

[Alex's age should be equal to 100] expected:<100> but was:(34)

6. Java 8

AssertJ aproveita ao máximo os recursos de programação funcional do Java 8. Vamos examinar um exemplo e vê-lo em ação. Primeiro, vamos ver como fazemos isso no Java 7: 

assertThat(fellowshipOfTheRing)
  .filteredOn("race", HOBBIT)
  .containsOnly(sam, frodo, pippin, merry);

Aqui estamos filtrando uma coleção na corrida Hobbit e no Java 8 podemos fazer algo assim: 

assertThat(fellowshipOfTheRing)
  .filteredOn(character -> character.getRace().equals(HOBBIT))
  .containsOnly(sam, frodo, pippin, merry);

Exploraremos os recursos Java8 de AssertJ em um artigo futuro desta série. Os exemplos acima foram retirados dewebsite de AssertJ.

7. Conclusion

Neste artigo, exploramos brevemente as possibilidades que o AssertJ nos fornece, juntamente com as asserções mais populares para os principais tipos de Java.

A implementação de todos os exemplos e trechos de código pode ser encontrada em aGitHub project.

Related