Objetivo
Criar uma aplicação personalizada e customizável, voltada para testar APIs de maneira simples e prática, onde teremos, visualmente, um relatório sobre os testes executados.
Do que se trata os testes mencionados?
São testes que simulam transações/requisições de uma grande quantidade e usuários em um determinado tempo.
Por que utilizar Scala?
Scala é uma linguagem orientada a objetos e funcional, baseada fortemente em Java. Com ela você consegue utilizar a ferramenta Gatling, uma ferramenta para realizar testes de performance.
Utilização do VS Code
Editor de texto criado pela Microsoft que tem um grande potencial. Muitas funcionalidades são adicionadas, modificadas e melhoradas constantemente. Além disso, permite adição de diversos plugins, possibilitando programar em diversas linguagens.
Instalando dependências
Primeiramente, baixa-se a IDE a ser utilizada que, no caso, será o VS Code, onde pode ser encontrado no link:
Logo após, deve-se instalar o Java 8 JDK, caso ainda não tenha instalado – ele pode ser encontrado neste link.
Após a instalação, abre-se o terminal e verifica-se a versão que instalou, se está realmente correta:
Agora é preciso configurar o JAVA_HOME. Para isso, vá em ‘Painel de Controle’, ‘Sistema’ e ‘Configurações avançadas do sistema’. Será aberta uma janela. Selecione a opção ‘Variáveis de Ambiente’:
Após abrir a janela contendo as variáveis de ambiente, uma nova é adicionada (caso não exista), chamada JAVA_HOME, contendo como valor o caminho do JDK instalado anteriormente:
Para executar programas feitos em Scala, é preciso ter um servidor para o mesmo. O próprio VS Code tem um plugin que disponibiliza tal recurso, encontrado neste link. Basta clicar em ‘Instalar’, que será aberto o plugin no VS Code, onde deverá selecionar, também, a opção ‘Instalar’. Com o plugin instalado, reinicie a IDE.
Tendo como base a necessidade de executar os comandos do Scala em um terminal, tem-se que instalar uma ferramenta que se chama SBT, encontrada aqui. Basta baixá-la e executar o instalador.
Criando o projeto
Abre-se o terminal e navega-se até a pasta onde deseja criar o projeto. Feito isso, digita-se o seguinte comando:
— sbt new
scala/hello-world.g8
Esse comando criará um projeto baseado no tamplete ‘hello-world’ do GitHub. Após executar o comando, o mesmo solicitará o nome do projeto – dá-se o nome de ‘teste-automatizado’.
Estrutura do projeto
- project : utilizado para instalar plugins e dependências
- src/main/scala: contém todo o código em scala desenvolvido
- src/main/scala/Main.scala: ponto inicial do projeto
- build.sbt: arquivo de definição e compilação
Customizando projeto
Com a estrutura já criada devemos alterar o arquivo build.sbt para o seguinte código:
enablePlugins(GatlingPlugin)
libraryDependencies += "io.gatling" % "gatling-core" % "2.3.1"
libraryDependencies += "io.gatling" % "gatling-http" % "2.3.1"
libraryDependencies += "io.gatling.highcharts" % "gatling-charts-highcharts" % "2.3.1" % "test"
libraryDependencies += "io.gatling" % "gatling-test-framework" % "2.3.1" % "test"
Ele servirá para adicionar as dependências necessárias para o desenvolvimento.
Além disso, devemos criar o arquivo de nome ‘plugins.sbt’ dentro da pasta ‘project’ e inserir o seguinte código:
addSbtPlugin("io.gatling" % "gatling-sbt" % "2.2.2")
Na estrutura do projeto, cria-se mais uma sub-pasta para desenvolvimento dos testes, ficando dessa maneira:
Após realizar todas as alterações, executamos o terminal e navegamos até o diretório onde o projeto se encontra e executa o seguinte comando:
— sbt
Com isso, o terminal reconhecerá todos os comandos referentes à ferramenta SBT. Logo em seguida, executamos o seguinte comando:
— compile
Isso fará com que todas as dependências do projeto sejam baixadas.
Criação do teste
No diretório ‘src/test/scala’ cria-se um arquivo chamado ‘Test.scala’. Programamos os testes de performance nele e, com isso, inserimos o seguinte algoritmo:
package test
import io.gatling.core.Predef._
import io.gatling.http.Predef._
import io.gatling.core.scenario.Simulation
class Test extends Simulation {
val baseurl = "https://localhost:44398/api/values"
val httpConf = http.baseURL(baseurl)
val scn = scenario("TESTE").exec(http("REQUEST").get("/"))
setUp(scn.inject(atOnceUsers(5))).protocols(httpConf)
}
- No arquivo coloca-se o nome do pacote (opcional)
- Importação das bibliotecas necessárias para execução
- Declaração da classe, onde a mesma deve herdar de Simulation
- httpConf : configuração comum para todas as requisições (nesta classe conseguimos cabeçalhos, linguagem, tipo de agente, etc)
- scenario(“TESTE”): definição do cenário
- exec(http(“REQUEST”): requisição HTTP, onde é informado um nome que será apresentado ao executar o teste
- .get(“/”)): url destinada para o método GET
- setUp( : configuração dos cenários a serem simulados
- scn.inject(atOnceUsers(5)): injetando no cenário cinco usuários para simulação
- .protocols(httpConf): anexando configuração HTTP declarada acima
Execução do teste
Vale ressaltar que foi criada uma API simples como teste para a aplicação construída.
Com o código todo escrito devemos executar o seguinte comando:
— gatling:test
Com isso, executará o teste correspondente e o resultado final gerado será:
Como pode observar, o teste executou cinco requisições, e para todas foi apresentada uma resposta com tempo menor que 800ms. Sendo assim, o teste resultou em sucesso.
Visualização de relatórios
Para visualização do relatório gerado pela ferramenta Gatling, basta acessarmos o diretório ‘target\gatling\’. No diretório terá diversas sub-pastas referentes aos testes executados. A cada teste executado uma nova pasta é criada contendo informações para gerar o relatório. Sendo assim, basta acessar alguma das pastas e selecionar o arquivo index.html (presente dentro da pasta).
Tipos de relatórios
Os dados exibidos abaixo são referentes ao teste criado.
Observação: Relatórios podem ser gerados a partir do arquivo ‘simulation.log’, mesmo que o cenário tenha sido interrompido.
O código referente à aplicação criada se encontra em:
Conclusão
Nota-se uma grande facilidade em criar testes de performance customizados de maneira simples e prática. Onde, com poucas linhas de código, tem-se toda a aplicação de testes construída.
Referências
- https://www.devmedia.com.br/testes-de-desempenho-carga-e-stress/26546
- https://medium.com/socialbase/usando-gatling-load-testing-para-fazer-teste-de-performance-d1c0db6af455
- http://pedrro.github.io/2015/testes-de-performance/
- https://www.devmedia.com.br/conheca-a-linguagem-scala/32850
- https://medium.com/@programadriano/hoje-irei-apresentar-o-vs-code-visual-studio-code-para-quem-ainda-n%C3%A3o-teve-contato-com-ele-6a0d6bd3baec
- https://imasters.com.br/desenvolvimento/o-vs-code-faz-isso-e-eu-nem-sabia
- https://klauslaube.com.br/2018/06/04/eu-me-rendo-vscode.html
- https://docs.scala-lang.org/getting-started-sbt-track/getting-started-with-scala-and-sbt-on-the-command-line.html
- https://www.scala-lang.org/documentation/your-first-lines-of-scala.html
- https://www.scala-sbt.org/1.x/docs/Running.html
- https://gatling.io/docs/2.3/quickstart/
- https://blog.codecentric.de/en/2017/06/gatling-load-testing-part-1-using-gatling/
- https://gatling.io/docs/2.2/general/reports/#indicators