Coverage for tests/brokers/redis/test_autoclaim.py: 99%

140 statements  

« prev     ^ index     » next       coverage.py v7.17.3, created at 2026-11-17 21:20 +0000

1import asyncio 

2from contextlib import suppress 

3from typing import Any 

4from unittest.mock import MagicMock, patch 

5 

6import pytest 

7from redis.asyncio import Redis 

8 

9from faststream.exceptions import NackMessage 

10from faststream.redis import StreamSub 

11from tests.brokers.base.consume import BrokerRealConsumeTestcase 

12from tests.tools import spy_decorator 

13 

14from .basic import RedisTestcaseConfig 

15 

16 

17@pytest.mark.connected() 

18@pytest.mark.redis() 

19@pytest.mark.asyncio() 

20class TestAutoClaim(RedisTestcaseConfig, BrokerRealConsumeTestcase): 

21 @pytest.mark.slow() 

22 async def test_consume_stream_with_min_idle_time( 

23 self, 

24 queue: str, 

25 mock: MagicMock, 

26 event: asyncio.Event, 

27 ) -> None: 

28 """Verify that subscribers with min_idle_time use XAUTOCLAIM to reclaim pending messages.""" 

29 consume_broker = self.get_broker(apply_types=True) 

30 

31 @consume_broker.subscriber( 

32 stream=StreamSub( 

33 queue, 

34 group="test_group", 

35 consumer="consumer1", 

36 ), 

37 ) 

38 async def regular(msg: str) -> None: 

39 raise NackMessage 

40 

41 @consume_broker.subscriber( 

42 stream=StreamSub( 

43 queue, 

44 group="test_group", 

45 consumer="consumer1", 

46 min_idle_time=100, # 100ms 

47 ), 

48 ) 

49 async def retry(msg: str) -> None: 

50 mock(msg) 

51 event.set() 

52 

53 async with self.patch_broker(consume_broker) as br: 

54 with ( 

55 patch.object( 

56 Redis, "xautoclaim", spy_decorator(Redis.xautoclaim) 

57 ) as xautoclaim, 

58 patch.object( 

59 Redis, "xreadgroup", spy_decorator(Redis.xreadgroup) 

60 ) as xreadgroup, 

61 ): 

62 await br.start() 

63 

64 # First, publish a message and let it become pending 

65 await br.publish("pending_message", stream=queue) 

66 

67 # The subscriber with XAUTOCLAIM should reclaim it 

68 await asyncio.wait( 

69 (asyncio.create_task(event.wait()),), 

70 timeout=3, 

71 ) 

72 

73 assert event.is_set() 

74 mock.assert_called_once_with("pending_message") 

75 

76 # Verify that XAUTOCLAIM was used, not XREADGROUP 

77 assert xautoclaim.mock.called 

78 assert xreadgroup.mock.called # regular subscriber uses xreadgroup 

79 

80 @pytest.mark.slow() 

81 async def test_get_one_with_min_idle_time( 

82 self, 

83 queue: str, 

84 ) -> None: 

85 """Verify that get_one() method uses XAUTOCLAIM when min_idle_time is configured.""" 

86 broker = self.get_broker(apply_types=True) 

87 

88 async with self.patch_broker(broker) as br: 

89 await br.start() 

90 

91 # First, create a pending message 

92 await br.publish({"data": "pending"}, stream=queue) 

93 with suppress(Exception): 

94 client = await br.connect() 

95 await client.xgroup_create(queue, "idle_group", id="0", mkstream=True) 

96 

97 # Read it but don't ack to make it pending 

98 await client.xreadgroup( 

99 groupname="idle_group", 

100 consumername="temp_consumer", 

101 streams={queue: ">"}, 

102 count=1, 

103 ) 

104 

105 # Wait for it to become idle 

106 await asyncio.sleep(0.1) 

107 

108 # Now use get_one with min_idle_time 

109 subscriber = br.subscriber( 

110 stream=StreamSub( 

111 queue, 

112 group="idle_group", 

113 consumer="claiming_consumer", 

114 min_idle_time=1, 

115 ) 

116 ) 

117 

118 with ( 

119 patch.object( 

120 Redis, "xautoclaim", spy_decorator(Redis.xautoclaim) 

121 ) as xautoclaim, 

122 patch.object( 

123 Redis, "xreadgroup", spy_decorator(Redis.xreadgroup) 

124 ) as xreadgroup, 

125 ): 

126 message = await subscriber.get_one(timeout=3) 

127 

128 assert message is not None 

129 decoded = await message.decode() 

130 assert decoded == {"data": "pending"} 

131 # Should use XAUTOCLAIM, not XREADGROUP 

132 assert xautoclaim.mock.called 

133 assert not xreadgroup.mock.called 

134 

135 @pytest.mark.slow() 

