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

1from __future__ import annotations 

2 

3import copy 

4import uuid 

5from datetime import datetime, timedelta 

6 

7from robot_dispatch.db.models import OutboxMessage, Robot, Task, TaskEvent 

8from robot_dispatch.domain.enums import QUEUED_TASK_STATUSES, RobotStatus 

9 

10 

11class Snapshot: 

12 __slots__ = ("tasks", "robots", "events", "outbox") 

13 

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 

19 

20 

21class InMemoryStore: 

22 """Process-local stand-in for PostgreSQL, used by unit tests.""" 

23 

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] = [] 

29 

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 ) 

37 

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 

43 

44 

45class InMemoryTaskRepository: 

46 def __init__(self, store: InMemoryStore) -> None: 

47 self._store = store 

48 

49 async def add(self, task: Task) -> Task: 

50 self._store.tasks[task.id] = task 

51 return task 

52 

53 async def get(self, task_id: uuid.UUID) -> Task | None: 

54 return self._store.tasks.get(task_id) 

55 

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 

61 

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] 

71 

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] 

82 

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] 

101 

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 

107 

108 

109class InMemoryRobotRepository: 

110 def __init__(self, store: InMemoryStore) -> None: 

111 self._store = store 

112 

113 async def add(self, robot: Robot) -> Robot: 

114 self._store.robots[robot.id] = robot 

115 return robot 

116 

117 async def get(self, robot_id: uuid.UUID) -> Robot | None: 

118 return self._store.robots.get(robot_id) 

119 

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 

125 

126 async def list(self) -> list[Robot]: 

127 return sorted(self._store.robots.values(), key=lambda robot: robot.name) 

128 

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 

143 

144 

145class InMemoryEventRepository: 

146 def __init__(self, store: InMemoryStore) -> None: 

147 self._store = store 

148 

149 async def add(self, event: TaskEvent) -> TaskEvent: 

150 self._store.events.append(event) 

151 return event 

152 

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] 

157 

158 

159class InMemoryOutboxRepository: 

160 def __init__(self, store: InMemoryStore) -> None: 

161 self._store = store 

162 

163 async def add(self, message: OutboxMessage) -> OutboxMessage: 

164 self._store.outbox.append(message) 

165 return message 

166 

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] 

175 

176 async def mark_sent(self, message: OutboxMessage, sent_at: datetime) -> None: 

177 message.sent_at = sent_at 

178 message.attempts += 1 

179 

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 

186 

187 

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) 

196 

197 async def __aenter__(self) -> InMemoryUnitOfWork: 

198 self._snapshot = self._store.snapshot() 

199 return self 

200 

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 

205 

206 async def commit(self) -> None: 

207 self._snapshot = None 

208 

209 async def rollback(self) -> None: 

210 if self._snapshot is not None: 

211 self._store.restore(self._snapshot) 

212 self._snapshot = None 

213 

214 

215class InMemoryUnitOfWorkFactory: 

216 def __init__(self, store: InMemoryStore | None = None) -> None: 

217 self.store = store or InMemoryStore() 

218 

219 def __call__(self) -> InMemoryUnitOfWork: 

220 return InMemoryUnitOfWork(self.store)