Coverage for tests/brokers/redis/test_test_client.py: 97%

196 statements  

« prev     ^ index     » next       coverage.py v7.17.3, created at 2026-11-17 21:20 +0000

1import asyncio 

2from typing import Any 

3 

4import pytest 

5 

6from faststream import BaseMiddleware 

7from faststream.exceptions import SetupError 

8from faststream.redis import ListSub, StreamSub 

9from faststream.redis.testing import FakeProducer 

10from tests.brokers.base.testclient import BrokerTestclientTestcase 

11 

12from .basic import RedisMemoryTestcaseConfig 

13 

14 

15@pytest.mark.redis() 

16@pytest.mark.asyncio() 

17class TestTestclient(RedisMemoryTestcaseConfig, BrokerTestclientTestcase): 

18 @pytest.mark.connected() 

19 async def test_with_real_testclient(self, queue: str, event: asyncio.Event) -> None: 

20 broker = self.get_broker() 

21 

22 @broker.subscriber(queue) 

23 def subscriber(m: Any) -> None: 

24 event.set() 

25 

26 async with self.patch_broker(broker, with_real=True) as br: 

27 await asyncio.wait( 

28 ( 

29 asyncio.create_task(br.publish("hello", queue)), 

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

31 ), 

32 timeout=3, 

33 ) 

34 

35 assert event.is_set() 

36 

37 async def test_respect_middleware(self, queue: str) -> None: 

38 routes: list[Any] = [] 

39 

40 class Middleware(BaseMiddleware): 

41 async def on_receive(self) -> None: 

42 routes.append(None) 

43 return await super().on_receive() 

44 

45 broker = self.get_broker(middlewares=(Middleware,)) 

46 

47 @broker.subscriber(queue) 

48 async def h1(m: Any) -> None: ... 

49 

50 @broker.subscriber(queue + "1") 

51 async def h2(m: Any) -> None: ... 

52 

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

54 await br.publish("", queue) 

55 await br.publish("", queue + "1") 

56 

57 assert len(routes) == 2 

58 

59 @pytest.mark.connected() 

60 async def test_real_respect_middleware(self, queue: str) -> None: 

61 routes: list[Any] = [] 

62 

63 class Middleware(BaseMiddleware): 

64 async def on_receive(self) -> None: 

65 routes.append(None) 

66 return await super().on_receive() 

67 

68 broker = self.get_broker(middlewares=(Middleware,)) 

69 

70 @broker.subscriber(queue) 

71 async def h1(m: Any) -> None: ... 

72 

73 @broker.subscriber(queue + "1") 

74 async def h2(m: Any) -> None: ... 

75 

76 async with self.patch_broker(broker, with_real=True) as br: 

77 await br.publish("", queue) 

78 await br.publish("", queue + "1") 

79 await h1.wait_call(3) 

80 await h2.wait_call(3) 

81 

82 assert len(routes) == 2 

83 

84 async def test_pub_sub_pattern(self) -> None: 

85 broker = self.get_broker() 

86 

87 @broker.subscriber("test.{name}") 

88 async def handler(msg: Any) -> Any: 

89 return msg 

90 

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

92 assert await (await br.request(1, "test.name.useless")).decode() == 1 

93 handler.mock.assert_called_once_with(1) 

94 

95 async def test_pub_sub_pattern_matches_whole_channel(self) -> None: 

96 broker = self.get_broker() 

97 

98 @broker.subscriber("logs.*.error") 

99 async def handler(msg: Any) -> None: ... 

100 

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

102 await br.publish("1", "logs.app.error") 

103 await br.publish("2", "logs.app.error.extra") 

104 await br.publish("3", "logs.app.errors") 

105 

106 handler.mock.assert_called_once_with("1") 

107 

108 async def test_list( 

109 self, 

110 queue: str, 

111 ) -> None: 

112 broker = self.get_broker() 

113 

114 @broker.subscriber(list=queue) 

115 async def handler(msg: Any) -> Any: 

116 return msg 

117 

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

119 assert await (await br.request(1, list=queue)).decode() == 1 

120 handler.mock.assert_called_once_with(1) 

121 

122 async def test_batch_pub_by_default_pub( 

123 self, 

124 queue: str, 

125 ) -> None: 

126 broker = self.get_broker() 

127 

128 @broker.subscriber(list=ListSub(queue, batch=True)) 

129 async def m(msg: Any) -> None: 

130 pass 

131 

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

133 await br.publish("hello", list=queue) 

134 m.mock.assert_called_once_with(["hello"]) 

135 

