How do I mock Oracle queries in tests?

Record your application once against a real Oracle with Keploy. It captures each query, its bind variables, and the result set with column precision, then answers the same queries from that recording with no instance running.

Is Keploy a Testcontainers Oracle alternative?

For replay, yes, and the gap is larger here than for other databases: the Oracle image is very large and slow to become usable. Keploy records a real instance once and replays with no container.

Can I use Keploy instead of H2 in Oracle mode?

Yes, and with much higher fidelity. H2's Oracle compatibility mode implements a subset, so MERGE, sequences, and hierarchical queries can diverge. Keploy replays responses that came from Oracle itself.

Is Keploy free to use with Oracle?

Yes. The Keploy CLI is open source under Apache 2.0 and free to run on any service with no seat limits. Nothing is installed into the database and no licence is required to record.

Keploy as a Oracle Database testing framework

Keploy mocks Oracle by recording its wire protocol beneath your driver, capturing the exact result sets and column metadata your queries returned, then replaying them during tests. No Oracle instance runs in CI, no schema is created, and no seed script is involved.

Generate Oracle Database tests free

keploy record -c "java -jar orders.jar"

18.4K+

1.2M+300M+mocks createdSlack

What Keploy gives a Oracle Database team

Captured at the Oracle Net protocol

Keploy records beneath the driver, so what replays is the bytes the instance sent — including the NUMBER precision and scale the server reported, which is where a surprising number of Oracle bugs live.

Below Oracle JDBC, cx_Oracle, and node-oracledb
NUMBER precision and scale preserved
Bind variables captured per query
PL/SQL calls and REF CURSORs recorded

Try Keploy for free Explore the docs

The problem

Why Oracle Database 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 Oracle Database: by hand, with Testcontainers Oracle, or with Keploy

Testcontainers gives real Oracle semantics and charges a very large image plus a slow boot per job. Keploy records that instance once and replays its responses with neither.

By hand

Testcontainers Oracle

With Keploy

Select any row for the full comparison, with code.

Get started Book a call

Same coverage, three costs

What you write for Oracle Database 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

OrderDaoStub.java

hand-written

// Hand-written stub: no SQL is executed or type-mapped.

package com.acme.orders;

import java.math.BigDecimal;

import java.util.*;

class OrderDaoStub implements OrderDao {

private final Map<String, Order> rows = new HashMap<>(Map.of(

// A guess. Oracle NUMBER(12,2) may map differently.

"ord_1", new Order("ord_1", new BigDecimal("42.00"), "NEW")));

@Override

public Optional<Order> findById(String id) {

return Optional.ofNullable(rows.get(id));

}

The stub chooses its own BigDecimal scale, so a NUMBER precision or rounding mismatch is impossible to reproduce and impossible to catch.

Testcontainers Oracle1–2 hours

OrderDaoIT.java

tool-assisted

// Testcontainers Oracle: real instance, very large image.

package com.acme.orders;

class OrderDaoIT {

static OracleContainer oracle =

new OracleContainer("gvenzl/oracle-free:23-slim")

.withInitScript("schema-and-seed.sql");

@BeforeAll static void boot() { oracle.start(); }

@AfterAll static void stop() { oracle.stop(); }

@Test

void findsASeededOrder() {

var dao = new JdbcOrderDao(dataSource(oracle));

var order = dao.findById("ord_1").orElseThrow();

assertEquals(new BigDecimal("42.00"), order.amount());

}

Accurate down to NUMBER scale — and every job pulls a multi-gigabyte image and waits for the instance to open before the first assertion.

With Keploy~5 minutes

mocks.yaml

auto-generated

# Recorded with: keploy record -c './your-service'

# The Oracle response, captured at the protocol level.

version: api.keploy.io/v1beta1

kind: SQL

name: mock-2

spec:

metadata:

server: "Oracle Database 23ai"

request:

query: "SELECT id, amount, state FROM orders WHERE id = :1"

binds:

- "ord_1"

response:

columns:

- name: ID

type: VARCHAR2

- name: AMOUNT

type: NUMBER

precision: 12

scale: 2

- name: STATE

type: VARCHAR2

rows:

- { ID: "ord_1", AMOUNT: "42.00", STATE: "NEW" }

Precision and scale come from Oracle's own describe, so the driver's NUMBER conversion runs on every replay rather than being chosen by a stub.

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

Explore the docs Request a trial

Keploy vs the alternatives

Oracle Database testing tools, compared

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

Keploy

Testcontainers

H2

DBUnit

pg-mem

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 Oracle Database app once, replay it forever

Keploy sits below your Oracle Database 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 Oracle Database appGET/api/v1/orders/{id}200

RecordingKeploy proxyeBPF · userspace

JavaJDBC driver and Spring Data

Pythonthe DB-API driver and SQLAlchemy

Node.jsthe official driver and an ORM on top

Godatabase/sql and GORM

+2 more Oracle Database clients

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

Oracle Database clients Keploy records, driver by driver

Keploy captures Oracle Database at the wire protocol, so 5 of these 6 clients need no adapter, no test double, and no Oracle Database instance in CI.

Explore the docs Book a call

Quick start

Your first Oracle Database test suite in under five minutes

Every command below runs against your existing Oracle Database 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 orders.jar"
3
3Exercise the paths you care about
Run the app with your development Oracle reachable. Every query, its bind variables, and the rows returned are captured together.
curl localhost:8080/orders/ord_1
curl -X POST localhost:8080/orders/ord_1/confirm -d '{"paymentToken":"tok_123"}'
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 orders.jar" --delay 18