modern-di-pytest 0.1.0__tar.gz

modern_di_pytest-0.1.0/.gitignore

@@ -0,0 +1,21 @@
+# Generic things
+*.pyc
+*~
+__pycache__/*
+*.swp
+*.sqlite3
+*.map
+.vscode
+.idea
+.DS_Store
+.env
+.pytest_cache
+.ruff_cache
+.coverage
+htmlcov/
+coverage.xml
+pytest.xml
+dist/
+.python-version
+.venv
+uv.lock

modern_di_pytest-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Artur Shiriev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

modern_di_pytest-0.1.0/PKG-INFO

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: modern-di-pytest
+Version: 0.1.0
+Summary: Pytest integration for Modern-DI: turn DI dependencies into pytest fixtures
+Project-URL: repository, https://github.com/modern-python/modern-di-pytest
+Project-URL: docs, https://modern-di.readthedocs.io
+Author-email: Artur Shiriev <me@shiriev.ru>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: DI,dependency injector,fixtures,ioc-container,pytest,python
+Classifier: Framework :: Pytest
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: <4,>=3.10
+Requires-Dist: modern-di<3,>=2
+Requires-Dist: pytest>=7
+Description-Content-Type: text/markdown
+
+"Modern-DI-Pytest"
+==
+[![Supported versions](https://img.shields.io/pypi/pyversions/modern-di-pytest.svg)](https://pypi.python.org/pypi/modern-di-pytest)
+[![downloads](https://img.shields.io/pypi/dm/modern-di-pytest.svg)](https://pypistats.org/packages/modern-di-pytest)
+[![GitHub stars](https://img.shields.io/github/stars/modern-python/modern-di-pytest)](https://github.com/modern-python/modern-di-pytest/stargazers)
+
+Pytest integration for [Modern-DI](https://github.com/modern-python/modern-di).
+
+Turn any DI dependency into a pytest fixture with one line.
+
+## Install
+
+```bash
+uv add --dev modern-di-pytest
+```
+
+## Usage
+
+The user owns the root container fixture. Pick whatever pytest scope fits the test suite:
+
+```python
+# conftest.py
+import typing
+
+import modern_di
+import pytest
+from modern_di_pytest import expose, modern_di_fixture
+
+from app import ioc
+from app.ioc import Dependencies
+from app.services import EmailClient
+
+
+@pytest.fixture
+def di_container() -> typing.Iterator[modern_di.Container]:
+    with modern_di.Container(groups=ioc.ALL_GROUPS) as container:
+        yield container
+
+
+# Bulk: every Provider on Dependencies becomes a pytest fixture
+# named after the class attribute.
+expose(Dependencies)
+
+# Manual: turn a single type or Provider into a named fixture.
+email_client = modern_di_fixture(EmailClient)
+```
+
+Tests then receive resolved dependencies by name:
+
+```python
+from app.services import EmailClient, UserService
+
+
+def test_listing(user_service: UserService) -> None:  # generated by expose(Dependencies)
+    assert user_service.list_users() == []
+
+
+def test_email(email_client: EmailClient) -> None:    # generated manually
+    email_client.send("hi")
+```
+
+## Pointing a fixture at a child container
+
+```python
+import typing
+
+import modern_di
+import pytest
+from modern_di_pytest import modern_di_fixture
+
+from app.services import UserService
+
+
+@pytest.fixture
+def request_container(
+    di_container: modern_di.Container,
+) -> typing.Iterator[modern_di.Container]:
+    with di_container.build_child_container(scope=modern_di.Scope.REQUEST) as container:
+        yield container
+
+
+request_user_service = modern_di_fixture(
+    UserService, container_fixture="request_container"
+)
+```
+
+## Overrides
+
+Use `Container.override()` directly — `modern-di` already ships a first-class
+override mechanism backed by a tree-shared `OverridesRegistry`:
+
+```python
+import modern_di
+
+from app.ioc import Dependencies
+from app.services import UserService
+from tests.fakes import FakeRepo
+
+
+def test_with_override(
+    di_container: modern_di.Container,
+    user_service: UserService,
+) -> None:
+    di_container.override(Dependencies.user_repo, FakeRepo())
+    try:
+        assert user_service.list_users() == []
+    finally:
+        di_container.reset_override(Dependencies.user_repo)
+```
+
+## API
+
+### `modern_di_fixture(dependency, *, container_fixture="di_container", name=None, pytest_scope="function")`
+
+Turn a single dependency into a pytest fixture. ``dependency`` is either a
+type (resolved via ``container.resolve``) or a Provider (resolved via
+``container.resolve_provider``). The returned object is a real pytest fixture
+— assign it to a module-level name and pytest will collect it.
+
+### `expose(group, *, container_fixture="di_container", pytest_scope="function", module=None)`
+
+Walk ``group`` (a ``Group`` subclass) and inject one pytest fixture per
+Provider class attribute into the caller's module. Fixture names equal the
+class-attribute names. Non-Provider class attributes are skipped. Pass
+``module=`` explicitly when stack introspection cannot identify the caller.
+
+## 📚 [Documentation](https://modern-di.readthedocs.io)

modern_di_pytest-0.1.0/README.md

@@ -0,0 +1,127 @@
+"Modern-DI-Pytest"
+==
+[![Supported versions](https://img.shields.io/pypi/pyversions/modern-di-pytest.svg)](https://pypi.python.org/pypi/modern-di-pytest)
+[![downloads](https://img.shields.io/pypi/dm/modern-di-pytest.svg)](https://pypistats.org/packages/modern-di-pytest)
+[![GitHub stars](https://img.shields.io/github/stars/modern-python/modern-di-pytest)](https://github.com/modern-python/modern-di-pytest/stargazers)
+
+Pytest integration for [Modern-DI](https://github.com/modern-python/modern-di).
+
+Turn any DI dependency into a pytest fixture with one line.
+
+## Install
+
+```bash
+uv add --dev modern-di-pytest
+```
+
+## Usage
+
+The user owns the root container fixture. Pick whatever pytest scope fits the test suite:
+
+```python
+# conftest.py
+import typing
+
+import modern_di
+import pytest
+from modern_di_pytest import expose, modern_di_fixture
+
+from app import ioc
+from app.ioc import Dependencies
+from app.services import EmailClient
+
+
+@pytest.fixture
+def di_container() -> typing.Iterator[modern_di.Container]:
+    with modern_di.Container(groups=ioc.ALL_GROUPS) as container:
+        yield container
+
+
+# Bulk: every Provider on Dependencies becomes a pytest fixture
+# named after the class attribute.
+expose(Dependencies)
+
+# Manual: turn a single type or Provider into a named fixture.
+email_client = modern_di_fixture(EmailClient)
+```
+
+Tests then receive resolved dependencies by name:
+
+```python
+from app.services import EmailClient, UserService
+
+
+def test_listing(user_service: UserService) -> None:  # generated by expose(Dependencies)
+    assert user_service.list_users() == []
+
+
+def test_email(email_client: EmailClient) -> None:    # generated manually
+    email_client.send("hi")
+```
+
+## Pointing a fixture at a child container
+
+```python
+import typing
+
+import modern_di
+import pytest
+from modern_di_pytest import modern_di_fixture
+
+from app.services import UserService
+
+
+@pytest.fixture
+def request_container(
+    di_container: modern_di.Container,
+) -> typing.Iterator[modern_di.Container]:
+    with di_container.build_child_container(scope=modern_di.Scope.REQUEST) as container:
+        yield container
+
+
+request_user_service = modern_di_fixture(
+    UserService, container_fixture="request_container"
+)
+```
+
+## Overrides
+
+Use `Container.override()` directly — `modern-di` already ships a first-class
+override mechanism backed by a tree-shared `OverridesRegistry`:
+
+```python
+import modern_di
+
+from app.ioc import Dependencies
+from app.services import UserService
+from tests.fakes import FakeRepo
+
+
+def test_with_override(
+    di_container: modern_di.Container,
+    user_service: UserService,
+) -> None:
+    di_container.override(Dependencies.user_repo, FakeRepo())
+    try:
+        assert user_service.list_users() == []
+    finally:
+        di_container.reset_override(Dependencies.user_repo)
+```
+
+## API
+
+### `modern_di_fixture(dependency, *, container_fixture="di_container", name=None, pytest_scope="function")`
+
+Turn a single dependency into a pytest fixture. ``dependency`` is either a
+type (resolved via ``container.resolve``) or a Provider (resolved via
+``container.resolve_provider``). The returned object is a real pytest fixture
+— assign it to a module-level name and pytest will collect it.
+
+### `expose(group, *, container_fixture="di_container", pytest_scope="function", module=None)`
+
+Walk ``group`` (a ``Group`` subclass) and inject one pytest fixture per
+Provider class attribute into the caller's module. Fixture names equal the
+class-attribute names. Non-Provider class attributes are skipped. Pass
+``module=`` explicitly when stack introspection cannot identify the caller.
+
+## 📚 [Documentation](https://modern-di.readthedocs.io)

modern_di_pytest-0.1.0/modern_di_pytest/__init__.py

@@ -0,0 +1,7 @@
+from modern_di_pytest.factory import expose, modern_di_fixture
+
+
+__all__ = [
+    "expose",
+    "modern_di_fixture",
+]

modern_di_pytest-0.1.0/modern_di_pytest/factory.py

@@ -0,0 +1,103 @@
+import inspect
+import types
+import typing
+
+import pytest
+from modern_di.group import Group
+from modern_di.providers.abstract import AbstractProvider
+
+
+T = typing.TypeVar("T")
+
+_PytestScope = typing.Literal["function", "class", "module", "package", "session"]
+
+
+def modern_di_fixture(
+    dependency: type[T] | AbstractProvider[T],
+    *,
+    container_fixture: str = "di_container",
+    name: str | None = None,
+    pytest_scope: _PytestScope = "function",
+) -> typing.Any:  # noqa: ANN401
+    """Turn a modern-di dependency into a pytest fixture.
+
+    Args:
+        dependency: A type (resolved via ``container.resolve``) or a Provider
+            (resolved via ``container.resolve_provider``).
+        container_fixture: Name of the pytest fixture that yields the container
+            to resolve from. Defaults to ``"di_container"``. Use a child
+            container fixture (e.g. ``"di_request_container"``) to resolve at a
+            deeper scope.
+        name: Optional pytest fixture name. Defaults to the assigned variable
+            name in the conftest.
+        pytest_scope: pytest fixture scope (``"function"`` by default).
+
+    Returns:
+        A pytest fixture object. Assign it to a module-level name and pytest
+        will collect it.
+
+    Example::
+
+        user_service = modern_di_fixture(UserService)
+
+
+        def test_listing(user_service):
+            assert user_service.list_users() == []
+
+    """
+
+    @pytest.fixture(name=name, scope=pytest_scope)
+    def _fixture(request: pytest.FixtureRequest) -> typing.Any:  # noqa: ANN401
+        container = request.getfixturevalue(container_fixture)
+        if isinstance(dependency, AbstractProvider):
+            return container.resolve_provider(dependency)
+        return container.resolve(dependency)
+
+    return _fixture
+
+
+def expose(
+    group: type[Group],
+    *,
+    container_fixture: str = "di_container",
+    pytest_scope: _PytestScope = "function",
+    module: types.ModuleType | None = None,
+) -> None:
+    """Register one pytest fixture per Provider in ``group``.
+
+    Each generated fixture is named after the class attribute it came from.
+
+    Args:
+        group: A ``Group`` subclass whose class attributes are Providers.
+        container_fixture: Name of the pytest fixture yielding the container.
+        pytest_scope: pytest fixture scope applied to every generated fixture.
+        module: Module to inject fixtures into. Defaults to the caller's module
+            (located via ``inspect.stack()``).
+
+    Example (in ``conftest.py``)::
+
+        from modern_di_pytest import expose
+        from app.ioc import Dependencies
+
+        expose(Dependencies)
+
+    Every ``Dependencies.<attr>`` that is a Provider becomes a pytest fixture
+    named ``<attr>``. Non-Provider class attributes are skipped.
+
+    """
+    if module is None:
+        frame = inspect.stack()[1].frame
+        module = inspect.getmodule(frame)
+    if module is None:
+        msg = "expose() could not determine the caller module; pass module=... explicitly."
+        raise RuntimeError(msg)
+
+    for attr_name, attr_value in vars(group).items():
+        if isinstance(attr_value, AbstractProvider):
+            fixture = modern_di_fixture(
+                attr_value,
+                container_fixture=container_fixture,
+                name=attr_name,
+                pytest_scope=pytest_scope,
+            )
+            setattr(module, attr_name, fixture)

modern_di_pytest-0.1.0/pyproject.toml

@@ -0,0 +1,77 @@
+[project]
+name = "modern-di-pytest"
+description = "Pytest integration for Modern-DI: turn DI dependencies into pytest fixtures"
+authors = [{ name = "Artur Shiriev", email = "me@shiriev.ru" }]
+requires-python = ">=3.10,<4"
+license = "MIT"
+readme = "README.md"
+keywords = ["DI", "dependency injector", "ioc-container", "pytest", "fixtures", "python"]
+classifiers = [
+    "Framework :: Pytest",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Typing :: Typed",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development :: Testing",
+]
+dependencies = ["modern-di>=2,<3", "pytest>=7"]
+version = "0.1.0"
+
+[project.urls]
+repository = "https://github.com/modern-python/modern-di-pytest"
+docs = "https://modern-di.readthedocs.io"
+
+[dependency-groups]
+dev = [
+    "pytest",
+    "pytest-cov",
+]
+lint = [
+    "ty",
+    "ruff",
+    "eof-fixer",
+    "typing-extensions",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build]
+include = ["modern_di_pytest"]
+
+[tool.ruff]
+fix = false
+unsafe-fixes = true
+line-length = 120
+target-version = "py310"
+
+[tool.ruff.format]
+docstring-code-format = true
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+    "D1",
+    "S101",
+    "TCH",
+    "FBT",
+    "D203",
+    "D213",
+    "COM812",
+    "ISC001",
+    "G004",
+]
+isort.lines-after-imports = 2
+isort.no-lines-before = ["standard-library", "local-folder"]
+
+[tool.pytest.ini_options]
+addopts = "--cov=. --cov-report term-missing"
+
+[tool.coverage.report]
+exclude_also = [
+    "if typing.TYPE_CHECKING:",
+]