136 async def test_batch_pub_by_pub_batch( 

137 self, 

138 queue: str, 

139 ) -> None: 

140 broker = self.get_broker() 

141 

142 @broker.subscriber(list=ListSub(queue, batch=True)) 

143 async def m(msg: Any) -> None: 

144 pass 

145 

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

147 await br.publish_batch("hello", list=queue) 

148 m.mock.assert_called_once_with(["hello"]) 

149 

150 async def test_batch_assert_called_once_with(self, queue: str) -> None: 

151 broker = self.get_broker() 

152 

153 @broker.subscriber(list=ListSub(queue, batch=True)) 

154 async def m(msg: Any) -> None: ... 

155 

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

157 await br.publish_batch({"n": 1}, {"n": 2}, list=queue) 

158 

159 await m.assert_called_once_with([{"n": 1}, {"n": 2}]) 

160 

161 # A batch has one header set per message, so there is no single answer 

162 with pytest.raises(SetupError, match="received a batch"): 

163 await m.assert_called_once_with(headers={"key": "value"}) 

164 

165 async def test_publish_batch_to_single_list(self, queue: str) -> None: 

166 broker = self.get_broker() 

167 received: list[Any] = [] 

168 

169 @broker.subscriber(list=queue) 

170 async def handler(msg: Any) -> None: 

171 received.append(msg) 

172 

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

174 await br.publish_batch(1, "hi", {"n": 2}, list=queue) 

175 

176 assert received == [1, "hi", {"n": 2}] 

177 

178 async def test_batch_publisher_mock( 

179 self, 

180 queue: str, 

181 ) -> None: 

182 broker = self.get_broker() 

183 

184 batch_list = ListSub(queue + "1", batch=True) 

185 publisher = broker.publisher(list=batch_list) 

186 

187 @publisher 

188 @broker.subscriber(queue) 

189 async def m(msg: Any) -> Any: 

190 return 1, 2, 3 

191 

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

193 await br.publish("hello", queue) 

194 m.mock.assert_called_once_with("hello") 

195 publisher.mock.assert_called_once_with([1, 2, 3]) 

196 

197 @pytest.mark.parametrize( 

198 "returned", 

199 (pytest.param(None, id="None"), pytest.param([], id="Empty Sequence")), 

200 ) 

201 async def test_batch_publisher_empty_result_matches_default_publisher( 

202 self, 

203 queue: str, 

204 returned: Any, 

205 ) -> None: 

206 """Fixes https://github.com/ag2ai/faststream/issues/3056. 

207 

208 An empty result publishes one empty message, exactly as a non-batch 

209 publisher does. 

210 """ 

211 broker = self.get_broker() 

212 

213 batch_publisher = broker.publisher(list=ListSub(queue + "1", batch=True)) 

214 default_publisher = broker.publisher(list=queue + "2") 

215 

216 @batch_publisher 

217 @broker.subscriber(queue) 

218 async def batched(msg: Any) -> Any: 

219 return returned 

220 

221 @default_publisher 

222 @broker.subscriber(queue + "3") 

223 async def single(msg: Any) -> None: 

224 return None 

225 

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

227 await br.publish("hello", queue) 

228 await br.publish("hello", queue + "3") 

229 

230 default_publisher.mock.assert_called_once_with(b"") 

231 # Redis batch subscribers decode every element to `str`, so the same 

232 # empty message on the wire is observed as `""` rather than `b""`. 

233 batch_publisher.mock.assert_called_once_with([""]) 

234 

235 async def test_stream( 

236 self, 

237 queue: str, 

238 ) -> None: 

239 broker = self.get_broker() 

240 

241 @broker.subscriber(stream=queue) 

242 async def handler(msg: Any) -> Any: 

243 return msg 

244 

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

246 assert await (await br.request(1, stream=queue)).decode() == 1 

247 handler.mock.assert_called_once_with(1) 

248 

249 async def test_stream_batch_pub_by_default_pub( 

250 self, 

251 queue: str, 

252 ) -> None: 

253 broker = self.get_broker() 

254 

255 @broker.subscriber(stream=StreamSub(queue, batch=True)) 

256 async def m(msg: Any) -> None: 

257 pass 

258 

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

260 await br.publish("hello", stream=queue) 

261 m.mock.assert_called_once_with(["hello"]) 

262 

263 async def test_stream_publisher( 

264 self, 

265 queue: str, 

266 ) -> None: 

267 broker = self.get_broker() 

268 

269 batch_stream = StreamSub(queue + "1") 

270 publisher = broker.publisher(stream=batch_stream) 

271 

272 @publisher 

273 @broker.subscriber(queue) 

274 async def m(msg: Any) -> Any: 

275 return 1, 2, 3 

276 

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

278 await br.publish("hello", queue) 

279 m.mock.assert_called_once_with("hello") 

280 publisher.mock.assert_called_once_with([1, 2, 3]) 

281 

282 async def test_stream_same_group_delivers_to_one_consumer( 

283 self, 

284 queue: str, 

285 ) -> None: 

286 broker = self.get_broker() 

287 

288 @broker.subscriber( 

289 stream=StreamSub(queue, group="workers", consumer="consumer-1"), 

290 ) 

291 async def subscriber1(msg: Any) -> None: ... 

292 

293 @broker.subscriber( 

294 stream=StreamSub(queue, group="workers", consumer="consumer-2"), 

295 ) 

296 async def subscriber2(msg: Any) -> None: ... 

297 

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

299 await br.publish("hello", stream=queue) 

300 

301 # exactly one consumer of the group handles the message 

302 called = [m for m in (subscriber1.mock, subscriber2.mock) if m.call_count] 

303 assert len(called) == 1 

304 called[0].assert_called_once_with("hello") 

305 

306 async def test_stream_different_groups_all_receive( 

307 self, 

308 queue: str, 

309 ) -> None: 

310 broker = self.get_broker() 

311 

312 @broker.subscriber( 

313 stream=StreamSub(queue, group="workers-a", consumer="consumer-1"), 

314 ) 

315 async def subscriber1(msg: Any) -> None: ... 

316 

317 @broker.subscriber( 

318 stream=StreamSub(queue, group="workers-b", consumer="consumer-1"), 

319 ) 

320 async def subscriber2(msg: Any) -> None: ... 

321 

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

323 await br.publish("hello", stream=queue) 

324 

325 subscriber1.mock.assert_called_once_with("hello") 

326 subscriber2.mock.assert_called_once_with("hello") 

327 

328 async def test_stream_without_group_always_receives( 

329 self, 

330 queue: str, 

331 ) -> None: 

332 broker = self.get_broker() 

333 

334 @broker.subscriber( 

335 stream=StreamSub(queue, group="workers", consumer="consumer-1"), 

336 ) 

337 async def grouped(msg: Any) -> None: ... 

338 

339 @broker.subscriber(stream=queue) 

340 async def ungrouped(msg: Any) -> None: ... 

341 

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

343 await br.publish("hello", stream=queue) 

344 

345 grouped.mock.assert_called_once_with("hello") 

346 ungrouped.mock.assert_called_once_with("hello") 

347 

348 async def test_publish_to_none(self) -> None: 

349 broker = self.get_broker() 

350 

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

352 with pytest.raises(ValueError): # ruff: ignore[pytest-raises-too-broad] 

353 await br.publish("hello") 

354 

355 @pytest.mark.connected() 

356 async def test_broker_gets_patched_attrs_within_cm(self) -> None: 

357 await super().test_broker_gets_patched_attrs_within_cm(FakeProducer) 

358 

359 @pytest.mark.connected() 

360 async def test_broker_with_real_doesnt_get_patched(self) -> None: 

361 await super().test_broker_with_real_doesnt_get_patched() 

362 

363 @pytest.mark.connected() 

364 async def test_broker_with_real_patches_publishers_and_subscribers( 

365 self, 

366 queue: str, 

367 ) -> None: 

368 await super().test_broker_with_real_patches_publishers_and_subscribers(queue) 

369 

370 @pytest.mark.xfail(reason="https://github.com/ag2ai/faststream/issues/2513") 

371 async def test_publisher_without_destination(self) -> None: 

372 """Fixes https://github.com/ag2ai/faststream/issues/2513.""" 

373 broker = self.get_broker() 

374 

375 # use two publishers to check that we don't have conflicts 

376 channel_publisher = broker.publisher(channel="") 

377 another_channel_publisher = broker.publisher(channel="") 

378 

379 list_publisher = broker.publisher(list="") 

380 stream_publisher = broker.publisher(stream="") 

381 

382 async with self.patch_broker(broker): 

383 await channel_publisher.publish(None, channel="new-key") 

384 channel_publisher.mock.assert_called_once() 

385 

386 await another_channel_publisher.publish(None, channel="new-key") 

387 another_channel_publisher.mock.assert_called_once() 

388 

389 await list_publisher.publish(None, list="new-key") 

390 list_publisher.mock.assert_called_once() 

391 

392 await stream_publisher.publish(None, stream="new-key") 

393 stream_publisher.mock.assert_called_once()