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

116 statements  

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

1import asyncio 

2import datetime as dt 

3from typing import Any 

4from unittest.mock import MagicMock 

5 

6import pytest 

7from freezegun import freeze_time 

8 

9from faststream import BaseMiddleware 

10from faststream.exceptions import SubscriberNotFound 

11from faststream.rabbit import ( 

12 ExchangeType, 

13 RabbitBroker, 

14 RabbitExchange, 

15 RabbitQueue, 

16) 

17from faststream.rabbit.annotations import RabbitMessage 

18from faststream.rabbit.testing import FakeProducer, _is_handler_matches, apply_pattern 

19from tests.brokers.base.testclient import BrokerTestclientTestcase 

20 

21from .basic import RabbitMemoryTestcaseConfig 

22from .test_publish import TestPublishWithExchange as PublishWithExchangeCase 

23 

24_frozen_time = dt.datetime(2026, 2, 10, 12, 0, 0, tzinfo=dt.timezone.utc) 

25 

26 

27@pytest.mark.rabbit() 

28@pytest.mark.asyncio() 

29class TestTestclient( 

30 PublishWithExchangeCase, RabbitMemoryTestcaseConfig, BrokerTestclientTestcase 

31): 

32 @pytest.mark.connected() 

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

34 broker = self.get_broker() 

35 

36 @broker.subscriber(queue) 

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

38 event.set() 

39 

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

41 await asyncio.wait( 

42 ( 

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

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

45 ), 

46 timeout=3, 

47 ) 

48 

49 assert event.is_set() 

50 

51 async def test_direct_not_found( 

52 self, 

53 ) -> None: 

54 broker = self.get_broker() 

55 

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

57 with pytest.raises(SubscriberNotFound): 

58 await br.request("", "") 

59 

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

61 async def test_publisher_without_destination(self) -> None: 

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

63 broker = self.get_broker() 

64 

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

66 publisher = broker.publisher(exchange="test_exchange") 

67 another_publisher = broker.publisher(exchange="test_exchange") 

68 

69 async with self.patch_broker(broker): 

70 await publisher.publish(None, routing_key="new-key") 

71 publisher.mock.assert_called_once() 

72 

73 await another_publisher.publish(None, routing_key="new-key") 

74 another_publisher.mock.assert_called_once() 

75 

76 async def test_consume_manual_ack( 

77 self, 

78 queue: str, 

79 exchange: RabbitExchange, 

80 event: asyncio.Event, 

81 event2: asyncio.Event, 

82 event3: asyncio.Event, 

83 ) -> None: 

84 broker = self.get_broker(apply_types=True) 

85 

86 @broker.subscriber(queue=queue, exchange=exchange) 

87 async def handler(msg: RabbitMessage) -> None: 

88 await msg.raw_message.ack() 

89 event.set() 

90 

91 @broker.subscriber(queue=queue + "1", exchange=exchange) 

92 async def handler2(msg: RabbitMessage) -> None: 

93 await msg.raw_message.nack() 

94 event2.set() 

95 raise ValueError 

96 

97 @broker.subscriber(queue=queue + "2", exchange=exchange) 

98 async def handler3(msg: RabbitMessage) -> None: 

99 await msg.raw_message.reject() 

100 event3.set() 

101 raise ValueError 

102 

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

104 await asyncio.wait( 

105 ( 

106 asyncio.create_task( 

107 br.publish("hello", queue=queue, exchange=exchange), 

108 ), 

109 asyncio.create_task( 

110 br.publish("hello", queue=queue + "1", exchange=exchange), 

111 ), 

112 asyncio.create_task( 

113 br.publish("hello", queue=queue + "2", exchange=exchange), 

114 ), 

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

116 asyncio.create_task(event2.wait()), 

117 asyncio.create_task(event3.wait()), 

118 ), 

119 timeout=3, 

120 ) 

121 

122 assert event.is_set() 

123 assert event2.is_set() 

124 assert event3.is_set() 

125 

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

127 routes: list[Any] = [] 

128 

129 class Middleware(BaseMiddleware): 

130 async def on_receive(self) -> None: 

131 routes.append(None) 

132 return await super().on_receive() 

133 

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

135 

136 @broker.subscriber(queue) 

137 async def h1(msg: Any) -> None: ... 

138 

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

140 async def h2(msg: Any) -> None: ... 

141 

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

143 await br.publish("", queue) 

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

145 

146 assert len(routes) == 2 

147 

