simple-module-test 0.0.38__tar.gz → 0.0.40__tar.gz

{simple_module_test-0.0.38 → simple_module_test-0.0.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_test
-Version: 0.0.38
+Version: 0.0.40
 Summary: Shared pytest fixtures (app, client, db_session, authenticated_client) for writing simple_module module tests
 Project-URL: Homepage, https://github.com/antosubash/simple_module_python
 Project-URL: Repository, https://github.com/antosubash/simple_module_python
@@ -21,14 +21,14 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Testing
 Classifier: Typing :: Typed
 Requires-Python: >=3.12
-Requires-Dist: fastapi<0.157,>=0.140
-Requires-Dist: httpx>=0.27
-Requires-Dist: pytest-asyncio>=0.24
-Requires-Dist: pytest>=8.0
-Requires-Dist: simple-module-core==0.0.38
-Requires-Dist: simple-module-db==0.0.38
-Requires-Dist: simple-module-hosting==0.0.38
-Requires-Dist: sqlalchemy>=2.0
+Requires-Dist: fastapi<0.159,>=0.140
+Requires-Dist: httpx<0.29,>=0.27
+Requires-Dist: pytest-asyncio<2,>=0.24
+Requires-Dist: pytest<10,>=8.0
+Requires-Dist: simple-module-core==0.0.40
+Requires-Dist: simple-module-db==0.0.40
+Requires-Dist: simple-module-hosting==0.0.40
+Requires-Dist: sqlalchemy<3,>=2.0
 Description-Content-Type: text/markdown
 
 # simple_module_test

{simple_module_test-0.0.38 → simple_module_test-0.0.40}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_test"
-version = "0.0.38"
+version = "0.0.40"
 description = "Shared pytest fixtures (app, client, db_session, authenticated_client) for writing simple_module module tests"
 readme = "README.md"
 license = "MIT"
@@ -21,14 +21,14 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "fastapi>=0.140,<0.157",
-    "httpx>=0.27",
-    "pytest>=8.0",
-    "pytest-asyncio>=0.24",
-    "simple_module_core==0.0.38",
-    "simple_module_db==0.0.38",
-    "simple_module_hosting==0.0.38",
-    "sqlalchemy>=2.0",
+    "fastapi>=0.140,<0.159",
+    "httpx>=0.27,<0.29",
+    "pytest>=8.0,<10",
+    "pytest-asyncio>=0.24,<2",
+    "simple_module_core==0.0.40",
+    "simple_module_db==0.0.40",
+    "simple_module_hosting==0.0.40",
+    "sqlalchemy>=2.0,<3",
 ]
 
 [project.entry-points.pytest11]

{simple_module_test-0.0.38 → simple_module_test-0.0.40}/simple_module_test/_schema.py

@@ -29,9 +29,17 @@ def _ensure_models_imported() -> list:
     return list(all_module_bases)
 
 
-@lru_cache(maxsize=1)
+_heads_cache: tuple[str, ...] | None = None
+
+
 def _alembic_heads() -> tuple[str, ...]:
-    """Cached head revisions — cannot change within a pytest run.
+    """Head revisions — cannot change within a pytest run, once found.
+
+    Only a non-empty result is cached. ``resolve_head_revisions`` returns ``()``
+    when ``alembic.ini`` is not found, which is what happens under a test that
+    points ``SM_PROJECT_ROOT`` at a tmp dir; caching that would leave every
+    later test in the worker unstamped while its app, resolving the real ini,
+    demands the heads ("Database is N revision(s) behind").
 
     Plural: each module's first migration sets its own ``branch_labels``, so
     the history has one head per module and a real upgraded database carries
@@ -39,9 +47,15 @@ def _alembic_heads() -> tuple[str, ...]:
     looking un-applied, which now reads as a behind-head schema and puts every
     test app behind the setup gate.
     """
+    global _heads_cache
     from simple_module_hosting.migrations import resolve_head_revisions
 
-    return resolve_head_revisions()
+    if _heads_cache is None:
+        heads = resolve_head_revisions()
+        if not heads:
+            return heads
+        _heads_cache = heads
+    return _heads_cache
 
 
 async def _create_all_tables(engine) -> None:

{simple_module_test-0.0.38 → simple_module_test-0.0.40}/simple_module_test/fixtures.py

@@ -161,6 +161,9 @@ async def _seed_setup_admin(application) -> None:
 async def _build_app(settings: Settings, *, seed_admin: bool):
     from simple_module_hosting.app_builder import create_app
 
+    # Process-wide state is reset per test by the autouse fixture in
+    # ``process_state``, not here: a second app built inside one test must not
+    # reset the live first app's mail sender or lease backend.
     application = create_app(settings)
 
     await _create_all_tables(application.state.sm.db.engine)

{simple_module_test-0.0.38 → simple_module_test-0.0.40}/simple_module_test/mail.py

@@ -10,8 +10,7 @@ from __future__ import annotations
 from collections.abc import Iterator
 
 import pytest
-from simple_module_core import mail as core_mail
-from simple_module_core.mail import MailMessage
+from simple_module_core.mail import MailMessage, install_mail_sender
 
 
 class CapturedMail:
@@ -28,14 +27,6 @@ class CapturedMail:
         return [m for m in self.messages if m.to == address]
 
 
-@pytest.fixture(autouse=True)
-def _reset_process_mail_sender() -> Iterator[None]:
-    sender, resolver = core_mail._sender, core_mail._resolver
-    yield
-    core_mail.install_mail_sender(sender)
-    core_mail.install_mail_resolver(resolver)
-
-
 @pytest.fixture
 def captured_mail() -> Iterator[CapturedMail]:
     """Install a recording sender that claims to deliver; yields it.
