Coverage for src/robot_dispatch/repositories/memory.py: 97%
135 statements
« prev ^ index » next coverage.py v7.17.2, created at 2026-11-07 17:18 +0000
« prev ^ index » next coverage.py v7.17.2, created at 2026-11-07 17:18 +0000
1from __future__ import annotations
3import copy
4import uuid
5from datetime import datetime, timedelta
7from robot_dispatch.db.models import OutboxMessage, Robot, Task, TaskEvent
8from robot_dispatch.domain.enums import QUEUED_TASK_STATUSES, RobotStatus
11class Snapshot:
12 __slots__ = ("tasks", "robots", "events", "outbox")
14 def __init__(self, tasks: dict, robots: dict, events: list, outbox: list) -> None:
15 self.tasks = tasks
16 self.robots = robots
17 self.events = events
18 self.outbox = outbox
21class InMemoryStore:
22 """Process-local stand-in for PostgreSQL, used by unit tests."""
24 def __init__(self) -> None:
25 self.tasks: dict[uuid.UUID, Task] = {}
26 self.robots: dict[uuid.UUID, Robot] = {}
27 self.events: list[TaskEvent] = []
28 self.outbox: list[OutboxMessage] = []
30 def snapshot(self) -> Snapshot:
31 return Snapshot(
32 tasks=copy.deepcopy(self.tasks),
33 robots=copy.deepcopy(self.robots),
34 events=copy.deepcopy(self.events),
35 outbox=copy.deepcopy(self.outbox),
36 )
38 def restore(self, snapshot: Snapshot) -> None:
39 self.tasks = snapshot.tasks
40 self.robots = snapshot.robots
41 self.events = snapshot.events
42 self.outbox = snapshot.outbox
45class InMemoryTaskRepository:
46 def __init__(self, store: InMemoryStore) -> None:
47 self._store = store
49 async def add(self, task: Task) -> Task:
50 self._store.tasks[task.id] = task
51 return task
53 async def get(self, task_id: uuid.UUID) -> Task | None:
54 return self._store.tasks.get(task_id)
56 async def get_by_external_id(self, external_id: str) -> Task | None:
57 for task in self._store.tasks.values():
58 if task.external_id == external_id:
59 return task
60 return None
62 async def lock_ready(self, *, now: datetime, limit: int) -> list[Task]:
63 queued = [
64 task
65 for task in self._store.tasks.values()
66 if task.status in {status.value for status in QUEUED_TASK_STATUSES}
67 and task.available_at <= now
68 ]
69 queued.sort(key=lambda task: (-task.priority, task.available_at, task.created_at))
70 return queued[:limit]
72 async def lock_expired_leases(self, *, now: datetime, limit: int) -> list[Task]:
73 expired = [
74 task
75 for task in self._store.tasks.values()
76 if task.status in {"pending", "retrying", "assigned", "running"}
77 and task.lease_expires_at is not None
78 and task.lease_expires_at < now
79 ]
80 expired.sort(key=lambda task: task.lease_expires_at or task.created_at)
81 return expired[:limit]
83 async def list(
84 self,
85 *,
86 statuses: list[str] | None = None,
87 robot_id: uuid.UUID | None = None,
88 task_type: str | None = None,
89 limit: int = 50,
90 offset: int = 0,
91 ) -> list[Task]:
92 items = list(self._store.tasks.values())
93 if statuses:
94 items = [task for task in items if task.status in statuses]
95 if robot_id is not None:
96 items = [task for task in items if task.robot_id == robot_id]
97 if task_type is not None:
98 items = [task for task in items if task.type == task_type]
99 items.sort(key=lambda task: task.created_at, reverse=True)
100 return items[offset : offset + limit]
102 async def count_by_status(self) -> dict[str, int]:
103 counts: dict[str, int] = {}
104 for task in self._store.tasks.values():
105 counts[task.status] = counts.get(task.status, 0) + 1
106 return counts
109class InMemoryRobotRepository:
110 def __init__(self, store: InMemoryStore) -> None:
111 self._store = store
113 async def add(self, robot: Robot) -> Robot:
114 self._store.robots[robot.id] = robot
115 return robot
117 async def get(self, robot_id: uuid.UUID) -> Robot | None:
118 return self._store.robots.get(robot_id)
120 async def get_by_name(self, name: str) -> Robot | None:
121 for robot in self._store.robots.values():
122 if robot.name == name:
123 return robot
124 return None
126 async def list(self) -> list[Robot]:
127 return sorted(self._store.robots.values(), key=lambda robot: robot.name)
129 async def find_idle_for(
130 self, *, task_type: str, now: datetime, offline_after: int
131 ) -> Robot | None:
132 threshold = now - timedelta(seconds=offline_after)
133 candidates = [
134 robot
135 for robot in self._store.robots.values()
136 if robot.status == RobotStatus.IDLE.value
137 and robot.last_seen_at is not None
138 and robot.last_seen_at >= threshold
139 and robot.supports(task_type)
140 ]
141 candidates.sort(key=lambda robot: robot.last_seen_at or robot.created_at, reverse=True)
142 return candidates[0] if candidates else None
145class InMemoryEventRepository:
146 def __init__(self, store: InMemoryStore) -> None:
147 self._store = store
149 async def add(self, event: TaskEvent) -> TaskEvent:
150 self._store.events.append(event)
151 return event
153 async def list_for_task(self, task_id: uuid.UUID, *, limit: int = 200) -> list[TaskEvent]:
154 items = [event for event in self._store.events if event.task_id == task_id]
155 items.sort(key=lambda event: event.created_at)
156 return items[:limit]
159class InMemoryOutboxRepository:
160 def __init__(self, store: InMemoryStore) -> None:
161 self._store = store
163 async def add(self, message: OutboxMessage) -> OutboxMessage:
164 self._store.outbox.append(message)
165 return message
167 async def lock_pending(self, *, now: datetime, limit: int) -> list[OutboxMessage]:
168 pending = [
169 message
170 for message in self._store.outbox
171 if message.sent_at is None and message.available_at <= now
172 ]
173 pending.sort(key=lambda message: message.created_at)
174 return pending[:limit]
176 async def mark_sent(self, message: OutboxMessage, sent_at: datetime) -> None:
177 message.sent_at = sent_at
178 message.attempts += 1
180 async def mark_failed(
181 self, message: OutboxMessage, error: str, available_at: datetime, attempts: int
182 ) -> None:
183 message.attempts = attempts
184 message.last_error = error[:2000]
185 message.available_at = available_at
188class InMemoryUnitOfWork:
189 def __init__(self, store: InMemoryStore) -> None:
190 self._store = store
191 self._snapshot: Snapshot | None = None
192 self.tasks = InMemoryTaskRepository(store)
193 self.robots = InMemoryRobotRepository(store)
194 self.events = InMemoryEventRepository(store)
195 self.outbox = InMemoryOutboxRepository(store)
197 async def __aenter__(self) -> InMemoryUnitOfWork:
198 self._snapshot = self._store.snapshot()
199 return self
201 async def __aexit__(self, exc_type, exc, tb) -> None:
202 if self._snapshot is not None:
203 self._store.restore(self._snapshot)
204 self._snapshot = None
206 async def commit(self) -> None:
207 self._snapshot = None
209 async def rollback(self) -> None:
210 if self._snapshot is not None:
211 self._store.restore(self._snapshot)
212 self._snapshot = None
215class InMemoryUnitOfWorkFactory:
216 def __init__(self, store: InMemoryStore | None = None) -> None:
217 self.store = store or InMemoryStore()
219 def __call__(self) -> InMemoryUnitOfWork:
220 return InMemoryUnitOfWork(self.store)