Dúvidas sobre Teste Unitários do Java

19 de setembro de 2018 4 respostas

wladyband 19 de setembro de 2018

Observem o código de teste do java

@RunWith(SpringRunner.class)
@DataJpaTest
@TestPropertySource("classpath:application.properties")
@ContextConfiguration(classes = {AppConfig.class})
public class AdicionarProjetoSucessApplicationTest {

	@Autowired
	private ProjectService projectService;
	
	
	
	@Autowired
	private EmployeeRepository employeeRepository;
	
	
	@Autowired
	private EmployeeProjectService employeeProjectService;

	
	@Test(expected = NameProjectEmployeeCadastradoException.class)
	public void testAdicionarProject() throws Exception{
		Project project1 = new Project("Google");
		this.projectService.salvar(project1);
		Assertions.assertThat(project1.getName()).isNotNull();
		
		Project project2 = new Project("TOTVS");
		this.projectService.salvar(project2);
		Assertions.assertThat(project2.getName()).isNotNull();
		
		Project project3 = new Project("Microsoft");
		this.projectService.salvar(project3);
		Assertions.assertThat(project3.getName()).isNotNull();
		
		Project project4 = new Project("TOVOS");
		this.projectService.salvar(project4);
		Assertions.assertThat(project4.getName()).isNotNull();
		
		
		Employee employee1 = new Employee("Douglas", BigDecimal.valueOf(16556));
		this.employeeRepository.save(employee1);
		Assertions.assertThat(employee1.getName()).isNotNull();
		Assertions.assertThat(employee1.getSalary()).isNotNull();
		
		Employee employee2 = new Employee("Paulo", BigDecimal.valueOf(16556));
		this.employeeRepository.save(employee2);
		Assertions.assertThat(employee2.getName()).isNotNull();
		Assertions.assertThat(employee2.getSalary()).isNotNull();
		
		
		Employee employee3 = new Employee("José", BigDecimal.valueOf(16556));
		this.employeeRepository.save(employee3);
		Assertions.assertThat(employee3.getName()).isNotNull();
		Assertions.assertThat(employee3.getSalary()).isNotNull();
		
		
		Employee employee4 = new Employee("Maria", BigDecimal.valueOf(16556));
		this.employeeRepository.save(employee4);
		Assertions.assertThat(employee4.getName()).isNotNull();
		Assertions.assertThat(employee4.getSalary()).isNotNull();
		
		
		EmployeeProject employeeProject1 = new EmployeeProject(1, 1);
		this.employeeProjectService.salvar(employeeProject1);
		Assertions.assertThat(employeeProject1.getEmp_id());
		Assertions.assertThat(employeeProject1.getProj_id());
		
		EmployeeProject employeeProject2 = new EmployeeProject(1, 1);
		this.employeeProjectService.salvar(employeeProject2);
		Assertions.assertThat(employeeProject2.getEmp_id());
		Assertions.assertThat(employeeProject2.getProj_id());
		
		
		EmployeeProject employeeProject3 = new EmployeeProject(1, 1);
		this.employeeProjectService.salvar(employeeProject3);
		Assertions.assertThat(employeeProject3.getEmp_id());
		Assertions.assertThat(employeeProject3.getProj_id());
		
		EmployeeProject employeeProject4 = new EmployeeProject(1, 1);
		this.employeeProjectService.salvar(employeeProject4);
		Assertions.assertThat(employeeProject4.getEmp_id());
		Assertions.assertThat(employeeProject4.getProj_id());
		
	}


}

Tem varias classes de exceção que gostaria de colocar aqui em baixo, mas só estou conseguindo colocar uma, como poderia colocar várias classe de exceção aqui nesse trecho de código?

@Test(expected = NameProjectEmployeeCadastradoException.class)

4 Respostas

darlan_machado 19 de set. de 2018

Se eu entendo o básico do básico de testes, acredito que você precisa testar, no mínimo, um cenário diferente para cada possível exceção a ser lançada.
Exemplo: Você tem um método que dispara uma FileNotFoudException, uma IOException e uma NumberFormatException, você precisa de 4 métodos, no mínimo: um que teste a FileNotFound, outra para a IOException, outra para a NumberFormat e uma que não dispare nenhum erro.
A documentação da anotação @Test vai te ajudar a entender a limitação.

wladyband 19 de set. de 2018

Entendi perfeitamente.

wladyband 19 de set. de 2018

eu tentei fazer eles separados, mas não funcionou porque eu não soube integrar-los, teria como me explica como poderia integrar-lo? por favor, se não puder eu vou entender.

darlan_machado 19 de set. de 2018

Vamos por partes.
Suponha que você tenha o seguinte método:

public Integer transformaEmInteiroEInvocaMétodo(String path) throws FileNotFoundException, IOException {
     File arq = new File(path);
     if(!arq.exists()) {
         throw new FileNotFoundException("Arquivo " + path + " não encontrado");
     }
     String value = "";
     try (Stream<String> stream = Files.lines(arq.toPath())) {
        stream.forEach(l -> {
            if(l.startsWith("ABC") {
                value = l.split("ABC")[1];
                break;
            }
        });
    } catch (IOException e) {
        e.printStackTrace();
    }
    return Integer.valueOf(value);
}

Agora, imagine que você tem um arquivo que não pode ser encontrado. Você consegue entender que só a exceção FileNotFoundException será disparada, né?
Logo, não tem necessidade de você ter um método de teste para contemplar os dois.
Agora, se o arquivo existe e o problema ocorre para ler o mesmo (sem autorização, por exemplo), então você já passou da validação de arquivo existente e está tentando ler o mesmo. Aí você não tem mais o FileNotFoundException e, sim, o IOException.
Por isso, não tem razão de você ter um método que espere o primeiro.

Por fim, se tudo deu certo, você não terá nenhuma exceção. Só terá que validar se o método executou e retornou o esperado.

Entendeu? Um método de teste diferente para cada cenário de testes:

Criado 19 de setembro de 2018

Ultima resposta 19 de set. de 2018

Respostas 4

Participantes 2

4 Respostas

Topicos relacionados