Asserções JUnit

6.1 afirma

Asserts são verificações especiais que podem ser inseridas em diferentes locais do código. Sua tarefa é determinar que algo deu errado. Ou melhor, para verificar se tudo está indo como deveria. Isso é “conforme necessário” e eles permitem que você o configure de várias maneiras.

Você já encontrou algumas asserções no código acima. A primeira é verificar a igualdade dos objetos. Se os objetos não forem iguais, uma exceção será lançada e o teste falhará.

A ordem de comparação é importante aqui , porque o JUnit no relatório final escreverá algo como “valor 1 recebido, mas 3 era esperado”. O formato geral para tal verificação é:

assertEquals(standard , meaning)

Exemplo:

@Test
public void whenAssertingEquality () {
    String expected = "3.1415";
    String actual = "3";

    assertEquals(expected, actual);
}

6.2 Métodos assertEquals, assertTrue, assertFalse

Abaixo, listarei os métodos mais populares - asserções. Por seus nomes, é bem possível adivinhar como eles funcionam. Mas vou escrever uma breve explicação de qualquer maneira:

Alguns desses métodos parecem redundantes. Por que usar assertSame(a, b) quando você pode apenas escrever assertTrue(a == b) ?

O ponto é que assert é um método muito inteligente. Ele faz muitas coisas úteis, incluindo escrever informações de erro no log . No primeiro caso, escreverá que o objeto A era esperado, mas foi recebido o objeto B. No segundo caso, simplesmente escreverá que true era esperado .

Quando você tem centenas de testes, especialmente aqueles executados em um servidor de teste dedicado, ter logs detalhados pode ser muito útil. Acho que você entende o que quero dizer.

Exemplo de comparação de array:

@Test
public void whenAssertingArraysEquality() {
    char[] expected = {'J','u','n','i','t'};
    char[] actual = "Junit".toCharArray();

    assertArrayEquals(expected, actual);
}

6.3 método assertAll

Conforme mencionado acima, o método assert não apenas executa uma verificação, mas também grava muitas informações sobre objetos comparáveis ​​no log.

Façamos uma comparação:

Address address = unitUnderTest.methodUnderTest();
assertEquals("Washington", address.getCity());
assertEquals("Oracle Parkway", address.getStreet());
assertEquals("500", address.getNumber());

Mas se um dos parâmetros não corresponder, o restante não será verificado. Mas eu gostaria que eles ainda ocorressem e seus resultados fossem registrados no log. Mas, ao mesmo tempo, se pelo menos uma verificação falhou, o teste ainda falhou.

Existe um método especial para isso - assertAll() . Como primeiro argumento, é preciso um comentário a ser gravado no log e, em seguida, qualquer número de funções assert.

Aqui está como nosso exemplo seria reescrito com ele:

Address address = unitUnderTest.methodUnderTest();
assertAll("Complex address comparison script",
    () -> assertEquals("Washington", address.getCity()),
    () -> assertEquals("Oracle Parkway", address.getStreet()),
    () -> assertEquals("500", address.getNumber())
);

Então, se o endereço estiver incorreto, algo assim será gravado no log:

	Complex scenario comparison address (3 failures)
	expected: <Washington> but was: <Seattle>
    expected: <Oracle Parkway> but was: <Main Street>
    expected: <500> but was: <5772>

6.4 método assertTimeout

Lembra da anotação @Timeout ? Permitiu controlar o tempo de execução de todo o método. Mas às vezes é útil definir restrições na execução de alguma parte do código dentro do método. Você pode usar assertTimeout() para isso .

O tempo é passado como o primeiro parâmetro, e o código (função) que deve ser executado dentro do tempo especificado é passado como o segundo. Exemplo:

@Test
public void whenAssertingTimeout() {
    assertTimeout(
  	ofSeconds(2),
  	() -> {
    	// pause for one second
    	Thread.sleep(1000);
  	}
	);
}

A classe Assert tem 12 variantes do método assertTimeout() . Se você quiser saber mais sobre eles, seja bem-vindo à documentação oficial .

6.5 método assertThrows

Muitas vezes, há situações em que você precisa ter certeza de que, em uma determinada situação, o código lança a exceção correta: ele detecta um erro e lança a exceção correta. Esta é uma situação muito comum.

Nesse caso, existe outro método assert útil - este é assertThrows() . O formato geral de sua chamada é:

assertThrows(exception , code)

Basicamente, é muito semelhante ao método assertTimeout() , apenas verifica se o código especificado lança a exceção correta. Exemplo:

@Test
void whenAssertingException() {
    Throwable exception = assertThrows(
  	IllegalArgumentException.class,
  	() -> {
      	throw new IllegalArgumentException("Exception message");
  	}
    );
    assertEquals("Exception message", exception.getMessage());
}