136 async def test_get_one_with_min_idle_time_no_pending( 

137 self, 

138 queue: str, 

139 mock: MagicMock, 

140 ) -> None: 

141 """Verify that get_one() returns None when no pending messages are available for claiming.""" 

142 broker = self.get_broker(apply_types=True) 

143 

144 subscriber = broker.subscriber( 

145 stream=StreamSub( 

146 queue, 

147 group="empty_group", 

148 consumer="consumer1", 

149 min_idle_time=100, 

150 ) 

151 ) 

152 

153 async with self.patch_broker(broker) as br: 

154 await br.start() 

155 

156 # Should return None after timeout 

157 result = await subscriber.get_one(timeout=0.5) 

158 mock(result) 

159 

160 mock.assert_called_once_with(None) 

161 

162 @pytest.mark.slow() 

163 async def test_iterator_with_min_idle_time( 

164 self, 

165 queue: str, 

166 mock: MagicMock, 

167 ) -> None: 

168 """Verify that async iterator uses XAUTOCLAIM when min_idle_time is configured.""" 

169 broker = self.get_broker(apply_types=True) 

170 

171 async with self.patch_broker(broker) as br: 

172 await br.start() 

173 

174 # Create pending messages 

175 await br.publish({"data": "msg1"}, stream=queue) 

176 await br.publish({"data": "msg2"}, stream=queue) 

177 

178 with suppress(Exception): 

179 client = await br.connect() 

180 await client.xgroup_create(queue, "iter_group", id="0", mkstream=True) 

181 

182 # Read them but don't ack 

183 await client.xreadgroup( 

184 groupname="iter_group", 

185 consumername="temp", 

186 streams={queue: ">"}, 

187 count=10, 

188 ) 

189 

190 await asyncio.sleep(0.1) 

191 

192 subscriber = br.subscriber( 

193 stream=StreamSub( 

194 queue, 

195 group="iter_group", 

196 consumer="iter_consumer", 

197 min_idle_time=1, 

198 ) 

199 ) 

200 

201 with ( 

202 patch.object( 

203 Redis, "xautoclaim", spy_decorator(Redis.xautoclaim) 

204 ) as xautoclaim, 

205 patch.object( 

206 Redis, "xreadgroup", spy_decorator(Redis.xreadgroup) 

207 ) as xreadgroup, 

208 ): 

209 count = 0 

210 async for msg in subscriber: 210 ↛ 217line 210 didn't jump to line 217 because the loop on line 210 didn't complete

211 decoded = await msg.decode() 

212 mock(decoded) 

213 count += 1 

214 if count >= 2: 

215 break 

216 

217 assert count == 2 

218 mock.assert_any_call({"data": "msg1"}) 

219 mock.assert_any_call({"data": "msg2"}) 

220 # Should use XAUTOCLAIM, not XREADGROUP 

221 assert xautoclaim.mock.called 

222 assert not xreadgroup.mock.called 

223 

224 @pytest.mark.slow() 

225 async def test_consume_stream_batch_with_min_idle_time( 

226 self, 

227 queue: str, 

228 mock: MagicMock, 

229 event: asyncio.Event, 

230 ) -> None: 

231 """Verify that batch subscribers use XAUTOCLAIM when min_idle_time is configured.""" 

232 consume_broker = self.get_broker(apply_types=True) 

233 

234 @consume_broker.subscriber( 

235 stream=StreamSub( 

236 queue, 

237 group="batch_group", 

238 consumer="batch_consumer", 

239 batch=True, 

240 min_idle_time=1, 

241 ), 

242 ) 

243 async def handler(msg: list[Any]) -> None: 

244 mock(msg) 

245 event.set() 

246 

247 async with self.patch_broker(consume_broker) as br: 

248 # Create a pending message first (before starting subscriber) 

249 await br.publish({"data": "batch_msg"}, stream=queue) 

250 

251 with suppress(Exception): 

252 client = await br.connect() 

253 await client.xgroup_create(queue, "batch_group", id="0", mkstream=True) 

254 

255 # Read but don't ack (before starting subscriber) 

256 await client.xreadgroup( 

257 groupname="batch_group", 

258 consumername="temp", 

259 streams={queue: ">"}, 

260 count=1, 

261 ) 

262 

263 await asyncio.sleep(0.1) 

264 

265 # Now start subscriber and track calls 

266 with ( 

267 patch.object( 

268 Redis, "xautoclaim", spy_decorator(Redis.xautoclaim) 

269 ) as xautoclaim, 

270 patch.object( 

271 Redis, "xreadgroup", spy_decorator(Redis.xreadgroup) 

272 ) as xreadgroup, 

273 ): 

274 await br.start() 

275 

276 # Now the subscriber should reclaim it 

277 await asyncio.wait( 

278 (asyncio.create_task(event.wait()),), 

279 timeout=3, 

280 ) 

