Keploy for your stack

JavaScript

Languages

Record a running JavaScript service once and get integration coverage without mocking every module the handler touches.

TypeScript

Languages

Get integration coverage for a TypeScript service without typed mock factories, casts, or a ts-jest transform.

Go

Languages

Record a running Go binary once and get table-test-grade coverage with sqlmock-free database stubs and no httptest servers to maintain.

Python

Languages

Turn the requests your Python service already handles into a pytest-grade regression suite, with every dependency mocked from the recording.

Java

Languages

Generate JUnit-grade integration tests for any JVM service by recording the traffic it already serves.

Node.js

Languages

Replace nock registrations and in-memory database fixtures with tests recorded from the traffic your Node service already serves.

Ruby

Languages

Replace WebMock stubs and VCR cassettes with tests recorded from the traffic your Ruby app already serves.

Bun

Languages

Record a running Bun service once and get integration coverage without mocking modules with bun:test.

Clojure

Languages

Record a running Clojure service once and get integration coverage without rebinding vars with with-redefs.

Deno

Languages

Record a running Deno service once and get integration coverage without replacing globalThis.fetch.

Groovy

Languages

Record a running Groovy service once and get integration coverage without describing interactions in a Spock spec.

.NET

Languages

Test ASP.NET Core services against recorded EF Core queries and HTTP calls, without Moq setups or an in-memory provider.

Elixir

Languages

Record a running Elixir service once and replay real Ecto queries and HTTP responses without Mox behaviours or a database sandbox.

Kotlin

Languages

Record a running Kotlin service once and get coroutine-safe integration coverage without MockK relaxed mocks or Testcontainers.

PHP

Languages

Record a running PHP app once and replay real PDO result sets and Guzzle responses without a MockHandler stack per test.

Rust

Languages

Record a running Rust binary once and get integration coverage without mockall traits or a wiremock server per upstream.

Scala

Languages

Record a running Scala service once and get integration coverage without cake-pattern wiring or a Testcontainers fixture per suite.

Actix Web

Frameworks

Record a running Actix Web service once and get integration coverage without generating a trait mock per boundary.

AdonisJS

Frameworks

Record a running AdonisJS service once and get integration coverage without swapping Lucid models for fakes.

Axum

Frameworks

Record a running Axum service once and get integration coverage without generating a trait mock per boundary.

Dropwizard

Frameworks

Record a running Dropwizard service once and get integration coverage without mocking every resource dependency.

Hono

Frameworks

Record a running Hono service once and get integration coverage without stubbing every binding and fetch.

Ktor

Frameworks

Record a running Ktor service once and get integration coverage without stubbing every injected client.

Litestar

Frameworks

Record a running Litestar service once and get integration coverage without overriding dependencies per test.

Record a running Micronaut service once and get integration coverage without replacing beans with @MockBean.

Nuxt

Frameworks

Record a running Nuxt service once and get integration coverage without mocking every server-side composable.

Phoenix

Frameworks

Record a running Phoenix service once and get integration coverage without defining a Mox mock per behaviour.

Sanic

Frameworks

Record a running Sanic service once and get integration coverage without patching every awaited dependency.

Sinatra

Frameworks

Record a running Sinatra service once and get integration coverage without stubbing every collaborator.

Tornado

Frameworks

Record a running Tornado service once and get integration coverage without patching every coroutine it awaits.

Vert.x

Frameworks

Record a running Vert.x service once and get integration coverage without stubbing every event-bus consumer.

ASP.NET Core

Frameworks

Test ASP.NET Core endpoints through Kestrel instead of WebApplicationFactory, with EF Core queries replayed from a recording.

Django

Frameworks

No test database to create and destroy, no fixtures to load — Keploy records your Django app serving real requests and replays the ORM queries it made.

Echo

Frameworks

Test Echo handlers through the real server instead of a mock Context, with SQL and upstream calls replayed from a recording.

Express

Frameworks

Test the whole middleware chain, not a hand-built app instance — Keploy records real requests through your Express router and replays them.

FastAPI

Frameworks

Test FastAPI routes through the real ASGI server instead of TestClient, with async database calls mocked from the recording.

Fastify

Frameworks

Test Fastify routes through the real server rather than app.inject, with schema validation and hooks genuinely exercised.

Fiber

Frameworks

Test Fiber handlers through the real server instead of app.Test, with SQL and upstream calls replayed from a recording.

Flask

Frameworks

Test Flask routes through the real WSGI server, with SQLAlchemy queries and requests calls replayed from a recording.

