Arquivo para fevereiro de 2017

Testando serviços REST com Spring Boot e RestTemplate

Uma das principais características do Spring Boot é a sua simplicidade em permitir criar rapidamente uma aplicação sem abrir mão do design do seu código. E se você realmente quer fazer um trabalho de qualidade não pode abrir mão dos testes. Um bom modo de se fazer isso é com testes efetivos (não mocks) rodando no seu ambiente desenvolvimento. No trecho de códigos criamos o nosso primeiro teste.

package br.com.erudio;

import java.io.IOException;
import java.util.List;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.web.client.RestTemplate;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import br.com.erudio.models.Person;
import br.com.erudio.repository.PersonRepository;

//Inicializamos o SpringRunner
@RunWith(SpringRunner.class)
//Setamos como uma classe de testes com o Server inicializando em uma porta fixa
//Essa porta pode ser a 8080 ou a que desejarmos setada no nosso aplication.properties
//Acesse src/test/resources/application.properties caso deseje alterar
//No nosso caso é a 8888 como você pode ver no aplication.properties "server.port = 8888"
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
public class PersonEndpointTests {
    
    //URL base para onde as requests serão feitas
    final String BASE_PATH = "http://localhost:8888/person";

    //Injetamos o repositório para acesso ao Banco de dados
    @Autowired
    private PersonRepository repository;
	
    //Definimos o restTemplate
    private RestTemplate restTemplate;
    
    //Definimos o JacksonMapper responsável por converter
    //JSON para Objeto e vice versa
    private ObjectMapper MAPPER = new ObjectMapper();
    
    //Definimos o que será feito antes da execução do teste
    @Before
    public void setUp() throws Exception {

        //Deletamos todos os registros do banco
        repository.deleteAll();

        //Inserimos alguma pessoas no banco
        repository.save(new Person("Diego", "Samuel", "Asa Sul"));
        repository.save(new Person("Eudes", "Silva", "Rosário"));
        repository.save(new Person("Anderson", "Silva", "Santa Teresa"));
	repository.save(new Person("Alice", "Ferreira", "Bombeiros"));
	repository.save(new Person("Alan", "Franco", "Granja Marileusa"));        
       
        //Inicializamos o objeto restTemplate
        restTemplate = new RestTemplate();
    }
    
    @Test
    public void testCreatePerson() throws JsonProcessingException{

        //Criamos uma nova pessoa
        Person person = new Person("Leandro", "Costa", "Presidente Roosevelt");

        //Fazemos um HTTP request do tipo POST passando a pessoa como parâmetro
        Person response = restTemplate.postForObject(BASE_PATH, person, Person.class);

        //Verificamos se o resultado da requisição é igual ao esperado
        //Se sim significa que tudo correu bem
        Assert.assertEquals("Leandro Costa", response.getFirstName() + " " + response.getLastName());
    }
    
  

}

Agora faremos um HTTP request do tipo GET para listar todas as pessoas ou uma em específico

    @Test
    public void testFindOne() throws IOException{

        //Fazemos uma requisição HTTP GET buscando por todas as pessoas
    	String response = restTemplate
			.getForObject(BASE_PATH + "/findAll", String.class);

        //Convertemos a resposta JSON para Objeto usando op Jackson
        List<Person> persons = MAPPER.readValue(response, 
			MAPPER.getTypeFactory().constructCollectionType(List.class, Person.class));
        //Pegamos o ID da pessoa na posição 1 da lista e fazemos nova requisição
        //Recuperando as informações da mesma
        Person person = restTemplate.getForObject(BASE_PATH + "/" +
			persons.get(1).getIdPerson(), Person.class);
        
        //Verificamos se o resultado da requisição é igual ao esperado
        //Se sim significa que tudo correu bem
        Assert.assertNotNull(person);
    	Assert.assertEquals("Eudes", person.getFirstName());
    	Assert.assertEquals("Silva", person.getLastName());
    }

