Matriz de Rastreabilidade - Mapeando os impactos das alterações do sistema

 

Nesse artigo eu vou falar sobre Matriz de Rastreabilidade. Essa matriz é um gráfico que mostra a dependência entre partes do sistema.

 

         O objetivo é ter uma ferramenta visual de rápida identificação de áreas que precisam ser testadas para evitar erros em produção devido à falta de testes suficientes após alterações que parecem pontuais, mas na verdade tem um impacto maior.

 

         A matriz possui 2 eixos: Manutenção e Impacto; e é construída colocando o nome dos módulos do sistema (ou partes importantes que se deseja controlar, como por exemplo, um método que é muito usado) em ambos os eixos, e depois marcando os pontos onde há dependências.

 

         Aqui abaixo tem um exemplo:

 

 

         A matriz de rastreabilidade pode ser feita por qualquer pessoa da equipe, mas um DEV tem maior conhecimento dessas dependências e pode dar uma grande ajuda.

 

Essa matriz pode ser bem grande dependendo do tamanho do sistema e do nível de detalhes, que pode mudar de acordo com a necessidade, por exemplo, pode ser mapeado módulos mas também classes ou métodos muito utilizados.

 

Deve ser atualizada sempre que novas dependências forem encontradas e estar disponível para a equipe de testes e homologação calcular o que testar e ter uma ideia do tempo dos testes.

Consumindo API Rest com Spring Boot usando a classe WebClient

           Nesse artigo vou mostrar como fazer um cliente para uma API Rest com Spring 5 usando a classe WebClient que é parte do novo WebFlux Framework. Esse cliente vai consumir uma API de Livros. Aproveitando o post, já vou criar esse cliente em uma classe de teste usando JUnit para mostrar o teste de APIs com ele. Mas a forma de uso aqui não se limita a testes.

         

Como o foco é a construção de um cliente para consumir uma API, vou omitir o código da API, trazendo só a construção do cliente. Então vamos ao código:

 

import java.util.List;

import org.junit.jupiter.api.Assertions

import org.junit.jupiter.api.BeforeAll;

import org.junit.jupiter.api.Test;

import org.springframework.core.ParameterizedTypeReference;

import org.springframework.http.HttpHeaders;

import org.springframework.http.HttpMethod;

import org.springframework.http.MediaType;

import org.springframework.web.reactive.function.client.WebClient;

import org.springframework.web.reactive.function.client.WebClient.Builder;

import org.springframework.web.reactive.function.client.WebClient.ResponseSpec;

 

import br.com.socialbooks.model.Livro;

import reactor.core.publisher.Mono;

 

class LivroControllerTest {

 

       @BeforeAll

       static void inserirLivro() {

             // configura uma requisição

             Builder builder = WebClient.builder();

             builder.baseUrl("http://localhost:8080");

 

             Livro livro = new Livro("Aprendendo Spring boot");

 

             // prepara o cliente

             WebClient client = builder.build();

             ResponseSpec response = client.method(HttpMethod.POST).uri("/livros").bodyValue(livro).retrieve();

 

             // recebendo o recurso salvo

             Mono<Livro> monoLivro = response.bodyToMono(Livro.class);

             livro = monoLivro.block();

       }

 

       @Test

       void testGetListaLivros() {

             // configura uma requisição

             Builder builder = WebClient.builder();

             builder.baseUrl("http://localhost:8080");

             builder.defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);

 

             // prepara o client

             WebClient client = builder.build();

             ResponseSpec response = client.method(HttpMethod.GET).uri("/livros").retrieve();

 

             /*

              * recebe o Mono que executa de forma assíncrona. OBS: Para carregar uma lista

              * de objetos, é preciso usar o ParameterizedTypeReference.

              */

             Mono<List<Livro>> monoLivro = response.bodyToMono(new                  ParameterizedTypeReference<List<Livro>>() {

             });

 

             // como funciona de forma assincrona, usamos o block para forçar ele esperar a resposta.

             List<Livro> livros = monoLivro.block();

 

