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

1"""Integration tests for RedisClusterBroker. 

2 

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""" 

7 

8import asyncio 

9from typing import Any 

10 

11import pytest 

12from redis.cluster import RedisCluster as _SyncRC 

13 

14from faststream.redis import RedisClusterBroker, StreamSub 

15from tests.brokers.base.connection import BrokerConnectionTestcase 

16 

17from .settings import SettingsCluster 

18 

19 

20@pytest.mark.connected() 

21@pytest.mark.redis_cluster() 

22class TestClusterConnection(BrokerConnectionTestcase): 

23 broker = RedisClusterBroker 

24 

25 def get_broker_args(self, settings: SettingsCluster) -> dict[str, Any]: 

26 return {"url": settings.url, "startup_nodes": settings.startup_nodes} 

27 

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() 

38 

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) 

51 

52 

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

68 

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() 

74 

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 ) 

83 

84 assert received == ["a", "b"] 

85 

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

98 

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() 

104 

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 ) 

112 

113 assert received == ["x", "y", "z"] 

114 

115 

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

131 

132 @broker.subscriber(stream=f"test-stream-{queue}") 

133 async def handler(msg: str) -> None: 

134 received.append(msg) 

135 event.set() 

136 

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 

147 

148 assert received == ["hello"] 

149 

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

162 

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() 

173 

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 ) 

181 

182 assert received == ["group msg"] 

183 

184 

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}" 

198 

199 broker = RedisClusterBroker( 

200 url=settings_cluster.url, 

201 startup_nodes=settings_cluster.startup_nodes, 

202 ) 

203 

204 # Create stream and pending messages directly via the cluster client 

205 async with broker: 

206 await broker.start() 

207 c = await broker.connect() 

208 

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) 

212 

213 # Read without ACKing → messages go to PEL 

214 await c.xreadgroup(group, "temp", {stream: ">"}, count=2) 

215 

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

222 

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() 

235 

236 async with claimer: 

237 await claimer.start() 

238 await asyncio.wait( 

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

240 timeout=10, 

241 ) 

242 

243 assert len(claimed) == 2 

244 

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}" 

255 

256 broker = RedisClusterBroker( 

257 url=settings_cluster.url, 

258 startup_nodes=settings_cluster.startup_nodes, 

259 ) 

260 

261 async with broker: 

262 await broker.start() 

263 c = await broker.connect() 

264 

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) 

269 

270 claimer = RedisClusterBroker( 

271 url=settings_cluster.url, 

272 startup_nodes=settings_cluster.startup_nodes, 

273 ) 

274 claimed = [] 

275 

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) 

286 

287 async with claimer: 

288 await claimer.start() 

289 await asyncio.sleep(5) 

290 

291 assert len(claimed) >= 5 

292 

293 

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") 

307 

308 broker = RedisClusterBroker( 

309 url=settings_cluster.url, 

310 startup_nodes=settings_cluster.startup_nodes, 

311 ) 

312 received = [] 

313 

314 @broker.subscriber(f"test-pubsub-{queue}") 

315 async def handler(msg: str) -> None: 

316 received.append(msg) 

317 event.set() 

318 

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 ) 

326 

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`.