Spring + Testing

1. Configuração do Maven:
   • Certifique-se de que o Maven esteja instalado em seu sistema.
   • No arquivo pom.xml do seu projeto, adicione as dependências necessárias para JUnit e o suporte de testes do Spring Boot. Normalmente, essas dependências (normalmente spring-boot-starter-test) já estão incluídas no arquivo de modelo gerado pelo Spring Initializr ao criar um projeto Spring Boot.
2. Estrutura de diretórios:
   • No diretório do seu projeto, crie a estrutura de diretórios padrão para testes: src/test/java e src/test/resources.
   • Os testes de unidade devem ser colocados no diretório src/test/java seguindo a mesma estrutura de pacotes do código-fonte principal.
3. Criação de testes:

   • Crie classes de teste, essas classes de teste são geralmente nomeadas de acordo com a classe que estão testando, seguidas por "Test". Exemplo: UserService, →**UserServiceTest**.

   • Anote a classe de teste com @RunWith(SpringRunner.class) para permitir a execução do teste no contexto do Spring Boot.

   • Anote a classe de teste com @SpringBootTest para carregar o contexto do Spring Boot durante a execução do teste.

   • Injete as dependências necessárias

   • Crie métodos de teste usando a anotação @Test e implemente a lógica de teste dentro desses métodos.

     • Se esse teste lançar uma exceção, defina a propriedade expected na annotation.

JUnit - Testes de Unidade

• Testes de unidade são testes feitos para cobrir um comportamento ou unidade específica de execução dentro de um método.
  • Seu método de iniciar conversação pode ter vários e-se, nesse caso, um teste de unidade seria criado para validar cada e-se
• Testes de unidade, de maneira geral são executados com a biblioteca JUnit, que será o foco desse capítulo. Para sua utilização, criamos um método que retorna void e é anotado por @Test, esse método deve conter operações e validações (assertions) para garantir o retorno esperado.

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class CalculadoraTest {

	@Test
  @DisplayName("Testando soma")
	public void testSoma() {
	    // Arrange (preparação)
	    Calculadora calculadora = new Calculadora();
	
	    // Act (ação)
	    int resultado = calculadora.soma(2, 3);
	
	    // Assert (verificação)
	    assertEquals(5, resultado);
	}
	
	@Test
	public void testSubtracao() {
	    // Arrange
	    Calculadora calculadora = new Calculadora();
	
	    // Act
	    int resultado = calculadora.subtracao(5, 2);
	
	    // Assert
	    assertEquals(3, resultado);
	}

	@Disabled("Esperando resolverem o bug que 3 é diferente de 1")
	@Test
	public void testNaoSeiOq(){
		  assertEquals(3,1);
  }
}

• Normalmente organizamos nossos testes de unidade em 3 etapas: given-when-then ou o triplo A: Arrange, Act & Assert

Assertions

// Padrão: 
assertEquals(2, calculadora.soma(1, 1));
assertEquals(4, calculadora.multiplica(2, 2), "The optional failure message is now the last parameter");
assertTrue('a' < 'b');
// Exceptions
Exception exception = assertThrows(Aritmetica.class, () -> calculadora.divide(1, 0));
assertEquals("/ por zero", exception.getMessage()); // opcional

Existem também bibliotecas focadas em gerar assertions mais legíveis/fluentes, como AssertJ e Hamcrest, podemos usa-las em conjunto com JUnit:

import static org.assertj.core.api.Assertions.*;
assertThat(frodo.getName()).isEqualTo("Frodo");
assertThat(frodo).isNotEqualTo(sauron);
assertThat(fellowshipOfTheRing).hasSize(9)
                               .contains(frodo, sam)
                               .doesNotContain(sauron);

Testes Parametrizados

Testes parametrizados permitem a execução do “mesmo teste”, mas com inputs diferentes, com bem mais facilidade do que criar testes separados:

import org.junit.Test;
import org.junit.runner.RunWith;

import java.util.Arrays;
import java.util.Collection;
import static org.junit.Assert.assertEquals;

public class CalculadoraTest {

    @ParameterizedTest
	  @CsvSource({"2, 3, 5",
								"5, 2, 3",
								"0, 0, 0",
								"-1, 1, 0"})
    public void testSoma(int inputA, int inputB, int expectedResult) {
       // Arrange
        Calculadora calculadora = new Calculadora();
        // Act
        int resultado = calculadora.soma(inputA, inputB);
        // Assert
        assertEquals(expectedResult, resultado);
    }
}

Note que passamos os valores usando @CsvSource, mas não é a única maneira

@ValueSource