Gin

Frameworks

Test Gin handlers through the real HTTP server instead of httptest recorders, with SQL and upstream calls replayed from a recording.

hapi

Frameworks

Test hapi routes through the real server instead of server.inject, with lifecycle extensions and validation genuinely exercised.

Koa

Frameworks

Test Koa routes through the real server rather than a fabricated ctx, with the whole middleware cascade genuinely exercised.

Laravel

Frameworks

Test Laravel routes against recorded Eloquent queries and real HTTP responses, without RefreshDatabase or Http::fake.

NestJS

Frameworks

Test NestJS controllers through the real HTTP server instead of a Test.createTestingModule graph with every provider mocked.

Next.js

Frameworks

Test Next.js route handlers and server actions through the real server, with database calls replayed instead of mocked per module.

Quarkus

Frameworks

Test Quarkus endpoints against recorded JDBC and REST client calls, without @QuarkusTest boot time or an @InjectMock per service.

Ruby on Rails

Frameworks

Test Rails requests against recorded ActiveRecord queries and real HTTP responses, with no schema load and no VCR cassettes.

Spring Boot

Frameworks

Skip @SpringBootTest context loads and @MockBean wiring — record the running application and replay every layer from real traffic.

Symfony

Frameworks

Test Symfony controllers through the real kernel instead of the test client, with Doctrine queries replayed from a recording.

Cassandra

Databases

Mock Cassandra at the CQL binary protocol without a cluster, a keyspace, or waiting for a replication factor to settle.

ClickHouse

Databases

Record real ClickHouse aggregate results once and replay analytical queries in tests without a running cluster.

DynamoDB

Databases

Record real DynamoDB responses once and replay them in tests without DynamoDB Local, a table definition, or AWS credentials.

MariaDB

Databases

Mock MariaDB at the wire protocol instead of running a container, with real result sets and real column metadata replayed.

MongoDB

Databases

Mock MongoDB at the wire protocol — real documents, real BSON types, real aggregation results — without a mongod binary in CI.

MySQL

Databases

Mock MySQL at the wire protocol instead of standing up a container or swapping in H2 — the rows your queries really returned, replayed.

Oracle Database

Databases

Mock Oracle at the wire protocol instead of pulling a multi-gigabyte container, with real result sets and NUMBER precision preserved.

PostgreSQL

Databases

Record the Postgres frontend/backend protocol once and replay real result sets in tests — no container, no pg-mem, no schema to rebuild.

SQLite

Databases

Record SQLite queries once and replay them in CI without shipping a fixture database or rebuilding a schema per test.

SQL Server

Databases

Mock SQL Server at the TDS protocol instead of standing up a container or swapping in an in-memory provider.

Elasticsearch

Caches & Stores

Record real Elasticsearch search responses once and replay them in tests without a cluster, an index, or a refresh wait.

Memcached

Caches & Stores

Record Memcached get, set, and miss exchanges once and replay real cache behaviour without a running daemon.

Redis

Caches & Stores

Record RESP traffic once and replay real cache hits, misses, TTLs, and pipeline responses without a Redis server in CI.

Amazon SQS

Message Queues

Test SQS producers and consumers against recorded messages, with no LocalStack, no queue, and no AWS credentials in CI.

Apache Kafka

Message Queues

Test producers and consumers against recorded broker exchanges — no embedded Kafka, no Testcontainers cluster, no flaky poll loops.

NATS

Message Queues

Test NATS publishers and subscribers against recorded messages, with no server to run and no JetStream stream to create.

RabbitMQ

Message Queues

Test publishers and consumers against recorded AMQP exchanges, with no broker to start and no queue to declare.

Amazon S3

Cloud & Infra

Record real S3 uploads, downloads, and presigned URL calls once and replay them in tests without a bucket or credentials.

AWS Lambda

Cloud & Infra

Record a Lambda handler's real invocation and downstream calls once, then replay them as tests without SAM local or a deploy.

Docker

Cloud & Infra

Record traffic inside a container once and replay it in CI without Docker Compose, a test stack, or a daemon in the runner.

GraphQL

Cloud & Infra

Record real GraphQL operations once and replay resolver-level coverage without a mocked schema or hand-written resolver stubs.

gRPC

Cloud & Infra

Record real gRPC exchanges over HTTP/2 and replay them as tests — no in-process stub server, no hand-written mock service implementation.

Kubernetes

Cloud & Infra

Record traffic from a running pod and replay it as tests in CI, without a cluster, a namespace, or a service mesh.