TOC

Recursos do Java 8 da AssertJ

Recursos do Java 8 da AssertJ

*1. Visão geral *

Este artigo concentra-se nos recursos relacionados ao Java8 de https://joel-costigliola.github.io/assertj/[AssertJunette e é o terceiro artigo da série.

Se você estiver procurando informações gerais sobre seus principais recursos, consulte o primeiro artigo da série no link:/Introduction-to-assertj [Introdução ao AssertJ] e, em seguida, no link:/assertJ-for-goiaba [AssertJ for Guava ]

===* 2. Dependências do Maven *

O suporte do Java 8 está incluído no módulo principal do AssertJ Core desde a versão 3.5.1. Para usar o módulo, você precisará incluir a seção a seguir no seu arquivo pom.xml:

<dependency>
    <groupId>org.assertj</groupId>
    <artifactId>assertj-core</artifactId>
    <version>3.5.1</version>
    <scope>test</scope>
</dependency>

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

A versão mais recente do Core pode ser encontrada aqui.

===* 3. Recursos do Java 8 *

O AssertJ aproveita os recursos do Java 8, fornecendo métodos auxiliares especiais e novas asserções para os tipos do Java 8.

====* 3.1 Optional asserções *

Vamos criar uma instância Optional simples:

Optional<String> givenOptional = Optional.of("something");

Agora podemos verificar facilmente se um Optional contém algum valor e qual é esse valor que contém:

assertThat(givenOptional)
  .isPresent()
  .hasValue("something");

====* 3.2 Predicate asserções *

Vamos criar uma instância Predicate simples, verificando o comprimento de uma String:

Predicate<String> predicate = s -> s.length() > 4;

Agora você pode facilmente verificar quais Strings são rejeitadas ou aceitas pelo _Predicate: _

assertThat(predicate)
  .accepts("aaaaa", "bbbbb")
  .rejects("a", "b")
  .acceptsAll(asList("aaaaa", "bbbbb"))
  .rejectsAll(asList("a", "b"));

====* 3.3 LocalDate asserções *

Vamos começar definindo dois objetos LocalDate:

LocalDate givenLocalDate = LocalDate.of(2016, 7, 8);
LocalDate todayDate = LocalDate.now();

Agora você pode facilmente verificar se uma determinada data é anterior/posterior a uma determinada data ou hoje:

assertThat(givenLocalDate)
  .isBefore(LocalDate.of(2020, 7, 8))
  .isAfterOrEqualTo(LocalDate.of(1989, 7, 8));

assertThat(todayDate)
  .isAfter(LocalDate.of(1989, 7, 8))
  .isToday();

====* 3.4 Declarações LocalDateTime *

As asserções LocalDateTime funcionam de maneira semelhante a LocalDate‘s , _ mas não compartilham o método _isToday.

Vamos criar um exemplo de objeto LocalDateTime:

LocalDateTime givenLocalDate = LocalDateTime.of(2016, 7, 8, 12, 0);

E agora você pode verificar:

assertThat(givenLocalDate)
  .isBefore(LocalDateTime.of(2020, 7, 8, 11, 2));

====* 3.5 Declarações LocalTime *

As asserções LocalTime funcionam de maneira semelhante a outras asserções java.util.time.* _, Mas elas têm um método exclusivo: _hasSameHourAs.

Vamos criar um exemplo de objeto LocalTime:

LocalTime givenLocalTime = LocalTime.of(12, 15);

e agora você pode afirmar:

assertThat(givenLocalTime)
  .isAfter(LocalTime.of(1, 0))
  .hasSameHourAs(LocalTime.of(12, 0));

3.6 Método auxiliar FlatExtracting

O FlatExtracting é um método utilitário especial que utiliza lambdas do Java 8 para extrair propriedades de Iterable elements .

Vamos criar uma List simples com objetos LocalDate:

List<LocalDate> givenList = asList(ofYearDay(2016, 5), ofYearDay(2015, 6));

agora podemos verificar facilmente se esta List contém pelo menos um objeto LocalDate com o ano de 2015:

assertThat(givenList)
  .flatExtracting(LocalDate::getYear)
  .contains(2015);

o método flatExtracting não nos limita à extração de campo. Nós sempre podemos fornecê-lo com qualquer função:

assertThat(givenList)
  .flatExtracting(LocalDate::isLeapYear)
  .contains(true);

ou até:

assertThat(givenList)
  .flatExtracting(Object::getClass)
  .contains(LocalDate.class);

Você também pode extrair várias propriedades de uma vez:

assertThat(givenList)
  .flatExtracting(LocalDate::getYear, LocalDate::getDayOfMonth)
  .contains(2015, 6);

3.7 Satisfies Método auxiliar

O método Satisfies permite verificar rapidamente se um objeto atende a todas as asserções fornecidas.

Vamos criar um exemplo de instância String:

String givenString = "someString";

e agora podemos fornecer asserções como um corpo lambda:

assertThat(givenString)
  .satisfies(s -> {
    assertThat(s).isNotEmpty();
    assertThat(s).hasSize(10);
  });

3.8 Método auxiliar HasOnlyOneElementSatisfying

O método auxiliar HasOnlyOneElement permite verificar se uma instância Iterable contém exatamente apenas um elemento que satisfaz as asserções fornecidas.

Vamos criar um exemplo _List: _

List<String> givenList = Arrays.asList("");

e agora você pode afirmar:

assertThat(givenList)
  .hasOnlyOneElementSatisfying(s -> assertThat(s).isEmpty());

3.9 Método auxiliar Matches

O método auxiliar Matches permite verificar se um determinado objeto corresponde à função Predicate.

Vamos dar uma _String vazia: _

String emptyString = "";

e agora podemos verificar seu estado, fornecendo uma função Predicate lambda adequada:

assertThat(emptyString)
  .matches(String::isEmpty);

4. Conclusão

Neste último artigo da série AssertJ, exploramos todos os recursos avançados do AssertJ Java 8, que concluem a série.

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

Related