python-neva 0.2.1__tar.gz → 0.3.0__tar.gz

{python_neva-0.2.1 → python_neva-0.3.0}/PKG-INFO

@@ -1,12 +1,14 @@
 Metadata-Version: 2.4
 Name: python-neva
-Version: 0.2.1
+Version: 0.3.0
 Summary: Add your description here
 Requires-Python: >=3.12
 Requires-Dist: dependency-injector>=4.48.3
 Requires-Dist: dishka>=1.7.2
 Requires-Dist: fastapi-cli>=0.0.16
 Requires-Dist: fastapi[all]>=0.124.0
+Requires-Dist: flexmock>=0.13.0
 Requires-Dist: pyinstrument>=5.1.1
+Requires-Dist: pytest>=9.0.2
 Requires-Dist: structlog>=25.5.0
 Requires-Dist: tortoise-orm[accel]>=0.25.3

{python_neva-0.2.1 → python_neva-0.3.0}/neva/arch/app.py

@@ -13,7 +13,6 @@ from typing import Any, Callable
 import fastapi
 import dishka
 from dishka.integrations.fastapi import setup_dishka
-from starlette.middleware import Middleware
 from starlette.routing import BaseRoute
 from starlette.types import StatefulLifespan, StatelessLifespan
 
@@ -29,7 +28,7 @@ class App(fastapi.FastAPI):
         self,
         *,
         routes: list[BaseRoute] | None = None,
-        middlewares: Sequence[Middleware] | None = None,
+        middlewares: Sequence[type] | None = None,
         lifespan: StatelessLifespan["App"] | StatefulLifespan["App"] | None = None,
         config_path: str | Path | None = None,
     ) -> None:
@@ -59,8 +58,9 @@ class App(fastapi.FastAPI):
             docs_url=config.get("app.docs_url", default="/docs").unwrap(),
             redoc_url=config.get("app.redoc_url", default="/redoc").unwrap(),
             lifespan=self._create_lifespan(),
-            middleware=middlewares,
         )
+        for middleware in middlewares or []:
+            self.add_middleware(middleware)
 
         setup_dishka(self.application.container, app=self)
 

python_neva-0.3.0/neva/testing/__init__.py

@@ -0,0 +1,5 @@
+"""Testing utilities for Neva applications."""
+
+from neva.testing.test_case import TestCase
+
+__all__ = ["TestCase"]

python_neva-0.3.0/neva/testing/fixtures.py

@@ -0,0 +1,41 @@
+"""Fixtures for testing."""
+
+from collections.abc import AsyncIterator
+from pathlib import Path
+import pytest
+
+from neva.arch import Application, App
+
+
+@pytest.fixture
+def test_config(tmp_path: Path) -> Path:
+    """Returns a test config directory."""
+    config_dir = tmp_path / "config"
+    config_dir.mkdir()
+    _ = (config_dir / "app.py").write_text(
+        """config = { "name": "TestApp", "debug": True, "environment": "testing"}"""
+    )
+    _ = (config_dir / "providers.py").write_text("""config = { "providers": []}""")
+    return config_dir
+
+
+@pytest.fixture
+async def application(test_config: Path) -> AsyncIterator[Application]:
+    """Pytest fixture for app lifecycle.
+
+    Yields:
+        AsyncIterator[Application]: The application instance.
+    """
+    app = Application(config_path=test_config)
+    async with app.lifespan():
+        yield app
+
+
+@pytest.fixture
+def webapp(test_config: Path) -> App:
+    """Pytest fixture for the HTTP Neva app.
+
+    Returns:
+        App: The Neva application instance.
+    """
+    return App(config_path=test_config)

python_neva-0.3.0/neva/testing/http.py

@@ -0,0 +1,21 @@
+"""HTTP Test helpers."""
+
+from collections.abc import AsyncIterator
+from httpx import ASGITransport, AsyncClient
+import pytest
+
+from neva.arch import App
+
+
+@pytest.fixture
+async def http_client(webapp: App) -> AsyncIterator[AsyncClient]:
+    """An async httpx client to test the application.
+
+    Yields:
+        An async httpx client.
+    """
+    async with AsyncClient(
+        transport=ASGITransport(webapp),
+        base_url="http://localhost:8000",
+    ) as client:
+        yield client

