Abortando testes com falhas no K6
Tags: testing, k6, go, performance
Published: 2023-06-20 23:14:42

Um dos principais objetivos dos testes de software é a identificação de falhas no sistema, que permitam antecipar problemas e garantir entregas com alto nível de qualidade.

Quando olhamos para testes não funcionais, estamos muito mais interessados nos indicadores que poderemos colher dessas falhas e na evolução do sistema com base nesse indicadores.

Mas e se quiséssemos abortar o nosso teste caso um determinado indicador fosse atingido?

Nesse artigo, abordaremos como abortar um teste de performance com K6 caso uma alta taxa de erros seja identificada.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/5td9tl8z0g5n4n8i6j5h.png)

## Entendendo os thresholds🚧

Os thresholds ou limites no k6, são métricas de desempenho pré-definidas usadas para avaliar os resultados dos testes. E servem como referências para avaliar o desempenho de uma aplicação. 

Ao definir limites, os testadores podem estabelecer níveis de desempenho aceitáveis, garantindo que o aplicativo atenda aos requisitos desejados.

```
export const options = {
  thresholds: {
    http_req_failed: ['rate<0.01']
  },
};
```
> No exemplo acima, estamos definido que o nosso teste de performance precisa ter uma taxa de requisições com erro inferior a 1%.

Durante a execução de um teste, o k6 monitora continuamente as métricas definidas e as compara com os limites configurados. Se alguma métrica ultrapassar o valor do limite, o k6 emite um alerta, indicando um problema de desempenho. 

Por padrão a ferramenta não interrompe o teste quando um limite é atingido e segue realizando a coleta de dados para análise. 

## Utilizando o abortOnFail🛑

Em cenários em que é necessário interromper o teste após a ultrapassagem de um limite, podemos utilizar a propriedade abortOnFail para essa finalidade.

Ela basicamente aborta a execução do teste assim que o limite for rompido:

```
export const options = {
  thresholds: {
    http_req_failed: [{ threshold: 'rate<0.01', abortOnFail: true }],
  },
};
```
> A propriedade abortOnFail deve ser definida para cada limite que você especificar.

É relevante ressaltar que existe a possibilidade de retardar a ação da propriedade `abortOnFail`, permitindo que o teste continue a ser executado e gere mais dados  mesmo após o rompimento de um limite. Isso ao definir a propriedade `delayAbortEval`: 
```
export const options = {
  thresholds: {
    http_req_failed: [{ threshold: 'rate<0.01', abortOnFail: true, delayAbortEval: '30s' }],
  },
};
```
> No exemplo acima, estamos definindo um delay de 30 segundos para que o teste seja abortado caso o limite _http_req_failed_ seja rompido.

## Quando considerar abortar uma execução?🙄

Com base na estratégia de teste de performance, é importante considerar a necessidade de interromper o teste quando um limite for alcançado. 

Essa decisão deve levar em consideração diversos aspectos, sendo a maturidade da aplicação em relação aos diferentes tipos de testes de performance e as métricas que se deseja obter os principais. Vejamos dois exemplos:

Exemplo 1: Maria configurou um teste de carga para avaliar pontos cruciais, como a taxa de resposta e a taxa de erros de sua API.

```
export const options = {
  stages: [
    { duration: '1m', target: 100 }, 
    { duration: '2m', target: 100 },
    { duration: '1m', target: 0 },
  ],
  thresholds: {
    http_req_failed: ['rate<0.01']
  },
};
```

Exemplo 2: João configurou um teste de imersão em sua API para avaliar a utilização dos recursos computacionais, como CPU, RAM, rede, além de verificar possíveis problemas relacionados ao esgotamento de armazenamento de logs ou banco de dados.
```
export const options = {
  stages: [
    { duration: '5m', target: 100 }, 
    { duration: '8h', target: 100 }, 
    { duration: '5m', target: 0 }, 
  ],
  thresholds: {
    http_req_failed: ['rate<0.1']
  },
};
```
No primeiro cenário, Maria demonstra um interesse significativo na taxa de erros da sua aplicação, tornando as requisições com falhas um indicador crucial para ela.

Por outro lado, no segundo cenário, João concentra-se principalmente nas métricas da sua aplicação, e uma alta taxa de erros pode indicar que o ambiente ainda não está maduro o suficiente para suportar um teste tão longo.

Portanto, se o teste planejado por João está produzindo resultados inconsistentes, comportamento inesperado ou métricas que não estão alinhadas às expectativas, pode ser necessário interromper o teste para investigar as causas do problema.

## Conclusão💖

Realizar testes de performance requer um planejamento abrangente, no qual é crucial considerar os pontos de interrupção da execução para evitar custos operacionais decorrentes do teste.

Gostou do conteúdo e quer saber mais sobre testes de performance com K6? Então não deixe de conferir meu curso na Udemy:

- [Teste de performance com K6](https://www.udemy.com/course/teste-de-performance-com-k6/?referralCode=95CCD8BC9F22A2A96BDA) ✨