DevSecOps

11 fev, 2019

Testes de performance em APIs

100 visualizações
Publicidade

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:

Versão do java instalada

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’:

Configurações avançadas do sistema

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:

Adicionando JAVA_HOME

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.

Plugin servidor para Scala

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’.

Criação do projeto

Estrutura do projeto

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:

Estrutura para criação de testes

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á:

Resultado do teste executado

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.

Tempos de respostas das execuções distribuídas entre intervalos padronizados.
Exibe o número de solicitações que obtiveram sucesso e as que não obtiveram.
Estatísticas padrão como valores mínimos, máximos, média, desvio padrão e percentuais globais e por solicitação.
Usuários ativos durante a simulação (total e por cenário)
Distribuição dos tempos de resposta
Percentual do tempo de resposta ao longo do tempo, apenas para solicitações bem sucedidas.
Número de solicitações enviadas por segundo ao longo do tempo
Número de respostas por segundo ao longo do tempo

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