281 

282 assert event.is_set() 

283 # In batch mode, should receive list 

284 assert mock.call_count == 1 

285 called_with = mock.call_args[0][0] 

286 assert isinstance(called_with, list) 

287 assert len(called_with) > 0 

288 # Should use XAUTOCLAIM, not XREADGROUP 

289 assert xautoclaim.mock.called 

290 assert not xreadgroup.mock.called 

291 

292 @pytest.mark.slow() 

293 async def test_xautoclaim_with_deleted_messages( 

294 self, 

295 queue: str, 

296 mock: MagicMock, 

297 ) -> None: 

298 """Verify that XAUTOCLAIM handles deleted messages gracefully without errors.""" 

299 consume_broker = self.get_broker(apply_types=True) 

300 

301 async with self.patch_broker(consume_broker) as br: 

302 await br.start() 

303 

304 # Create and consume a message without ack 

305 msg_id = await br.publish({"data": "will_delete"}, stream=queue) 

306 

307 with suppress(Exception): 

308 client = await br.connect() 

309 await client.xgroup_create(queue, "delete_group", id="0", mkstream=True) 

310 

311 # Read to make it pending 

312 await client.xreadgroup( 

313 groupname="delete_group", 

314 consumername="temp", 

315 streams={queue: ">"}, 

316 count=1, 

317 ) 

318 

319 # Delete the message from stream 

320 await client.xdel(queue, msg_id) 

321 

322 await asyncio.sleep(0.1) 

323 

324 # XAUTOCLAIM should handle deleted messages gracefully 

325 subscriber = br.subscriber( 

326 stream=StreamSub( 

327 queue, 

328 group="delete_group", 

329 consumer="delete_consumer", 

330 min_idle_time=1, 

331 ) 

332 ) 

333 

334 # Should timeout gracefully without errors 

335 result = await subscriber.get_one(timeout=0.5) 

336 mock(result) 

337 

338 # Should return None (no valid messages to claim) 

339 mock.assert_called_once_with(None) 

340 

341 @pytest.mark.slow() 

342 async def test_xautoclaim_circular_scanning_with_idle_timeout( 

343 self, 

344 queue: str, 

345 mock: MagicMock, 

346 ) -> None: 

347 """Verify that XAUTOCLAIM performs circular scanning and claims messages as they become idle.""" 

348 consume_broker = self.get_broker(apply_types=True) 

349 

350 async with self.patch_broker(consume_broker) as br: 

351 await br.start() 

352 

353 # Create multiple pending messages 

354 msg_ids = [] 

355 for i in range(5): 

356 msg_id = await br.publish({"data": f"msg{i}"}, stream=queue) 

357 msg_ids.append(msg_id) 

358 

359 with suppress(Exception): 

360 client = await br.connect() 

361 await client.xgroup_create(queue, "circular_group", id="0", mkstream=True) 

362 

363 # Read all messages with consumer1 but don't ack - making them pending 

364 await client.xreadgroup( 

365 groupname="circular_group", 

366 consumername="consumer1", 

367 streams={queue: ">"}, 

368 count=10, 

369 ) 

370 

371 # Wait for messages to become idle 

372 await asyncio.sleep(0.1) 

373 

374 # Create subscriber with XAUTOCLAIM 

375 subscriber = br.subscriber( 

376 stream=StreamSub( 

377 queue, 

378 group="circular_group", 

379 consumer="consumer2", 

380 min_idle_time=1, 

381 ) 

382 ) 

383 

384 # First pass: claim all messages one by one 

385 claimed_messages_first_pass = [] 

386 for _ in range(5): 

387 msg = await subscriber.get_one(timeout=1) 

388 if msg: 388 ↛ 386line 388 didn't jump to line 386 because the condition on line 388 was always true

389 decoded: Any = await msg.decode() 

390 claimed_messages_first_pass.append(decoded) 

391 mock(f"first_pass_{decoded['data']}") 

392 

393 # Should have claimed all 5 messages in order 

394 assert len(claimed_messages_first_pass) == 5 

395 assert claimed_messages_first_pass == [{"data": f"msg{i}"} for i in range(5)] 

396 

397 # After reaching the end, XAUTOCLAIM should restart from "0-0" 

398 # and scan circularly - messages are still pending since we didn't ACK them 

399 # Second pass: verify circular behavior by claiming messages again 

400 msg = await subscriber.get_one(timeout=1) 

401 assert msg is not None 

402 decoded = await msg.decode() 

403 # Should get msg0 again (circular scan restarted) 

404 assert decoded["data"] == "msg0" 

405 mock("second_pass_msg0") 

406 

407 # Verify messages were claimed in both passes 

408 mock.assert_any_call("first_pass_msg0") 

409 mock.assert_any_call("second_pass_msg0")