Se você procurou uma forma de obter testes de API sem escrevê-los à mão, provavelmente se deparou com o Keploy. Ele promete algo que parece quase conveniente demais: aponte-o para sua aplicação em execução, deixe-o observar o tráfego real e saia com uma suíte de testes. Então, o que o Keploy realmente está fazendo por baixo dos panos e onde ele se encaixa na sua pilha de testes?
Este guia explica o que é o Keploy, como seu motor de gravação e reprodução funciona na camada de rede eBPF, os dois fluxos de trabalho que ele oferece, como instalá-lo e executá-lo, e os limites honestos que você deve conhecer antes de adotá-lo.
O que é o Keploy
Keploy é uma plataforma de código aberto (licença Apache-2.0) para criar sandboxes de produção seguras e isoladas para testes de API, integração e ponta a ponta. A ideia central é que sua aplicação real já exercita o comportamento que você deseja testar. Em vez de pedir para você descrever esse comportamento em código de teste, o Keploy o observa e o transforma em testes reproduzíveis.
Ele oferece duas maneiras de fazer isso:
- Gravar e reproduzir captura interações reais de API e suas dependências, depois as reproduz com determinismo.
- Geração de testes por IA constrói suítes de testes de API validadas a partir de uma especificação, uma coleção, um comando cURL ou um endpoint ativo.
Ambos produzem testes executáveis mais os mocks necessários para executá-los sem atingir dependências ativas. O projeto é de código aberto, então você pode ler o código e auto-hospedá-lo. O repositório está em github.com/keploy/keploy, e a documentação oficial está em keploy.io/docs.
Como a gravação do Keploy funciona na camada eBPF
Esta é a parte que torna o Keploy distinto. Quando você executa keploy record, ele não pede para você adicionar um SDK ou mudar uma única linha do código da sua aplicação. Ele captura o tráfego na camada de rede usando eBPF, uma tecnologia do kernel Linux que permite que programas observem e ajam sobre eventos do sistema com segurança.
Aqui está o que isso lhe oferece na prática:
- Captura sem código. Sem instrumentação, sem harness de teste, sem decoradores nos seus handlers. O Keploy fica abaixo da sua aplicação e observa os bytes entrando e saindo.
- Captura agnóstica à linguagem. Como a captura acontece na camada de rede do kernel, em vez de dentro de um runtime, funciona da mesma forma, seja seu serviço escrito em Go, Python ou Rust.
- Captura de dependências. O Keploy não registra apenas a chamada de API de entrada e sua resposta. Ele também registra as chamadas de saída que seu serviço faz para suas dependências, como consultas de banco de dados e eventos de rede ou streaming.
Este último ponto é importante. Quando o Keploy registra uma requisição, ele captura a imagem completa: a requisição de API, a resposta da API e cada chamada de dependência que ocorreu no meio. Ele então escreve dois artefatos a partir dessa única interação observada:
- Um caso de teste descrevendo a requisição e resposta esperadas.
- Mocks e stubs para cada chamada de dependência, para que o teste possa ser reproduzido sem um banco de dados ativo ou serviço downstream.
A reprodução fecha o ciclo. Quando você executa keploy test, ele envia as requisições gravadas de volta para sua aplicação, serve as respostas de dependência capturadas dos mocks gerados e compara as novas respostas com as gravadas. Uma incompatibilidade significa que algo mudou. É por isso que a abordagem é chamada de gravação e reprodução: você registra o comportamento real em tempo de execução uma vez, depois o reproduz de forma determinística como um teste de regressão a cada alteração.
Os dois fluxos de trabalho do Keploy
Gravação e reprodução
Use isso quando você já tem uma aplicação funcionando e quer cobertura de regressão rapidamente. Você executa o aplicativo com o Keploy, exercita-o da forma que um usuário ou cliente real faria (chamadas manuais, um teste de integração existente ou tráfego ao vivo), e o Keploy armazena cada interação como um teste mais seus mocks. Execuções posteriores reproduzem essas interações e sinalizam qualquer desvio de comportamento.
Geração de testes por IA
Use isso quando quiser uma cobertura mais ampla do que a produzida pelo seu exercício manual, ou quando estiver começando de um contrato em vez de um fluxo em execução. O Keploy pode gerar suítes de testes de API validadas a partir de uma especificação OpenAPI, uma coleção Postman, um comando cURL ou um endpoint ativo. Ele simula dependências automaticamente e executa uma passagem de limpeza automática para que você não fique com casos redundantes.
Os dois fluxos de trabalho são complementares. A gravação e reprodução ancoram os testes no comportamento real observado; a geração de testes por IA preenche as lacunas da sua especificação. Se você estiver avaliando ferramentas que geram testes a partir de um esquema, nosso resumo de geradores de casos de teste de IA e o guia para gerar scripts de teste a partir de OpenAPI são bons companheiros.
Instalando o Keploy
O Keploy oferece um script de instalação. Em um sistema suportado, você executa:
curl --silent -O -L https://keploy.io/install.sh && source install.sh
Isso busca o binário e configura o comando keploy. A partir daí, você controla tudo através de dois comandos.
Os principais comandos do Keploy
Existem dois comandos que você mais usará. O primeiro registra:
keploy record -c "COMANDO_PARA_EXECUTAR_APLICATIVO"
Você passa o comando exato que inicia sua aplicação através de -c. O Keploy inicia seu aplicativo, observa o tráfego enquanto você o exercita e salva os casos de teste e mocks capturados.
O segundo reproduz:
keploy test -c "COMANDO_PARA_EXECUTAR_APLICATIVO" --delay 10
A flag --delay 10 instrui o Keploy a aguardar dez segundos antes de começar a disparar as requisições gravadas, o que dá tempo suficiente para um serviço mais lento iniciar completamente antes do início da reprodução. Se seu aplicativo precisar de mais tempo para iniciar, aumente o número; se ele iniciar rapidamente, você pode diminuir.
Uma típica primeira sessão se parece com isto:
# 1. Grave enquanto você acessa sua API
keploy record -c "node server.js"
# 2. Reproduza os casos capturados e verifique se há desvio
keploy test -c "node server.js" --delay 10
Esse é o ciclo completo. Grave uma vez contra uma versão conhecida e boa, e então execute keploy test no CI a cada alteração.
Linguagens, protocolos e armazenamentos de dados suportados
Como a captura ocorre na camada de rede, o Keploy abrange uma ampla superfície:
| Categoria | Suportado |
|---|---|
| Linguagens | Go, Java, Node.js, Python, Rust, C#, C/C++, TypeScript e mais |
| Protocolos | HTTP/REST, gRPC, GraphQL, Kafka, RabbitMQ |
| Armazenamentos de Dados | PostgreSQL, MySQL, MongoDB, Redis |
A abrangência é uma consequência direta do design eBPF. O Keploy está lendo conversas de rede, então uma nova linguagem ou framework não precisa de um novo plugin, desde que fale um desses protocolos.
Executando Keploy no CI
Ambos os comandos são feitos para automação. Em um pipeline, você comita os casos de teste e mocks gravados junto com seu código, e então executa keploy test -c "..." como uma etapa. Como os mocks substituem as dependências reais, a reprodução não precisa de um banco de dados ativo ou serviço downstream no executor do CI, o que mantém o trabalho rápido e determinístico. Uma reprodução falha reprova a build, da mesma forma que um teste de unidade faria.
Limitações honestas a considerar
Keploy é forte no que faz, mas não se encaixa em todas as situações. Uma avaliação justa inclui os trade-offs:
- Inclina-se para Linux e privilégios elevados. eBPF é um recurso do kernel Linux, e capturar nessa camada geralmente requer permissões elevadas. Isso molda onde e como você pode executá-lo.
- Testes gerados precisam de curadoria. Testes construídos a partir de tráfego real ou geração por IA são um ponto de partida, não uma suíte finalizada. Você ainda os revisa, remove ruídos e decide quais comportamentos capturados são realmente contratos que valem a pena impor.
- É uma ferramenta de teste e geração de testes, não uma plataforma completa de ciclo de vida de API. Keploy foca em capturar, gerar e reproduzir testes. Não é projetado para lidar com design de API, documentação, publicação de mock-servers para consumidores ou colaboração em torno de uma especificação de API.
Nenhuma dessas são críticas ao Keploy. São os limites naturais de sua categoria. Conhecê-los ajuda você a decidir se ele resolve seu problema ou apenas parte dele.
Onde o Apidog se encaixa como a alternativa de teste projetado
Se sua necessidade for mais ampla do que "transformar o tráfego observado em testes de regressão", vale a pena considerar uma plataforma de ciclo de vida completo. O Apidog é uma plataforma de API tudo-em-um que cobre design, depuração, mocking, documentação e testes em um só lugar. A diferença de filosofia é o ponto chave a ser entendido, porque Apidog e Keploy se enquadram em categorias diferentes.
O Keploy captura e reproduz o comportamento real em tempo de execução, incluindo mocks de dependências, sem código. O Apidog segue o caminho oposto: você projeta e elabora cenários de teste manteníveis, e então os executa a partir do terminal e do CI com o Apidog CLI. O CLI executa suas coleções elaboradas com testes orientados a dados via CSV ou JSON, alternância de ambientes e relatórios CLI, HTML e JSON. O Apidog também oferece geração de casos de teste por IA a partir de seu esquema de API e endpoints, elaborados dentro do aplicativo, que é onde as duas ferramentas se sobrepõem.
Para ser claro sobre o limite: o Apidog não captura tráfego ao vivo via eBPF, e não gera testes automaticamente gravando chamadas de produção mais mocks de dependência. Essa capacidade de gravar a partir do tráfego real é genuinamente do Keploy. O enquadramento honesto é que você escolhe com base na tarefa. Use o Keploy quando quiser captura e reprodução em tempo de execução com zero código. Use o Apidog quando quiser suítes de teste projetadas e manteníveis dentro de uma plataforma que também lida com o restante do ciclo de vida da API. Para uma comparação mais aprofundada, consulte Apidog vs Keploy, e se você decidiu mudar, o passo a passo da migração cobre a transferência de seus testes.
Se testes de API elaborados e manteníveis são o que você procura, você pode baixar o Apidog e começar com o guia para testar uma API com Apidog.
Perguntas frequentes
O Keploy é gratuito e de código aberto? Sim. O Keploy é de código aberto sob a licença Apache-2.0, e o código está no GitHub. Você pode auto-hospedá-lo.
O Keploy exige a alteração do código da minha aplicação? Não. O fluxo de trabalho de gravação e reprodução captura o tráfego na camada de rede eBPF, portanto, não há SDK para adicionar e não há alterações de código. É por isso também que funciona em muitas linguagens.
O que a flag --delay em keploy test faz? Ela define quantos segundos o Keploy espera antes de enviar as requisições gravadas, dando tempo para o seu aplicativo inicializar. --delay 10 espera dez segundos; aumente para serviços de inicialização lenta.
O Keploy pode simular meu banco de dados durante os testes? Sim. Ao gravar uma interação, ele também captura as chamadas de dependência (como consultas de banco de dados) e escreve mocks para elas, para que as reproduções ocorram sem um banco de dados ativo.
O Keploy substitui uma ferramenta de design e documentação de API? Não. O Keploy é uma ferramenta de teste e geração de testes. Para design de API, documentação, mocking para consumidores e colaboração junto com os testes, uma plataforma de ciclo de vida completo como o Apidog é mais adequada.
A versão resumida
O Keploy é uma ferramenta de código aberto que transforma o comportamento real da API em testes. Seu motor de gravação e reprodução usa eBPF para capturar requisições, respostas e chamadas de dependência na camada de rede sem alterações de código, e então os reproduz como testes de regressão determinísticos. Sua geração de testes por IA cria suítes a partir de uma especificação ou endpoint. É rápido de adotar e agnóstico à linguagem, com as desvantagens de um modelo de captura voltado para Linux, testes que precisam de revisão e um escopo limitado a testes. Se você deseja suítes de teste elaboradas e manteníveis dentro de uma plataforma de API completa, o Apidog é a alternativa a ser comparada.