148 @pytest.mark.connected() 

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

150 routes: list[Any] = [] 

151 

152 class Middleware(BaseMiddleware): 

153 async def on_receive(self) -> None: 

154 routes.append(None) 

155 return await super().on_receive() 

156 

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

158 

159 @broker.subscriber(queue) 

160 async def h1(msg: Any) -> None: ... 

161 

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

163 async def h2(msg: Any) -> None: ... 

164 

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

166 await br.publish("", queue) 

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

168 await h1.wait_call(3) 

169 await h2.wait_call(3) 

170 

171 assert len(routes) == 2 

172 

173 @pytest.mark.connected() 

174 async def test_broker_gets_patched_attrs_within_cm(self) -> None: 

175 await super().test_broker_gets_patched_attrs_within_cm(FakeProducer) 

176 

177 @pytest.mark.connected() 

178 async def test_broker_with_real_doesnt_get_patched(self) -> None: 

179 await super().test_broker_with_real_doesnt_get_patched() 

180 

181 @pytest.mark.connected() 

182 async def test_broker_with_real_patches_publishers_and_subscribers( 

183 self, 

184 queue: str, 

185 ) -> None: 

186 await super().test_broker_with_real_patches_publishers_and_subscribers(queue) 

187 

188 @pytest.mark.asyncio() 

189 @pytest.mark.parametrize( 

190 ("expiration", "expected"), 

191 ( 

192 pytest.param(None, None, id="none"), 

193 pytest.param(1, 1, id="int"), 

194 pytest.param(1.5, 1.5, id="float"), 

195 pytest.param(dt.timedelta(seconds=1.1), 1.1, id="timedelta"), 

196 pytest.param(_frozen_time, 0, id="datetime"), 

197 ), 

198 ) 

199 @freeze_time(_frozen_time) 

200 async def test_publish_expiration_propagated( 

201 self, expiration: Any, expected: Any, queue: str, mock: MagicMock 

202 ) -> None: 

203 broker = self.get_broker(apply_types=True) 

204 

205 args, kwargs = self.get_subscriber_params(queue) 

206 

207 @broker.subscriber(*args, **kwargs) 

208 async def m(msg: RabbitMessage) -> None: 

209 mock(msg) 

210 

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

212 await br.start() 

213 await br.publish("hello", queue, expiration=expiration) 

214 msg = mock.call_args[0][0] 

215 assert msg.raw_message.expiration == expected 

216 

217 

218@pytest.mark.rabbit() 

219@pytest.mark.parametrize( 

220 ("pattern", "current", "result"), 

221 ( 

222 pytest.param("", "", True, id="empty binding and routing key"), 

223 pytest.param("#", "", True, id="# - empty routing key"), 

224 pytest.param("#.*", "", False, id="#.* - empty routing key"), 

225 pytest.param("*.#", "", False, id="*.# - empty routing key"), 

226 pytest.param("#", "1.2.3", True, id="#"), 

227 pytest.param("*", "1", True, id="*"), 

228 pytest.param("*", "1.2", False, id="* - broken"), 

229 pytest.param("test.*", "test.1", True, id="test.*"), 

230 pytest.param("test.#", "test.1", True, id="test.#"), 

231 pytest.param("test.#", "test", True, id="test.# - zero words"), 

232 pytest.param("#.test", "test", True, id="#.test - zero words"), 

233 pytest.param("#.*", "1", True, id="#.* - zero words"), 

234 pytest.param("#.test", "test.test.test", True, id="#.test - repeated word"), 

235 pytest.param("#.test.#", "1.2.test.1.2", True, id="#.test.#"), 

236 pytest.param("#.test.*", "1.2.test.1", True, id="#.test.*"), 

237 pytest.param("#.test.*.*", "1.2.test.1.2", True, id="#.test.*."), 

238 pytest.param("#.test.*.*.*", "1.2.test.1.2", False, id="#.test.*.*.* - broken"), 

239 pytest.param( 

240 "#.test.*.test.#", 

241 "1.2.test.1.test.1.2", 

242 True, 

243 id="#.test.*.test.#", 

244 ), 

245 pytest.param("#.*.test", "1.2.2.test", True, id="#.*.test"), 

246 pytest.param("#.2.*.test", "1.2.2.test", True, id="#.2.*.test"), 

247 pytest.param("#.*.*.test", "1.2.2.test", True, id="#.*.*.test"), 

248 pytest.param("*.*.*.test", "1.2.test", False, id="*.*.*.test - broken"), 

249 pytest.param("#.*.*.test", "1.2.test", True, id="#.*.*.test - zero words"), 

250 pytest.param("#.*.*.test", "1.test", False, id="#.*.*.test - broken"), 

251 ), 

252) 

