Does Keploy replace clojure.test + with-redefs?

No. Keep clojure.test + with-redefs for unit tests, where it is the right tool. Keploy covers the integration layer, where the cost is the dependencies rather than the assertions.

Do I have to change my Clojure code?

No. Keploy runs the process you already run and captures at the socket, so no annotation, no wrapper and no dependency injection change is needed.

What happens when a dependency changes?

Re-record. One command refreshes every captured interaction in the suite, so a changed contract shows up as a diff rather than as a silently passing stale mock.

Does it work with deps.edn and Leiningen?

Yes. Keploy runs the built artifact, so the build tool makes no difference. Nothing is added to either project file.

Can I run this in CI?

Yes, and that is the point: replay needs nothing running. No database service, no broker, no network access to upstreams, so the job is the same on every runner.

Keploy as a Clojure testing framework

Keploy tests Clojure services by recording real HTTP and database traffic from a running process, then replaying it as assertions. There is no var to rebind and nothing to mock by hand, because capture happens below the JVM at the socket.

Generate Clojure tests free

keploy record -c "java -jar target/app-standalone.jar"

18.4K+

1.2M+300M+mocks createdSlack

What Keploy gives a Clojure team

Any Clojure service, unchanged

Keploy runs the uberjar. Ring, Pedestal, Reitit and a bare Jetty adapter all record identically, because capture is at the socket rather than inside the handler stack.

Clojure 1.10 and above
Ring, Pedestal, Reitit
Leiningen or deps.edn
No plugin needed

Try Keploy for free Explore the docs

The problem

Why Clojure integration tests slow teams down

The friction is rarely the assertions. It is everything around them — spinning up dependencies, keeping mocks honest, and repairing tests after every refactor.

Book a call Explore the docs

Three ways to do it

Testing Clojure: by hand, with clojure.test + with-redefs, or with Keploy

clojure.test + with-redefs describes the exchange by hand and still needs the dependency supplied. Keploy records both halves once and replays them with nothing running.

By hand

clojure.test + with-redefs

With Keploy

Select any row for the full comparison, with code.

Get started Book a call

Same coverage, three costs

What you write for Clojure vs what Keploy records

All three produce the same assertion. Only the third still passes after the next refactor without anyone editing it.

By hand2–4 hours

orders_test.clj

hand-written

(ns app.orders-test

(:require [clojure.test :refer [deftest is]]

[app.orders :as orders]

[app.db :as db]

[app.payments :as payments]))

(deftest confirms-an-order

;; Rebound for this form only, and thread-local: anything the handler

;; does on another thread escapes the rebinding entirely.

(with-redefs [db/find-order (fn [_] {:id "o-1" :total 4200 :status "NEW"})

payments/authorize (fn [_] {:status "AUTHORIZED"})]

(let [res (orders/confirm {:params {:id "o-1"}})]

(is (= 200 (:status res)))

(is (= "CONFIRMED" (get-in res [:body :status]))))))

with-redefs rebinds the var for this form only, so next.jdbc never runs.

clojure.test + with-redefs1–2 hours

orders_wiremock_test.clj

tool-assisted

(ns app.orders-wiremock-test

(:require [clojure.test :refer [deftest is use-fixtures]]

[app.orders :as orders])

(:import [com.github.tomakehurst.wiremock WireMockServer]))

(def server (WireMockServer. 8787))

(use-fixtures :once

(fn [f]

(.start server)

;; One stub mapping per outbound URL, written by hand.

(.stubFor server (-> (post (url-equal-to "/v1/payment_intents/tok_123/confirm"))

(.willReturn (ok-json "{\"status\":\"AUTHORIZED\"}"))))

(f)

(.stop server)))

;; A real Postgres is still required, migrated and seeded per run.

(deftest confirms-an-order

(let [res (orders/confirm {:params {:id "o-1"}})]

(is (= 200 (:status res)))))

WireMock serves the upstream. The database is still a real one.

With Keploy~5 minutes

keploy/test-set-0/test-1.yaml

auto-generated

version: api.keploy.io/v1beta1

kind: Http

name: test-1

spec:

req:

method: POST

url: /orders/o-1/confirm

resp:

status_code: 200

body: '{"id":"o-1","status":"CONFIRMED","total":4200}'

assertions:

noise:

- body.confirmedAt

---

kind: Postgres

spec:

query: select id, total, status from orders where id = $1

rows:

- { id: "o-1", total: 4200, status: "NEW" }

---

kind: Http

spec:

request:

url: https://api.payments.example.com/v1/payment_intents/tok_123/confirm

response:

body: '{"status":"AUTHORIZED"}'

Recorded from one real request. Nothing here was typed by hand.

Times are estimates for authoring one endpoint’s coverage from scratch, not measurements.

Explore the docs Request a trial

Keploy vs the alternatives

Clojure testing tools, compared

The options a team on the JVM actually reaches for, and where each one genuinely wins. Select a row for the full comparison.

Keploy

JUnit + Mockito

WireMock

REST Assured

Testcontainers

Postman

SmartBear ReadyAPI

Best in classStrongPartialNot covered

Assessments reflect each tool’s documented behaviour, not benchmark measurements.

Request a trial Book a call

How it works

Record your Clojure app once, replay it forever

Keploy sits below your Clojure process at the network layer. It watches the calls your app already makes, then serves them back on replay so tests run with no dependencies attached.

Your Clojure appGET/api/v1/orders/{id}200

RecordingKeploy proxyeBPF · userspace

PostgreSQLPostgres protocol beneath next.jdbc

MySQLMySQL protocol beneath the JDBC driver

RedisRESP beneath carmine

Apache KafkaKafka protocol beneath jackdaw

Outbound HTTPEvery clj-http and hato call

An example shape of a captured call. Your own endpoints and dependencies come from your real traffic, so nothing here has to be written by hand.

Try Keploy for free Request a trial

Mock coverage

What Keploy mocks for Clojure, with zero config

5 of the 6 dependencies a typical Clojure service talks to are stubbed from the recording itself — no mock classes, no fixture files, no containers in CI.

Auto-mocked
PostgreSQLView page
Postgres protocol beneath next.jdbc
Auto-mocked
MySQLView page
MySQL protocol beneath the JDBC driver
Datomic
On the roadmap
Datomic
Peer protocol, where it crosses the network
Auto-mocked
RedisView page
RESP beneath carmine
Auto-mocked
Apache KafkaView page
Kafka protocol beneath jackdaw
Outbound HTTP
Auto-mocked
Outbound HTTP
Every clj-http and hato call

Explore the docs Book a call

Quick start

Your first Clojure test suite in under five minutes

Every command below runs against your existing Clojure service. Nothing in your source tree changes.

1
1Install the Keploy CLI
A single binary. It needs a Linux kernel with eBPF support, or Docker on macOS and Windows — and it adds nothing to your project's dependencies.
curl -sSL https://keploy.io/install.sh | bash
2
2Record your service
Pass the command you already use to start the app. Keploy runs it and watches every socket it opens.
keploy record -c "java -jar target/app-standalone.jar"
3
3Exercise the paths you care about
Use curl, your frontend, or an existing smoke script. Every request becomes a test case with its Clojure calls captured alongside it.
curl -X POST localhost:3000/orders/o-1/confirm
curl localhost:3000/orders/o-1
4
4Replay in CI
Replay serves the recorded dependency responses, so the job needs no service containers and no Docker daemon.
keploy test -c "java -jar target/app-standalone.jar" --delay 20