DEV Community: Luiz Leite Oliveira

GraphQL no Quarkus

Luiz Leite Oliveira — Thu, 02 Jul 2020 19:54:17 +0000

Tudo que está nesse projeto pode ser encontrado no repositório GitHub.

Para a nossa poc o que fizemos foi primeiro pegar.

Intro ao projeto

Esse projeto já foi contextualizado no dev.to. Basicamente o que ele faz
é pegar usar o get da api encontrada em https://randomuser.me/api e aplica um GraphQL na resposta.

GRAPHQL On Quarkus

Dependências

Para utilizar o GraphQL neste projeto utilizamos uma dependência da Vert.x, documentação completa você pode encontrar
aqui para importar basta adicionar em seu pom.xml

    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-web-graphql</artifactId>
    </dependency>

Vamos para o código

Antes de usar o GraphQL precisamos modelar alguns DTO's para nossa modelagem:

public class Names {

    private String title;
    private String first;
    private String last;

//    Getters and Setters

}

Para esse modelo precisamos utilizaremos um Fetcher, que deve ficar da seguinte forma:

public class UserFetcher implements DataFetcher<List<User>> {

    private final UserClient userClient;

    public UserFetcher(UserClient userClient) {
        this.userClient = userClient;
    }


    private Results getResult() {
        return userClient.getUsers();
    }

    @Override
    public List<User> get(DataFetchingEnvironment environment) throws Exception {
        return getResult().getResults();
    }
}

Producer

Para pegar os resultados, vamos precisar também de uma classe producer como a seguir, é um pouco de boilerplate, vou tentar fazer uma
extensão de quarkus para reduzir essa e outras partes que são repetitivas, enquanto isso não acontece, a classe fica da seguinte forma:

 public class GraphQLProducer {

     private Logger LOGGER = LoggerFactory.getLogger(GraphQLProducer.class);

     @RestClient
     @Inject
     private UserClient userClient;

     @Produces
     public GraphQL setup() {

         LOGGER.info("Setting up GraphQL..");

         SchemaParser schemaParser = new SchemaParser();
         TypeDefinitionRegistry registry = schemaParser.parse(
             new InputStreamReader(
                 Objects.requireNonNull(Thread.currentThread().getContextClassLoader()
                     .getResourceAsStream("META-INF/resources/graphql.schema"))));

         SchemaGenerator schemaGenerator = new SchemaGenerator();
         GraphQLSchema graphQLSchema = schemaGenerator.makeExecutableSchema(registry, wirings());
         return GraphQL.newGraphQL(graphQLSchema).build();
     }

     private RuntimeWiring wirings() {

         LOGGER.info("Wiring queries..");

         return RuntimeWiring.newRuntimeWiring()
             .type("Query",
                 builder -> builder.dataFetcher("allUsers", new UserFetcher(userClient)))
             .build();
     }


 }

Na parte de getResourceAsStream() você coloca o schema de graphql que você desejar, no nosso caso ficou o META-INF/resources/graphql.schema

type Names {
  first: String
  last: String
}


type User {
  email: String
  name: Names
  gender: String
  phone: String
  cell: String
  nat: String
}

type Query {
  allUsers : [User]
}

Além disto, na parte de wirings() colocamos quem será o Fetcher que vai ser utilizado para allUsers que foi declarado dentro do graphql.schema

Finalizando temos que declarar a parte de Rotas (outra parte que é um pouco boilerplate que também pode entrar na extensão).

@ApplicationScoped
public class Routes {

    @Inject
    GraphQL graphQL;

    public void init(@Observes Router router) {

        boolean enableGraphiQL = true;

        router.route("/graphql")
            .handler(new GraphQLHandlerImpl(graphQL, new GraphQLHandlerOptions()));
        router.route("/graphiql/*").handler(
            GraphiQLHandler.create(new GraphiQLHandlerOptions().setEnabled(enableGraphiQL)));
    }

}

Foram declaradas duas rotas:

