fakeredis

Warnings

• breaking Fakeredis versions older than 2.34.1 might encounter issues when used with `redis-py` 7.2.0 or newer, particularly concerning deprecated arguments. Ensure `fakeredis` is updated to maintain compatibility.
  Fix: Upgrade `fakeredis` to version 2.34.1 or higher: `pip install --upgrade fakeredis`.
• breaking In `fakeredis` v1.0, the default behavior changed: each `FakeRedis` or `FakeStrictRedis` instance now contains its own isolated state. This means instances created without explicitly sharing a `FakeServer` will not share data. Previous versions defaulted to a shared (singleton) state.
  Fix: To achieve shared state between instances, explicitly create a `FakeServer` and pass it to each `FakeRedis` instance, e.g., `server = FakeServer(); r1 = FakeRedis(server=server); r2 = FakeRedis(server=server)`.
• breaking Older `FakeAsyncRedis` versions (prior to v2.33.0) might not fully support the RESP3 protocol, which is important for newer Redis features and client-server communication.
  Fix: Upgrade `fakeredis` to version 2.33.0 or higher to ensure proper RESP3 support for `FakeAsyncRedis`: `pip install --upgrade fakeredis`.
• gotcha `TcpFakeServer` for starting a threaded fake Redis server requires the `lupa` package for Lua scripting support (which includes `redis.lock.Lock` functionality). If Lua features are needed, install `fakeredis` with the `[lua]` extra.
  Fix: If using `TcpFakeServer` and Lua scripting, install with `pip install "fakeredis[lua]"`.
• gotcha Fakeredis, while comprehensive, does not guarantee bit-for-bit identical behavior to a real Redis server for all edge cases or undefined behaviors (e.g., iteration order of `SCAN`/`ZSCAN`, specifics of HyperLogLog implementation, or the exact set of bugs present in a specific Redis version).
  Fix: Be aware of these known limitations; for critical integration tests requiring exact Redis behavior, consider using `Testcontainers` with a real Redis instance.
• deprecated Support for `aioredis` as a separate entity from `redis-py` (specifically `redis-py` versions 4.1.2 and below) was removed. Modern `fakeredis` versions integrate async capabilities directly through `redis-py`'s unified client.
  Fix: Ensure you are using `redis-py` version 4.3 or higher, and rely on `FakeAsyncRedis` which mirrors `redis-py`'s async client functionality.

Install

• pip install fakeredis Basic Installation
• pip install "fakeredis[lua]" With Lua scripting support (requires lupa)
• pip install "fakeredis[json]" With RedisJSON support (requires jsonpath-ng)
• pip install "fakeredis[probabilistic]" With probabilistic data structures (requires pyprobables)

Imports

• FakeRedis

  from fakeredis import FakeRedis

• FakeStrictRedis

  from fakeredis import FakeStrictRedis

  Equivalent to FakeRedis in modern versions, but historically a distinct class reflecting redis-py's StrictRedis. Both are subclasses of Redis.
• FakeAsyncRedis

  from fakeredis import FakeAsyncRedis

• FakeServer

  from fakeredis import FakeServer

  Used to share state between multiple FakeRedis instances; a new one is created implicitly if not provided.
• TcpFakeServer

  from fakeredis import TcpFakeServer

  For starting a fake Redis server on a separate thread/socket.

Quickstart

Initialize `FakeRedis` for synchronous operations or `FakeAsyncRedis` for `asyncio` based applications. These instances mimic the `redis-py` client interface, allowing you to interact with an in-memory Redis store. By default, each instance manages its own isolated state.

import fakeredis

# Basic synchronous usage
r_sync = fakeredis.FakeRedis()
r_sync.set('mykey', 'myvalue')
print(f"Synchronous get: {r_sync.get('mykey')}")

# Basic asynchronous usage
import asyncio

async def async_example():
    r_async = fakeredis.FakeAsyncRedis()
    await r_async.set('myasync_key', 'myasync_value')
    print(f"Asynchronous get: {await r_async.get('myasync_key')}")

if __name__ == '__main__':
    asyncio.run(async_example())