Lucas

Posted on Jun 17 • Originally published at apidog.com

Apidog CLI vs Keploy: Gravação e Reprodução ou Testes de API Projetados

Se você está comparando Apidog CLI vs Keploy, comece pela diferença de categoria: os dois executam testes de API, mas resolvem problemas diferentes. O Keploy grava tráfego real e dependências em runtime; o Apidog CLI executa cenários de teste criados ou gerados a partir da sua especificação de API.

Experimente o Apidog hoje

O Keploy gera automaticamente testes e mocks de dependência gravando tráfego real na camada de rede com eBPF. Não exige alteração de código, SDK ou linguagem específica. Já o Apidog CLI roda cenários definidos em uma plataforma que também cobre design, mock, documentação e testes de API.

A decisão prática é esta: você quer capturar o comportamento atual de um serviço existente ou construir uma suíte de testes sustentável e mantida pela equipe?

A diferença central em um parágrafo

Keploy monitora sua aplicação em execução. Você inicia o app com keploy record, envia requisições reais e o Keploy captura essas chamadas junto com dependências downstream, como banco de dados, eventos de rede e streams, usando eBPF. Depois, ele transforma esse tráfego em casos de teste e mocks para reprodução determinística.

O Apidog funciona no sentido oposto: você define endpoints, esquemas e cenários de teste, ou gera casos a partir de uma especificação OpenAPI, e executa tudo pelo terminal com apidog run.

Em termos simples:

Keploy: registra a realidade.
Apidog CLI: executa a intenção testável da API.

Nenhuma abordagem é “melhor” em absoluto. Elas respondem a perguntas diferentes.

Como os testes são criados

Criando testes com Keploy

Com o Keploy, os testes vêm do comportamento observado. A instalação pode ser feita com:

curl --silent -O -L https://keploy.io/install.sh && source install.sh

Depois, você grava e reproduz contra sua aplicação real:

keploy record -c "CMD_TO_RUN_APP"
keploy test -c "CMD_TO_RUN_APP" --delay 10

Fluxo típico:

Suba sua aplicação com keploy record.
Faça chamadas reais para a API.
O Keploy captura as requisições e dependências.
Rode keploy test para reproduzir os casos capturados.

Durante a gravação, cada interação real vira um caso de teste, e cada chamada de dependência vira um mock. O Keploy também possui geração de testes por IA a partir de OpenAPI, Postman, cURL ou endpoint ao vivo, com limpeza automática.

Como a captura acontece na camada de rede via eBPF, ele não precisa de SDK e funciona com Go, Java, Node.js, Python, Rust, C#, C/C++ e TypeScript, além de protocolos como gRPC, GraphQL, HTTP/REST, Kafka e RabbitMQ.

Criando testes com Apidog CLI

Com o Apidog, os testes partem do design da API. Você define endpoints e esquemas na plataforma, cria cenários com passos, asserções e variáveis, e depois executa pelo CLI.

Exemplo:

apidog run --access-token <TOKEN> -t <SCENARIO_ID> -e <ENV_ID>

Fluxo típico:

Modele ou importe sua API no Apidog.
Crie cenários de teste com requisições e asserções.
Configure ambientes, variáveis e dados de entrada.
Execute no terminal ou pipeline CI/CD com apidog run.

Os testes são artefatos que a equipe pode revisar, manter e evoluir. Eles não são apenas snapshots de uma sessão de gravação.

Para ver o executor em detalhes, consulte o guia completo do Apidog CLI, que cobre cenários, tokens e códigos de saída.

Apidog CLI vs Keploy: comparação de recursos

Dimensão	Keploy	Apidog CLI
Abordagem principal	Grava tráfego real e reproduz deterministicamente	Executa cenários de teste criados ou gerados a partir de especificação
Como os testes são criados	Capturados de chamadas reais da API e dependências	Projetados na plataforma ou gerados a partir de uma especificação
Alterações de código necessárias	Nenhuma, por usar captura eBPF sem SDK	Nenhuma no aplicativo; você cria os cenários de teste
Agnóstico à linguagem	Sim, por capturar na camada de rede	Sim, funciona contra APIs HTTP independentemente da stack
Mock de dependência	Gerado automaticamente a partir do tráfego capturado	Servidores mock configurados por design
Teste baseado em dados	Derivado de variações gravadas	Suportado via `-d` com CSV ou JSON
Relatórios	Resultados das execuções de reprodução	CLI, HTML, JSON e relatórios na nuvem com `--upload-report`
Restrições de SO	Mais dependente de Linux e privilégios elevados para eBPF	Roda em macOS, Linux, Windows e CI
Abrangência da plataforma	Focado em testes e geração de testes	Ciclo completo: design, depuração, mock, documentação e teste
Código aberto	Sim, Apache-2.0	Camada gratuita; plataforma comercial

Mock de dependência: a principal diferença prática

A maior diferença aparece quando sua API depende de banco de dados, serviços externos, filas ou streams.

