pytest-redis 5.0.0

Quickstart: first test

1. Install the plugin and your test dependencies (as you normally do for your project).

2. Ensure Redis is available (local install or container). The redis-server executable must be on PATH, or pass it explicitly with --redis-exec. If Redis can’t be found or started, pytest-redis raises RedisMisconfigured.

3. Create a test that uses the built-in fixture:

def test_can_connect(redisdb):
    redisdb.set("ping", "pong")
    assert redisdb.get("ping") == b"pong"

4. Run your tests:

pytest

The plugin contains four fixtures:

• redisdb - function-scoped client fixture that cleans all databases after each test.

• redisdb_async - function-scoped redis.asyncio client fixture, the asynchronous counterpart of redisdb. Requires the async extra, see Asynchronous Redis client.

• redis_proc - session-scoped fixture that starts Redis at first use and stops at the end of the tests.

• redis_noproc - no-process fixture that connects to an already running Redis instance.

Simply include one of these fixtures in your test fixture list.

Asynchronous Redis client

redisdb_async is the asynchronous counterpart of redisdb. It yields a redis.asyncio.Redis client connected to the very same Redis instance the process fixtures manage, flushes all databases after each test and closes the client’s connection pool on teardown.

It builds on pytest-asyncio, which is an optional dependency. Install it along with pytest-redis:

pip install 'pytest-redis[async]'

Then use the fixture from an async test:

import pytest

@pytest.mark.asyncio
async def test_redis_async(redisdb_async):
    """Check that it's actually working on redis database."""
    await redisdb_async.set('test1', 'test')

    assert await redisdb_async.get('test1') == b'test'

The redisdb_async factory takes the same arguments as redisdb, so additional async client fixtures are created the same way - including ones connecting to an already running server through redis_noproc:

from pytest_redis import factories

redis_my_proc = factories.redis_proc(port=None)
redis_my_async = factories.redisdb_async('redis_my_proc')
redis_external_async = factories.redisdb_async('redis_noproc')

Connecting to already existing redis database

Some projects use already running Redis servers (i.e. on Docker instances). In order to connect to them, one would be using the redis_noproc fixture.

redis_external = factories.redisdb('redis_noproc')

def test_redis(redis_external):
    """Check that it's actually working on redis database."""
    redis_external.set('test1', 'test')
    redis_external.set('test2', 'test')

    my_functionality = MyRedisBasedComponent()
    my_functionality.do_something()
    assert my_functionality.did_something

    assert redis_external.get("did_it") == 1

Standard configuration options apply to it. Note that the modules configuration option has no effect with the redis_noproc fixture, it is the responsibility of the already running redis server to be properly started with extension modules, if needed.

By default the redis_noproc fixture would connect to Redis instance using 6379 port attempting to make a successful socket connection within 15 seconds. The fixture will block your test run within this timeout window. You can overwrite the timeout like so:

# set the blocking wait to 5 seconds
redis_noproc = factories.redis_noproc(startup_timeout=5)
redis_external = factories.redisdb('redis_noproc')

def test_redis(redis_external):
    """Check that it's actually working on redis database."""
    redis_external.set('test1', 'test')
    # etc etc

These are the configuration options that are working on all levels with the redis_noproc fixture: