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

1import asyncio 

2from contextlib import suppress 

3from typing import Any 

4from unittest.mock import AsyncMock, MagicMock, patch 

5 

6import pytest 

7from dirty_equals import HasLen, IsInt, IsPartialDict 

8from redis.asyncio import Redis 

9from redis.exceptions import ResponseError 

10 

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 

15 

16 

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

24 

25 

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) 

35 

36 client = await br.connect() 

37 with suppress(Exception): 

38 await client.xgroup_create(queue, group, id="0", mkstream=True) 

39 

40 await client.xreadgroup( 

41 groupname=group, 

42 consumername="temp", 

43 streams={queue: ">"}, 

44 count=len(payloads) + 10, 

45 ) 

46 

47 

48class StreamClaimTestcase(BaseTestcaseConfig[Any]): 

49 client_cls: Any = Redis 

50 """The client class whose `xreadgroup` the unsupported-server test patches; the cluster overrides it.""" 

51 

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) 

60 

61 received: list[tuple[Any, int, int]] = [] 

62 

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

79 

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

81 await skip_without_claim_support(br) 

82 

83 await make_pending(br, queue, "claim_group") 

84 await asyncio.sleep(0.3) 

85 await br.publish("new_message", stream=queue) 

86 

87 await br.start() 

88 

89 await asyncio.wait( 

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

91 timeout=3, 

92 ) 

93 

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 ] 

99 

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) 

108 

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

112 

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

126 

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

128 await skip_without_claim_support(br) 

129 

130 await make_pending( 

131 br, 

132 queue, 

133 "batch_claim_group", 

134 payloads=("first", "second"), 

135 ) 

136 await asyncio.sleep(0.5) 

137 

138 await br.start() 

139 

140 await asyncio.wait( 

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

142 timeout=3, 

143 ) 

144 

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

152 

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 

160 

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) 

165 

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

167 await skip_without_claim_support(br) 

168 await br.start() 

169 

170 await make_pending( 

171 br, 

172 queue, 

173 "repeat_claim_group", 

174 payloads=("first", "second"), 

175 ) 

176 await asyncio.sleep(0.3) 

177 

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 ) 

186 

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

196 

197 assert got == {"first", "second"} 

198 # The group read cursor survived both reads 

199 assert subscriber.read_id == ">" 

200 

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) 

205 

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

207 await skip_without_claim_support(br) 

208 await br.start() 

209 

210 await make_pending( 

211 br, 

212 queue, 

213 "iter_repeat_group", 

214 payloads=("first", "second"), 

215 ) 

216 await asyncio.sleep(0.3) 

217 

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 ) 

226 

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 

235 

236 assert got == {"first", "second"} 

237 assert subscriber.read_id == ">" 

238 

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

249 

250 consume_broker = self.get_broker(apply_types=True) 

251 

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

261 

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

263 fake_app = MagicMock() 

264 br.context.set_global("app", fake_app) 

265 

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) 

270 

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 

276 

277 assert not br.subscribers[0].running 

278 fake_app.exit.assert_called_once() 

279 

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) 

288 

289 received: list[Any] = [] 

290 

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

304 

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

306 await skip_without_claim_support(br) 

307 

308 await make_pending(br, queue, "concurrent_claim_group") 

309 await asyncio.sleep(0.3) 

310 await br.publish("new_message", stream=queue) 

311 

312 await br.start() 

313 

314 await asyncio.wait( 

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

316 timeout=3, 

317 ) 

318 

319 assert set(received) == {"pending_message", "new_message"} 

320 

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 ) 

326 

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

328 await br.start() 

329 

330 await br.publish("plain_message", stream=queue) 

331 

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

333 

334 assert message is not None 

335 assert set(message.raw_message) == {"type", "channel", "message_ids", "data"}