yaddd-sqlalchemy 0.1.0__tar.gz → 0.2.0__tar.gz

{yaddd_sqlalchemy-0.1.0 → yaddd_sqlalchemy-0.2.0}/.gitignore

@@ -140,10 +140,14 @@ venv.bak/
 # mkdocs documentation
 /site
 
+# ruff
+.ruff_cache/
+
 # mypy
 .mypy_cache/
-.dmypy.json
-dmypy.json
+
+# ty
+.ty/
 
 # Pyre type checker
 .pyre/

{yaddd_sqlalchemy-0.1.0 → yaddd_sqlalchemy-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: yaddd-sqlalchemy
-Version: 0.1.0
+Version: 0.2.0
 Summary: SQLAlchemy integration for yaddd: SqlCrudRepository, SqlUnitOfWork, VOTypeDecorator
 Project-URL: Homepage, https://github.com/netstuff/yaddd
 Author-email: Yuri Andreev <andreev.jr@gmail.com>
@@ -17,7 +17,7 @@ Classifier: Topic :: Internet
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.12
 Requires-Dist: sqlalchemy[asyncio]>=2.0
-Requires-Dist: yaddd>=0.1
+Requires-Dist: yaddd>=0.5
 Description-Content-Type: text/markdown
 
 # yaddd-sqlalchemy

{yaddd_sqlalchemy-0.1.0 → yaddd_sqlalchemy-0.2.0}/pyproject.toml

@@ -19,10 +19,10 @@ classifiers = [
 ]
 requires-python = '>=3.12'
 dependencies = [
-    "yaddd>=0.1",
+    "yaddd>=0.5",
     "sqlalchemy[asyncio]>=2.0",
 ]
-version = "0.1.0"
+version = "0.2.0"
 readme = 'README.md'
 
 [project.urls]

yaddd_sqlalchemy-0.2.0/src/yaddd_sqlalchemy/__init__.py

@@ -0,0 +1,16 @@
+"""SQLAlchemy integration for yaddd."""
+
+from yaddd_sqlalchemy.repositories import SqlCrudRepository, SqlTransactionBoundRepository
+from yaddd_sqlalchemy.session import SqlSession, SqlTransaction
+from yaddd_sqlalchemy.uow import SqlUnitOfWork
+from yaddd_sqlalchemy.value_objects import VOTypeDecorator
+
+
+__all__ = [
+    "SqlCrudRepository",
+    "SqlSession",
+    "SqlTransaction",
+    "SqlTransactionBoundRepository",
+    "SqlUnitOfWork",
+    "VOTypeDecorator",
+]

yaddd_sqlalchemy-0.2.0/src/yaddd_sqlalchemy/agents/manifest.toml

@@ -0,0 +1,20 @@
+schema = 1
+name = "yaddd-sqlalchemy"
+version = "0.2.0"
+
+[[relaxes]]
+rule = "IMPORTS_INFRASTRUCTURE"
+allow_add = ["sqlalchemy", "yaddd_sqlalchemy"]
+reason = "SqlCrudRepository, SqlUnitOfWork and VOTypeDecorator implement persistence ports."
+when = { dependency = "yaddd-sqlalchemy", specifier = ">=0.1" }
+
+[[restricts]]
+rule = "IMPORTS_APPLICATION"
+deny_add = ["sqlalchemy", "yaddd_sqlalchemy"]
+reason = "Application stays persistence-agnostic; only infrastructure may know SQLAlchemy."
+when = { dependency = "yaddd-sqlalchemy" }
+
+[rules.SQLALCHEMY_PERSISTENCE]
+layer = "infrastructure"
+kind = "guidance"
+doc = "rules/infrastructure.md"

yaddd_sqlalchemy-0.2.0/src/yaddd_sqlalchemy/agents/rules/infrastructure.md

@@ -0,0 +1,12 @@
+# SQLAlchemy persistence
+
+Additive to the base infrastructure rules. This pack relaxes exactly one import
+rule: infrastructure may use `sqlalchemy` and `yaddd_sqlalchemy`.
+
+- **Use `SqlCrudRepository`** for Core-based repositories and
+  `SqlUnitOfWork` for transaction boundaries. Do not commit inside a
+  repository.
+- **Use `VOTypeDecorator`** for columns that hold value objects, so values are
+  validated on the way in and on the way out.
+- **Keep SQLAlchemy out of `application`.** The pack also restricts that layer:
+  use cases depend on ports, not sessions or tables.

{yaddd_sqlalchemy-0.1.0 → yaddd_sqlalchemy-0.2.0}/src/yaddd_sqlalchemy/repositories.py

@@ -5,13 +5,16 @@ from typing import Any, ClassVar
 
 from sqlalchemy import Column, Table, delete, insert, select, update
 from sqlalchemy.engine import Row
+from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession
+
 from yaddd.domain.entities import AggregateRoot, PrimaryKey
 from yaddd.domain.repositories import CrudRepository
-from yaddd.exceptions import EntityNotFoundError
+from yaddd.exceptions import ConflictError, EntityNotFoundError
+from yaddd_sqlalchemy.session import SqlTransaction
 
 
-__all__ = ["SqlCrudRepository"]
+__all__ = ["SqlCrudRepository", "SqlTransactionBoundRepository"]
 
 
 class SqlCrudRepository[T: AggregateRoot](CrudRepository[T], ABC):
@@ -39,7 +42,11 @@ class SqlCrudRepository[T: AggregateRoot](CrudRepository[T], ABC):
     table: ClassVar[Table]
 
     def __init__(self, session: AsyncSession) -> None:
-        self._session = session
+        self._async_session = session
+
+    @property
+    def _session(self) -> AsyncSession:
+        return self._async_session
 
     @abstractmethod
     def to_domain(self, row: Row[Any]) -> T:
@@ -73,15 +80,51 @@ class SqlCrudRepository[T: AggregateRoot](CrudRepository[T], ABC):
         return [self.to_domain(row) for row in result.all()]
 
     async def create(self, instance: T) -> T:
-        await self._session.execute(insert(self.table).values(**self.to_row(instance)))
+        try:
+            await self._session.execute(insert(self.table).values(**self.to_row(instance)))
+        except IntegrityError as exc:
+            raise ConflictError(str(exc)) from exc
         return instance
 
     async def update(self, instance: T) -> T:
         if await self.get(instance.pk) is None:
             raise EntityNotFoundError(f"{type(instance).__name__}({instance.pk})")
         stmt = update(self.table).where(self._pk_column == instance.pk).values(**self.to_row(instance))
-        await self._session.execute(stmt)
+        try:
+            await self._session.execute(stmt)
+        except IntegrityError as exc:
+            raise ConflictError(str(exc)) from exc
         return instance
 
     async def delete(self, pk: PrimaryKey) -> None:
-        await self._session.execute(delete(self.table).where(self._pk_column == pk))
+        try:
+            await self._session.execute(delete(self.table).where(self._pk_column == pk))
+        except IntegrityError as exc:
+            raise ConflictError(str(exc)) from exc
+
+
+class SqlTransactionBoundRepository[T: AggregateRoot](SqlCrudRepository[T], ABC):
+    """SQLAlchemy repository bound to a ``SqlTransaction``.
+
+    The SQLAlchemy session is resolved lazily from the active transaction, so
+    the repository can be constructed before the transaction context is
+    entered. Created and updated aggregates are automatically tracked for
+    event publication on commit.
+    """
+
+    def __init__(self, transaction: SqlTransaction) -> None:
+        self._transaction = transaction
+
+    @property
+    def _session(self) -> AsyncSession:
+        return self._transaction.session.session
+
+    async def create(self, instance: T) -> T:
+        result = await super().create(instance)
+        self._transaction.track(instance)
+        return result
+
+    async def update(self, instance: T) -> T:
+        result = await super().update(instance)
+        self._transaction.track(instance)
+        return result

yaddd_sqlalchemy-0.2.0/src/yaddd_sqlalchemy/session.py

@@ -0,0 +1,54 @@
+"""SQLAlchemy implementation of the application ``Session`` protocol."""
+
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from yaddd.application.session import Session
+from yaddd.exceptions import ConflictError
+from yaddd.infrastructure.transaction import BaseTransaction
+
+
+__all__ = ["SqlSession", "SqlTransaction"]
+
+
+class SqlSession(Session):
+    """Transactional session over a SQLAlchemy ``AsyncSession``."""
+
+    def __init__(self, session_maker: async_sessionmaker[AsyncSession]) -> None:
+        self._session_maker = session_maker
+        self._session: AsyncSession | None = None
+
+    @property
+    def session(self) -> AsyncSession:
+        """The currently active SQLAlchemy session."""
+        if self._session is None:
+            raise RuntimeError("SQLAlchemy session is not active")
+        return self._session
+
+    async def begin(self) -> None:
+        """Open a new SQLAlchemy session."""
+        self._session = self._session_maker()
+        await self._session.__aenter__()
+
+    async def commit(self) -> None:
+        """Commit the current session, translating integrity failures."""
+        if self._session is not None:
+            try:
+                await self._session.commit()
+            except IntegrityError as exc:
+                raise ConflictError(str(exc)) from exc
+
+    async def rollback(self) -> None:
+        """Roll back the current session."""
+        if self._session is not None:
+            await self._session.rollback()
+
+    async def close(self) -> None:
+        """Close the current session."""
+        if self._session is not None:
+            await self._session.__aexit__(None, None, None)
+            self._session = None
+
+
+class SqlTransaction(BaseTransaction[SqlSession]):
+    """Transaction bound to a single SQLAlchemy session."""

yaddd_sqlalchemy-0.2.0/src/yaddd_sqlalchemy/uow.py

@@ -0,0 +1,56 @@
+"""``UnitOfWork`` implementation over a SQLAlchemy transaction."""
+
+from types import TracebackType
+from typing import Self, TypeVar
+
+from yaddd.application.uow import UnitOfWork
+from yaddd.domain.entities import AggregateRoot
+from yaddd_sqlalchemy.session import SqlTransaction
+
+
+R = TypeVar("R")
+
+__all__ = ["SqlUnitOfWork"]
+
+
+class SqlUnitOfWork[R](UnitOfWork[R]):
+    """Unit of work over a single SQLAlchemy transaction.
+
+    Repositories in ``repos`` share the underlying ``SqlTransaction``.
+    ``commit()`` persists the work and publishes domain events from tracked
+    aggregates. Exiting the context without ``commit()`` — or with an
+    exception — rolls back.
+    """
+
+    def __init__(self, transaction: SqlTransaction, repos: R) -> None:
+        self._transaction = transaction
+        self._repos = repos
+
+    @property
+    def repos(self) -> R:
+        """Repository bundle used within this unit of work."""
+        return self._repos
+
+    def track(self, aggregate: AggregateRoot) -> None:
+        """Register an aggregate whose events should be published on commit."""
+        self._transaction.track(aggregate)
+
+    async def __aenter__(self) -> Self:
+        await self._transaction.__aenter__()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        await self._transaction.__aexit__(exc_type, exc_value, traceback)
+
+    async def commit(self) -> None:
+        """Persist all tracked changes and publish domain events."""
+        await self._transaction.commit()
+
+    async def rollback(self) -> None:
+        """Discard all tracked changes."""
+        await self._transaction.rollback()

{yaddd_sqlalchemy-0.1.0 → yaddd_sqlalchemy-0.2.0}/src/yaddd_sqlalchemy/value_objects.py

@@ -4,6 +4,7 @@ from typing import Any, ClassVar
 
 from sqlalchemy.engine import Dialect
 from sqlalchemy.types import TypeDecorator
+
 from yaddd.domain.value_object import ValueObject
 
 

yaddd_sqlalchemy-0.2.0/tests/test_session.py

@@ -0,0 +1,32 @@
+import pytest
+from sqlalchemy.ext.asyncio import async_sessionmaker
+
+from yaddd_sqlalchemy import SqlSession
+
+
+async def test_sql_session_lifecycle(engine):
+    session_maker = async_sessionmaker(engine, expire_on_commit=False)
+    sql_session = SqlSession(session_maker)
+
+    with pytest.raises(RuntimeError):
+        _ = sql_session.session
+
+    await sql_session.begin()
+    assert sql_session.session is not None
+
+    await sql_session.commit()
+    await sql_session.close()
+
+    with pytest.raises(RuntimeError):
+        _ = sql_session.session
+
+
+async def test_sql_session_rollback(engine):
+    session_maker = async_sessionmaker(engine, expire_on_commit=False)
+    sql_session = SqlSession(session_maker)
+
+    await sql_session.begin()
+    await sql_session.rollback()
+    await sql_session.close()
+
+    assert sql_session._session is None

yaddd_sqlalchemy-0.2.0/tests/test_transaction_bound_repository.py

@@ -0,0 +1,84 @@
+from uuid import uuid4
+
+import pytest
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import async_sessionmaker
+
+from yaddd import DomainEvent, InMemoryEventPublisher
+from yaddd_sqlalchemy import SqlSession, SqlTransaction, SqlTransactionBoundRepository
+
+from conftest import Order, orders_table
+
+
+class OrderPlaced(DomainEvent):
+    order_id: str
+
+
+class TxOrderRepository(SqlTransactionBoundRepository[Order]):
+    table = orders_table
+
+    def to_domain(self, row) -> Order:
+        return Order(id=str(row.id), status=str(row.status), total=int(row.total))
+
+    def to_row(self, instance: Order) -> dict[str, object]:
+        return {"id": instance.pk, "status": instance.status, "total": instance.total}
+
+
+@pytest.fixture
+def session_maker(engine):
+    return async_sessionmaker(engine, expire_on_commit=False)
+
+
+async def test_create_tracks_aggregate_and_publishes_event(session_maker):
+    publisher = InMemoryEventPublisher()
+    events: list[DomainEvent] = []
+
+    async def collect(event: DomainEvent) -> None:
+        events.append(event)
+
+    publisher.subscribe(OrderPlaced, collect)
+
+    sql_session = SqlSession(session_maker)
+    tx = SqlTransaction(sql_session, publisher)
+    repo = TxOrderRepository(tx)
+
+    async with tx:
+        order = Order(id=uuid4().hex, status="new", total=42)
+        order.add_event(OrderPlaced(order_id=order.pk))
+        await repo.create(order)
+        await tx.commit()
+
+    assert len(events) == 1
+    assert isinstance(events[0], OrderPlaced)
+    assert events[0].order_id == order.pk
+
+    async with session_maker() as session:
+        row = (await session.execute(select(orders_table).where(orders_table.c.id == order.pk))).one()
+        assert row.total == 42
+
+
+async def test_rollback_does_not_publish_event(session_maker):
+    publisher = InMemoryEventPublisher()
+    events: list[DomainEvent] = []
+
+    async def collect(event: DomainEvent) -> None:
+        events.append(event)
+
+    publisher.subscribe(OrderPlaced, collect)
+
+    sql_session = SqlSession(session_maker)
+    tx = SqlTransaction(sql_session, publisher)
+    repo = TxOrderRepository(tx)
+
+    with pytest.raises(RuntimeError):
+        async with tx:
+            order = Order(id=uuid4().hex, status="new", total=10)
+            order.add_event(OrderPlaced(order_id=order.pk))
+            await repo.create(order)
+            raise RuntimeError("boom")
+
+    assert len(events) == 0
+
+    async with session_maker() as session:
+        row = (await session.execute(select(orders_table).where(orders_table.c.id == order.pk))).one_or_none()
+        assert row is None

yaddd_sqlalchemy-0.2.0/tests/test_uow.py

@@ -0,0 +1,139 @@
+from dataclasses import dataclass
+from uuid import uuid4
+
+import pytest
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncEngine, async_sessionmaker
+
+from yaddd import ConflictError, DomainEvent, InMemoryEventPublisher
+from yaddd_sqlalchemy import SqlSession, SqlTransaction, SqlTransactionBoundRepository, SqlUnitOfWork
+
+from conftest import Order, orders_table
+
+
+class TxOrderRepository(SqlTransactionBoundRepository[Order]):
+    table = orders_table
+
+    def to_domain(self, row) -> Order:
+        return Order(id=str(row.id), status=str(row.status), total=int(row.total))
+
+    def to_row(self, instance: Order) -> dict[str, object]:
+        return {"id": instance.pk, "status": instance.status, "total": instance.total}
+
+
+@dataclass
+class OrderRepos:
+    orders: TxOrderRepository
+
+
+class OrderPlaced(DomainEvent):
+    order_id: str
+
+
+def build_uow(engine: AsyncEngine) -> SqlUnitOfWork[OrderRepos]:
+    session_maker = async_sessionmaker(engine, expire_on_commit=False)
+    sql_session = SqlSession(session_maker)
+    publisher = InMemoryEventPublisher()
+    tx = SqlTransaction(sql_session, publisher)
+    repos = OrderRepos(orders=TxOrderRepository(tx))
+    return SqlUnitOfWork(tx, repos)
+
+
+async def test_uow_exposes_repositories(engine: AsyncEngine):
+    uow = build_uow(engine)
+    async with uow:
+        assert isinstance(uow.repos.orders, TxOrderRepository)
+
+
+async def test_commit_persists_changes(engine: AsyncEngine):
+    uow = build_uow(engine)
+    order_id = uuid4().hex
+
+    async with uow:
+        order = Order(id=order_id, status="new", total=10)
+        await uow.repos.orders.create(order)
+        await uow.commit()
+
+    async with async_sessionmaker(engine, expire_on_commit=False)() as verify:
+        result = await verify.execute(select(orders_table).where(orders_table.c.id == order_id))
+        assert result.first() is not None
+
+
+async def test_exit_without_commit_rolls_back(engine: AsyncEngine):
+    uow = build_uow(engine)
+    order_id = uuid4().hex
+
+    async with uow:
+        order = Order(id=order_id, status="new", total=10)
+        await uow.repos.orders.create(order)
+
+    async with async_sessionmaker(engine, expire_on_commit=False)() as verify:
+        result = await verify.execute(select(orders_table).where(orders_table.c.id == order_id))
+        assert result.first() is None
+
+
+async def test_exception_inside_context_rolls_back(engine: AsyncEngine):
+    uow = build_uow(engine)
+    order_id = uuid4().hex
+
+    with pytest.raises(RuntimeError, match="boom"):
+        async with uow:
+            order = Order(id=order_id, status="new", total=10)
+            await uow.repos.orders.create(order)
+            raise RuntimeError("boom")
+
+    async with async_sessionmaker(engine, expire_on_commit=False)() as verify:
+        result = await verify.execute(select(orders_table).where(orders_table.c.id == order_id))
+        assert result.first() is None
+
+
+async def test_rollback_discards_pending_changes(engine: AsyncEngine):
+    uow = build_uow(engine)
+    order_id = uuid4().hex
+
+    async with uow:
+        order = Order(id=order_id, status="new", total=10)
+        await uow.repos.orders.create(order)
+        await uow.rollback()
+
+    async with async_sessionmaker(engine, expire_on_commit=False)() as verify:
+        result = await verify.execute(select(orders_table).where(orders_table.c.id == order_id))
+        assert result.first() is None
+
+
+async def test_commit_publishes_tracked_events(engine: AsyncEngine):
+    publisher = InMemoryEventPublisher()
+    events: list[DomainEvent] = []
+
+    async def collect(event: DomainEvent) -> None:
+        events.append(event)
+
+    publisher.subscribe(OrderPlaced, collect)
+
+    session_maker = async_sessionmaker(engine, expire_on_commit=False)
+    sql_session = SqlSession(session_maker)
+    tx = SqlTransaction(sql_session, publisher)
+    repos = OrderRepos(orders=TxOrderRepository(tx))
+    uow = SqlUnitOfWork(tx, repos)
+
+    async with uow:
+        order = Order(id=uuid4().hex, status="new", total=10)
+        order.add_event(OrderPlaced(order_id=order.pk))
+        await uow.repos.orders.create(order)
+        await uow.commit()
+
+    assert len(events) == 1
+    assert isinstance(events[0], OrderPlaced)
+
+
+async def test_duplicate_commit_raises_conflict(engine: AsyncEngine):
+    order_id = uuid4().hex
+
+    async with build_uow(engine) as uow:
+        await uow.repos.orders.create(Order(id=order_id, status="new", total=10))
+        await uow.commit()
+
+    with pytest.raises(ConflictError):
+        async with build_uow(engine) as uow:
+            await uow.repos.orders.create(Order(id=order_id, status="new", total=10))
+            await uow.commit()

yaddd_sqlalchemy-0.1.0/src/yaddd_sqlalchemy/__init__.py

@@ -1,8 +0,0 @@
-"""SQLAlchemy integration for yaddd."""
-
-from yaddd_sqlalchemy.repositories import SqlCrudRepository
-from yaddd_sqlalchemy.uow import SqlUnitOfWork
-from yaddd_sqlalchemy.value_objects import VOTypeDecorator
-
-
-__all__ = ["SqlCrudRepository", "SqlUnitOfWork", "VOTypeDecorator"]

yaddd_sqlalchemy-0.1.0/src/yaddd_sqlalchemy/uow.py

@@ -1,47 +0,0 @@
-"""``UnitOfWork`` implementation over a SQLAlchemy ``AsyncSession``."""
-
-from types import TracebackType
-from typing import Self
-
-from sqlalchemy.ext.asyncio import AsyncSession
-from yaddd.application.uow import UnitOfWork
-
-
-__all__ = ["SqlUnitOfWork"]
-
-
-class SqlUnitOfWork(UnitOfWork):
-    """Transactional boundary over a single ``AsyncSession``.
-
-    ``commit()`` flushes and commits the session. Leaving the context without
-    a commit — or with an exception — rolls back; the session is always
-    closed on exit.
-    """
-
-    def __init__(self, session: AsyncSession) -> None:
-        self._session = session
-        self._committed = False
-
-    async def __aenter__(self) -> Self:
-        return self
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_value: BaseException | None,
-        traceback: TracebackType | None,
-    ) -> None:
-        try:
-            if exc_type is not None or not self._committed:
-                await self.rollback()
-        finally:
-            await self._session.close()
-
-    async def commit(self) -> None:
-        """Persist all changes made within the unit of work."""
-        await self._session.commit()
-        self._committed = True
-
-    async def rollback(self) -> None:
-        """Discard all changes made within the unit of work."""
-        await self._session.rollback()

