Testando o Serverest com Kotlin e REST-Assured.
O Serverest é uma API (Application Programming Interface) para treinamento desenvolvido pela comunidade brasileira de Qualidade, organizado por Paulo Gonçalves, tem como ideia esse projeto de dar treinamento em REST-Assured para a empresa aonde trabalho.
Resumidamente a estrutura do REST-Assured trabalha no formato de BDD (Behavior Driven Development), mas diretamente no código fonte o que torna mais ágil que o cucumber, não faz sentido usar o cumcuber com REST-Assured, ele faz chamadas para o serviço utilizando a sintaxe Given, When e Then, e também usa a sintax Extract para extrair os dados.
Detalhando melhor as palavras chaves do framework REST-Assured, temos o Given inicialmente, para passar as pré-condições do nosso teste, como por exemplo token de autenticação e o body ou as configuração globais que chamamos de spec. No When efetuamos a chamada para o método a ser testado, ou seja os métodos\verbos HTTP 1.1 (GET, POST, PUT, DELETE e etc), e o Then tem como função trabalhar com os retornos da requisição ou efetuando assertivas, as assertivas são as validações que meu teste deve fazer, exemplo como retorna 200 OK, ou validar os dados de um determinado campo. Por fim usamos o Extract que é um comando opcional, para extrair dados da requisição feita no “body do response”.
Em vez de duplicar as expectativas de resposta (Meus Pré-requisitos) a cada teste, você pode reutilizar uma especificação “spec(requestSpecification())”, como no exemplo abaixo. Para fazer isso, você define uma especificação usando RequestSpecBuilder ou ResponseSpecBuilder.
REST Assured suporta qualquer método HTTP, mas tem suporte explícito para POST , GET , PUT , DELETE , OPTIONS , PATCH e HEAD e inclui especificar e validar, por exemplo, parâmetros, cabeçalhos, cookies e corpo facilmente. A diferença principal do Rest Assured para outros framework é a sintax Gherkin do BDD e a forma como extrai os dados e valida o mesmo.
O protocolo HTTP define um conjunto de métodos de requisição responsáveis por indicar a ação a ser executada para um dado recurso. Embora esses métodos possam ser descritos como substantivos, eles também são comumente referenciados como HTTP Verbs (Verbos HTTP). Cada um deles implementa uma semântica diferente, mas alguns recursos são compartilhados por um grupo deles, como por exemplo, qualquer método de requisição pode ser do tipo safe, idempotent ou cacheable (en-US).
GET
O método GET solicita a representação de um recurso específico. Requisições utilizando o método GET devem retornar apenas dados.
HEAD
O método HEAD solicita uma resposta de forma idêntica ao método GET, porém sem conter o corpo da resposta.
POST
O método POST é utilizado para submeter uma entidade a um recurso específico, frequentemente causando uma mudança no estado do recurso ou efeitos colaterais no servidor.
PUT
O método PUT substitui todas as atuais representações do recurso de destino pela carga de dados da requisição.
DELETE
O método DELETE remove um recurso específico.
CONNECT
O método CONNECT estabelece um túnel para o servidor identificado pelo recurso de destino.
OPTIONS
O método OPTIONS é usado para descrever as opções de comunicação com o recurso de destino.
TRACE
O método TRACE executa um teste de chamada loop-back junto com o caminho para o recurso de destino.
PATCH
O método PATCH é utilizado para aplicar modificações parciais em um recurso.
# Kotlin Extension Module
A Partir da versão 4.1.0 foi introduzido um novo módulo chamado “kotlin-extensions”. Este módulo fornece algumas funções de extensão úteis ao trabalhar com REST Assured e Kotlin.
- Primeiro Passo:
Adicionar o dependências abaixo ao projeto, nesse caso fizemos um projeto usando maven, podemos também usar o gradle, use o link abaixo para ver a sintax do gradle:
<dependency>
<groupId>io.rest-assured</groupId>
<artifactId>rest-assured</artifactId>
<version>4.4.0</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>io.rest-assured</groupId>
<artifactId>kotlin-extensions</artifactId>
<version>4.4.0</version>
<scope>test</scope>
</dependency>https://mvnrepository.com/artifact/io.rest-assured/rest-assured/4.4.0
https://mvnrepository.com/artifact/io.rest-assured/kotlin-extensions/4.4.0
2. Segundo Passo:
Lendo os dados do body para realizar o teste, eu preciso usar data class para declarar as variáveis, escrever ou ler, essa é a principal diferença de Java para Kotlin, não precisamos do famos GETs e SETs do Java. Segue um exemplo do mesmo abaixo.
Podemos usar o plugin “JSON To Kotlin Class”, para transformar o json em um data class, esse é caminho mais curto sem escrever código.
https://plugins.jetbrains.com/plugin/9960-json-to-kotlin-class-jsontokotlinclass-
Para criar o data class precisamos do json, no projeto acionamos dentro de resources.
{
"nome": "Reinaldo Rossetti",
"email": "reinaldo3@paygo.com.br",
"password": "teste",
"administrador": "true"
}Nosso data class ficaria assim:
data class User( var nome: String, var email: String,
val password: String, val administrador: String)https://github.com/reinaldorossetti/rest-assured-kotlin/blob/main/src/test/java/resources/user.json
// pega o caminho do projeto
val pathProject = System.getProperty("user.dir")
// ler o arquivo json
var cadastroJson = File("$pathProject/src/main/resources/cadastro_user.json").readText(Charsets.UTF_8)
// passa os dados de json para objetos para o kotlin ler.
val cadastroDados = Gson().fromJson(cadastroJson, CadastroUsuario::class.java)3. Terceiro Passo:
Agora vamos escrever nosso teste começando pelo função de Pré-requisito para os nossos testes:
fun requestSpecification(): RequestSpecification {
return RequestSpecBuilder()
.setBaseUri(“http://localhost:4200”)
.addHeader(“Accept", “application/json”)
.setContentType(ContentType.JSON)
.setRelaxedHTTPSValidation()
.build()
}Teste básico de cadastro, um teste positivo e outro negativo, seguindo a sintax do Rest-Assured:
Given > Contém pre-requisitos do meu teste, como URL, Header, Content Type, Aceita certificado invalido, e o Body.
When > Metodo HTTP que vai ser utilizado e o end point.
Then > Vai conter as validacoes\assertivas como retorno 201 e message igual ao valor esperado.
Extract > Vai extrair a informação da mensagem para ser usada no relatório.
@Test
@Order(1)
fun cadastroDeUsuarioTest(){
step("Realizando os testes de cadastro")
cadastroDadosBody.email = faker.internet().emailAddress()
val id: String =
Given {
spec(requestSpecification())
body(cadastroDadosBody)
} When {
post("/usuarios")
} Then {
statusCode(201)
status().is2xxSuccessful
body("message", equalTo("Cadastro realizado com sucesso"))
body("_id", notNullValue())
body("_id.length()", equalTo(16))
} Extract {
path("_id")
}
println(id)
step("ID: $id")
toJsonFile(id)
} @Test
@Order(2)
fun cadastroDeUsuarioMessageEmailTest(){
step("Realizando os testes de cadastro")
val response: Response =
Given {
spec(requestSpecification())
body(cadastroDadosBody)
} When {
post("/usuarios")
} Then {
statusCode(400)
body("message", equalTo("Este email já está sendo usado"))
body("message", containsString("email já está sendo usado"))
body("_id", emptyOrNullString())
} Extract {
response()
}
val message = response.path("message") as String
step("message: $message"); step("response:${response.print()}")
}
O método step vem da biblioteca do Allure Reports. Método que imprime a mensagem dentro do nosso relatório. Através dela podemos descrever melhor o que o teste faz, nesse caso você pode escrever o que seu teste faz usando o Gerkin. Você pode colocar dois comandos na mesma linha separado por ponto e virgula “;”.
Foi usado a biblioteca do Faker Java, para gerar um e-mail randômico, ele substitui o valor padrão que foi atribuído no Json.
Temos o Pipeline dos nossos testes no Git Actions, click no link abaixo para ver:
Concluindo temos um código mais enxuto que em Java, de forma simples fizemos o nosso teste em Kotlin e Rest-Assured, a sintax do REST-Assured de Kotlin e Java, tem o mesmo nome dos métodos, no entanto tem o uso dos colchetes pra deixar no Estilo Kotlin, poderíamos deixar todo o teste em uma linha, mas temos o principio da legibilidade do código acima de quantidade de código. Agora precisamos trabalhar na estrutura do projeto.
Vídeo explicando o Projeto:
PARTE 2 -> No próximo Post, vamos melhorar a estrutura do nosso teste, dessa forma não conseguimos reutilizar as funções do REST Assured porque elas estão diretamente dentro do meu teste. No entanto foi essa ideia inicial de entender como faz um teste básico usando o Kotlin e REST-Assured.
Nosso projeto no git: https://github.com/reinaldorossetti/rest-assured-kotlin
# Links para estudo:
https://softdesign.com.br/blog/restassured-o-que-e-e-como-usar
https://developer.mozilla.org/pt-BR/docs/Web/HTTP/Methods
https://github.com/rest-assured/rest-assured/wiki/GettingStarted
https://github.com/rest-assured/rest-assured/wiki/Usage#kotlin-extension-module
allure report: https://docs.qameta.io/allure/
API ServeRest: https://serverest.dev/#/
# Ferramentas para download:
Para fazer o download do apache maven:
https://maven.apache.org/download.cgi
Para fazer o download do nodejs:
https://nodejs.org/en/download/
Para fazer o download do intellij:
https://www.jetbrains.com/pt-br/idea/download/#section=windows
Site para criar a estrutura do projeto em kotlin:
https://start.spring.io