How do I mock Memcached in tests?

Record your application once against a real memcached with Keploy. It captures every command and reply at the protocol level, then answers the same commands from that recording during tests — with no daemon running.

Can Keploy test cache-miss and write-back logic?

Yes, and this is where it helps most. Recording a cold key captures the real miss reply, the set with its actual flags and expiry, and the subsequent hit — so the fallthrough branch most suites skip is covered by default.

Does Keploy capture Memcached expiry correctly?

Yes. The expiry and flags sent with each set are recorded, so passing seconds where a Unix timestamp was meant shows up as a wrong recorded value rather than being silently discarded by a stub.

Does Keploy work with pymemcache and spymemcached?

Yes, and identically. Capture happens at the Memcached protocol beneath the client, so pymemcache, spymemcached, gomemcache, dalli, and the PHP extension all record and replay the same exchanges.

Can Keploy replay Memcached multi-get responses?

Yes. A multi-get is a single command with several VALUE replies followed by END, and Keploy records that whole exchange, so partial hits replay exactly as the daemon returned them.

Is Keploy free to use with Memcached?

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 memcached and no configuration change is required.

Keploy as a Memcached testing framework

Keploy mocks Memcached by recording its protocol beneath your client, capturing every get, set, miss, and expiry exactly as the daemon replied, then replaying them during tests. No memcached runs in CI and no in-process fake stands in for it.

Generate Memcached tests free

keploy record -c "./orders-service"

18.4K+

1.2M+300M+mocks createdSlack

What Keploy gives a Memcached team

Captured at the Memcached protocol

Keploy reads the text and binary protocols beneath your client, recording each command and reply in order — so a miss replies END exactly as the daemon did, not as a stub's default.

Below pymemcache, memcached-client, and gomemcache
Text and binary protocols
Flags and expiry captured
Multi-get responses preserved

Try Keploy for free Explore the docs

The problem

Why Memcached 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 Memcached: by hand, with a running memcached, or with Keploy

A real daemon gives true expiry and flags behaviour and still needs to run somewhere. Keploy records those exchanges once and replays them with nothing running.

By hand

a running memcached

With Keploy

Select any row for the full comparison, with code.

Get started Book a call

Same coverage, three costs

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

cache_stub.py

hand-written

# Hand-written stub: no expiry, no flags, no eviction.

class StubCache:

def __init__(self):

self._values = {"order:ord_1": {"id": "ord_1", "state": "NEW"}}

def get(self, key):

# Always a hit. The fallthrough path never runs.

return self._values.get(key)

def set(self, key, value, expire=0):

# The expire argument is accepted and discarded.

self._values[key] = value

return True

The expiry is accepted and thrown away, so passing seconds where a Unix timestamp was meant is impossible to catch. Every read is a hit.

a running memcached1–2 hours

test_cache_real.py

tool-assisted

# A real memcached daemon in the test environment.

import time

from pymemcache.client.base import Client

def test_order_cache():

client = Client(("localhost", 11211))

client.flush_all()

cache = OrderCache(client)

cache.set("order:ord_1", {"state": "NEW"}, expire=1)

assert cache.get("order:ord_1") is not None

# Real expiry means really waiting for it.

time.sleep(1.5)

assert cache.get("order:ord_1") is None

Accurate down to expiry semantics — and it needs a daemon running, a flush between tests, and a real sleep to observe expiry.

With Keploy~5 minutes

mocks.yaml

auto-generated

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

# Two real exchanges: a miss, then the write-back.

version: api.keploy.io/v1beta1

kind: Memcached

name: mock-6

spec:

exchanges:

- request: "get order:ord_1"

# The real miss reply — the branch stubs skip.

response: "END"

- request: "set order:ord_1 0 300 34"

response: "STORED"

- request: "get order:ord_1"

response: "VALUE order:ord_1 0 34"

flags: 0

expiry_seconds: 300

The recorded sequence includes the miss, the set with its real flags and expiry, and the subsequent hit — the whole cache path as it happened.

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

Explore the docs Request a trial

Keploy vs the alternatives

Memcached testing tools, compared

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

Keploy

Testcontainers

fakeredis

miniredis

redis-mock

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

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

RecordingKeploy proxyeBPF · userspace

Pythonpymemcache and python-memcached

Javaspymemcached and Xmemcached

Gogomemcache

PHPthe Memcached extension and Laravel cache

+2 more Memcached 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

Memcached clients Keploy records, driver by driver

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

Explore the docs Book a call

Quick start

Your first Memcached test suite in under five minutes

Every command below runs against your existing Memcached 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 "./orders-service"
3
3Exercise the paths you care about
Hit an endpoint on a cold key to record the miss and write-back, then hit it again to record the hit.
curl localhost:8080/orders/ord_1
curl localhost:8080/orders/ord_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 "./orders-service" --delay 8