Keploy

Keploy intercepts live HTTP/HTTPS traffic at the network layer (via eBPF or proxy middleware) to capture request-response pairs in real-time without code instrumentation. It records full request bodies, headers, query parameters, response payloads, and timing metadata, storing them in a normalized format for later replay and test generation. This approach enables zero-modification capture of production or staging traffic without requiring developers to add logging code.

Keploy analyzes captured HTTP traffic to automatically generate executable test cases by extracting request patterns, response assertions, and dependency chains. It uses heuristics to identify test boundaries (e.g., transaction start/end), deduplicates similar requests, and generates parameterized test templates that cover multiple scenarios from a single traffic sample. The generated tests are output in standard formats (Go test files, JavaScript Jest, etc.) with assertions on status codes, response schemas, and latency thresholds.

Keploy extracts response payloads from captured traffic and generates mock stubs (test doubles) that simulate external service behavior without requiring live dependencies. It creates stub definitions that match request patterns to canned responses, supports response templating for dynamic values (e.g., timestamps, IDs), and integrates with testing frameworks to inject mocks during test execution. Stubs are versioned and can be updated as APIs evolve, enabling tests to run offline and in parallel without coordinating with external services.

Keploy normalizes captured traffic by identifying and deduplicating semantically identical requests that differ only in non-essential fields (e.g., timestamps, session IDs, request IDs). It applies configurable rules to extract request signatures, groups similar requests, and generates parameterized test templates that represent multiple traffic samples with a single test case. This reduces test suite bloat and improves maintainability by consolidating redundant test cases into reusable patterns.

Keploy executes generated tests while replaying captured traffic to satisfy inter-request dependencies (e.g., using a user ID returned from one request in subsequent requests). It maintains state across test steps, injects captured responses for external dependencies, and validates that the system under test produces expected outputs given the replayed inputs. This enables end-to-end testing of workflows that span multiple API calls without requiring manual state setup or fixture management.

Keploy maintains version history of generated test cases and detects regressions by comparing current test execution results against baseline results from previous versions. It tracks which tests changed, which assertions failed, and provides diff views showing what changed in requests, responses, or assertions. This enables teams to identify unintended behavior changes and validate that refactoring or updates don't break existing functionality.

Keploy generates test code in multiple programming languages (Go, Node.js, Python) using language-specific testing frameworks (Go testing, Jest, pytest) and assertion libraries. It produces idiomatic code that follows language conventions, integrates with native test runners, and generates tests that can be committed to version control and run in standard CI/CD pipelines. The generated code includes proper imports, setup/teardown logic, and assertion syntax specific to each language.

Keploy infers API request/response schemas from captured traffic and validates that subsequent requests and responses conform to the inferred contracts. It detects schema violations (unexpected fields, type mismatches, missing required fields) and generates schema definitions (JSON Schema, OpenAPI) from traffic patterns. This enables contract-based testing without requiring explicit API specifications, and detects breaking changes when APIs evolve.

Keploy captures and analyzes latency metrics from test execution, comparing actual response times against baselines from captured traffic. It identifies performance regressions (requests slower than expected), generates performance assertions (e.g., 'response must complete within 500ms'), and provides latency distribution reports. This enables performance testing without requiring explicit performance test code or load testing tools.

Keploy integrates with CI/CD systems (GitHub Actions, GitLab CI, Jenkins) to automatically capture traffic, generate tests, and execute them on every commit or deployment. It provides plugins/actions that hook into pipeline stages, manage test artifacts, and report results back to the CI system. This enables continuous test generation and execution without manual intervention, keeping tests synchronized with code changes.