Com o Keploy, os mocks são gerados automaticamente. Como ele captura consultas de banco de dados e eventos de rede junto com as chamadas de API, a reprodução não precisa de um banco de dados ao vivo ou serviço externo rodando. Isso é útil quando você quer congelar o comportamento atual de um serviço existente.

Exemplo de uso ideal para Keploy:

serviço legado sem suíte de testes;
muitas dependências downstream;
necessidade de cobertura rápida;
pouco tempo para escrever mocks manualmente.

Com o Apidog, o mocking é projetado. Você configura servidores mock, define respostas esperadas e controla os cenários simulados. Ele não captura chamadas reais de banco de dados via eBPF, nem transforma tráfego de produção em stubs automaticamente.

Exemplo de uso ideal para Apidog:

API ainda em design;
frontend precisa consumir endpoints antes do backend estar pronto;
equipe quer documentar, simular e testar o contrato da API;
respostas precisam representar comportamento esperado, não apenas comportamento observado.

Se o objetivo é congelar como um serviço em produção se comunica com o banco de dados, o Keploy se encaixa melhor. Se o objetivo é modelar contratos, mocks e cenários intencionais, o Apidog faz mais sentido.

Essas ferramentas fazem parte do espaço maior de testes de contrato e mocking, mas a escolha depende de uma pergunta simples: você está capturando ou projetando?

Um ponto importante: o Apidog não captura tráfego ao vivo via eBPF e não gera testes automaticamente a partir de chamadas de produção com mocks de dependência. Essa é a capacidade distintiva do Keploy. A sobreposição real é menor do que parece: ambos podem gerar testes a partir de especificações, mas apenas o Keploy gera testes a partir do comportamento em runtime.

Execuções baseadas em dados e relatórios

Quando você já tem cenários definidos, o Apidog CLI funciona como executor de testes para CI/CD.

Exemplo com dados de entrada e relatório HTML:

apidog run -t <SCENARIO_ID> -e <ENV_ID> -d ./users.csv -r html,cli

Principais flags:

-t <SCENARIO_ID>   # cenário de teste
-e <ENV_ID>        # ambiente
-d ./users.csv     # arquivo CSV ou JSON para testes baseados em dados
-r html,cli,json   # formato dos relatórios
--upload-report    # envia relatório para a nuvem

Você pode usar a flag -d com CSV ou JSON para executar o mesmo cenário contra várias entradas. Isso é útil para validar combinações de usuários, permissões, payloads ou códigos de erro.

Exemplo de CSV:

email,password,expectedStatus
user1@example.com,pass123,200
blocked@example.com,pass123,403
invalid@example.com,wrong,401

Depois, no cenário do Apidog, essas colunas podem alimentar variáveis usadas nas requisições e asserções.

Para aprofundar, veja o guia de testes baseados em dados, a análise de relatórios de teste e o passo a passo de configuração de CI/CD.

O Keploy, por outro lado, relata se os casos capturados continuam passando contra o código atual. Isso é excelente para detectar regressões no comportamento existente. É uma pergunta diferente de “minhas asserções projetadas continuam válidas para 200 entradas de teste?”.

Restrições de SO e ambiente

A captura eBPF do Keploy depende de Linux e privilégios elevados para instrumentar a camada de rede. Esse é o custo da captura sem SDK e sem alteração de código. Em ambientes Linux ou CI baseado em Linux, isso pode ser aceitável, mas precisa entrar no planejamento.

O Apidog CLI é um binário portátil que envia requisições HTTP para sua API. Por isso, roda em macOS, Linux, Windows e runners de CI comuns.

Outro ponto prático é a curadoria dos testes.

Testes gerados a partir de tráfego real capturam o que aconteceu, incluindo dados ruidosos, estados temporários e comportamentos acidentais. Antes de usar essa suíte como baseline, revise e limpe os casos gerados.

Testes projetados partem da intenção. Eles tendem a ser mais limpos inicialmente, mas exigem esforço de autoria e manutenção.

Abrangência da plataforma

O Keploy é focado em testes e geração de testes. Ele não tenta ser uma interface de design de API, ferramenta de documentação ou plataforma de colaboração para contratos.

O Apidog adota o modelo oposto. O CLI é a camada de execução de uma plataforma que também cobre:

design de API;
depuração de endpoints;
servidores mock;
documentação automática;
importação de OpenAPI;
gerenciamento de endpoints e esquemas;
colaboração em branches e requisições de merge;
execução de testes pelo terminal.

Se sua dor é a fragmentação entre ferramentas separadas de design, mock, documentação e teste, a consolidação do Apidog é o principal benefício. Se você só precisa capturar e reproduzir o comportamento de um serviço existente, essa abrangência pode ser mais do que o necessário.

Para entender onde o Apidog se encaixa no mercado, veja esta visão sobre ferramentas de automação de teste de API.

Como escolher na prática

Use esta regra rápida:

Escolha Keploy se você precisa:

