Coverage for tests/brokers/base/consume.py: 99%
294 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
2from contextlib import suppress
3from typing import Any
4from unittest.mock import MagicMock, call, patch
6import anyio
7import pytest
8from pydantic import BaseModel
10from faststream import AckPolicy, BaseMiddleware, Context, Depends, FastStream, TestApp
11from faststream.exceptions import StopConsume
12from faststream.message import StreamMessage
13from tests.tools import spy_decorator
15from .basic import BaseTestcaseConfig
18@pytest.mark.asyncio()
19class MultibrokerTestcase(BaseTestcaseConfig[Any]):
20 async def test_multi_consume(
21 self, queue: str, mock: MagicMock, event: asyncio.Event, event2: asyncio.Event
22 ) -> None:
23 broker1, broker2 = self.get_broker(), self.get_broker()
25 args, kwargs = self.get_subscriber_params(queue)
26 args2, kwargs2 = self.get_subscriber_params(queue + "1")
28 # A sync handler runs in a thread per broker, and two threads racing
29 # between `mock()` and the count check leave `event` unset
30 @broker1.subscriber(*args, **kwargs)
31 @broker2.subscriber(*args2, **kwargs2)
32 async def subscriber(m: Any) -> None:
33 mock()
34 if mock.call_count == 1:
35 event.set()
36 else:
37 event2.set()
39 app = FastStream(broker1, broker2)
41 async with (
42 self.patch_broker(broker1) as br1,
43 self.patch_broker(broker2) as br2,
44 TestApp(app),
45 ):
46 await asyncio.wait(
47 (
48 asyncio.create_task(br1.publish("hello", queue)),
49 asyncio.create_task(br2.publish("hello", queue + "1")),
50 asyncio.create_task(event.wait()),
51 asyncio.create_task(event2.wait()),
52 ),
53 timeout=self.timeout,
54 )
56 assert event.is_set()
57 assert event2.is_set()
58 assert mock.call_count == 2
60 async def test_another_broker_publisher(
61 self, queue: str, mock: MagicMock, event: asyncio.Event
62 ) -> None:
63 broker1, broker2 = self.get_broker(), self.get_broker()
65 args, kwargs = self.get_subscriber_params(queue)
67 @broker1.subscriber(*args, **kwargs)
68 @broker2.publisher(queue + "1")
69 def subscriber(m: Any) -> Any:
70 return m
72 args2, kwargs2 = self.get_subscriber_params(queue + "1")
74 # publisher sends message to the same broker
75 @broker2.subscriber(*args2, **kwargs2)
76 def subscriber2(m: Any) -> None:
77 mock(m)
78 event.set()
80 app = FastStream(broker1, broker2)
82 async with (
83 self.patch_broker(broker1) as br1,
84 self.patch_broker(broker2),
85 TestApp(app),
86 ):
87 await asyncio.wait(
88 (
89 asyncio.create_task(br1.publish("hello", queue)),
90 asyncio.create_task(event.wait()),
91 ),
92 timeout=self.timeout,
93 )
95 assert event.is_set()
96 mock.assert_called_once_with("hello")
98 async def test_crossbroker_publisher(
99 self, queue: str, mock: MagicMock, event: asyncio.Event
100 ) -> None:
101 broker1, broker2 = self.get_broker(), self.get_broker()
103 args, kwargs = self.get_subscriber_params(queue)
105 @broker1.subscriber(*args, **kwargs)
106 @broker2.publisher(queue + "1")
107 def subscriber(m: Any) -> Any:
108 return m
110 args2, kwargs2 = self.get_subscriber_params(queue + "1")
112 # publisher sends message to another broker
113 @broker1.subscriber(*args2, **kwargs2)
114 def subscriber2(m: Any) -> None:
115 mock(m)
116 event.set()
118 app = FastStream(broker1, broker2)
120 async with (
121 self.patch_broker(broker1, broker2) as (br1, _),
122 TestApp(app),
123 ):
124 await asyncio.wait(
125 (
126 asyncio.create_task(br1.publish("hello", queue)),
127 asyncio.create_task(event.wait()),
128 ),
129 timeout=self.timeout,
130 )
132 assert event.is_set()
133 mock.assert_called_once_with("hello")
136@pytest.mark.asyncio()
137class BrokerConsumeTestcase(MultibrokerTestcase, BaseTestcaseConfig[Any]):
138 async def test_consume(self, queue: str, event: asyncio.Event) -> None:
139 consume_broker = self.get_broker()
141 args, kwargs = self.get_subscriber_params(queue)
143 @consume_broker.subscriber(*args, **kwargs)
144 def subscriber(m: Any) -> None:
145 event.set()
147 async with self.patch_broker(consume_broker) as br:
148 await br.start()
149 await asyncio.wait(
150 (
151 asyncio.create_task(br.publish("hello", queue)),
152 asyncio.create_task(event.wait()),
153 ),
154 timeout=self.timeout,
155 )
157 assert event.is_set()
159 async def test_consume_from_multi(
160 self,
161 queue: str,
162 mock: MagicMock,
163 event: asyncio.Event,
164 event2: asyncio.Event,
165 ) -> None:
166 consume_broker = self.get_broker()
168 args, kwargs = self.get_subscriber_params(queue)
169 args2, kwargs2 = self.get_subscriber_params(queue + "1")
171 @consume_broker.subscriber(*args, **kwargs)
172 @consume_broker.subscriber(*args2, **kwargs2)
173 def subscriber(m: Any) -> None:
174 mock()
175 if not event.is_set():
176 event.set()
177 else:
178 event2.set()
180 async with self.patch_broker(consume_broker) as br:
181 await br.start()
182 await asyncio.wait(
183 (
184 asyncio.create_task(br.publish("hello", queue)),
185 asyncio.create_task(br.publish("hello", queue + "1")),
186 asyncio.create_task(event.wait()),
187 asyncio.create_task(event2.wait()),
188 ),
189 timeout=self.timeout,
190 )
192 assert event.is_set()
193 assert event2.is_set()
194 assert mock.call_count == 2
196 async def test_consume_double(
197 self,
198 queue: str,
199 mock: MagicMock,
200 event: asyncio.Event,
201 event2: asyncio.Event,
202 ) -> None:
203 consume_broker = self.get_broker()
205 args, kwargs = self.get_subscriber_params(queue)
207 @consume_broker.subscriber(*args, **kwargs)
208 async def handler(m: Any) -> None:
209 mock()
210 if not event.is_set():
211 event.set()
212 else:
213 event2.set()
215 async with self.patch_broker(consume_broker) as br:
216 await br.start()
217 await asyncio.wait(
218 (
219 asyncio.create_task(br.publish("hello", queue)),
220 asyncio.create_task(br.publish("hello", queue)),
221 asyncio.create_task(event.wait()),
222 asyncio.create_task(event2.wait()),
223 ),
224 timeout=self.timeout,
225 )
227 assert event2.is_set()
228 assert event.is_set()
229 assert mock.call_count == 2
231 async def test_different_consume(
232 self,
233 queue: str,
234 mock: MagicMock,
235 event: asyncio.Event,
236 event2: asyncio.Event,
237 ) -> None:
238 consume_broker = self.get_broker()
240 args, kwargs = self.get_subscriber_params(queue)
242 @consume_broker.subscriber(*args, **kwargs)
243 def handler(m: Any) -> None:
244 mock.handler()
245 event.set()
247 another_topic = queue + "1"
248 args, kwargs = self.get_subscriber_params(another_topic)
250 @consume_broker.subscriber(*args, **kwargs)
251 def handler2(m: Any) -> None:
252 mock.handler2()
253 event2.set()
255 async with self.patch_broker(consume_broker) as br:
256 await br.start()
257 await asyncio.wait(
258 (
259 asyncio.create_task(br.publish("hello", queue)),
260 asyncio.create_task(br.publish("hello", another_topic)),
261 asyncio.create_task(event.wait()),
262 asyncio.create_task(event2.wait()),
263 ),
264 timeout=self.timeout,
265 )
267 assert event.is_set()
268 assert event2.is_set()
269 mock.handler.assert_called_once()
270 mock.handler2.assert_called_once()
272 async def test_consume_with_filter(
273 self,
274 queue: str,
275 mock: MagicMock,
276 event: asyncio.Event,
277 event2: asyncio.Event,
278 ) -> None:
279 consume_broker = self.get_broker()
281 args, kwargs = self.get_subscriber_params(
282 queue,
283 )
285 sub = consume_broker.subscriber(*args, **kwargs)
287 @sub(filter=lambda m: m.content_type == "application/json")
288 async def handler(m: Any) -> None:
289 mock.handler(m)
290 event.set()
292 @sub
293 async def handler2(m: Any) -> None:
294 mock.handler2(m)
295 event2.set()
297 async with self.patch_broker(consume_broker) as br:
298 await br.start()
299 await asyncio.wait(
300 (
301 asyncio.create_task(br.publish({"msg": "hello"}, queue)),
302 asyncio.create_task(br.publish("hello", queue)),
303 asyncio.create_task(event.wait()),
304 asyncio.create_task(event2.wait()),
305 ),
306 timeout=self.timeout,
307 )
309 assert event.is_set()
310 assert event2.is_set()
311 mock.handler.assert_called_once_with({"msg": "hello"})
312 mock.handler2.assert_called_once_with("hello")
314 async def test_consume_validate_false(
315 self, queue: str, mock: MagicMock, event: asyncio.Event
316 ) -> None:
317 consume_broker = self.get_broker(
318 apply_types=True,
319 serializer=None,
320 )
322 class Foo(BaseModel):
323 x: int
325 def dependency() -> str:
326 return "100"
328 args, kwargs = self.get_subscriber_params(queue)
330 @consume_broker.subscriber(*args, **kwargs)
331 async def handler(
332 m: Foo,
333 dep: int = Depends(dependency),
334 broker: Any = Context(),
335 ) -> None:
336 mock(m, dep, broker)
337 event.set()
339 async with self.patch_broker(consume_broker) as br:
340 await br.start()
342 await asyncio.wait(
343 (
344 asyncio.create_task(br.publish({"x": 1}, queue)),
345 asyncio.create_task(event.wait()),
346 ),
347 timeout=self.timeout,
348 )
350 assert event.is_set()
351 mock.assert_called_once_with({"x": 1}, "100", consume_broker)
353 async def test_dynamic_sub(self, queue: str, event: asyncio.Event) -> None:
354 consume_broker = self.get_broker()
356 async def subscriber(m: Any) -> None:
357 event.set()
359 async with self.patch_broker(consume_broker) as br:
360 await br.start()
362 args, kwargs = self.get_subscriber_params(queue)
363 sub = br.subscriber(*args, **kwargs)
364 sub(subscriber)
365 await sub.start()
367 await br.publish("hello", queue)
369 with anyio.move_on_after(self.timeout):
370 await event.wait()
372 await sub.stop()
374 assert event.is_set()
376 async def test_sub_start_use_context_manager(
377 self, queue: str, event: asyncio.Event
378 ) -> None:
379 consume_broker = self.get_broker()
381 async def subscriber(m: Any) -> None:
382 event.set()
384 async with self.patch_broker(consume_broker) as br:
385 await br.start()
387 args, kwargs = self.get_subscriber_params(queue)
388 sub = br.subscriber(*args, **kwargs)
389 sub(subscriber)
391 async with sub:
392 await br.publish("hello", queue)
394 with anyio.move_on_after(self.timeout):
395 await event.wait()
397 assert event.is_set()
399 async def test_get_one_conflicts_with_handler(self, queue: str) -> None:
400 broker = self.get_broker(apply_types=True)
401 args, kwargs = self.get_subscriber_params(queue)
402 subscriber = broker.subscriber(*args, **kwargs)
404 @subscriber
405 async def t() -> None: ...
407 async with self.patch_broker(broker) as br:
408 await br.start()
410 with pytest.raises(AssertionError):
411 await subscriber.get_one(timeout=1e-24)
413 @pytest.mark.parametrize(
414 "ack_policy",
415 (
416 pytest.param(AckPolicy.ACK, id="ack"),
417 pytest.param(
418 AckPolicy.REJECT_ON_ERROR,
419 id="reject_on_error",
420 marks=[
421 pytest.mark.filterwarnings(
422 "ignore:AckPolicy.REJECT_ON_ERROR has the same effect"
423 )
424 ],
425 ),
426 pytest.param(AckPolicy.NACK_ON_ERROR, id="nack_on_error"),
427 ),
428 )
429 async def test_consume_cancel_skips_ack_nack_reject(
430 self,
431 queue: str,
432 ack_policy: AckPolicy,
433 event: asyncio.Event,
434 ) -> None:
435 if not self.supports_cancel_ack_skip:
436 pytest.skip("broker default subscriber has no acknowledgement middleware")
438 broker = self.get_broker(graceful_timeout=0.2)
439 args, kwargs = self.get_subscriber_params(
440 queue,
441 ack_policy=ack_policy,
442 **self.get_cancel_ack_subscriber_kwargs(queue),
443 )
445 @broker.subscriber(*args, **kwargs)
446 async def handler(_msg: Any) -> None:
447 event.set()
448 await asyncio.sleep(60)
450 with (
451 patch.object(
452 StreamMessage,
453 "nack",
454 spy_decorator(StreamMessage.nack),
455 ) as nack,
456 patch.object(
457 StreamMessage,
458 "ack",
459 spy_decorator(StreamMessage.ack),
460 ) as ack,
461 patch.object(
462 StreamMessage,
463 "reject",
464 spy_decorator(StreamMessage.reject),
465 ) as reject,
466 ):
467 async with self.patch_broker(broker) as br:
468 await br.start()
469 publish_task = asyncio.create_task(br.publish("hello", queue))
470 await asyncio.wait_for(event.wait(), timeout=self.timeout)
472 # TestBroker awaits the handler inside publish; real brokers
473 # return after enqueue, so cancel publish when still running.
474 # Otherwise broker context exit stops and cancels after
475 # graceful_timeout.
476 if not publish_task.done():
477 publish_task.cancel()
478 with pytest.raises(asyncio.CancelledError):
479 await publish_task
480 else:
481 await publish_task
483 nack.mock.assert_not_awaited()
484 ack.mock.assert_not_awaited()
485 reject.mock.assert_not_awaited()
487 async def test_consume_acks_on_middleware_error(
488 self,
489 queue: str,
490 event: asyncio.Event,
491 ) -> None:
492 if not self.supports_cancel_ack_skip:
493 pytest.skip("broker default subscriber has no acknowledgement middleware")
495 class FailingMiddleware(BaseMiddleware):
496 async def on_receive(self) -> None:
497 raise ValueError
499 broker = self.get_broker()
500 broker.add_middleware(FailingMiddleware)
501 args, kwargs = self.get_subscriber_params(
502 queue,
503 ack_policy=AckPolicy.ACK,
504 **self.get_cancel_ack_subscriber_kwargs(queue),
505 )
507 @broker.subscriber(*args, **kwargs)
508 async def handler(_msg: Any) -> None: ...
510 with patch.object(StreamMessage, "ack", spy_decorator(StreamMessage.ack)) as ack:
511 ack.mock.side_effect = lambda *_, **__: event.set()
513 async with self.patch_broker(broker) as br:
514 await br.start()
516 with suppress(ValueError):
517 await br.publish("hello", queue)
519 await asyncio.wait_for(event.wait(), timeout=self.timeout)
521 ack.mock.assert_awaited_once()
524@pytest.mark.asyncio()
525class BrokerRealConsumeTestcase(BrokerConsumeTestcase):
526 async def test_get_one(
527 self,
528 queue: str,
529 mock: MagicMock,
530 ) -> None:
531 broker = self.get_broker(apply_types=True)
533 args, kwargs = self.get_subscriber_params(queue)
534 subscriber = broker.subscriber(*args, **kwargs)
536 async with self.patch_broker(broker) as br:
537 await br.start()
539 async def consume() -> None:
540 mock(await subscriber.get_one(timeout=self.timeout))
542 async def publish() -> None:
543 await anyio.sleep(1e-24)
544 await br.publish("test_message", queue)
546 await asyncio.wait(
547 (
548 asyncio.create_task(consume()),
549 asyncio.create_task(publish()),
550 ),
551 timeout=self.timeout,
552 )
554 mock.assert_called_once()
555 message = mock.call_args[0][0]
556 assert message
557 assert await message.decode() == "test_message", await message.decode()
559 async def test_get_one_timeout(
560 self,
561 queue: str,
562 mock: MagicMock,
563 ) -> None:
564 broker = self.get_broker(apply_types=True)
565 args, kwargs = self.get_subscriber_params(queue)
566 subscriber = broker.subscriber(*args, **kwargs)
568 async with self.patch_broker(broker) as br:
569 await br.start()
571 mock(await subscriber.get_one(timeout=1e-24))
572 mock.assert_called_once_with(None)
574 @pytest.mark.slow()
575 async def test_stop_consume_exc(
576 self, queue: str, mock: MagicMock, event: asyncio.Event
577 ) -> None:
578 consume_broker = self.get_broker()
580 args, kwargs = self.get_subscriber_params(queue)
582 @consume_broker.subscriber(*args, **kwargs)
583 def subscriber(m: Any) -> None:
584 mock()
585 event.set()
586 raise StopConsume
588 async with self.patch_broker(consume_broker) as br:
589 await br.start()
590 await asyncio.wait(
591 (
592 asyncio.create_task(br.publish("hello", queue)),
593 asyncio.create_task(event.wait()),
594 ),
595 timeout=self.timeout,
596 )
597 await asyncio.sleep(0.5)
598 await br.publish("hello", queue)
599 await asyncio.sleep(0.5)
601 assert event.is_set()
602 mock.assert_called_once()
604 @pytest.mark.asyncio()
605 async def test_iteration(
606 self,
607 queue: str,
608 mock: MagicMock,
609 ) -> None:
610 expected_messages = ("test_message_1", "test_message_2")
612 broker = self.get_broker(apply_types=True)
614 args, kwargs = self.get_subscriber_params(queue)
615 subscriber = broker.subscriber(*args, **kwargs)
617 async with self.patch_broker(broker) as br:
618 await br.start()
620 async def publish_test_message() -> None:
621 for msg in expected_messages:
622 await br.publish(msg, queue)
624 async def consume() -> None:
625 index_message = 0
626 async for msg in subscriber: 626 ↛ exitline 626 didn't return from function 'consume' because the loop on line 626 didn't complete
627 result_message = await msg.decode()
629 mock(result_message)
631 index_message += 1
632 if index_message >= len(expected_messages):
633 break
635 await asyncio.wait(
636 (
637 asyncio.create_task(consume()),
638 asyncio.create_task(publish_test_message()),
639 ),
640 timeout=self.timeout,
641 )
643 calls = [call(msg) for msg in expected_messages]
644 mock.assert_has_calls(calls=calls)