TOC

Testando com JGoTesting

Testando com JGoTesting

1. Visão geral

JGoTesting é umJUnit-compatible testing framework inspired by Go’s testing package.

Neste artigo, vamos explorar os principais recursos da estrutura JGoTesting e implementar exemplos para mostrar seus recursos.

2. Dependência do Maven

Primeiro, vamos adicionar a dependênciajgotesting ao nossopom.xml: 


    org.jgotesting
    jgotesting
    0.12

A versão mais recente deste artefato pode ser encontradahere.

3. Introdução

O JGoTesting nos permite escrever testes compatíveis com o JUnit. For every assertion method JGoTesting provides, there is one in JUnit with the same signature, portanto, implementar esta biblioteca é realmente simples.

No entanto,unlike JUnit, when an assertion fails, JGoTesting doesn’t stop the execution of the test. Em vez disso, a falha é registrada comoevente apresentada a nós apenas quando todas as afirmações foram executadas.

4. JGoTesting em ação

Nesta seção, veremos exemplos de como configurar o JGoTesting e explorar suas possibilidades.

4.1. Começando

Para escrever nossos testes, vamos primeiro importar os métodos de asserção do JGoTesting: 

import static org.jgotesting.Assert.*; // same methods as JUnit
import static org.jgotesting.Check.*; // aliases starting with "check"
import static org.jgotesting.Testing.*;

A biblioteca requer uma instânciaJGoTestRule obrigatória marcada com a anotação@Rule. Isso indica que todos os testes da classe serão gerenciados pelo JGoTesting.

Vamos criar uma classe declarando essa regra: 

public class JGoTestingUnitTest {

    @Rule
    public final JGoTestRule test = new JGoTestRule();

    //...
}

4.2. Escrevendo testes

O JGoTesting fornece dois conjuntos de métodos de asserção para escrever nossos testes. Os nomes dos métodos no primeiro conjunto começam comassert e são compatíveis com JUnit, e os outros começam comcheck.

Os dois conjuntos de métodos se comportam da mesma forma e a biblioteca fornece uma correspondência individual entre eles.

Aqui está um exemplo para testar se um número é igual a outro, usando as duas versões: 

@Test
public void whenComparingIntegers_thenEqual() {
    int anInt = 10;

    assertEquals(anInt, 10);
    checkEquals(anInt, 10);
}

O resto da API é autoexplicativo, então não entraremos em mais detalhes. Para todos os exemplos a seguir, vamos nos concentrar apenas na versãocheck dos métodos.

4.3. Eventos e mensagens de falha

Quando uma verificação falha, o JGoTesting registra a falha para que o caso de teste continue sua execução. After the test ends, the failures are reported.

Aqui está um exemplo para mostrar como é: 

@Test
public void whenComparingStrings_thenMultipleFailingAssertions() {
    String aString = "The test string";
    String anotherString = "The test String";

    checkEquals("Strings are not equal!", aString, equalTo(anotherString));
    checkTrue("String is longer than one character", aString.length() == 1);
    checkTrue("A failing message", aString.length() == 2);
}

Depois de executar o teste, obtemos a seguinte saída: 

org.junit.ComparisonFailure: Strings are not equal!
  expected:<[the test s]tring> but was:<[The Test S]tring>
// ...
java.lang.AssertionError: String is longer than one character
// ...
java.lang.AssertionError: Strings are not the same
  expected the same: was not:

Além de transmitir as mensagens de falha em cada método, também podemos registrá-las para que elas apareçam apenas quando um teste tiver pelo menos uma falha.

Vamos escrever um método de teste que coloque isso em prática: 

@Test
public void whenComparingNumbers_thenLoggedMessage() {
    log("There was something wrong when comparing numbers");

    int anInt = 10;
    int anotherInt = 10;

    checkEquals(anInt, 10);
    checkTrue("First number should be bigger", 10 > anotherInt);
    checkSame(anInt, anotherInt);
}

Após a execução do teste, obtemos a seguinte saída: 

org.jgotesting.events.LogMessage: There was something wrong
  when comparing numbers
// ...
java.lang.AssertionError: First number should be bigger

Observe que, além delogf(), que pode formatar mensagens como o métodoString.format(), os métodos_ we can also use the _logIf()elogUnless() para registrar mensagens com base em uma expressão condicional.

4.4. Interrompendo testes

O JGoTesting fornece várias maneiras de encerrar casos de testes quando eles não conseguem passar em uma determinada condição prévia.

Aqui está um exemplo detest that ends prematurely porque um arquivo necessário não existe: 

@Test
public void givenFile_whenDoesnotExists_thenTerminated() throws Exception {
    File aFile = new File("a_dummy_file.txt");

    terminateIf(aFile.exists(), is(false));

    // this doesn't get executed
    checkEquals(aFile.getName(), "a_dummy_file.txt");
}

Observe que também podemos usar os métodosterminate()eterminateUnless() para interromper a execução do teste.

4.5. Encadeamento

A classeJGoTestRule também tem umfluent API that we can use to chain checks together.

Vejamos um exemplo que usa nossa instância deJGoTestRule para encadear várias verificações em objetosString: 

@Test
public void whenComparingStrings_thenMultipleAssertions() {
    String aString = "This is a string";
    String anotherString = "This Is a String";

    test.check(aString, equalToIgnoringCase(anotherString))
      .check(aString.length() == 16)
      .check(aString.startsWith("This"));
}

4.6. Verificações personalizadas

Além das expressõesboolean e instânciasMatcher,JGoTestRule‘s methods can accept a custom Checker object to do the checking. Esta é uma interface de Método Abstrato Único que pode ser implementada usando uma expressão lambda.

Aqui está um exemplo que verifica se umString corresponde a uma expressão regular específica usando a interface mencionada: 

@Test
public void givenChecker_whenComparingStrings_thenEqual() throws Exception {
    Checker aChecker = s -> s.matches("\\d+");

    String aString = "1235";

    test.check(aString, aChecker);
}

5. Conclusão

Neste tutorial rápido, exploramos os recursos que o JGoTesting nos fornece para escrever testes.

Apresentamos os métodosassert compatíveis com JUnit, bem como suas contrapartescheck. Também vimos como a biblioteca registra e relata eventos de falha e escrevemos umChecker personalizado usando uma expressão lambda.

Como sempre, o código-fonte completo deste artigo pode ser encontradoover on Github.

Related