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
« 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
6import pytest
7from freezegun import freeze_time
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
21from .basic import RabbitMemoryTestcaseConfig
22from .test_publish import TestPublishWithExchange as PublishWithExchangeCase
24_frozen_time = dt.datetime(2026, 2, 10, 12, 0, 0, tzinfo=dt.timezone.utc)
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()
36 @broker.subscriber(queue)
37 def subscriber(m: Any) -> None:
38 event.set()
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 )
49 assert event.is_set()
51 async def test_direct_not_found(
52 self,
53 ) -> None:
54 broker = self.get_broker()
56 async with self.patch_broker(broker) as br:
57 with pytest.raises(SubscriberNotFound):
58 await br.request("", "")
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()
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")
69 async with self.patch_broker(broker):
70 await publisher.publish(None, routing_key="new-key")
71 publisher.mock.assert_called_once()
73 await another_publisher.publish(None, routing_key="new-key")
74 another_publisher.mock.assert_called_once()
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)
86 @broker.subscriber(queue=queue, exchange=exchange)
87 async def handler(msg: RabbitMessage) -> None:
88 await msg.raw_message.ack()
89 event.set()
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
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
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 )
122 assert event.is_set()
123 assert event2.is_set()
124 assert event3.is_set()
126 async def test_respect_middleware(self, queue: str) -> None:
127 routes: list[Any] = []
129 class Middleware(BaseMiddleware):
130 async def on_receive(self) -> None:
131 routes.append(None)
132 return await super().on_receive()
134 broker = self.get_broker(middlewares=(Middleware,))
136 @broker.subscriber(queue)
137 async def h1(msg: Any) -> None: ...
139 @broker.subscriber(queue + "1")
140 async def h2(msg: Any) -> None: ...
142 async with self.patch_broker(broker) as br:
143 await br.publish("", queue)
144 await br.publish("", queue + "1")
146 assert len(routes) == 2
148 @pytest.mark.connected()
149 async def test_real_respect_middleware(self, queue: str) -> None:
150 routes: list[Any] = []
152 class Middleware(BaseMiddleware):
153 async def on_receive(self) -> None:
154 routes.append(None)
155 return await super().on_receive()
157 broker = self.get_broker(middlewares=(Middleware,))
159 @broker.subscriber(queue)
160 async def h1(msg: Any) -> None: ...
162 @broker.subscriber(queue + "1")
163 async def h2(msg: Any) -> None: ...
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)
171 assert len(routes) == 2
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)
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()
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)
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)
205 args, kwargs = self.get_subscriber_params(queue)
207 @broker.subscriber(*args, **kwargs)
208 async def m(msg: RabbitMessage) -> None:
209 mock(msg)
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
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
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)
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)
284broker = RabbitBroker()
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 )