Postman para Engenheiros QA: Do Primeiro Request à Suite de Testes de API

A aba Tests do Postman roda asserções JavaScript contra cada resposta, e pm.environment.set() é o que encadeia as requisições. Uma requisição de login salva seu token no environment, e todas as requisições seguintes da coleção o pegam automaticamente. Sem esse padrão, você copia tokens entre requisições na mão a cada execução.

O que é o Postman

Postman é uma ferramenta com interface gráfica para fazer requisições HTTP. Em vez de escrever comandos curl ou código, você preenche uma URL, escolhe um método (GET, POST, etc.) e clica em Send. Você vê a resposta imediatamente.

Além das requisições simples, o Postman permite:

• Escrever asserções de teste em JavaScript
• Encadear requisições (usar a resposta da requisição A na requisição B)
• Rodar coleções de requisições automaticamente
• Compartilhar coleções com colegas de time
• Gerar documentação de API

Configuração

1. Baixe em postman.com

2. Crie uma conta gratuita (necessária para sincronização e colaboração)

3. Abra o app; você vai ver um workspace com o editor de requisições

Sua primeira requisição

1. Clique na aba + para abrir uma nova requisição

2. Mantenha o método como GET

3. Insira a URL: https://jsonplaceholder.typicode.com/users

4. Clique em Send

Você recebe de volta um array JSON com 10 usuários. É isso: você acabou de fazer uma requisição de API.

• Body — os dados retornados
• Status — código de status HTTP (200 OK, 404 Not Found, etc.)
• Time — quanto tempo a requisição levou
• Size — tamanho da resposta em bytes

Coleções e pastas

Coleções são a forma de organizar requisições. Pense nelas como pastas para chamadas de API.

1. Clique em Collections na barra lateral esquerda

2. Clique em + > New Collection

3. Dê um nome (ex.: "BecomeQA API Tests")

1. Abra uma aba de requisição

2. Clique em Save > escolha sua coleção

3. Dê um nome à requisição (ex.: "Get all users")

• Auth/ — login, logout, refresh token
• Users/ — operações CRUD
• Products/ — gerenciamento de produtos

Variáveis de ambiente

Colocar URLs e tokens fixos no código torna as coleções frágeis. Use variáveis de ambiente.

1. Clique em Environments na barra lateral esquerda

2. Clique em + > New Environment

3. Dê o nome "Local" ou "Staging"

4. Adicione variáveis:

| Variável | Valor |

|----------|-------|

| baseUrl | http://localhost:3000 |

| userEmail | admin@test.com |

| userPassword | AdminPass1 |

| authToken | (deixe vazio — preenchido pela requisição de login) |

{{baseUrl}}/api/users

A sintaxe {{variableName}} substitui o valor em tempo de execução.

Autenticação

A maioria das APIs exige autenticação. O fluxo comum: fazer login primeiro, obter um token, usá-lo nas requisições seguintes.

• Método: POST
• URL: {{baseUrl}}/api/auth/login
• Body (JSON):

{
  "email": "{{userEmail}}",
  "password": "{{userPassword}}"
}

Na aba Tests da requisição de login (JavaScript):

const response = pm.response.json();
pm.environment.set('authToken', response.token);

Agora, toda vez que você rodar a requisição de login, o token é salvo no environment.

Na aba Authorization da requisição:

• Type: Bearer Token
• Token: {{authToken}}

Ou na aba Headers:

Authorization: Bearer {{authToken}}

Escrevendo testes

A aba Tests de cada requisição permite escrever asserções JavaScript. O Postman fornece o objeto pm (Postman) com tudo que você precisa.

Verificações de status code

pm.test('Status é 200', function() {
  pm.response.to.have.status(200);
});

pm.test('Status é 201 Created', function() {
  pm.response.to.have.status(201);
});

Verificações do corpo da resposta

pm.test('Resposta tem objeto de usuário', function() {
  const body = pm.response.json();
  pm.expect(body).to.have.property('id');
  pm.expect(body).to.have.property('email');
  pm.expect(body.role).to.equal('member');
});

Resposta com array