Agora faremos um HTTP request do tipo PUT para atualizar uma pessoa em específico

    
    @Test
    public void testUpdatePerson() throws IOException{
    	String response = restTemplate.getForObject(BASE_PATH + "/findAll", String.class);
        List<Person> persons = MAPPER.readValue(response,
			MAPPER.getTypeFactory().constructCollectionType(List.class, Person.class));
        
        //Pegamos o ID da pessoa na posição 2 da lista e fazemos nova requisição
        //Recuperando as informações da mesma
        Person person = restTemplate.getForObject(BASE_PATH + "/" +
			persons.get(2).getIdPerson(), Person.class);

        //Alteramos as informações da pessoa recuperada
        person.setFirstName("Tiago");
        person.setLastName("Ferreira");

        //Fazemos um HTTP request do tipo PUT passando a pessoa 
        //e suas novas informações como parâmetro
        restTemplate.put(BASE_PATH, person);
        
        //como a operação PUT do RestTemplate é do tipo void
        //Precisamos fazer uma nova requisição para recuperar 
        //as informações da pessoa atualizada
        Person person2 = restTemplate.getForObject(BASE_PATH + "/" +
			persons.get(2).getIdPerson(), Person.class);
       
        //Verificamos se o resultado da requisição é igual ao esperado
        //Se sim significa que tudo correu bem
        Assert.assertNotNull(person2);
    	Assert.assertEquals("Tiago", person2.getFirstName());
    	Assert.assertEquals("Ferreira", person2.getLastName());
        
    }

Sendo assim nos testamos as operações do nosso endpoint. Se quiser ver mais detalhes você pode baixar o código deste post aqui, descompactar o arquivo zip e importar na sua IDE preferida ou clonar usando Git:


git clone https://github.com/leandrocgsi/spring-boot-rest-with-mongodb-example.git


Você pode acessar outros posts sobre SpringBoot e REST aqui mesmo no blog. É isso aí bons estudos e se gostou da postagem, vá até o topo desta página e torne-se um membro VIP para receber conteúdos exclusivos.

Tags: , ,

Guia Rápido de Docker

Fala rapazeada recentemente eu tirei um tempo pra estudar Docker e usar deploiando aplicações com Spring Boot. Este é minha lista de comandos básicos. Se você tiver alguma dica adicional que não está listada aqui sinta-se livre para mencionar nos comentários e eu irei atualizar o post. Lembrando que a maioria dos comandos podem ser usados em qualquer tipo de aplicação e não apenas com Spring Boot.

Exibir informações do Docker

docker info

Listar Todas as Docker Images

docker images -a

Listar Todos os Docker Containers que estão em execução

docker ps

Listar Todos os Docker Containers

docker ps -a

Iniciar um Docker Container

docker start <container name>

Parar um Docker Container

docker stop <container name>

Reiniciar um Docker Container

docker restart <container name>

Visualizar os logs de um Docker Container em execução

docker logs <container name>

Deletar um Docker Container

Use a opção -f caso precise forçar a remoção.

docker rm <container name>

Deletar Todos os Docker Containers

Use a opção -f caso precise forçar a remoção.

docker rm $(docker ps -a -q)

Remover uma Docker Image

docker rmi <image name>

Remover Todas as Docker Images

docker rmi $(docker images -q)

Acessando o Shell de um Docker Container em execução

sudo docker exec -it <container name> bash

Saindo do Shell de um Docker Container em execução

CTRL+P+Q

Baixando uma imagem do DockerHub

docker pull <image name>

Criando uma Tag de Uma imagem a ser commitada no DockerHub

docker tag <docker hub user>/<image name> <docker hub user>/<image name> 

Autenticar no DockerHub

docker login

Enviar uma imagem para o DockerHub

docker push <docker hub user>/<image name>

Cosntruindo uma imagem a partir de um Dockerfile no diretório atual

docker build -t="<image name>" .

Exibir o histórico de um container em execução

docker history <container name>

Criando um Alias para um comando Docker

alias dps="docker ps"

Limpando o console

reset

Dicas espertas de Dockerfile para developers Spring Boot

Add Oracle Java to an Image

Para Ubuntu versão 16.10 LTS

FROM dockerfile/ubuntu

# Instala o Java 8.
RUN \
  echo oracle-java8-installer shared/accepted-oracle-license-v1-1 select true | debconf-set-selections && \
  add-apt-repository -y ppa:webupd8team/java && \
  apt-get update && \
  apt-get install -y oracle-java8-installer && \
  rm -rf /var/lib/apt/lists/* && \
  rm -rf /var/cache/oracle-jdk8-installer


# Define o diretório de trabalho.
WORKDIR /data

# Define a variável de ambiente JAVA_HOME
ENV JAVA_HOME /usr/lib/jvm/java-8-oracle

# Define o comando padrão.
CMD ["bash"]

Adicionando e executando um .jar de uma aplicação Spring Boot a uma Docker Image

VOLUME /tmp
ADD /maven/myapp-0.0.1-SNAPSHOT.jar myapp.jar
RUN sh -c 'touch /myapp.jar'
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/myapp.jar"]

É isso aí bons estudos e se gostou da postagem vá até o topo dessa página e torne-se um membro VIP para receber conteúdos exclusivos.

Tags: , ,