Coverage for src/robot_dispatch/db/uow.py: 98%

47 statements  

« prev     ^ index     » next       coverage.py v7.17.2, created at 2026-11-07 17:18 +0000

1from __future__ import annotations 

2 

3from collections.abc import Callable 

4from typing import Any 

5 

6from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker 

7 

8from robot_dispatch.repositories.sql import ( 

9 SqlEventRepository, 

10 SqlOutboxRepository, 

11 SqlRobotRepository, 

12 SqlTaskRepository, 

13) 

14 

15 

16class SqlUnitOfWork: 

17 """One database transaction per unit of work. 

18 

19 The session is created on enter and closed on exit. `commit()` is explicit: 

20 leaving the block without a commit rolls the transaction back, exactly like a 

21 session that gets closed by the garbage collector in SQLAlchemy. 

22 """ 

23 

24 def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None: 

25 self._session_factory = session_factory 

26 self.session: AsyncSession | None = None 

27 self.tasks: SqlTaskRepository 

28 self.robots: SqlRobotRepository 

29 self.events: SqlEventRepository 

30 self.outbox: SqlOutboxRepository 

31 self._committed = False 

32 

33 async def __aenter__(self) -> SqlUnitOfWork: 

34 self.session = self._session_factory() 

35 self.tasks = SqlTaskRepository(self.session) 

36 self.robots = SqlRobotRepository(self.session) 

37 self.events = SqlEventRepository(self.session) 

38 self.outbox = SqlOutboxRepository(self.session) 

39 self._committed = False 

40 return self 

41 

42 async def __aexit__(self, exc_type: Any, exc: Any, tb: Any) -> None: 

43 if self.session is None: 

44 return 

45 try: 

46 if exc_type is not None or not self._committed: 

47 await self.session.rollback() 

48 finally: 

49 await self.session.close() 

50 self.session = None 

51 

52 async def commit(self) -> None: 

53 if self.session is None: 

54 raise RuntimeError("unit of work is not started") 

55 await self.session.commit() 

56 self._committed = True 

57 

58 async def rollback(self) -> None: 

59 if self.session is None: 

60 return 

61 await self.session.rollback() 

62 self._committed = False 

63 

64 async def flush(self) -> None: 

65 if self.session is not None: 

66 await self.session.flush() 

67 

68 

69def make_sql_uow_factory( 

70 session_factory: async_sessionmaker[AsyncSession], 

71) -> Callable[[], SqlUnitOfWork]: 

72 def factory() -> SqlUnitOfWork: 

73 return SqlUnitOfWork(session_factory) 

74 

75 return factory