pm.test('Retorna array de usuários', function() {
  const users = pm.response.json();
  pm.expect(users).to.be.an('array');
  pm.expect(users.length).to.be.greaterThan(0);
});

pm.test('Cada usuário tem os campos obrigatórios', function() {
  const users = pm.response.json();
  users.forEach(user => {
    pm.expect(user).to.have.property('id');
    pm.expect(user).to.have.property('email');
  });
});

Tempo de resposta

pm.test('Tempo de resposta abaixo de 500ms', function() {
  pm.expect(pm.response.responseTime).to.be.below(500);
});

Headers da resposta

pm.test('Content-Type é JSON', function() {
  pm.response.to.have.header('Content-Type', 'application/json; charset=utf-8');
});

Pre-request Scripts

Pre-request scripts rodam ANTES do envio da requisição. Útil para gerar dados dinâmicos.

// Gera email único para cada execução
const email = `test_${Date.now()}@example.com`;
pm.environment.set('testEmail', email);
pm.environment.set('testPassword', 'ValidPass1');

Agora o corpo da requisição pode usar {{testEmail}}:

{
  "email": "{{testEmail}}",
  "password": "{{testPassword}}"
}

Encadeamento de requisições

Usar a saída de uma requisição como entrada para a próxima.

Aba Tests:

const user = pm.response.json();
pm.environment.set('createdUserId', user.id);

URL: {{baseUrl}}/api/users/{{createdUserId}}

O Postman preenche o ID da requisição anterior automaticamente.

URL: {{baseUrl}}/api/users/{{createdUserId}}

Método: DELETE

Rodando coleções

O Collection Runner roda todas as requisições de uma coleção automaticamente.

1. Clique na sua coleção > Run collection

2. Escolha o environment (Local, Staging, etc.)

3. Defina as iterações (quantas vezes rodar)

4. Clique em Run [Nome da Coleção]

Você vê os resultados: pass/fail para cada teste em cada requisição.

Newman — Postman CLI

O Newman roda coleções Postman pela linha de comando. Necessário para pipelines de CI.

npm install -g newman

Coleção > três pontos > Export > salve como api-tests.json

Environments > três pontos > Export > salve como local-env.json

newman run api-tests.json -e local-env.json

newman run api-tests.json -e local-env.json --reporters html --reporter-html-export results.html

Um fluxo de teste realista

Como um engenheiro de QA usa o Postman em um projeto real:

• Enviar requisições manualmente, ler as respostas
• Entender o fluxo de autenticação
• Descobrir o que cada endpoint retorna

• Pasta Auth: Login, Logout, Refresh
• Pasta Users: Create, Get, Update, Delete
• Casos negativos: login inválido, acesso não autorizado

• Asserções de status code
• Campos obrigatórios na resposta
• Lógica de negócio (role está correto, timestamps estão presentes)

• Local: http://localhost:3000
• Staging: https://staging.myapp.com
• Produção: https://myapp.com (só testes somente-leitura)

• Exportar coleção + environment
• Adicionar newman run ao pipeline
• Parsear saída JUnit para resultados de teste

Postman vs testes de API com Playwright

| | Postman | Playwright API Testing |

|--|---------|----------------------|

| Curva de aprendizado | Menor | Maior (código) |

| Integração com CI | Newman CLI | Nativo |

| Reuso de código | Limitado | TypeScript completo |

| UI + API combinados | Não | Sim |

| Compartilhamento com o time | Postman cloud | Git |

Para exploração simples de API e testes manuais: Postman. Para suites de regressão automatizadas que compartilham código com testes de UI: Playwright.

Muitos times usam os dois: Postman para exploração e documentação, Playwright para regressão automatizada.

Resumo

• Coleções organizam requisições relacionadas em uma suite de teste
• Environments permitem alternar entre local/staging/produção
• Pre-request scripts geram dados dinâmicos de teste
• A aba Tests roda asserções JavaScript contra as respostas
• Encadeamento passa dados entre requisições
• Newman CLI roda coleções em pipelines de CI

Comece com exploração manual no Postman, depois adicione testes a cada requisição. Em uma tarde você pode ter uma coleção que cobre toda a sua API, executável manualmente ou no CI.