How i simplified my performance testing setup with StackSpot AI

A utilização de ferramentas de IA tem se tornado uma pratica comum no ciclo de desenvolvimento de software, o que inclui a etapa de testes.

Soluções baseadas em IA e Agentes especialidos tem sido utilizados em todas as etapas de teste, desde plnejamento, modelagem e execução, auxiliando em procesos antes extremanente manuais e simplificando atualmente os processos automatizados.

Como em testes funcionais, os testes não funcionais tambem necessitam de planejamento, modelagem e execução, nesse artigo, veremos como uma Agent de IA especializado em testes de performance criado com StackSpot AI, pode simplificar a criação de testes de performance com K6.

StackSpot AI

A Stackspot AI é uma solução de agents inteligentes que auxiliam em todo ciclo de desenvolvimento de software e que fazem parte da plataforma de desenvolvimento Stackspot. Enquanto outras ferramentas de IA generativa podem em inumera situações te fornecer respostas genéricas (ou até alucinações por falta de contexto), a StackSpot AI trabalha com hipercontextualização.

Na prática, isso significa que a StackSpot AI:

• Conhece seu código: Entende padrões, estruturas e convenções do seu projeto.
• Respeita sua stack: Não vai sugerir tecnologias aleatórias que não fazem sentido.
• Considera regras de negócio: Incorpora documentação, APIs e especificações da sua empresa. Adapta-se ao time: Aprende com as práticas e metodologias estabelecidas.

Não é somente sobre entender o projeto atual, a StackSpot AI compreende o ecossistema completo da sua organização. Ela conecta diferentes projetos, padrões corporativos e conhecimento institucional para entregar sugestões realmente relevantes.

Existem alguns conceitos extremamente importantes sobre StackSpot AI, e que serão abordados nesse artigo, sendo eles:

• Knowledge Source
• Quick Command
• Agents

Knowledge Sources são as bases de conhecimento que você alimenta na ferramenta - desde snippets de código e documentação técnica até APIs e padrões internos da empresa. É aqui que mora a mágica da hipercontextualização: quanto mais conhecimento relevante você adicionar, mais precisas ficam as sugestões e respostas da STackspot AI.

Quick Commands funcionam como atalhos inteligentes para tarefas repetitivas do dia a dia. Quer gerar testes unitários, documentar código ou fazer refatoração? Podemos transforma isso em comandos rapidos.

Agents são especialistas virtuais focados em áreas específicas do desenvolvimento. Pense neles como colegas de equipe que nunca se cansam: um para revisar código, outro para transformar requisitos em user stories detalhadas, outro para caçar vulnerabilidades de segurança. Cada agent é treinado para uma função específica, garantindo expertise e qualidade nas entregas.

Como leitura complementar recomendo o artigo StackSpot AI: sua plataforma multiagentes de Inteligência Artificial para o ciclo de desenvolvimento de software do blog oficial da StackSpot, bem como o artigo Mudando o Jogo com StackSpot AI & Testes Automatizados do colega Rafael Berçam.

Como o K6 entra no topico AI?

Quem acompanha minhas publicações aqui no dev.to, deve esta familiariazado com inumeras publicações sobre o assunto testes de performance & K6.

o k6 é uma ferramenta open source para realização de testes de performance modernos baseados em script, pensada para desenvolvedores e testadores na nova era do DevOps. É uma solução open source que hoje faz parte da Grafana Labs.

Por ser uma solução Open Source e recente no mercado, correções e novas funcionalidades estão frequentemente sendo lançadas e disponibilizadas para a comunidade, isso implicar em muitas resposta de ferramentas de IA com contexto de versões antigas da ferramenta. vejamos dois experimentos basicos.

Leitura eficiente de um arquivo CSV

Ao realizamos a simples pergunta _You're an expert at creating performance tests with the K6 tool. How can you read a mass of data in CSV format most efficiently using the tool?_ aos principais modelos do mercado: Claude, Geminie GPT, observamos um vies de resposta com base em soluções de versões antigas do K6, como baseadas na jslib.k6, menos performatica que os recentes modulos nativos:

