Pytest Mock Resources

Warnings

• gotcha Most `pytest-mock-resources` fixtures (PostgreSQL, MongoDB, Redis, MySQL, Redshift) require Docker to be installed and running on the test environment. SQLite is a notable exception.
  Fix: Ensure Docker Desktop or a Docker daemon is active before running tests that rely on these fixtures. Refer to the official Docker documentation for installation and setup.
• gotcha While `pytest-mock-resources` provides 'extras' for installing database drivers (e.g., `[postgres]` for `psycopg2-binary`), the maintainers recommend explicitly installing these client libraries (e.g., `psycopg2-binary`, `pymongo`, `redis`) as first-party dependencies in your project. This avoids potential version conflicts or unexpected behavior.
  Fix: Always add specific database client libraries (e.g., `pip install psycopg2-binary`) directly to your project's `requirements.txt` or `pyproject.toml` instead of relying on `pytest-mock-resources` extras.
• gotcha When using asynchronous database fixtures, you will generally need to install `pytest-asyncio` for proper fixture handling and test execution.
  Fix: Install `pytest-asyncio` (`pip install pytest-asyncio`) and mark your async test functions with `@pytest.mark.asyncio`.
• gotcha Running `Redis` tests in parallel (e.g., with `pytest-xdist`) can lead to cross-test state issues if operations like `flushall` are used, as internal Redis database selection mechanisms might not fully isolate tests. The default Redis container limit also restricts simultaneous tests to 16.
  Fix: Avoid `flushall` or other global state-modifying commands in parallel Redis tests. Consider `scope='session'` for Redis if global setup is acceptable, or use distinct keyspacing for each test to prevent clashes. Be aware of the 16-test parallel limit for Redis.
• breaking For PostgreSQL drivers, `pytest-mock-resources` versions 2.10.3 and 2.12.3 included fixes for improved default driver selection heuristics and compatibility with `psycopg` (specifically `psycopg2-binary` and async use with the dynamic `psycopg` drivername). If you were relying on older driver auto-detection or using `psycopg` for async, these versions might alter behavior.
  Fix: If experiencing issues, ensure your specific PostgreSQL driver is explicitly configured using `PostgresConfig(drivername='...')` within a `pmr_postgres_config` fixture to match your setup. For `psycopg` (v3), be aware of the new installation `psycopg[binary]` vs. `psycopg2-binary`.
• gotcha Running tests with `pytest-mock-resources` in CI/CD environments (e.g., CircleCI, GitLab) often requires specific Docker service configurations and environment variables to ensure the test containers are accessible.
  Fix: Refer to the `pytest-mock-resources` documentation on 'CI Support' for detailed configuration examples, including `setup_remote_docker` for CircleCI or `services: - docker:dind` and `DOCKER_HOST`, `PYTEST_MOCK_RESOURCES_HOST` environment variables for GitLab.

Install

• pip install pytest-mock-resources pytest Install core library and pytest
• pip install pytest-mock-resources[postgres] psycopg2-binary Install with PostgreSQL support (example)

Imports

• create_postgres_fixture

  from pytest_mock_resources import create_postgres_fixture

  Used to create a pytest fixture for a PostgreSQL database.
• PostgresConfig

  from pytest_mock_resources import PostgresConfig

  Used to customize the configuration for PostgreSQL fixtures.
• create_mongo_fixture

  from pytest_mock_resources import create_mongo_fixture

  Used to create a pytest fixture for a MongoDB database.
• create_redis_fixture

  from pytest_mock_resources import create_redis_fixture

  Used to create a pytest fixture for a Redis instance.

Quickstart

This quickstart demonstrates how to use `pytest-mock-resources` to create a mock PostgreSQL database. It defines a simple SQLAlchemy model, sets up a `create_postgres_fixture` that yields a SQLAlchemy session, and then shows two isolated tests creating users.

import pytest
from sqlalchemy import create_engine, text
from sqlalchemy.orm import declarative_base, sessionmaker

# Define a simple SQLAlchemy model (if using ORM)
Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String)

    def __repr__(self):
        return f"<User(id={self.id}, name='{self.name}')>"

from sqlalchemy import Column, Integer, String
from pytest_mock_resources import create_postgres_fixture

# Create a PostgreSQL fixture, providing the SQLAlchemy Base and enabling session
# This fixture will provide a SQLAlchemy session object to tests that request 'pg'
pg = create_postgres_fixture(Base, session=True)

def test_user_creation(pg):
    """Test creating a user in the mock PostgreSQL database."""
    # 'pg' is a SQLAlchemy session provided by the fixture
    new_user = User(name='Alice')
    pg.add(new_user)
    pg.commit()
    pg.refresh(new_user)

    result = pg.execute(text("SELECT name FROM users WHERE id = :id"), {'id': new_user.id}).scalar_one()
    assert result == 'Alice'

def test_another_user_creation(pg):
    """Another test, ensuring isolation between tests (new empty database)."""
    # This test gets a fresh, empty database instance
    assert pg.query(User).count() == 0
    new_user = User(name='Bob')
    pg.add(new_user)
    pg.commit()
    assert pg.query(User).count() == 1