Coverage for tests/brokers/redis/stream_claim.py: 97%
128 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 AsyncMock, MagicMock, patch
6import pytest
7from dirty_equals import HasLen, IsInt, IsPartialDict
8from redis.asyncio import Redis
9from redis.exceptions import ResponseError
11from faststream.redis import RedisBroker, StreamSub
12from faststream.redis.annotations import RedisBatchStreamMessage, RedisStreamMessage
13from tests.brokers.base.basic import BaseTestcaseConfig
14from tests.marks import require_redis_v710
17async def skip_without_claim_support(broker: RedisBroker) -> None:
18 """XREADGROUP CLAIM needs Redis server 8.4+; there is no client-side gate for it."""
19 client = await broker.connect()
20 info = await client.info("server")
21 major, minor, *_ = info["redis_version"].split(".")
22 if (int(major), int(minor)) < (8, 4): 22 ↛ 23line 22 didn't jump to line 23 because the condition on line 22 was never true
23 pytest.skip("XREADGROUP CLAIM requires Redis server 8.4+")
26async def make_pending(
27 br: RedisBroker,
28 queue: str,
29 group: str,
30 payloads: tuple[str, ...] = ("pending_message",),
31) -> None:
32 """Publish and read as the `temp` consumer, leaving the entries pending."""
33 for payload in payloads:
34 await br.publish(payload, stream=queue)
36 client = await br.connect()
37 with suppress(Exception):
38 await client.xgroup_create(queue, group, id="0", mkstream=True)
40 await client.xreadgroup(
41 groupname=group,
42 consumername="temp",
43 streams={queue: ">"},
44 count=len(payloads) + 10,
45 )
48class StreamClaimTestcase(BaseTestcaseConfig[Any]):
49 client_cls: Any = Redis
50 """The client class whose `xreadgroup` the unsupported-server test patches; the cluster overrides it."""
52 @pytest.mark.slow()
53 @require_redis_v710
54 async def test_consume_claimed_and_new_in_one_handler(
55 self,
56 queue: str,
57 event: asyncio.Event,
58 ) -> None:
59 consume_broker = self.get_broker(apply_types=True)
61 received: list[tuple[Any, int, int]] = []
63 @consume_broker.subscriber(
64 stream=StreamSub(
65 queue,
66 group="claim_group",
67 consumer="claimer",
68 claim_min_idle_time=100,
69 ),
70 )
71 async def handler(msg: str, message: RedisStreamMessage) -> None:
72 received.append((
73 msg,
74 message.raw_message["delivery_counts"][0],
75 message.raw_message["idle_times"][0],
76 ))
77 if len(received) >= 2:
78 event.set()
80 async with self.patch_broker(consume_broker) as br:
81 await skip_without_claim_support(br)
83 await make_pending(br, queue, "claim_group")
84 await asyncio.sleep(0.3)
85 await br.publish("new_message", stream=queue)
87 await br.start()
89 await asyncio.wait(
90 (asyncio.create_task(event.wait()),),
91 timeout=3,
92 )
94 # Claimed entries come first, with their previous deliveries and idle time
95 assert received[:2] == [
96 ("pending_message", IsInt(ge=1), IsInt(ge=100)),
97 ("new_message", 0, 0),
98 ]
100 @pytest.mark.slow()
101 @require_redis_v710
102 async def test_batch_metadata_aligned(
103 self,
104 queue: str,
105 event: asyncio.Event,
106 ) -> None:
107 consume_broker = self.get_broker(apply_types=True)
109 # Every delivery is kept: batches may split, and the in-flight batch
110 # can be re-claimed before shutdown.
111 snapshots: list[dict[str, Any]] = []
113 @consume_broker.subscriber(
114 stream=StreamSub(
115 queue,
116 group="batch_claim_group",
117 consumer="claimer",
118 batch=True,
119 claim_min_idle_time=300,
120 ),
121 )
122 async def handler(msg: list[Any], message: RedisBatchStreamMessage) -> None:
123 snapshots.append(dict(message.raw_message))
124 if sum(len(s["message_ids"]) for s in snapshots) >= 2: 124 ↛ exitline 124 didn't return from function 'handler' because the condition on line 124 was always true
125 event.set()
127 async with self.patch_broker(consume_broker) as br:
128 await skip_without_claim_support(br)
130 await make_pending(
131 br,
132 queue,
133 "batch_claim_group",
134 payloads=("first", "second"),
135 )
136 await asyncio.sleep(0.5)
138 await br.start()
140 await asyncio.wait(
141 (asyncio.create_task(event.wait()),),
142 timeout=3,
143 )
145 # Metadata is aligned with `message_ids` in every delivery
146 for snap in snapshots:
147 size = len(snap["message_ids"])
148 assert snap == IsPartialDict({
149 "delivery_counts": HasLen(size),
150 "idle_times": HasLen(size),
151 })
153 # Only the first delivery of each original entry has predictable values
154 entries = [
155 entry
156 for snap in snapshots
157 for entry in zip(snap["delivery_counts"], snap["idle_times"], strict=True)
158 ]
159 assert entries[:2] == [(1, IsInt(ge=300))] * 2
161 @pytest.mark.slow()
162 @require_redis_v710
163 async def test_repeated_get_one_keeps_claiming(self, queue: str) -> None:
164 broker = self.get_broker(apply_types=True)
166 async with self.patch_broker(broker) as br:
167 await skip_without_claim_support(br)
168 await br.start()
170 await make_pending(
171 br,
172 queue,
173 "repeat_claim_group",
174 payloads=("first", "second"),
175 )
176 await asyncio.sleep(0.3)
178 subscriber = br.subscriber(
179 stream=StreamSub(
180 queue,
181 group="repeat_claim_group",
182 consumer="claimer",
183 claim_min_idle_time=100,
184 ),
185 )
187 got: set[str] = set()
188 for _ in range(2):
189 message = await subscriber.get_one(timeout=3)
190 assert message is not None
191 assert message.raw_message == IsPartialDict({
192 "delivery_counts": [IsInt(ge=1)],
193 "idle_times": [IsInt(ge=100)],
194 })
195 got.add(await message.decode())
197 assert got == {"first", "second"}
198 # The group read cursor survived both reads
199 assert subscriber.read_id == ">"
201 @pytest.mark.slow()
202 @require_redis_v710
203 async def test_iterator_repeated_messages(self, queue: str) -> None:
204 broker = self.get_broker(apply_types=True)
206 async with self.patch_broker(broker) as br:
207 await skip_without_claim_support(br)
208 await br.start()
210 await make_pending(
211 br,
212 queue,
213 "iter_repeat_group",
214 payloads=("first", "second"),
215 )
216 await asyncio.sleep(0.3)
218 subscriber = br.subscriber(
219 stream=StreamSub(
220 queue,
221 group="iter_repeat_group",
222 consumer="claimer",
223 claim_min_idle_time=100,
224 ),
225 )
227 got: set[str] = set()
228 async for message in subscriber: 228 ↛ 236line 228 didn't jump to line 236 because the loop on line 228 didn't complete
229 assert message.raw_message == IsPartialDict({
230 "delivery_counts": [IsInt(ge=1)],
231 })
232 got.add(await message.decode())
233 if len(got) >= 2:
234 break
236 assert got == {"first", "second"}
237 assert subscriber.read_id == ">"
239 @pytest.mark.slow()
240 @require_redis_v710
241 async def test_unsupported_server_stops_app(
242 self,
243 queue: str,
244 monkeypatch: pytest.MonkeyPatch,
245 ) -> None:
246 # The global conftest disables the task supervisor; this test is about
247 # not entering its restart loop, so turn it back on.
248 monkeypatch.setenv("FASTSTREAM_SUPERVISOR_DISABLED", "0")
250 consume_broker = self.get_broker(apply_types=True)
252 @consume_broker.subscriber(
253 stream=StreamSub(
254 queue,
255 group="unsupported_group",
256 consumer="claimer",
257 claim_min_idle_time=100,
258 ),
259 )
260 async def handler(msg: str) -> None: ...
262 async with self.patch_broker(consume_broker) as br:
263 fake_app = MagicMock()
264 br.context.set_global("app", fake_app)
266 reject = AsyncMock(side_effect=ResponseError("syntax error"))
267 with patch.object(self.client_cls, "xreadgroup", reject):
268 await br.start()
269 await asyncio.sleep(0.3)
271 calls_after_stop = reject.call_count
272 await asyncio.sleep(0.3)
273 # The supervisor is live: a stable count proves the rejection
274 # stops the subscriber instead of restarting it in a hot loop
275 assert reject.call_count == calls_after_stop
277 assert not br.subscribers[0].running
278 fake_app.exit.assert_called_once()
280 @pytest.mark.slow()
281 @require_redis_v710
282 async def test_concurrent_subscriber(
283 self,
284 queue: str,
285 event: asyncio.Event,
286 ) -> None:
287 consume_broker = self.get_broker(apply_types=True)
289 received: list[Any] = []
291 @consume_broker.subscriber(
292 stream=StreamSub(
293 queue,
294 group="concurrent_claim_group",
295 consumer="claimer",
296 claim_min_idle_time=100,
297 ),
298 max_workers=2,
299 )
300 async def handler(msg: str) -> None:
301 received.append(msg)
302 if len(received) >= 2:
303 event.set()
305 async with self.patch_broker(consume_broker) as br:
306 await skip_without_claim_support(br)
308 await make_pending(br, queue, "concurrent_claim_group")
309 await asyncio.sleep(0.3)
310 await br.publish("new_message", stream=queue)
312 await br.start()
314 await asyncio.wait(
315 (asyncio.create_task(event.wait()),),
316 timeout=3,
317 )
319 assert set(received) == {"pending_message", "new_message"}
321 async def test_no_metadata_without_option(self, queue: str) -> None:
322 broker = self.get_broker(apply_types=True)
323 subscriber = broker.subscriber(
324 stream=StreamSub(queue, group="plain_group", consumer="plain"),
325 )
327 async with self.patch_broker(broker) as br:
328 await br.start()
330 await br.publish("plain_message", stream=queue)
332 message = await subscriber.get_one(timeout=3)
334 assert message is not None
335 assert set(message.raw_message) == {"type", "channel", "message_ids", "data"}