Claude Sonnet 4

import { SharedArray } from 'k6/data'; import papaparse from 'https://jslib.k6.io/papaparse/5.1.1/index.js'; const csvData = new SharedArray('users', function () { return papaparse.parse(open('./users.csv'), { header: true }).data; }); export default function () { // Access data efficiently const user = csvData[Math.floor(Math.random() * csvData.length)]; console.log(user.email); } 

GPT-4o

import { SharedArray } from 'k6/data'; import papaparse from 'https://jslib.k6.io/papaparse/5.1.1/index.js'; const csvData = new SharedArray('user data', function () { const f = open('../data/users.csv'); return papaparse.parse(f, { header: true }).data; }); export default function () { const user = csvData[Math.floor(Math.random() * csvData.length)]; // Example use console.log(`Using user ${user.username}`); } 

Gemini 2.5 Flash

import { open } from 'k6/experimental/fs'; import csv from 'k6/experimental/csv'; import { SharedArray } from 'k6/data'; import http from 'k6/http'; import { check, sleep } from 'k6'; import { vu } from 'k6/execution'; const csvData = new SharedArray('CSV data', function () { const file = open('./users.csv'); // asObjects: true will parse each row into an object using header names as keys return csv.parse(file, { header: true, asObjects: true }); }); export const options = { vus: 10, duration: '30s', thresholds: { http_req_failed: ['rate<0.01'], // http errors should be less than 1% http_req_duration: ['p(95)<200'], // 95% of requests should be below 200ms }, }; export default function () { // Get a unique row of data for each VU iteration // A common pattern is to use __VU or __ITER to select unique data. // Ensure you have enough data in your CSV for the number of VUs and iterations. const user = csvData[vu.idInTest % csvData.length]; // Example: round-robin selection console.log(`VU ${vu.idInTest} using user: ${user.username}`); const payload = JSON.stringify({ username: user.username, password: user.password, }); const params = { headers: { 'Content-Type': 'application/json', }, }; const res = http.post('https://api.example.com/login', payload, params); check(res, { 'status is 200': (r) => r.status === 200, 'login successful': (r) => r.json().message === 'Login successful', }); sleep(1); } 

Uma resalva ao modelo do Google. O Gemini foi o unico modelo a mencionar o novo modulo do k6 de leitura de CSV k6/experimental/csv, lançado na versão v0.57.0, a pouco menos de 4 meses atras, na data que escrevo essa publicação. No entanto, tambem mencionou, baseados em soluções do jslib.k6.

Claude e GPT se basearam na solução baseado em um modulo papaparse da jslib.k6, menos eficiente e com mais utilização de recursos computacionais.

utilizando um modulo para geração de dados fakes

Este é um outro ponto que quem trabalha com k6 frequentemente vai utilizar, a geração de dados com o modulo faker.

Até um certo tempo atrás havia a necessidade de utilização de uma solução chamada XK6 que permitia a utilização de alguns modulos experimentais, gerando um binario alternativo do k6 para execução. No entanto isso abandonado na versão v1.0.0, necessitando apenas informar a flag K6_BINARY_PROVISIONING=true na cli, e o k6 ficando responsavel pelo restante.

Ao executar o seguinte prompt: Create a simple k6 performance testing script that uses the k6/x/faker module to efficiently generate fake data, providing instructions for executing the script at the end. Podemos observar que as instruções de execução dos modelos ainda utilizavam um contexto antigo de solução como resposta.

Claude Sonnet 4

#Install k6 (if not already installed): #Install the k6 faker extension: # Download and install xk6 (k6 extension builder) go install go.k6.io/xk6/cmd/xk6@latest # Build k6 with the faker extension xk6 build --with github.com/szkiba/xk6-faker@latest # This creates a custom k6 binary with faker support $Running the Script ./k6 run performance-test.js 

GPT-4o

✅ How to Run This Script Note: The x/faker module is an extension and requires a custom k6 binary built with xk6. 1. 🧰 Install xk6 (if not already installed) go install go.k6.io/xk6/cmd/xk6@latest 2. 🔧 Build a custom k6 binary with x/faker xk6 build latest --with github.com/szkiba/xk6-faker This will create a k6 binary in your current directory. 3. ▶️ Run the script ./k6 run script.js 

Gemini 2.5 Flash

To execute this script, follow these steps: Install k6: If you don't have k6 installed, you can download it from the official k6 website: https://k6.io/docs/getting-started/installation/ Install the xk6-faker extension: The k6/x/faker module is part of the xk6-faker extension. You need to build a custom k6 binary with this extension. Open your terminal or command prompt and run: k6 run --bundle github.com/k6io/xk6-faker@latest This command will download the xk6-faker extension and build a k6 binary that includes it. The command will also run the bundle. Save the script: Copy the provided JavaScript code and save it as a .js file (e.g., faker_test.js). Run the k6 test: Navigate to the directory where you saved faker_test.js in your terminal or command prompt, and then run the test using the custom k6 binary you just built: k6 run faker_test.js 

Consideramos apenas a resposta dos modelos as instruções de execução. Todos os modelos criaram scripts funcionais para o modulo k6/x/faker, no entanto com instruções defasadas de execução.

Escolha do melhor executor para teste de performance

Como ultimo cenario sobre contextualização dos modelos do mercado, podemos analisar funcionalidades do k6 que não tiverão mudanças significativa ao longa do seu ciclo de vida, uma dessa funcionalidades sao os executores.

Para testes de performance com K6, a escolha do executor correto está muita das vezes atrelado ao sucesso do testes baseado nos requisitos não funcionais definidos.

Utilizamos os requisito não funcionais da documentação publica do open finance fase 1 para criar o seguinte prompt referente aos limites de tráfego de requisições: Given the following non-functional performance requirements of a central bank integration solution, specify which best executor should be configured in a performance test script with k6, the main focus of this script is to ensure the achievement of the stipulated TPS.

Claude Sonnet 4

import http from 'k6/http'; import { check, sleep } from 'k6'; import { Rate } from 'k6/metrics'; // Custom metrics to track rate limiting const rateLimitErrors = new Rate('rate_limit_errors'); export const options = { scenarios: { // Primary scenario for TPS testing - uses constant-arrival-rate executor tps_load_test: { executor: 'constant-arrival-rate', rate: 300, // 300 TPS globally as specified timeUnit: '1s', duration: '5m', // 5 minute test duration preAllocatedVUs: 50, // Pre-allocated VUs for immediate start maxVUs: 200, // Maximum VUs that can be spawned tags: { test_type: 'tps_validation' }, }, 

GPT-4o

import http from 'k6/http'; import { check, sleep } from 'k6'; export const options = { scenarios: { global_tps_test: { executor: 'constant-arrival-rate', rate: 300, // 300 iterations (transactions) per second timeUnit: '1s', // 300 iterations per 1 second duration: '5m', // Test duration for 5 minutes preAllocatedVUs: 50, // Initial number of VUs to pre-allocate maxVUs: 500, // Maximum number of VUs k6 can spin up }, }, thresholds: { http_req_failed: ['rate<0.01'], // http errors should be less than 1% http_req_duration: ['p(95)<2000'], // 95% of requests should be below 2000ms 'http_req_duration{status:429}': ['count<100'], // Example: Allow up to 100 429 responses }, }; 

Gemini 2.5 Flash

import http from 'k6/http'; import { check } from 'k6'; export const options = { scenarios: { tps_target: { executor: 'constant-arrival-rate', rate: 300, // 300 requisições por segundo timeUnit: '1s', duration: '1m', // duração do teste preAllocatedVUs: 100, // estimativa inicial de VUs maxVUs: 500, // máximo permitido }, }, }; 

É evidente uma maior acertividade dos modelos em especificações mais antigas da ferramenta, onde o contexto fornecido no momento de treinamento, permitiu uma acertividade por todos os modelos utilizados para o prompt informado.

Montando um agent hipercontextualização em k6