python_neva-0.3.0/neva/testing/test_case.py

@@ -0,0 +1,20 @@
+"""Base test case class."""
+
+from typing import TypeVar
+
+import pytest
+
+from neva.arch import Application
+
+T = TypeVar("T")
+
+
+class TestCase:
+    """Base test case with auto-injected app and helper methods."""
+
+    app: Application
+
+    @pytest.fixture(autouse=True)
+    def _inject_app(self, application: Application) -> None:
+        """Auto-inject app fixture into self.app."""
+        self.app = application

{python_neva-0.2.1 → python_neva-0.3.0}/pyproject.toml

@@ -7,7 +7,7 @@ packages = ["neva"]
 
 [project]
 name = "python-neva"
-version = "0.2.1"
+version = "0.3.0"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -16,7 +16,9 @@ dependencies = [
   "dishka>=1.7.2",
   "fastapi-cli>=0.0.16",
   "fastapi[all]>=0.124.0",
+  "flexmock>=0.13.0",
   "pyinstrument>=5.1.1",
+  "pytest>=9.0.2",
   "structlog>=25.5.0",
   "tortoise-orm[accel]>=0.25.3",
 ]
@@ -27,7 +29,6 @@ dev = [
   "poethepoet>=0.38.0",
   "polyfactory>=3.1.0",
   "pre-commit>=4.5.0",
-  "pytest>=9.0.2",
   "pytest-asyncio>=0.25.3",
   "pytest-benchmark>=5.2.3",
   "pytest-cov>=7.0.0",
@@ -41,6 +42,12 @@ asyncio_default_fixture_loop_scope = "function"
 testpaths = ["tests"]
 
 [tool.poe.tasks]
+# Code quality
 lint = "ruff check"
 fmt = "ruff format"
 tc = "ty check"
+
+# Tests
+test = "pytest"
+test-cov = "pytest --cov=neva --cov-report=term-missing"
+test-full = "test-cov tests/"

{python_neva-0.2.1 → python_neva-0.3.0}/ruff.toml

@@ -23,6 +23,9 @@ select = [
 preview = true
 ignore = ["D203", "D213", "RUF029"]
 
+[lint.per-file-ignores]
+"tests/*" = ["D", "S101"]
+
 [lint.isort]
 force-single-line = false
 lines-after-imports = 2

python_neva-0.3.0/specifications/future_ideas.md

@@ -0,0 +1,5 @@
+# Future ideas
+
+## Testing
+
+Provide scoped fixtures for testing in addition to the one we have.

python_neva-0.3.0/tests/__init__.py

@@ -0,0 +1 @@
+"""Neva test suite."""

python_neva-0.3.0/tests/conftest.py

@@ -0,0 +1,5 @@
+"""Test configuration and fixtures."""
+
+# Import fixtures from neva.testing
+# This makes them available to all tests
+pytest_plugins = ["neva.testing.fixtures"]

python_neva-0.3.0/tests/test_example_usage.py

@@ -0,0 +1,188 @@
+from pathlib import Path
+
+import pytest
+
+from neva.arch import Application
+from neva.config import ConfigRepository
+
+
+class TestBasicUsage:
+    @pytest.mark.asyncio
+    async def test_simple_config_access(
+        self,
+        application: Application,
+    ) -> None:
+        config = application.make(ConfigRepository).unwrap()
+
+        app_name = config.get("app.name").unwrap()
+        assert app_name == "TestApp"
+
+        is_debug = config.get("app.debug").unwrap()
+        assert is_debug is True
+
+    @pytest.mark.asyncio
+    async def test_config_with_default(
+        self,
+        application: Application,
+    ) -> None:
+        config = application.make(ConfigRepository).unwrap()
+
+        missing = config.get("app.missing_key", "default_value").unwrap()
+        assert missing == "default_value"
+
+    @pytest.mark.asyncio
+    async def test_multiple_config_keys(
+        self,
+        application: Application,
+    ) -> None:
+        config = application.make(ConfigRepository).unwrap()
+
+        assert config.get("app.name").unwrap() == "TestApp"
+        assert config.get("app.debug").unwrap() is True
+        assert config.get("app.environment").unwrap() == "testing"
+
+
+class TestCustomConfig:
+    @pytest.fixture
+    def test_config(
+        self,
+        tmp_path: Path,
+    ) -> Path:
+        config_dir = tmp_path / "config"
+        config_dir.mkdir()
+
+        _ = (config_dir / "app.py").write_text(
+            """
+config = {
+    "name": "CustomApp",
+    "debug": False,
+    "environment": "custom",
+    "custom_feature": True,
+}
+"""
+        )
+
+        _ = (config_dir / "providers.py").write_text("""config = {"providers": []}""")
+
+        return config_dir
+
+    @pytest.mark.asyncio
+    async def test_uses_custom_config(
+        self,
+        application: Application,
+    ) -> None:
+        config = application.make(ConfigRepository).unwrap()
+
+        assert config.get("app.name").unwrap() == "CustomApp"
+        assert config.get("app.debug").unwrap() is False
+        assert config.get("app.environment").unwrap() == "custom"
+        assert config.get("app.custom_feature").unwrap() is True
+
+
+class TestConfigManipulation:
+    @pytest.mark.asyncio
+    async def test_add_database_config(
+        self,
+        test_config: Path,
+    ) -> None:
+        _ = (test_config / "database.py").write_text(
+            """
+config = {
+    "default": "sqlite",
+    "connections": {
+        "sqlite": {
+            "driver": "sqlite",
+            "database": ":memory:",
+        }
+    }
+}
+"""
+        )
+
+        app = Application(config_path=test_config)
+
+        async with app.lifespan():
+            config = app.make(ConfigRepository).unwrap()
+
+            # Verify database config is loaded
+            assert config.get("database.default").unwrap() == "sqlite"
+            assert config.get("database.connections.sqlite.driver").unwrap() == "sqlite"
+            assert (
+                config.get("database.connections.sqlite.database").unwrap()
+                == ":memory:"
+            )
+
+    @pytest.mark.asyncio
+    async def test_add_multiple_config_files(
+        self,
+        test_config: Path,
+    ) -> None:
+        _ = (test_config / "cache.py").write_text(
+            """config = {"driver": "memory", "ttl": 3600}"""
+        )
+
+        _ = (test_config / "logging.py").write_text(
+            """config = {"level": "DEBUG", "format": "json"}"""
+        )
+
+        app = Application(config_path=test_config)
+
+        async with app.lifespan():
+            config = app.make(ConfigRepository).unwrap()
+
+            # Verify both configs are loaded
+            assert config.get("cache.driver").unwrap() == "memory"
+            assert config.get("cache.ttl").unwrap() == 3600
+            assert config.get("logging.level").unwrap() == "DEBUG"
+            assert config.get("logging.format").unwrap() == "json"
+
+
+class TestAppLifecycle:
+    @pytest.mark.asyncio
+    async def test_manual_app_creation(
+        self,
+        test_config: Path,
+    ) -> None:
+        app = Application(config_path=test_config)
+
+        async with app.lifespan():
+            config = app.make(ConfigRepository).unwrap()
+            assert config.get("app.name").unwrap() == "TestApp"
+
+    @pytest.mark.asyncio
+    async def test_multiple_apps_in_one_test(
+        self,
+        test_config: Path,
+    ) -> None:
+        app1 = Application(config_path=test_config)
+        async with app1.lifespan():
+            config1 = app1.make(ConfigRepository).unwrap()
+            assert config1.get("app.name").unwrap() == "TestApp"
+
+        app2 = Application(config_path=test_config)
+        async with app2.lifespan():
+            config2 = app2.make(ConfigRepository).unwrap()
+            assert config2.get("app.name").unwrap() == "TestApp"
+
+        assert app1 is not app2
+
+
+class TestIsolation:
+    @pytest.mark.asyncio
+    async def test_isolation_test_one(
+        self,
+        application: Application,
+    ) -> None:
+        config = application.make(ConfigRepository).unwrap()
+
+        original_name = config.get("app.name").unwrap()
+        assert original_name == "TestApp"
+
+    @pytest.mark.asyncio
+    async def test_isolation_test_two(
+        self,
+        application: Application,
+    ) -> None:
+        config = application.make(ConfigRepository).unwrap()
+
+        assert config.get("app.name").unwrap() == "TestApp"

python_neva-0.3.0/tests/test_fixtures.py

@@ -0,0 +1,135 @@
+"""Test the testing fixtures themselves."""
+
+from pathlib import Path
+
+import pytest
+
+from neva.arch import Application
+from neva.config import ConfigRepository
+
+
+class TestTestConfig:
+    """Test the test_config fixture."""
+
+    def test_creates_config_directory(
+        self,
+        test_config: Path,
+    ) -> None:
+        """Test that test_config creates a config directory."""
+        assert test_config.exists()
+        assert test_config.is_dir()
+        assert test_config.name == "config"
+
+    def test_creates_app_config_file(
+        self,
+        test_config: Path,
+    ) -> None:
+        """Test that app.py config file is created."""
+        app_config = test_config / "app.py"
+        assert app_config.exists()
+        assert app_config.is_file()
+
+        content = app_config.read_text()
+        assert "TestApp" in content
+        assert "debug" in content
+        assert "testing" in content
+
+    def test_creates_providers_config_file(
+        self,
+        test_config: Path,
+    ) -> None:
+        """Test that providers.py config file is created."""
+        providers_config = test_config / "providers.py"
+        assert providers_config.exists()
+        assert providers_config.is_file()
+
+        content = providers_config.read_text()
+        assert "providers" in content
+
+
+class TestAppFixture:
+    @pytest.mark.asyncio
+    async def test_app_is_application_instance(
+        self,
+        application: Application,
+    ) -> None:
+        assert isinstance(application, Application)
+
+    @pytest.mark.asyncio
+    async def test_app_config_is_loaded(
+        self,
+        application: Application,
+    ) -> None:
+        config_result = application.make(ConfigRepository)
+        assert config_result.is_ok
+
+        config = config_result.unwrap()
+        assert config is not None
+
+        assert config.get("app.name").unwrap() == "TestApp"
+        assert config.get("app.debug").unwrap() is True
+        assert config.get("app.environment").unwrap() == "testing"
+
+    @pytest.mark.asyncio
+    async def test_app_is_fresh_per_test_first(
+        self,
+        application: Application,
+    ) -> None:
+        type(application).__test_marker = "first_test"
+        assert type(application).__test_marker == "first_test"
+
+    @pytest.mark.asyncio
+    async def test_app_is_fresh_per_test_second(
+        self,
+        application: Application,
+    ) -> None:
+        assert not hasattr(type(application), "__test_marker")
+
+    @pytest.mark.asyncio
+    async def test_app_can_resolve_services(
+        self,
+        application: Application,
+    ) -> None:
+        config_result = application.make(ConfigRepository)
+        assert config_result.is_ok
+
+        config = config_result.unwrap()
+        assert config is not None
+        assert isinstance(config, ConfigRepository)
+
+    @pytest.mark.asyncio
+    async def test_multiple_resolutions_return_same_instance(
+        self,
+        application: Application,
+    ) -> None:
+        config1 = application.make(ConfigRepository).unwrap()
+        config2 = application.make(ConfigRepository).unwrap()
+
+        assert config1 is config2
+
+
+class TestFixtureIntegration:
+    @pytest.mark.asyncio
+    async def test_test_config_and_app_work_together(
+        self,
+        test_config: Path,
+        application: Application,
+    ) -> None:
+        config = application.make(ConfigRepository).unwrap()
+
+        assert config.get("app.name").unwrap() == "TestApp"
+
+        app_config_file = test_config / "app.py"
+        assert app_config_file.exists()
+
+    @pytest.mark.asyncio
+    async def test_can_customize_config_in_test(self, test_config: Path) -> None:
+        _ = (test_config / "custom.py").write_text(
+            """config = {"custom_key": "custom_value"}"""
+        )
+
+        app = Application(config_path=test_config)
+
+        async with app.lifespan():
+            config = app.make(ConfigRepository).unwrap()
+            assert config.get("custom.custom_key").unwrap() == "custom_value"

python_neva-0.3.0/tests/test_test_case.py

@@ -0,0 +1,110 @@
+"""Test the TestCase base class."""
+
+from pathlib import Path
+import pytest
+
+from neva import UnwrapError
+from neva.arch import Application
+from neva.config import ConfigRepository
+from neva.testing import TestCase
+
+
+class TestTestCase(TestCase):
+    @pytest.mark.asyncio
+    async def test_app_is_injected(self) -> None:
+        assert hasattr(self, "app")
+        assert isinstance(self.app, Application)
+
+    @pytest.mark.asyncio
+    async def test_make_resolves_services(self) -> None:
+        config = self.app.make(ConfigRepository).unwrap()
+
+        assert config is not None
+        assert isinstance(config, ConfigRepository)
+
+    @pytest.mark.asyncio
+    async def test_make_unwraps_result(self) -> None:
+        config = self.app.make(ConfigRepository).unwrap()
+
+        name = config.get("app.name").unwrap()
+        assert name == "TestApp"
+
+    @pytest.mark.asyncio
+    async def test_make_raises_on_error(self) -> None:
+        class NonExistentService:
+            pass
+
+        with pytest.raises(UnwrapError):
+            _ = self.app.make(NonExistentService).unwrap()
+
+    @pytest.mark.asyncio
+    async def test_app_isolation_between_tests_first(self) -> None:
+        self.app.__test_marker = "first"  # type: ignore
+        assert self.app.__test_marker == "first"  # type: ignore
+
+    @pytest.mark.asyncio
+    async def test_app_isolation_between_tests_second(self) -> None:
+        assert not hasattr(self.app, "__test_marker")
+
+
+class TestTestCaseWithCustomConfig(TestCase):
+    @pytest.fixture
+    def test_config(self, tmp_path: Path) -> Path:
+        config_dir = tmp_path / "config"
+        config_dir.mkdir()
+
+        _ = (config_dir / "app.py").write_text(
+            """
+config = {
+    "name": "CustomTestApp",
+    "custom_feature": True,
+}
+"""
+        )
+
+        _ = (config_dir / "providers.py").write_text('config = {"providers": []}')
+
+        return config_dir
+
+    @pytest.mark.asyncio
+    async def test_uses_custom_config(self) -> None:
+        config = self.app.make(ConfigRepository).unwrap()
+
+        assert config.get("app.name").unwrap() == "CustomTestApp"
+        assert config.get("app.custom_feature").unwrap() is True
+
+
+class TestTestCaseInheritance:
+    class CustomTestCase(TestCase):
+        def get_app_name(self) -> str:
+            config = self.app.make(ConfigRepository).unwrap()
+            return config.get("app.name").unwrap()
+
+        def is_debug_mode(self) -> bool:
+            config = self.app.make(ConfigRepository).unwrap()
+            return config.get("app.debug").unwrap()
+
+    @pytest.mark.asyncio
+    async def test_custom_helpers_work(self) -> None:
+        test_case = self.CustomTestCase()
+
+        from neva.arch import Application
+        from pathlib import Path
+        from tempfile import TemporaryDirectory
+
+        with TemporaryDirectory() as tmp:
+            config_dir = Path(tmp) / "config"
+            config_dir.mkdir()
+            _ = (config_dir / "app.py").write_text(
+                """config = {"name": "TestApp", "debug":"""
+                + """ True, "environment": "testing"}"""
+            )
+            _ = (config_dir / "providers.py").write_text('config = {"providers": []}')
+
+            app = Application(config_path=config_dir)
+            async with app.lifespan():
+                test_case.app = app
+
+                # Use custom helpers
+                assert test_case.get_app_name() == "TestApp"
+                assert test_case.is_debug_mode() is True