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
« 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
6import pytest
7from redis.asyncio import Redis
9from faststream.exceptions import NackMessage
10from faststream.redis import StreamSub
11from tests.brokers.base.consume import BrokerRealConsumeTestcase
12from tests.tools import spy_decorator
14from .basic import RedisTestcaseConfig
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)
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
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()
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()
64 # First, publish a message and let it become pending
65 await br.publish("pending_message", stream=queue)
67 # The subscriber with XAUTOCLAIM should reclaim it
68 await asyncio.wait(
69 (asyncio.create_task(event.wait()),),
70 timeout=3,
71 )
73 assert event.is_set()
74 mock.assert_called_once_with("pending_message")
76 # Verify that XAUTOCLAIM was used, not XREADGROUP
77 assert xautoclaim.mock.called
78 assert xreadgroup.mock.called # regular subscriber uses xreadgroup
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)
88 async with self.patch_broker(broker) as br:
89 await br.start()
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)
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 )
105 # Wait for it to become idle
106 await asyncio.sleep(0.1)
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 )
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)
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
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)
144 subscriber = broker.subscriber(
145 stream=StreamSub(
146 queue,
147 group="empty_group",
148 consumer="consumer1",
149 min_idle_time=100,
150 )
151 )
153 async with self.patch_broker(broker) as br:
154 await br.start()
156 # Should return None after timeout
157 result = await subscriber.get_one(timeout=0.5)
158 mock(result)
160 mock.assert_called_once_with(None)
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)
171 async with self.patch_broker(broker) as br:
172 await br.start()
174 # Create pending messages
175 await br.publish({"data": "msg1"}, stream=queue)
176 await br.publish({"data": "msg2"}, stream=queue)
178 with suppress(Exception):
179 client = await br.connect()
180 await client.xgroup_create(queue, "iter_group", id="0", mkstream=True)
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 )
190 await asyncio.sleep(0.1)
192 subscriber = br.subscriber(
193 stream=StreamSub(
194 queue,
195 group="iter_group",
196 consumer="iter_consumer",
197 min_idle_time=1,
198 )
199 )
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
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
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)
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()
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)
251 with suppress(Exception):
252 client = await br.connect()
253 await client.xgroup_create(queue, "batch_group", id="0", mkstream=True)
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 )
263 await asyncio.sleep(0.1)
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()
276 # Now the subscriber should reclaim it
277 await asyncio.wait(
278 (asyncio.create_task(event.wait()),),
279 timeout=3,
280 )
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
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)
301 async with self.patch_broker(consume_broker) as br:
302 await br.start()
304 # Create and consume a message without ack
305 msg_id = await br.publish({"data": "will_delete"}, stream=queue)
307 with suppress(Exception):
308 client = await br.connect()
309 await client.xgroup_create(queue, "delete_group", id="0", mkstream=True)
311 # Read to make it pending
312 await client.xreadgroup(
313 groupname="delete_group",
314 consumername="temp",
315 streams={queue: ">"},
316 count=1,
317 )
319 # Delete the message from stream
320 await client.xdel(queue, msg_id)
322 await asyncio.sleep(0.1)
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 )
334 # Should timeout gracefully without errors
335 result = await subscriber.get_one(timeout=0.5)
336 mock(result)
338 # Should return None (no valid messages to claim)
339 mock.assert_called_once_with(None)
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)
350 async with self.patch_broker(consume_broker) as br:
351 await br.start()
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)
359 with suppress(Exception):
360 client = await br.connect()
361 await client.xgroup_create(queue, "circular_group", id="0", mkstream=True)
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 )
371 # Wait for messages to become idle
372 await asyncio.sleep(0.1)
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 )
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']}")
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)]
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")
407 # Verify messages were claimed in both passes
408 mock.assert_any_call("first_pass_msg0")
409 mock.assert_any_call("second_pass_msg0")