Coverage for tests/brokers/redis/cluster/test_cluster_connect.py: 98%
147 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
1"""Integration tests for RedisClusterBroker.
3Requires a running Redis Cluster (ports 7001-7003).
4Start with: ``just redis-cluster-up``
5Run with: ``just test-redis-cluster tests/brokers/redis/test_cluster_connect.py``
6"""
8import asyncio
9from typing import Any
11import pytest
12from redis.cluster import RedisCluster as _SyncRC
14from faststream.redis import RedisClusterBroker, StreamSub
15from tests.brokers.base.connection import BrokerConnectionTestcase
17from .settings import SettingsCluster
20@pytest.mark.connected()
21@pytest.mark.redis_cluster()
22class TestClusterConnection(BrokerConnectionTestcase):
23 broker = RedisClusterBroker
25 def get_broker_args(self, settings: SettingsCluster) -> dict[str, Any]:
26 return {"url": settings.url, "startup_nodes": settings.startup_nodes}
28 @pytest.mark.asyncio()
29 async def test_connect(
30 self,
31 settings_cluster: SettingsCluster,
32 ) -> None:
33 kwargs = self.get_broker_args(settings_cluster)
34 broker = self.broker(**kwargs)
35 _ = await broker.connect()
36 assert await self.ping(broker)
37 await broker.stop()
39 @pytest.mark.asyncio()
40 async def test_init_connect_by_raw_data(
41 self,
42 settings_cluster: SettingsCluster,
43 ) -> None:
44 async with RedisClusterBroker(
45 "redis://127.0.0.1:63791",
46 host=settings_cluster.host,
47 port=settings_cluster.port,
48 startup_nodes=settings_cluster.startup_nodes,
49 ) as broker:
50 assert await self.ping(broker)
53@pytest.mark.connected()
54@pytest.mark.redis_cluster()
55class TestClusterList:
56 @pytest.mark.asyncio()
57 async def test_list_subscriber(
58 self,
59 queue: str,
60 settings_cluster: SettingsCluster,
61 event: asyncio.Event,
62 ) -> None:
63 broker = RedisClusterBroker(
64 url=settings_cluster.url,
65 startup_nodes=settings_cluster.startup_nodes,
66 )
67 received = []
69 @broker.subscriber(list=f"test-cluster-list-{queue}")
70 async def handler(msg: str) -> None:
71 received.append(msg)
72 if len(received) == 2:
73 event.set()
75 async with broker:
76 await broker.start()
77 await broker.publish("a", list=f"test-cluster-list-{queue}")
78 await broker.publish("b", list=f"test-cluster-list-{queue}")
79 await asyncio.wait(
80 (asyncio.create_task(event.wait()),),
81 timeout=5,
82 )
84 assert received == ["a", "b"]
86 @pytest.mark.asyncio()
87 async def test_publish_batch(
88 self,
89 queue: str,
90 settings_cluster: SettingsCluster,
91 event: asyncio.Event,
92 ) -> None:
93 broker = RedisClusterBroker(
94 url=settings_cluster.url,
95 startup_nodes=settings_cluster.startup_nodes,
96 )
97 received = []
99 @broker.subscriber(list=f"test-cluster-batch-{queue}")
100 async def handler(msg: str) -> None:
101 received.append(msg)
102 if len(received) == 3:
103 event.set()
105 async with broker:
106 await broker.start()
107 await broker.publish_batch("x", "y", "z", list=f"test-cluster-batch-{queue}")
108 await asyncio.wait(
109 (asyncio.create_task(event.wait()),),
110 timeout=5,
111 )
113 assert received == ["x", "y", "z"]
116@pytest.mark.connected()
117@pytest.mark.redis_cluster()
118class TestClusterStream:
119 @pytest.mark.asyncio()
120 async def test_stream_consume(
121 self,
122 queue: str,
123 settings_cluster: SettingsCluster,
124 event: asyncio.Event,
125 ) -> None:
126 broker = RedisClusterBroker(
127 url=settings_cluster.url,
128 startup_nodes=settings_cluster.startup_nodes,
129 )
130 received = []
132 @broker.subscriber(stream=f"test-stream-{queue}")
133 async def handler(msg: str) -> None:
134 received.append(msg)
135 event.set()
137 async with broker:
138 await broker.start()
139 for _ in range(10): 139 ↛ 148line 139 didn't jump to line 148
140 await broker.publish("hello", stream=f"test-stream-{queue}")
141 done, _ = await asyncio.wait(
142 (asyncio.create_task(event.wait()),),
143 timeout=1.0,
144 )
145 if done: 145 ↛ 139line 145 didn't jump to line 139 because the condition on line 145 was always true
146 break
148 assert received == ["hello"]
150 @pytest.mark.asyncio()
151 async def test_stream_consume_group(
152 self,
153 queue: str,
154 settings_cluster: SettingsCluster,
155 event: asyncio.Event,
156 ) -> None:
157 broker = RedisClusterBroker(
158 url=settings_cluster.url,
159 startup_nodes=settings_cluster.startup_nodes,
160 )
161 received = []
163 @broker.subscriber(
164 stream=StreamSub(
165 f"test-stream-group-{queue}",
166 group=f"group-{queue}",
167 consumer=f"consumer-{queue}",
168 ),
169 )
170 async def handler(msg: str) -> None:
171 received.append(msg)
172 event.set()
174 async with broker:
175 await broker.start()
176 await broker.publish("group msg", stream=f"test-stream-group-{queue}")
177 await asyncio.wait(
178 (asyncio.create_task(event.wait()),),
179 timeout=5,
180 )
182 assert received == ["group msg"]
185@pytest.mark.connected()
186@pytest.mark.redis_cluster()
187class TestClusterStreamAutoclaim:
188 @pytest.mark.asyncio()
189 async def test_consume_stream_with_min_idle_time(
190 self,
191 queue: str,
192 settings_cluster: SettingsCluster,
193 event: asyncio.Event,
194 ) -> None:
195 """min_idle_time subscriber uses XAUTOCLAIM to reclaim pending messages."""
196 stream = f"test-autoclaim-{queue}"
197 group = f"group-{queue}"
199 broker = RedisClusterBroker(
200 url=settings_cluster.url,
201 startup_nodes=settings_cluster.startup_nodes,
202 )
204 # Create stream and pending messages directly via the cluster client
205 async with broker:
206 await broker.start()
207 c = await broker.connect()
209 await c.xadd(stream, {"data": b"m1"})
210 await c.xadd(stream, {"data": b"m2"})
211 await c.xgroup_create(stream, group, id="0", mkstream=True)
213 # Read without ACKing → messages go to PEL
214 await c.xreadgroup(group, "temp", {stream: ">"}, count=2)
216 # Now start a claimer with min_idle_time
217 claimer = RedisClusterBroker(
218 url=settings_cluster.url,
219 startup_nodes=settings_cluster.startup_nodes,
220 )
221 claimed = []
223 @claimer.subscriber(
224 stream=StreamSub(
225 stream,
226 group=group,
227 consumer="claimer",
228 min_idle_time=100,
229 ),
230 )
231 async def handler(msg: str) -> None:
232 claimed.append(msg)
233 if len(claimed) == 2:
234 event.set()
236 async with claimer:
237 await claimer.start()
238 await asyncio.wait(
239 (asyncio.create_task(event.wait()),),
240 timeout=10,
241 )
243 assert len(claimed) == 2
245 @pytest.mark.slow()
246 @pytest.mark.asyncio()
247 async def test_xautoclaim_circular_scanning(
248 self,
249 queue: str,
250 settings_cluster: SettingsCluster,
251 ) -> None:
252 """XAUTOCLAIM cursor wraps back to 0-0 at end of PEL."""
253 stream = f"test-circ-{queue}"
254 group = f"group-{queue}"
256 broker = RedisClusterBroker(
257 url=settings_cluster.url,
258 startup_nodes=settings_cluster.startup_nodes,
259 )
261 async with broker:
262 await broker.start()
263 c = await broker.connect()
265 for i in range(5):
266 await c.xadd(stream, {"data": f"msg-{i}".encode()})
267 await c.xgroup_create(stream, group, id="0", mkstream=True)
268 await c.xreadgroup(group, "temp", {stream: ">"}, count=5)
270 claimer = RedisClusterBroker(
271 url=settings_cluster.url,
272 startup_nodes=settings_cluster.startup_nodes,
273 )
274 claimed = []
276 @claimer.subscriber(
277 stream=StreamSub(
278 stream,
279 group=group,
280 consumer="claimer",
281 min_idle_time=100,
282 ),
283 )
284 async def handler(msg: str) -> None:
285 claimed.append(msg)
287 async with claimer:
288 await claimer.start()
289 await asyncio.sleep(5)
291 assert len(claimed) >= 5
294@pytest.mark.connected()
295@pytest.mark.redis_cluster()
296class TestClusterPubSub:
297 @pytest.mark.asyncio()
298 async def test_publish_subscribe(
299 self,
300 queue: str,
301 settings_cluster: SettingsCluster,
302 event: asyncio.Event,
303 ) -> None:
304 """Pub/Sub via sync cluster wrapper."""
305 if not hasattr(_SyncRC, "publish"): 305 ↛ 306line 305 didn't jump to line 306 because the condition on line 305 was never true
306 pytest.skip("sync cluster pubsub not available")
308 broker = RedisClusterBroker(
309 url=settings_cluster.url,
310 startup_nodes=settings_cluster.startup_nodes,
311 )
312 received = []
314 @broker.subscriber(f"test-pubsub-{queue}")
315 async def handler(msg: str) -> None:
316 received.append(msg)
317 event.set()
319 async with broker:
320 await broker.start()
321 await broker.publish("hello", channel=f"test-pubsub-{queue}")
322 await asyncio.wait(
323 (asyncio.create_task(event.wait()),),
324 timeout=5,
325 )
327 assert received == ["hello"]
328 # a future redis-py version fixes this the test can be written
329 # analogously to test_publish_subscribe with `sharded=True`.