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:
assertEquals | Verifica se dois objetos são iguais |
---|---|
assertArrayEquals | Verifica se duas matrizes contêm valores iguais |
assertNotNull | Verifica se o argumento não é nulo |
assertNull | Verifica se o argumento é nulo |
assertNotSame | Verifique se os dois argumentos não são o mesmo objeto |
afirmar o mesmo | Verifique se os dois argumentos são o mesmo objeto |
afirmarVerdadeiro | Verifica se o argumento é verdadeiro |
assertFalse | Verifica se o argumento é falso |
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());
}