Testes de performance & carga

Instalação — macOS

1. Homebrew (recomendado)
   brew install k6
2. Verificar
   k6 version → k6 v1.x.x
3. Clone testflow-k6
   npm install

Instalação — Linux

Debian/Ubuntu — repo oficial Grafana (docs)

1. Adicionar chave GPG e repositório
   curl -fsSL https://dl.k6.io/key.gpg | sudo gpg --dearmor -o /usr/share/keyrings/k6-archive-keyring.gpg
echo "deb [signed-by=…] https://dl.k6.io/deb stable main" | sudo tee /etc/apt/sources.list.d/k6.list
2. Instalar e verificar
   sudo apt-get update && sudo apt-get install k6
k6 version
3. Fedora / CentOS
   sudo dnf install https://dl.k6.io/rpm/repo.rpm && sudo dnf install k6
4. Clone testflow-k6
   npm install

Instalação — Windows

1. winget (recomendado — pacote oficial)
   winget install k6 --source winget
2. Chocolatey (alternativa)
   choco install k6
3. Verificar
   k6 version → k6 v1.x.x
4. Clone testflow-k6
   npm install

Ou baixe o instalador MSI / binário em GitHub Releases.

Instalação — Docker (sem k6 local)

# TestFlow + k6 via compose
npm run docker:up

# Smoke via wrapper (fallback Docker automático)
npm run test:smoke

# Imagem oficial
docker run --rm -i grafana/k6:1.0.0 version

scripts/run-k6.sh detecta se k6 existe; senão usa Docker com host.docker.internal:5050.

Conceitos fundamentais

Stages — ramp up / steady / down

// config/profiles.js — perfil load
load: {
  stages: [
    { duration: '1m', target: 10 },   // ramp up
    { duration: '3m', target: 25 },   // steady
    { duration: '2m', target: 25 },
    { duration: '1m', target: 0 },     // ramp down
  ],
  gracefulRampDown: '30s',
}

Thresholds — SLOs

// config/thresholds.js
export const smokeThresholds = {
  http_req_failed: ['rate<0.005'],
  http_req_duration: ['p(95)<1500', 'avg<800'],
  'http_req_duration{endpoint:health}': ['p(95)<500'],
  'http_req_duration{endpoint:auth_login}': ['p(95)<2000'],
  checks: ['rate>0.99'],
}

Alinhado aos budgets dos testes Cypress/Playwright (< 2s login, < 1s health).

Módulo HTTP & checks

import http from 'k6/http'
import { check } from 'k6'

const res = http.get(`${BASE_URL}/api/users`, {
  tags: { endpoint: 'users', name: 'GET /api/users' },
})

check(res, {
  'status 200': (r) => r.status === 200,
  'has users array': (r) => Array.isArray(r.json('users')),
  'p95 budget': (r) => r.timings.duration < 2000,
})

Auth TestFlow

// lib/auth.js
export function login() {
  const res = http.post(`${BASE_URL}/api/auth/login`, payload, {
    headers: { 'Content-Type': 'application/json' },
    tags: { endpoint: 'auth_login' },
  })
  check(res, { 'login 200': (r) => r.status === 200 })
  return res.json('token')
}

// Uso com Bearer
http.get(`${BASE_URL}/api/users`, {
  headers: { Authorization: `Bearer ${token}` },
})

Credenciais: DEMO_EMAIL / DEMO_PASSWORD via .env

setup() — dados compartilhados

export function setup() {
  const token = login()
  return { token }
}

export default function (data) {
  getUsers(data.token)
}

setup() roda uma vez antes do teste — ideal para obter token sem repetir login a cada VU na fase de setup.

Executors (cenários avançados)

Multi-scenario

export const options = {
  scenarios: {
    browse: {
      executor: 'constant-vus',
      vus: 10,
      duration: '5m',
      exec: 'browse',
      tags: { scenario: 'browse' },
    },
    api_write: {
      executor: 'ramping-arrival-rate',
      startRate: 5,
      timeUnit: '1s',
      stages: [{ duration: '5m', target: 50 }],
      exec: 'write',
      tags: { scenario: 'write' },
    },
  },
}

export function browse() { /* GET pages */ }
export function write() { /* POST login */ }

Relatórios & handleSummary

// lib/summary.js
export function handleSummary(data) {
  return {
    stdout: textSummary(data),
    'results/summary-latest.json': JSON.stringify(data),
  }
}

// No cenário:
export { handleSummary } from '../../lib/summary.js'

npm run test:report    # suíte + REPORT.md
npm run test:smoke:ui  # HTML dashboard no browser

Web Dashboard (HTML no browser)

# Live dashboard + export HTML ao final
npm run test:smoke:ui

# Variáveis k6 nativas
K6_WEB_DASHBOARD=true \
K6_WEB_DASHBOARD_OPEN=true \
K6_WEB_DASHBOARD_EXPORT=results/report.html \
k6 run script.js

• Ao vivo: http://localhost:5665
• HTML self-contained para compartilhar com o time
• npm run report:open reabre o último report

Report CI — GitHub Pages

A cada push em main, o job publish-pages em k6.yml roda a suíte de 7 cenários e publica o dashboard HTML.

• Performance report — PASS/FAIL, ramp-up, latência, checks
• Hub · npm run test:report localmente

Grafana + InfluxDB (tempo real)

Stack local com métricas em tempo real.

npm run grafana:up
npm run test:smoke:grafana

• Dashboard: K6 Test Results (local)
• VUs, req/s e latência em tempo real via InfluxDB v2
• npm run grafana:down para parar o stack

Tópicos avançados

k6 Browser module

import { browser } from 'k6/browser'

export const options = {
  scenarios: {
    ui: {
      executor: 'shared-iterations',
      vus: 2,
      iterations: 4,
      options: { browser: { type: 'chromium' } },
    },
  },
}

export default async function () {
  const page = await browser.newPage()
  await page.goto(`${BASE_URL}/web/login.html`)
  await page.locator('[data-testid="login-email"]').fill(email)
  await page.locator('[data-testid="login-submit"]').click()
  await page.close()
}

npm run test:browser:login

Weighted traffic & think time

// lib/http.js — tráfego realista
weightedPick([
  { weight: 35, fn: () => getHealth() },
  { weight: 30, fn: () => getUsers(token) },
  { weight: 20, fn: () => getStaticPage(page) },
  { weight: 15, fn: () => login() },
])
sleep(thinkTime(0.5, 2))  // pausa entre iterações

Cenário mixed-traffic.js simula mix de leitura, auth e páginas estáticas.

Variáveis de ambiente

k6 vs ferramentas clássicas