253def test(pattern: str, current: str, result: bool) -> None: 

254 assert apply_pattern(pattern, current) == result 

255 

256 

257exch_direct = RabbitExchange("exchange", auto_delete=True, type=ExchangeType.DIRECT) 

258exch_fanout = RabbitExchange("exchange", auto_delete=True, type=ExchangeType.FANOUT) 

259exch_topic = RabbitExchange("exchange", auto_delete=True, type=ExchangeType.TOPIC) 

260exch_headers = RabbitExchange("exchange", auto_delete=True, type=ExchangeType.HEADERS) 

261regular_queue = RabbitQueue("test-regular-queue", auto_delete=True) 

262 

263routing_key_queue = RabbitQueue( 

264 "test-routing-key-queue", 

265 auto_delete=True, 

266 routing_key="*.info", 

267) 

268one_key_queue = RabbitQueue( 

269 "test-one-key-queue", 

270 auto_delete=True, 

271 bind_arguments={"key": 1}, 

272) 

273any_keys_queue = RabbitQueue( 

274 "test-any-keys-queue", 

275 auto_delete=True, 

276 bind_arguments={"key": 2, "key2": 2, "x-match": "any"}, 

277) 

278all_keys_queue = RabbitQueue( 

279 "test-all-keys-queue", 

280 auto_delete=True, 

281 bind_arguments={"key": 2, "key2": 2, "x-match": "all"}, 

282) 

283 

284broker = RabbitBroker() 

285 

286 

287@pytest.mark.rabbit() 

288@pytest.mark.parametrize( 

289 ( 

290 "queue", 

291 "exchange", 

292 "routing_key", 

293 "headers", 

294 "expected_result", 

295 ), 

296 ( 

297 pytest.param( 

298 regular_queue, 

299 exch_direct, 

300 regular_queue.routing(), 

301 {}, 

302 True, 

303 id="direct match", 

304 ), 

305 pytest.param( 

306 regular_queue, 

307 exch_direct, 

308 "wrong key", 

309 {}, 

310 False, 

311 id="direct mismatch", 

312 ), 

313 pytest.param( 

314 regular_queue, 

315 exch_fanout, 

316 "", 

317 {}, 

318 True, 

319 id="fanout match", 

320 ), 

321 pytest.param( 

322 routing_key_queue, 

323 exch_topic, 

324 "log.info", 

325 {}, 

326 True, 

327 id="topic match", 

328 ), 

329 pytest.param( 

330 routing_key_queue, 

331 exch_topic, 

332 "log.wrong", 

333 {}, 

334 False, 

335 id="topic mismatch", 

336 ), 

337 pytest.param( 

338 one_key_queue, 

339 exch_headers, 

340 "", 

341 {"key": 1}, 

342 True, 

343 id="one header match", 

344 ), 

345 pytest.param( 

346 one_key_queue, 

347 exch_headers, 

348 "", 

349 {"key": "wrong"}, 

350 False, 

351 id="one header mismatch", 

352 ), 

353 pytest.param( 

354 any_keys_queue, 

355 exch_headers, 

356 "", 

357 {"key2": 2}, 

358 True, 

359 id="any headers match", 

360 ), 

361 pytest.param( 

362 any_keys_queue, 

363 exch_headers, 

364 "", 

365 {"key2": "wrong"}, 

366 False, 

367 id="any headers mismatch", 

368 ), 

369 pytest.param( 

370 all_keys_queue, 

371 exch_headers, 

372 "", 

373 {"key": 2, "key2": 2}, 

374 True, 

375 id="all headers match", 

376 ), 

377 pytest.param( 

378 all_keys_queue, 

379 exch_headers, 

380 "", 

381 {"key": "wrong", "key2": 2}, 

382 False, 

383 id="all headers mismatch", 

384 ), 

385 ), 

386) 

387def test_in_memory_routing( 

388 queue: str, 

389 exchange: RabbitExchange, 

390 routing_key: str, 

391 headers: dict[str, Any], 

392 expected_result: bool, 

393) -> None: 

394 subscriber = broker.subscriber(queue, exchange) 

395 assert ( 

396 _is_handler_matches(subscriber, routing_key, headers, exchange) is expected_result 

397 )