/graphql → onde ficam os "endpoints" para acesso dos usuários
/graphiql/* → onde fica a documentação para o que foi registrado.

## Concluindo
Resumindo tudo que fizemos não é muito complicado depois da primeira vez, mas falta muita documentação e várias vezes vi
lugares mostrando como se fosse meio que mágica, como se fizesse um import e já funciona. Depois de muitos testes funciona
bem, mas como já disse existem muitas partes que podem ser eliminadas por uma extensão mais completa.

Outra coisa que ficou muito obscuro e difícil são as headers como authorização não é muito simples de manipular e fazer alguma
validação com elas.

Com isso tudo não acho uma boa opção comparando com o que já tem em Spring Boot, para esse caso ainda não está maduro suficiente,
mas é claro que não está muito longe e, é fácil de ver como chegariam nesse ponto.

## Quer acompanhar um pouco mais?
Me siga nas plataformas._

GitHub: luizleite-hotmart

Twitter: luizleite_

Twitch: coffee_and_code

Linkedin: luizleiteoliveira

dev.to: luizleite_

Creating A/B (Split) test API in 2 hours

Luiz Leite Oliveira — Wed, 27 May 2020 16:30:02 +0000

What the hell is A/B or Split test

A/B test are those tests that, one user has a path, and will always follow this path,
and some other user will be on another flow in the same version. Nowadays we could use these tests for many things like:

[x] Split the users (10% will see the green button and rest another color) An important thing is, in this scenario, if a user 'X' will always be on the same path
[x] Rollout features. When you will release a new feature, you can make a rollout, progressively,
and if exists a bug or performance issue we can improve that part before all users have the same problem.

Those things are important but, more relevant is how we can collect data about those tests.
The simplest approach throws a log and gets this info on Kibana with a dashboard.

What we used

SpringBoot
H2
Hibernate
Spring Web
JPA

For the first part, this is all we need. A good improvement is to add a cache, another
thing is to use a better database but with H2 you put this on AWS S3 and handle over there.

The project

For persist, the only class needed is the Feature.kt, in this class will have all the algorithm.

import javax.persistence.Entity
import javax.persistence.GeneratedValue
import javax.persistence.Id

@Entity
data class Feature(var name: String = "",
                   var description: String = "",
                   var percentage: Int = 0) {
    fun userAbleUseFeature(ucode: String): Boolean {
        var ucodeNumber = ucode.hashCode()
        var result = (777 * ucodeNumber * this.id) % 100
        return result < this.percentage
    }

    @Id
    @GeneratedValue
    var id: Long = 0
}

The method .entity.Feature#userAbleUseFeature the algorithm will make the user be on the new feature or not.
The number 777 is just a constant, is not completely necessary, but it's important to be a multiplying factor with the feature id.

All tests will be in: com.luizleiteoliveira.abtest.entity.FeatureTest

    @Test
    fun `user not able to use feature`() {
        val feature = Feature(name = "name", description = "description", percentage = 10)
        feature.id = 10
        val user = User("ucode")
        Assertions.assertEquals(10,  feature.id) // 777 * 10 * 111111138 = 45115764 % 100 = 64
        val userAbleUseFeature = feature.userAbleUseFeature(user.ucode)
        Assertions.assertFalse(userAbleUseFeature)
    }

    @Test
    fun `user able to use feature increase the percentage`() {
        val feature = Feature(name = "name", description = "description", percentage = 65)
        feature.id = 10
        val user = User("ucode")
        Assertions.assertEquals(10,  feature.id) // 777 * 10 * 111111138 = 45115764 % 100 = 64
        val userAbleUseFeature = feature.userAbleUseFeature(user.ucode)
        Assertions.assertTrue(userAbleUseFeature)
    }

    @Test
    fun `user able to use feature`() {
        val feature = Feature(name = "name", description = "description", percentage = 21)
        feature.id = 10
        val user = User("L")
        Assertions.assertEquals(10,  feature.id) // 76 * 10 * 111111138 = 590520 % 100 = 20
        val userAbleUseFeature = feature.userAbleUseFeature(user.ucode)
        Assertions.assertTrue(userAbleUseFeature)
    }

To finish our project the last thing will be the controller from Feature.

import com.luizleiteoliveira.abtest.FeatureRepository
import com.luizleiteoliveira.abtest.entity.Feature
import org.springframework.web.bind.annotation.*

@RestController
@RequestMapping("/features")
class FeatureController(private val featureRepository: FeatureRepository) {

    @GetMapping
    fun getFeatures(): List<Feature> {
        return featureRepository.findAll().toList()
    }

    @PostMapping
    fun createFeature(@RequestBody feature: Feature): Long {
        featureRepository.save(feature)
        return feature.id
    }

    @PutMapping
    fun updateFeature(@RequestBody feature: Feature): Long {
        featureRepository.save(feature)
        return feature.id
    }

    @GetMapping("/{featureId}")
    fun checkUserAbleToUseFeature(@RequestParam("ucode") ucode: String, @PathVariable featureId: Long): Boolean {
        val feature = featureRepository.findById(featureId).get()
        return feature.userAbleUseFeature(ucode)
    }
}

The config will be on application.properties

spring.h2.console.enabled=true
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.datasource.url=jdbc:h2:file:/tmp/demo

Conclusion

There are many forms to apply split tests, for those we comment on beginning will work very well,
but there are many libs and API's to make this. All cases could have a specific thing that could not be the thing you need.

You can check this project on this link

Want to follow me?

You can get in contact me on this social media.

GitHub: luizleite-hotmart

Twitter: luizleite_

Twitch: coffee_and_code

Linkedin: luizleiteoliveira

dev.to: luizleite_

Como usar Rest Client em Quarkus

Luiz Leite Oliveira — Fri, 03 Apr 2020 16:31:08 +0000

Tudo que está nesse projeto pode ser encontrado no repositório GitHub.

Para criar o projeto utilizamos o próprio site de bootstrap do quarkus para criar o seu pode acessar aqui.

Dependências adicionadas

As dependências que vamos usar podem ser encontradas diretamente pelo bootstrap. São as seguintes:

JSON-B Utilizada para fazer json bind automático
REST Cliente Utilizada para criar chamada rest

Para quem usa maven as dependencias vão ficar assim:

     <dependency>
       <groupId>io.quarkus</groupId>
       <artifactId>quarkus-resteasy-jsonb</artifactId>
     </dependency>
     <dependency>
       <groupId>io.quarkus</groupId>
       <artifactId>quarkus-rest-client</artifactId>
     </dependency>

e em gradle:

io.quarkus:quarkus-rest-client
io.quarkus:quarkus-resteasy-jsonb

Background do projeto

Para facilitar a utilização do projeto vamos usar uma api já pronta que retorna usuários aleatórios, ela pode ser encontrada no site randomuser.me

Para ele vamos utilizar uma chamada no endpoint https://randomuser.me/api/

Quando fazemos um get nesse endpoint recebemos um usuário aleatório no formato de json como o a seguir:

{
  "results": [
    {
      "gender": "male",
      "name": {
        "title": "mr",
        "first": "brad",
        "last": "gibson"
      },
      "location": {
        "street": "9278 new road",
        "city": "kilcoole",
        "state": "waterford",
        "postcode": "93027",
        "coordinates": {
          "latitude": "20.9267",
          "longitude": "-7.9310"
        },
        "timezone": {
          "offset": "-3:30",
          "description": "Newfoundland"
        }
      },
      "email": "brad.gibson@example.com",
      "login": {
        "uuid": "155e77ee-ba6d-486f-95ce-0e0c0fb4b919",
        "username": "silverswan131",
        "password": "firewall",
        "salt": "TQA1Gz7x",
        "md5": "dc523cb313b63dfe5be2140b0c05b3bc",
        "sha1": "7a4aa07d1bedcc6bcf4b7f8856643492c191540d",
        "sha256": "74364e96174afa7d17ee52dd2c9c7a4651fe1254f471a78bda0190135dcd3480"
      },
      "dob": {
        "date": "1993-07-20T09:44:18.674Z",
        "age": 26
      },
      "registered": {
        "date": "2002-05-21T10:59:49.966Z",
        "age": 17
      },
      "phone": "011-962-7516",
      "cell": "081-454-0666",
      "id": {
        "name": "PPS",
        "value": "0390511T"
      },
      "picture": {
        "large": "https://randomuser.me/api/portraits/men/75.jpg",
        "medium": "https://randomuser.me/api/portraits/med/men/75.jpg",
        "thumbnail": "https://randomuser.me/api/portraits/thumb/men/75.jpg"
      },
      "nat": "IE"
    }
  ],
  "info": {
    "seed": "fea8be3e64777240",
    "results": 1,
    "page": 1,
    "version": "1.3"
  }
}

Caso chamemos o mesmo endpoint mas dessa vez com um Query Param results=N ele traz N resultados pra gente.

Modelagem

Os dados vão ser modelados da seguinte forma:

### Names.java
A classe name é utilizada para criar a parte name do usuário, que tem os campos String title, first, last

 package org.luizleiteoliveira.entity;

 public class Names {

     private String title;
     private String first;
     private String last;

     public String getTitle() {
         return title;
     }

     public void setTitle(String title) {
         this.title = title;
     }

     public String getFirst() {
         return first;
     }

     public void setFirst(String first) {
         this.first = first;
     }

     public String getLast() {
         return last;
     }

     public void setLast(String last) {
         this.last = last;
     }
 }

User.java

Para modelar o usuário a api vem com diversos campos, vamos utilizar além do objeto name , email, gender,
phone, cell, nat:

package org.luizleiteoliveira.entity;

public class User {

    private String email;
    private String gender;
    private Names name;
    private String phone;
    private String cell;
    private String nat;

    public User() {}

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public Names getName() {
        return name;
    }

    public void setName(Names name) {
        this.name = name;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getCell() {
        return cell;
    }

    public void setCell(String cell) {
        this.cell = cell;
    }

    public String getNat() {
        return nat;
    }

    public void setNat(String nat) {
        this.nat = nat;
    }
}

Results.java

Pra finalizar a classe que faz ficam todos os nossos resultados, pra nossa modelagem só vai conter uma lista de usuários.

package org.luizleiteoliveira.entity;

import java.util.List;

public class Results {

    private List<User> results;
    public Results() {}

    public List<User> getResults() {
        return results;
    }

    public void setResults(List<User> results) {
        this.results = results;
    }
}

Conclusão

Eu fiquei bem feliz com o modo que foi implementado, achei extremamente simples e intuitivo. Usar as mesmas notações para registrar o controller você utilizar pra executar a chamada facilita muito.

Quer acompanhar um pouco mais? Me siga nas plataformas.

GitHub: luizleite-hotmart

Twitter: luizleite_

Twitch: coffee_and_code

Linkedin: luizleiteoliveira

dev.to: luizleite_

Testes realmente unitários no Spring Boot

Luiz Leite Oliveira — Thu, 27 Feb 2020 22:03:55 +0000

Introdução

A um tempo fui rodar um teste que tinha a anotação @SpringBootTest e quando começou a rodar, já apareceu o Banner do Spring Boot
e uma mensagem:
contextLoader = 'org.springframework.boot.test.context.SpringBootContextLoader'

Quando eu vi isso, eu já vi que eu nem sabia o por quê de utilizar essa anotação e o qual deveria usar. Então o objetivo
deste post é de mostrar quais devem ser utilizadas pra qual cenário especifico.

Setup Inicial

Para o nosso setup inicial, vamos utilizar o mínimo e o pom vai precisar das seguintes depêndencias:

        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

a exclusão do junit-vintage-engine é necessária para utilização do JUnit5 que utiliza o junit-jupiter-engine .
O uso do H2 vai ser para testar a camada de dados.

Camada de serviços e DTOs

Vamos criar uma classe bem simples pra fazer alguns testes, para isso vamos criar um usuário:

public class User {

    private String name;
    private int age;
    private String document;

    public User(String name, int age, String document) {
        this.name = name;
        this.age = age;
        this.document = document;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getDocument() {
        return document;
    }

    public void setDocument(String document) {
        this.document = document;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", document='" + document + '\'' +
                '}';
    }
}

e o teste que vai executar sobre essa classe vai ser:

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;


public class EntityTest {

    @Test
    public void UserTest() {
        User user = new User("name", 12, "DOC12543");
        assertEquals("name", user.name);
        assertTrue(user.toString().contains("User{"));
    }
}

E deste jeito já tá rodando os nossos testes em 135ms enquanto se utilizarmos a notação @SpringBootTest roda em 459ms,
parece pouco mas vamos lembrar que esse teste é o mais simples e nossa aplicação não tem nada configurado. Mesmo assim
a diferenção entre os dois testes já foi mais que o triplo, isso só pra validar um DTO.

Camada de dados

Para testar nossa camada de dados vamos dar colocar em nossa classe User um atributo @Entity e o ID que fica obrigatório:

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String name;
    private int age;
    private String document;

    public User(String name, int age, String document) {
        this.name = name;
        this.age = age;
        this.document = document;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getDocument() {
        return document;
    }

    public void setDocument(String document) {
        this.document = document;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", document='" + document + '\'' +
                '}';
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }
}

E o acesso vamos fazer via JpaRepository com apenas um método:

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {

    public User findUserByNameAndDocument(String name, String doc);
}

Depois de ter criado essas classes já podemos criar alguns testes para essa parte. Alguns exemplos podem ser vistos a seguir:

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.test.context.junit.jupiter.SpringExtension;

import static org.junit.jupiter.api.Assertions.*;

@ExtendWith(SpringExtension.class)
@DataJpaTest
public class UserRepositoryTests {

    @Autowired
    private UserRepository userRepository;

    @Test
    public void insertUser() {
        User user = new User("name", 11, "DOC12355");
        userRepository.save(user);
        Integer countUser = userRepository.findAll().size();
        assertEquals(1, countUser);
    }

    @Test
    public void checkUserSavedWithDocument() {
        User user = new User("name", 11, "DOC12355");
        userRepository.save(user);
        Integer countUser = userRepository.findAll().size();
        assertEquals(1, countUser);
        User user1 = userRepository.findUserByNameAndDocument("name", "DOC12355");

        assertNotNull(user1);
        assertEquals(user, user1);
    }

    @Test
    public void checkUserSavedWithDocumentPassingOtherDocumentShouldReturnNull() {
        User user = new User("name", 11, "DOC12355");
        userRepository.save(user);
        Integer countUser = userRepository.findAll().size();
        assertEquals(1, countUser);
        User user1 = userRepository.findUserByNameAndDocument("name", "99999");

        assertNull(user1);
    }
}

Utilizando @DataJpaTest ajuda a configurar algumas coisas automagicamente:

Configuração de H2 in-memory
Spring Data, Datasource
Modo de logar o SQL ON

o modo de logar o sql para o nosso caso fica assim:

insert into user (age, document, name, id) values (?, ?, ?, ?)
select user0_.id as id1_0_, user0_.age as age2_0_, user0_.document as document3_0_, user0_.name as name4_0_ from user user0_
select user0_.id as id1_0_, user0_.age as age2_0_, user0_.document as document3_0_, user0_.name as name4_0_ from user user0_ where user0_.name=? and user0_.document=?

Esse teste com @SpringBootTest não roda.

Camada Web

Para camada web a gente já fez um post aqui
mas para o nosso caso de usuário vamos criar um controller para usuário, o mais simples seria o que retorna todos os usuários. Ficaria mais ou menos assim:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.List;

@Controller
public class UserController {

    @Autowired
    private UserRepository userRepository;

    @GetMapping(value = "/users")
    @ResponseBody
    public List<User> findAllUsers() {
        return userRepository.findAll();
    }
}

E um teste simples para resposta desse controller seria:


import org.hamcrest.Matchers;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.web.servlet.MockMvc;

import java.util.List;

import static org.hamcrest.Matchers.containsString;
import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@ExtendWith(SpringExtension.class)
@WebMvcTest(controllers = UserController.class)
class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private UserRepository userRepository;

    @Test
    public void findAllUsers() throws Exception {
        User user = new User("teste", 25, "DOC12346");
        List<User> userList = List.of(user);
        when(userRepository.findAll()).thenReturn(userList);
        this.mockMvc.perform(get("/users"))
                .andExpect(status().isOk())
                .andExpect(content().string(containsString("DOC12346")));
    }

}

Dentro desse teste utilizamos o MockMvc para fazer a chamada do controller, lembrando que isso é uma chamada "fake",
e o @MockBean para executar um mock do nosso repository. Outra coisa que fizemos foi adicionar.

Conclusão

Além destes existem mais algumas configurações automaticas que você pode checar aqui,
mas sempre surgem novas ferramentas. Mas utilizar a abordagem correta para parte que você deseja testar, vai facilitar o uso
além de te dar velocidade, tanto na hora de rodar, quanto na hora do desenvolvimento

## Gostou?
Se gostou aqui estão minhas redes sociais para acompanhar os novos posts.

Twitter: luizleite_

Twitch: coffee_and_code

Linkedin: luizleiteoliveira

dev.to: luizleite_

Como fazer testes unitários em controllers de um app Spring Boot

Luiz Leite Oliveira — Thu, 13 Feb 2020 20:15:52 +0000

Mas pra que?

Antes de começar a falar sobre o como fazer esses teste, temos que primeiro entender o motivo deles serem importantes e, considerados necessários. Os teste aqui vão fazer um mock de banco, conexões, serviços, com isso, a única parte que vai ser testada será o controller.

A maioria dos desenvolvedores, eu me incluo nessa parte, compartilha que nessa camada não deve existir regra de negócio ou chamada para os dados, existem outras camadas para isso. Então a única coisa que vai ser testada será uma resposta simulada (Mockada no bom português), muitos vêem que isso não é suficiente para criar testes unitários e testes end-to-end seriam mais adequados, mas vamos para um exemplo.

Imagine que você possui o seguinte código VO:

public class Stock {
    private Date date;
    private String code;
    private BigDecimal value;
}

e em um belo dia alguém decide subir o código novo removendo um dos atributos, que já foram combinados em contrato com as outras aplicações e ele fica assim:

public class Stock {
    private Date date;
    private BigDecimal value;
}

Claro que um teste de integração caso estejam bem executados pegariam antes de ir para produção, mas testes de integração custam caro e são lentos para executar. No conceito de Fail-Fast, em que quanto antes falhar menos danoso será para o seu projeto testes de contrato facilitariam muito para uma falha e correção antecipada.

Como fazer?

Já avisei aqui que este será focado em Spring Boot caso esteja em outro framework pode ser diferente.

Antes de começar vamos criar um projeto para isso você pode apenas ir em Start Spring e criar seu projeto apenas com a dependência Web, ou seguir o tutorial que fiz no GitHub

Se estiver tudo certo as dependências do seu Pom devem parecer com o código a seguir.

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

Agora vamos criar um VO de stocks que tem uma data, o código da ação e, o valor que ela tem. O meu código da classe ficou da seguinte forma.

import java.math.BigDecimal;
import java.util.Date;

public class Stock {
    private Date date;
    private String code;
    private BigDecimal value;

    public Stock(Date date, String code, BigDecimal value) {
        this.date = date;
        this.code = code;
        this.value = value;
    }

    public BigDecimal getValue() {
        return value;
    }

    public void setValue(BigDecimal value) {
        this.value = value;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public Date getDate() {
        return date;
    }

    public void setDate(Date date) {
        this.date = date;
    }
}

Agora para ser um pouco mais difícil vamos criar um service que retorna um algumas ações, o meu ficou da seguinte forma:

import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

@Service
public class StockServices {

    public List<Stock> createMockStocks(int howMany) {
        return IntStream.range(0, howMany).mapToObj(i -> new Stock(new Date(), "STK" + i, BigDecimal.valueOf(i))).collect(Collectors.toList());
    }
}

e agora pra finalizar, nossa camada Web que deve ter ficado algum código assim:

import com.luizleiteoliveira.restControllerTest.service.StockServices;
import com.luizleiteoliveira.restControllerTest.vo.Stock;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.List;

@Controller
public class StockController {

    private final StockServices stockServices;

    public StockController(StockServices stockServices) {
        this.stockServices = stockServices;
    }

    @GetMapping(value = "/stocks")
    public @ResponseBody
    List<Stock> getStocks(@RequestParam("howMany") int howMany) {
        return stockServices.createMockStocks(howMany);
    }
}

Agora se rodar nosso código e acessar localhost com 3 de parâmetro http://localhost:8080/stocks?howMany=3
Vamos ter o resultado a seguir:

[ 
   { 
      "date":"2020-01-27T08:34:42.925+0000",
      "code":"STK0",
      "value":0
   },
   { 
      "date":"2020-01-27T08:34:42.926+0000",
      "code":"STK1",
      "value":1
   },
   { 
      "date":"2020-01-27T08:34:42.926+0000",
      "code":"STK2",
      "value":2
   }
]

Agora basta testar, existem algumas formas de fazer isso, a que usuaremos vai ser com @WebMvcTest, esta anotação permite que você teste todos os controllers da sua aplicação. Melhor que isso você pode anotar qual controller que você quer testar, no nosso caso StockController, ficaria @WebMvcTest(StockController.class).

Agora para você testar a chamada o Spring Framework possui uma classe chamada MockMvc que permita que você execute essas chamadas.

Exemplo

#### 1) Teste de falha
Já sabemos que o nosso controller necessita um parâmetro chamado howMany, com isso, um teste de falha pode ser caso não seja passado esse parâmetro tem que retornar um erro.

O teste ficaria mais ou menos assim:

    @Test
    public void callingWithoutParameterShouldReturnBadRequest() throws Exception {
        List<Stock> result = new ArrayList<>();
        result.add(new Stock(new Date(),"NEWSTOCK", BigDecimal.TEN));
        Mockito.when(stockServices.createMockStocks(5)).thenReturn(result);
        this.mockMvc.perform(get("/stocks")).andExpect(MockMvcResultMatchers.status().isBadRequest());
    }

2)Teste de sucesso

Agora que já passamos por um erro o outro teste em que, passamos os parâmetros corretamente e ele retorna as stocks esperadas.

Esse teste ficaria da seguinte maneira:

    @Test
    public void shouldReturnJustOneFromResult() throws Exception {
        List<Stock> result = new ArrayList<>();
        result.add(new Stock(new Date(),"NEWSTOCK", BigDecimal.TEN));
        Mockito.when(stockServices.createMockStocks(1)).thenReturn(result);
        this.mockMvc.perform(get("/stocks").queryParam("howMany", "1"))
                .andExpect(MockMvcResultMatchers.status().isOk()).andExpect(content().string(containsString("NEWSTOCK")));
    }

Caso falte alguma coisa a classe inteira está a seguir:

package com.luizleiteoliveira.restControllerTest.controller;

import com.luizleiteoliveira.restControllerTest.service.StockServices;
import com.luizleiteoliveira.restControllerTest.vo.Stock;
import org.hamcrest.Matchers;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import static org.hamcrest.Matchers.containsString;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;

@RunWith(SpringRunner.class)
@WebMvcTest(StockController.class)
public class StockControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private StockServices stockServices;

    @Test
    public void callingWithoutParameterShouldReturnBadRequest() throws Exception {
        List<Stock> result = new ArrayList<>();
        result.add(new Stock(new Date(),"NEWSTOCK", BigDecimal.TEN));
        Mockito.when(stockServices.createMockStocks(5)).thenReturn(result);
        this.mockMvc.perform(get("/stocks")).andExpect(MockMvcResultMatchers.status().isBadRequest());
    }

    @Test
    public void shouldReturnJustOneFromResult() throws Exception {
        List<Stock> result = new ArrayList<>();
        result.add(new Stock(new Date(),"NEWSTOCK", BigDecimal.TEN));
        Mockito.when(stockServices.createMockStocks(1)).thenReturn(result);
        this.mockMvc.perform(get("/stocks").queryParam("howMany", "1"))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(content().string(containsString("NEWSTOCK")));
    }
}

Conclusão

Para uma classe simples foi bem tranquilo utilizar os conceitos de testar uma parte separada. Foi muito satisfatório utilizar o mockMvc pois para o primeiro teste eu tinha me esquecido de passar o parâmetro howMany e o teste quebrou mostrando o que poderia acontecer. Agora pretendo fazer alguns testes mais robustos com filters no controller para ver o quão simples vai ser além de tentar aplicar um TDD nessa parte para ver se faz sentido.

De qualquer forma acho que pelo custo que foi de implementar é muito válido utilizar testes assim, são leves e conseguem controlar a saída de dados como dados, tipo, httpStatus... Então é mais uma forma leve de cercar sua aplicação, na minha opinião utilize o maior ferramental de testes unitários que os desenvolvedores vão ficar mais felizes.

Até a proxima!! =)

# Quarkus depois do 1.0

Luiz Leite Oliveira — Thu, 09 Jan 2020 22:54:42 +0000

A um tempo escrevi sobre o que era o quarkus nesse post. Pouco tempo depois lançaram a versão 1.0 que uma visão fria fala sobre sair do beta. Depois desse fato muita coisa alterou e vou tentar citar as principais alterações.

Bootstrap para facilitar a inicialização

Indo na mesma direção que start.spring.io o quarkus também criou o seu bootstrap bem facilitado, quase um "next -> next -> finish", para iniciar o seu projeto.
Acessando code.quarkus.io já aparecem algumas opções para adicionar o nome do group, artifato, ferramenta de build Maven ou Gradle(Preview), Versão e package.

Além disso podem ser selecionadas quais extensões o seu projeto, a maioria das extensões já estão descritas em quarkus extensions, caso não tenha a extensão que você está precisando eles tem um tutorial de como criar uma nova aqui.

Versão nova do IDEA 2019.3

O Suporte do IntelliJ IDEA foi uma parte que ajuda pra quem não está acostumado com os quarkus, inicialmente ele vem em forma de TIPS, como mostrado na imagem abaixo

[imagem retirada do site da JetBrains em https://www.jetbrains.com/idea/whatsnew/]

Isso ainda é muito básico, perto do que existe para SpringBoot, mas já é um início e, uma forma de mostrar que eles estão prestando atenção nesses frameworks.

Documentação

Infelizmente, não houve alterações nessa parte, pra mim não é um problema tão grande eu até gosto dos desenhos que eles fazem exemplificando.

A parte que eu não lembro, mas chamou muito minha atenção foi o blog deles. Acessando, você pode ver casos de empresas grandes que estão migrando de uma tecnologia para Quarkus. Um post que chamou muito minha atenção foi o da Vodafone, dentro você vai ver os motivos pelos quais optaram por quarkus e o que eles já tinham em spring boot.

Suporte GraalVM 19.3 delay

Muito bem explicado nesse post, eles optaram ficar na versão do GraalVM 19.2 para corrigir algumas issues foi bem maduro, admitirem os problemas que tiveram e, mostrar a forma de trabalho que eles querem aplicar para resolver esses casos.

Plugin Intellij Quarkus by RedHat

Isso talvez tenha sido um ponto altíssimo que eles fizeram, a própria RedHat lançou um plugin para Intellij Idea. O plugin permite:

Criação do projeto com bootstrap dentro do Intellij.
- application.properties assistente para quarkus-ls (mais informações sobre Language Server aqui
- Tips para o código.

O grande problema, pra mim do plugin, é que ele não possui uma busca pra facilitar a adição das extensões do quarkus.

Conclusão

O projeto evoluiu bastante e, se torna cada vez mais amigável para desenvolvedores. Pode parecer pouca coisa, mas tips e bootstrap, fazem aumentar muito a velocidade do seu projeto.

Meu primeiro app com Quarkus

Luiz Leite Oliveira — Wed, 31 Jul 2019 11:39:35 +0000

Hoje eu decidi que iria criar meu primeiro APP utilizando Quarkus, mas por que?! Na verdade é só uma validação mesmo eu sei que o Spring boot tá bem na frente em alguns pontos, mas Quarkus e Micronaut são ótimas alternativas, e estão ganhando espaço principalmente por causa do BOOM que temos de GRAAL_VM.

Na verdade, esse é meu segundo projeto com Quarkus o primeiro que tive oportunidade de fazer foi no DevoxxUK19 juntamente com os commiters e criadores do projeto. Lá tive oportunidade de tirar duvidas e vi o potencial que existe dentro dessa parte.

O que é QUARKUS.IO?

Quarkus é uma alternativa de framework java assim como spring boot e micronaut. Tem como objetivo ser container first alguns dizem até ser Kubernets nativo. A home do projeto mostra um conceito bem legal de ser o Java supersônico e isso é possível.
Uma das coisas mais interessantes que eu achei foi ao ler essa parte do site em que eles comentam sobre live coding. Em que há a mudança de quase um paradigma Java.
De:
Escreva código -> Compile -> Deploy -> Refresh -> Repeat
Para:
Escreva código ->Refresh -> Repita
E parece idiota mais isso tira um tempo gigantesco de desenvolvimento.

Start do projeto

Para dar start no seu projeto basta rodar o comando a seguir

mvn io.quarkus:quarkus-maven-plugin:0.19.1:create \
    -DprojectGroupId=com.luizleiteoliveira \
    -DprojectArtifactId=helloworld \
    -DclassName="com.luizleiteoliveira.helloworld.ApplicationResource" \
    -Dpath="/hello"

O que esse comando está gerando ?

A estrutura completa do Maven
Uma classe ApplicationResource dentro de /hello
Uma classe de teste associada a classe acima
Uma landing page disponível ao subir a aplicação em http://localhost:8080
Dois exemplos de Dockerfile para modos nativos e jvm

O Hello World

Para criar o seu primeiro Hello World em rest nem tem muito esforço pois dentro da classe que você deu o start já vem ela automatica da seguinte forma:

@Path("/hello")
public class ApplicationResource {

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        return "hello";
    }
}

Depois disso basta executar o comando em um terminal para rodar o quakus em modo de desenvolvimento:

./mvnw compile quarkus:dev

Esse comando já habilita uma porta 5005 para debug, com isso, deve ser feita uma configuração de debug remoto na sua IDE favorita.

Configurando Debug Remoto do Intellij:

Dentro da edição de configurações do Intellij (CTRL+SHIT + A -> Edit Configurations)
Clique no '+' e adicione uma configuração para a porta 5005 deve ficar parecido com essa:

Primeiro teste o 'Hotdeploy'

Na hora que fiz a parte acima já pensei é perdi meu Hotdeploy vou ter que jogar isso no chão toda hora e me ferrei então resolvi fazer o teste e enquanto minha aplicação estava em rodando alterei o meu hello para:

@Path("/hello")
public class ApplicationResource {

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello(@QueryParam("who") final String who) {
        return "hello "+ who;
    }
}

Assim que chamei o endpoint http://localhost:8080/hello?who=teste apareceu no meu terminal a mensagem: 'Hot replace total time: 0.726s' e não é que meu endpoint estava realmente alterado e isso é uma situação que eu teria que com certeza eu deveria reiniciar minha aplicação só que ele fez isso sem reclamar.
Claro que eu não fui a fundo mas funcionou muito bem até agora. A partir da próxima vez vou começar a fazer uma aplicação mais real com o quarkus vendo como é salvar os dados e talvez consumir uma API ou algo assim.

O poder em ação

Até agora sem enormes vantagens e é a hora que entramos na parte legal, vamos para o nativo. Depois da aplicação ficar do jeito que está existe um comando maven para buildar um binario da aplicação.

mvn package -Pnative

Para executar esse comando suas variáveis de ambiente assim como seu Graal já deve estar configurado para funcionar corretamente. Após a execução vai ser criado dentro do /target um executável, para rodar é bem simples é só ./ , e agora sim o susto em 0.003s minha aplicação está rodando.

Conclusão.

Como já falei os testes que eu fiz não foram nada só mais um tipo de primeira impressão, mas até agora tá bem tranquilo. Achei muito simples o primeiro start do projeto e coloca-lo para funcionar foi absurdo o tanto que foi rápido.
Um outro ponto que gostei que é dentro do site existe uma parte de Guides, mostrando vários tutoriais de como executar coisa 'x' em Quarkus.

Sobre o meu projeto você pode consultar dentro do github.

luizleite-hotmart / quarkus-poc

Prove of concept from quarkus

quarkus-poc

Prove of concept from quarkus

View on GitHub