capturar comportamento real de um serviço existente;
gerar testes sem escrever cenários manualmente;
mockar dependências automaticamente;
testar serviços legados rapidamente;
reproduzir chamadas reais de banco, rede ou streams;
trabalhar em ambiente Linux com suporte a eBPF.

Escolha Apidog CLI se você precisa:

criar testes de API projetados e revisáveis;
manter cenários como parte do ciclo de vida da API;
rodar testes baseados em dados com CSV ou JSON;
gerar relatórios HTML, JSON e CLI;
integrar testes em pipelines CI/CD;
usar a mesma plataforma para design, mock, documentação e teste.

Exemplo de pipeline com Apidog CLI

Um uso comum do Apidog CLI é bloquear merges quando um cenário crítico falha.

Exemplo genérico em CI:

apidog run \
  --access-token "$APIDOG_ACCESS_TOKEN" \
  -t "$APIDOG_SCENARIO_ID" \
  -e "$APIDOG_ENV_ID" \
  -d ./test-data/users.csv \
  -r cli,json,html \
  --upload-report

Esse comando permite:

executar um cenário específico;
usar ambiente controlado;
alimentar dados externos;
gerar relatório para humanos e máquinas;
publicar o resultado na nuvem.

Em um pipeline, o código de saída do comando pode ser usado para aprovar ou falhar a build.

Veredito honesto: quem deve escolher qual

Escolha o Keploy quando quiser capturar como um serviço existente já se comporta, incluindo dependências de banco de dados e rede, com mínimo esforço manual. Se você tem uma aplicação rodando, pouca ou nenhuma suíte de testes e precisa de cobertura rápida sem escrever mocks ou alterar código, a gravação e reprodução do Keploy é difícil de superar.

Apenas planeje uma etapa de curadoria da suíte gerada e valide os requisitos de Linux e privilégios no seu ambiente.

Escolha o Apidog CLI quando quiser testes de API projetados, manteníveis e colaborativos dentro de uma plataforma única. Se sua equipe cria testes como parte do design da API, compartilha cenários, usa arquivos de dados e conecta relatórios à CI, o modelo do Apidog se encaixa melhor.

Na prática, a decisão Apidog vs Keploy raramente é sobre qual ferramenta é “melhor”. É sobre o tipo de problema:

Keploy para capturar realidade.
Apidog CLI para expressar intenção.

Algumas equipes usam o Keploy para iniciar cobertura em serviços legados e o Apidog para projetar e manter testes das APIs em desenvolvimento ativo. Essa divisão é razoável.

Se você está inclinado à abordagem projetada, o Apidog possui um plano gratuito, e você pode baixar o Apidog para experimentar o fluxo de trabalho.

Para se aprofundar, veja também:

Perguntas Frequentes

O Apidog grava tráfego ao vivo como o Keploy?

Não. O Apidog não captura tráfego ao vivo via eBPF e não gera testes automaticamente a partir de chamadas de produção. Você cria cenários de teste ou os gera a partir de uma especificação de API, e então executa com o CLI. Gravar comportamento em runtime e mocks de dependência é a capacidade distintiva do Keploy.

O Keploy ou o Apidog é melhor para um serviço com muitas dependências de banco de dados?

Para capturar e reproduzir essas dependências automaticamente, o Keploy. Sua captura eBPF registra consultas de banco de dados e as simula para que as reproduções ocorram sem um banco de dados ao vivo.

O Apidog usa servidores mock projetados que você configura. Isso é melhor quando você quer modelar comportamento esperado, contratos ou endpoints ainda em desenvolvimento.

Preciso alterar meu código para usar alguma dessas ferramentas?

Não. Nenhuma alteração de código é necessária.

O Keploy instrumenta na camada de rede com eBPF, sem SDK. O Apidog envia requisições HTTP para sua API e não modifica o código da aplicação; você apenas cria e executa os cenários.

Ambos podem gerar testes a partir de uma especificação OpenAPI?

Sim. Essa é a principal sobreposição.

O Keploy pode gerar suítes validadas a partir de OpenAPI, Postman, cURL ou endpoint ao vivo. O Apidog gera casos de teste por IA a partir do esquema e endpoints dentro da plataforma.

A diferença é que apenas o Keploy também gera testes a partir do comportamento registrado em runtime.

Qual roda mais facilmente em diferentes sistemas operacionais?

O Apidog CLI roda como binário portátil em macOS, Linux, Windows e runners de CI comuns.

A captura eBPF do Keploy depende de Linux e privilégios elevados. Isso pode funcionar bem em CI baseado em Linux, mas é uma restrição importante em outros ambientes.

Resumo

Se você precisa tirar um snapshot de um serviço existente sem escrever muitos testes manualmente, comece com o Keploy.

Se você precisa de testes projetados, revisáveis e mantidos dentro de uma plataforma que também lida com design, mocks e documentação, comece com o Apidog CLI.

Combine a ferramenta com o objetivo — capturar ou projetar — e a escolha fica clara.

DEV Community