yaddd_sqlalchemy-0.1.0/tests/test_uow.py

@@ -1,65 +0,0 @@
-from collections.abc import Awaitable, Callable
-
-import pytest
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
-
-from yaddd.application.uow import UnitOfWork
-from yaddd.testing import UnitOfWorkContract
-from yaddd_sqlalchemy import SqlUnitOfWork
-
-from conftest import Order, OrderRepository, orders_table
-
-
-class TestSqlUnitOfWork(UnitOfWorkContract):
-    @pytest.fixture
-    def uow(self, session: AsyncSession) -> UnitOfWork:
-        return SqlUnitOfWork(session)
-
-    @pytest.fixture
-    def assert_rolled_back(self, session: AsyncSession) -> Callable[[], Awaitable[None]]:
-        async def check() -> None:
-            assert not session.in_transaction()
-            assert not session.new and not session.dirty
-
-        return check
-
-
-async def test_commit_persists_changes(engine: AsyncEngine, session: AsyncSession):
-    async with SqlUnitOfWork(session) as uow:
-        await OrderRepository(session).create(Order(id="order-1", status="new", total=10))
-        await uow.commit()
-
-    async with AsyncSession(engine) as verify:
-        result = await verify.execute(select(orders_table).where(orders_table.c.id == "order-1"))
-        assert result.first() is not None
-
-
-async def test_exception_inside_context_rolls_back(engine: AsyncEngine, session: AsyncSession):
-    with pytest.raises(RuntimeError, match="boom"):
-        async with SqlUnitOfWork(session):
-            await OrderRepository(session).create(Order(id="order-2", status="new", total=10))
-            raise RuntimeError("boom")
-
-    async with AsyncSession(engine) as verify:
-        result = await verify.execute(select(orders_table).where(orders_table.c.id == "order-2"))
-        assert result.first() is None
-
-
-async def test_exit_without_commit_rolls_back(engine: AsyncEngine, session: AsyncSession):
-    async with SqlUnitOfWork(session):
-        await OrderRepository(session).create(Order(id="order-3", status="new", total=10))
-
-    async with AsyncSession(engine) as verify:
-        result = await verify.execute(select(orders_table).where(orders_table.c.id == "order-3"))
-        assert result.first() is None
-
-
-async def test_rollback_discards_pending_changes(engine: AsyncEngine, session: AsyncSession):
-    async with SqlUnitOfWork(session) as uow:
-        await OrderRepository(session).create(Order(id="order-4", status="new", total=10))
-        await uow.rollback()
-
-    async with AsyncSession(engine) as verify:
-        result = await verify.execute(select(orders_table).where(orders_table.c.id == "order-4"))
-        assert result.first() is None