              Assert.assertTrue(livros.get(0).getTituloLivro().equals("Aprendendo Spring boot"));

 

       }

 

       @Test

       void testGetLivro() {

             // configura uma requisição

             Builder builder = WebClient.builder();

             builder.baseUrl("http://localhost:8080");

             builder.defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);

 

             // prepara o client

             WebClient client = builder.build();

             ResponseSpec response =             client.method(HttpMethod.GET).uri("/livros/1").retrieve();

             // recebe o Mono que executa de forma assíncrona

             Mono<Livro> monoLivro = response.bodyToMono(Livro.class);

 

             // como funciona de forma assincrona, usamos o block para forçar ele esperar 

             // a resposta.

             Livro livro = monoLivro.block();

             Assert.assertTrue(livro.getTituloLivro().equals("Aprendendo Spring boot"));

       }

}

 

Pra esse artigo é só.

Esse artigo foi baseado estudos feitos em:

https://www.baeldung.com/spring-webclient-json-list

https://www.youtube.com/watch?v=Q1BjCuAQRrQ&list=LL&index=4

Exemplo de teste com JUnit e Mockito

       Nesse post eu trago um exemplo de testes usando Mockito para simular o comportamento de uma classe DAO, substituindo seu acesso ao banco por dados criados específicamente para os testes, de maneira que possamos testar apenas o comportamento desejado e não a integração com banco de dados, etc. Esse exemplo é do curso que fiz da Alura sobre testes com Mockito.

/**

 * Resumo:

 * 1 - Cria as propriedades SERVICE(s) e DAO(s)

 * 2 - No metodo inicializar:

 *      1 - mocka o(s) DAO(s)

 *      2 - inicia o(s) SERVICE(s) com os respectivos DAO(s) mockados

 * 3 - Cria os métodos de teste

 */

class FinalizarLeilaoServiceTest {

 

    private FinalizarLeilaoService finalizarLeilaoService;

 

    private LeilaoDao leilaoDao;

 

    @BeforeEach

    void inicializar() {

        // inicializa o mock e passa pro service

        leilaoDao = Mockito.mock( LeilaoDao.class );

        finalizarLeilaoService = new FinalizarLeilaoService( leilaoDao );

    }

 

    @Test

    void deveriaFinalizarLeilao() {

        List<Leilao> leiloes = leiloes();

 

        // defino o retorno de metodos do DAO mockado

        Mockito.when( leilaoDao.buscarLeiloesExpirados() ).thenReturn( leiloes );

 

        // metodo testado

        finalizarLeilaoService.finalizarLeiloesExpirados();

 

        // resultados esperados

        Leilao leilao = leiloes.get( 0 );

        Assert.assertTrue( leilao.isFechado() );

        Assert.assertEquals( new BigDecimal( "900" ), leilao.getLanceVencedor().getValor() );

        // Testa se determinado método do DAO foi chamado

        Mockito.verify( leilaoDao ).salvar( leilao );

    }

 

    //método com dados hardcode para teste

    private List<Leilao> leiloes() {

        List<Leilao> leiloes = new ArrayList<>();

 

        Leilao leilao = new Leilao( "Celular", new BigDecimal( "500" ), new Usuario( "Alguém" ) );

 

        Lance primeiro = new Lance( new Usuario( "Outro Alguém" ), new BigDecimal( "600" ) );

        Lance segundo = new Lance( new Usuario( "Mais Alguém" ), new BigDecimal( "900" ) );

        Lance terceiro = new Lance( new Usuario( "Um Alguém" ), new BigDecimal( "500" ) );

 

        leilao.propoe( primeiro );

        leilao.propoe( segundo );

        leilao.propoe( terceiro );

        leiloes.add( leilao );

        return leiloes;

    }

}

Usando JUnit para testar acesso a webservice

 Essa postagem traz um código simples de testes para um acesso a webservice:

import javax.ws.rs.client.Client;

import javax.ws.rs.client.ClientBuilder;

import javax.ws.rs.client.WebTarget;

import org.junit.Assert;

import org.junit.Test;

public class teste {

    @Test

    public void testaQueAConexaoComOServidorFunciona() {

        Client client = ClientBuilder.newClient();

        WebTarget target = client.target( "http://www.mocky.io" );

        String conteudo = target.path( "/v2/52aaf5deee7ba8c70329fb7d" ).request().get( String.class );

        System.out.println( conteudo );

        Assert.assertTrue( conteudo.contains( "Rua Vergueiro 3185" ) );

    }

}