@@ -45,5 +36,5 @@ def captured_mail() -> Iterator[CapturedMail]:
     reinstalls the real one; reinstall with ``install_mail_sender(captured)``.
     """
     captured = CapturedMail()
-    core_mail.install_mail_sender(captured)
+    install_mail_sender(captured)
     yield captured

{simple_module_test-0.0.38 → simple_module_test-0.0.40}/simple_module_test/plugin.py

@@ -33,7 +33,8 @@ from simple_module_test.fixtures import (  # noqa: F401
     settings,
     setup_pending_app,
 )
-from simple_module_test.mail import _reset_process_mail_sender, captured_mail  # noqa: F401
+from simple_module_test.mail import captured_mail  # noqa: F401
+from simple_module_test.process_state import _reset_process_state  # noqa: F401
 from simple_module_test.redis_server import redis_server  # noqa: F401
 from simple_module_test.tenant_client import tenant_client  # noqa: F401
 

simple_module_test-0.0.40/simple_module_test/process_state.py

@@ -0,0 +1,24 @@
+"""Reset process services between tests and apps built by the test plugin."""
+
+from collections.abc import Iterator
+
+import pytest
+from simple_module_core.leases import reset_lease_backend
+from simple_module_core.mail import reset_mail_sender
+from simple_module_hosting.sentry import reset_sentry
+
+
+def reset_process_state() -> None:
+    """Restore unconfigured services without retaining another app's resources."""
+    reset_mail_sender()
+    reset_lease_backend()
+    reset_sentry()
+
+
+@pytest.fixture(autouse=True)
+def _reset_process_state() -> Iterator[None]:
+    reset_process_state()
+    try:
+        yield
+    finally:
+        reset_process_state()

simple_module_test-0.0.40/tests/test_testing_process_state.py

@@ -0,0 +1,94 @@
+"""Process services are isolated between plugin-built apps and tests."""
+
+from unittest.mock import Mock
+
+from simple_module_core.leases import (
+    InProcessLeaseBackend,
+    configure_leases,
+    get_leases,
+    reset_lease_backend,
+)
+from simple_module_core.mail import (
+    ConsoleMailSender,
+    current_mail_sender,
+    install_mail_resolver,
+    install_mail_sender,
+    mail_transport_installed,
+    reset_mail_sender,
+    resolve_mail_sender,
+)
+from simple_module_hosting import sentry
+from simple_module_test.mail import CapturedMail
+from simple_module_test.process_state import reset_process_state
+
+
+async def test_reset_mail_clears_sender_and_worker_resolver() -> None:
+    sender = CapturedMail()
+
+    async def resolver(db):
+        return sender
+
+    install_mail_sender(sender)
+    install_mail_resolver(resolver)
+    reset_mail_sender()
+    assert not mail_transport_installed()
+    assert isinstance(current_mail_sender(), ConsoleMailSender)
+    assert isinstance(await resolve_mail_sender(object()), ConsoleMailSender)
+    assert current_mail_sender().include_body is False
+
+
+async def test_reset_leases_discards_configuration_and_held_names() -> None:
+    original = InProcessLeaseBackend()
+    configure_leases(original)
+    assert await original.acquire("held", "previous-app", 60) == 1
+    reset_lease_backend()
+    replacement = get_leases()
+    assert replacement is not original
+    assert isinstance(replacement, InProcessLeaseBackend)
+    assert await replacement.acquire("held", "next-app", 60) == 1
+
+
+def test_reset_sentry_closes_and_unbinds_client(monkeypatch) -> None:
+    import pytest
+
+    sdk = pytest.importorskip("sentry_sdk")
+    scope = Mock()
+    monkeypatch.setattr(sdk, "get_global_scope", lambda: scope)
+    monkeypatch.setattr(sentry, "_enabled", True)
+    sentry._request_scope.set({"type": "http"})
+    sentry.reset_sentry()
+    scope.client.close.assert_called_once_with()
+    scope.set_client.assert_called_once_with(None)
+    assert not sentry.is_enabled()
+    assert sentry._request_scope.get() is None
+    sentry.reset_sentry()
+    scope.client.close.assert_called_once_with()
+
+
+async def test_plugin_second_app_keeps_first_apps_services(settings, monkeypatch) -> None:
+    """Resets are per test (autouse fixture), so a second app in one test must not
+    wipe the first app's installed mail sender."""
+    from fastapi import FastAPI
+    from simple_module_hosting import app_builder
+    from simple_module_test import fixtures
+
+    def create_app(settings):
+        app = FastAPI()
+        app.state.sm = Mock()
+        return app
+
+    async def create_tables(engine):
+        pass
+
+    monkeypatch.setattr(app_builder, "create_app", create_app)
+    monkeypatch.setattr(fixtures, "_create_all_tables", create_tables)
+    install_mail_sender(CapturedMail())
+    async for _app in fixtures._build_app(settings, seed_admin=False):
+        assert mail_transport_installed()
+    reset_process_state()
+
+
+def test_autouse_reset_clears_state_left_by_a_previous_test() -> None:
+    # The autouse ``_reset_process_state`` fixture ran before this test.
+    assert not mail_transport_installed()
+    assert not sentry.is_enabled()