Coverage for tests/brokers/base/middlewares.py: 99%
482 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 collections.abc import Awaitable, Callable
3from types import TracebackType
4from typing import Any
5from unittest.mock import MagicMock, call
7import pytest
8from typing_extensions import Self
10from faststream import Context
11from faststream._internal.basic_types import DecodedMessage
12from faststream.exceptions import SkipMessage
13from faststream.middlewares import BaseMiddleware, ExceptionMiddleware
15from .basic import BaseTestcaseConfig
18@pytest.mark.asyncio()
19class MiddlewaresOrderTestcase(BaseTestcaseConfig[Any]):
20 async def test_broker_middleware_order(self, queue: str, mock: MagicMock) -> None:
21 class InnerMiddleware(BaseMiddleware):
22 async def __aenter__(self) -> Self:
23 mock.enter_inner()
24 mock.enter("inner")
25 return self
27 async def __aexit__(self, *args: Any) -> None:
28 mock.exit_inner()
29 mock.exit("inner")
31 async def consume_scope(
32 self, call_next: Callable[[Any], Awaitable[Any]], msg: Any
33 ) -> Any:
34 mock.consume_inner()
35 mock.sub("inner")
36 return await call_next(msg)
38 async def publish_scope(
39 self, call_next: Callable[[Any], Awaitable[Any]], cmd: Any
40 ) -> Any:
41 mock.publish_inner()
42 mock.pub("inner")
43 return await call_next(cmd)
45 class OuterMiddleware(BaseMiddleware):
46 async def __aenter__(self) -> Self:
47 mock.enter_outer()
48 mock.enter("outer")
49 return self
51 async def __aexit__(self, *args: Any) -> None:
52 mock.exit_outer()
53 mock.exit("outer")
55 async def consume_scope(
56 self, call_next: Callable[[Any], Awaitable[Any]], msg: Any
57 ) -> Any:
58 mock.consume_outer()
59 mock.sub("outer")
60 return await call_next(msg)
62 async def publish_scope(
63 self, call_next: Callable[[Any], Awaitable[Any]], cmd: Any
64 ) -> Any:
65 mock.publish_outer()
66 mock.pub("outer")
67 return await call_next(cmd)
69 broker = self.get_broker(middlewares=[OuterMiddleware, InnerMiddleware])
71 args, kwargs = self.get_subscriber_params(queue)
73 @broker.subscriber(*args, **kwargs)
74 async def handler(msg: Any) -> None:
75 pass
77 async with self.patch_broker(broker) as br:
78 await br.publish(None, queue)
80 mock.consume_inner.assert_called_once()
81 mock.consume_outer.assert_called_once()
82 mock.publish_inner.assert_called_once()
83 mock.publish_outer.assert_called_once()
84 mock.enter_inner.assert_called_once()
85 mock.enter_outer.assert_called_once()
86 mock.exit_inner.assert_called_once()
87 mock.exit_outer.assert_called_once()
89 assert [c.args[0] for c in mock.sub.call_args_list] == ["outer", "inner"]
90 assert [c.args[0] for c in mock.pub.call_args_list] == ["outer", "inner"]
91 assert [c.args[0] for c in mock.enter.call_args_list] == ["outer", "inner"]
92 assert [c.args[0] for c in mock.exit.call_args_list] == ["inner", "outer"]
94 async def test_broker_middleware_exit_on_enter_error(
95 self,
96 queue: str,
97 mock: MagicMock,
98 ) -> None:
99 class OuterMiddleware(BaseMiddleware):
100 async def after_processed(
101 self,
102 exc_type: type[BaseException] | None = None,
103 exc_val: BaseException | None = None,
104 exc_tb: TracebackType | None = None,
105 ) -> bool | None:
106 mock.exit_outer(exc_type)
107 return await super().after_processed(exc_type, exc_val, exc_tb)
109 class InnerMiddleware(BaseMiddleware):
110 async def on_receive(self) -> None:
111 error_msg = "Ooops!"
112 raise ValueError(error_msg)
114 broker = self.get_broker(middlewares=[OuterMiddleware, InnerMiddleware])
116 args, kwargs = self.get_subscriber_params(queue)
118 @broker.subscriber(*args, **kwargs)
119 async def handler(msg: Any) -> None:
120 pass
122 async with self.patch_broker(broker) as br:
123 with pytest.raises(ValueError, match="Ooops!"):
124 await br.publish(None, queue)
126 mock.exit_outer.assert_called_once_with(ValueError)
128 async def test_publisher_middleware_order(
129 self,
130 queue: str,
131 mock: MagicMock,
132 ) -> None:
133 class InnerMiddleware(BaseMiddleware):
134 async def publish_scope(
135 self, call_next: Callable[[Any], Awaitable[Any]], cmd: Any
136 ) -> Any:
137 mock.publish_inner()
138 mock("inner")
139 return await call_next(cmd)
141 class MiddleMiddleware(BaseMiddleware):
142 async def publish_scope(
143 self, call_next: Callable[[Any], Awaitable[Any]], cmd: Any
144 ) -> Any:
145 mock.publish_middle()
146 mock("middle")
147 return await call_next(cmd)
149 class OuterMiddleware(BaseMiddleware):
150 async def publish_scope(
151 self, call_next: Callable[[Any], Awaitable[Any]], cmd: Any
152 ) -> Any:
153 mock.publish_outer()
154 mock("outer")
155 return await call_next(cmd)
157 broker = self.get_broker(
158 middlewares=[OuterMiddleware, MiddleMiddleware, InnerMiddleware],
159 )
160 publisher = broker.publisher(queue)
162 args, kwargs = self.get_subscriber_params(queue)
164 @broker.subscriber(*args, **kwargs)
165 async def handler(msg: Any) -> None:
166 pass
168 async with self.patch_broker(broker):
169 await publisher.publish(None, queue)
171 mock.publish_inner.assert_called_once()
172 mock.publish_middle.assert_called_once()
173 mock.publish_outer.assert_called_once()
175 assert [c.args[0] for c in mock.call_args_list] == ["outer", "middle", "inner"]
177 async def test_publisher_with_router_middleware_order(
178 self,
179 queue: str,
180 mock: MagicMock,
181 ) -> None:
182 class InnerMiddleware(BaseMiddleware):
183 async def publish_scope(
184 self, call_next: Callable[[Any], Awaitable[Any]], cmd: Any
185 ) -> Any:
186 mock.publish_inner()
187 mock("inner")
188 return await call_next(cmd)
190 class MiddleMiddleware(BaseMiddleware):
191 async def publish_scope(
192 self, call_next: Callable[[Any], Awaitable[Any]], cmd: Any
193 ) -> Any:
194 mock.publish_middle()
195 mock("middle")
196 return await call_next(cmd)
198 class OuterMiddleware(BaseMiddleware):
199 async def publish_scope(
200 self, call_next: Callable[[Any], Awaitable[Any]], cmd: Any
201 ) -> Any:
202 mock.publish_outer()
203 mock("outer")
204 return await call_next(cmd)
206 broker = self.get_broker(middlewares=[OuterMiddleware])
207 router = self.get_router(middlewares=[MiddleMiddleware])
208 router2 = self.get_router(middlewares=[InnerMiddleware])
210 publisher = router2.publisher(queue)
212 args, kwargs = self.get_subscriber_params(queue)
214 @router2.subscriber(*args, **kwargs)
215 async def handler(msg: Any) -> None:
216 pass
218 router.include_router(router2)
219 broker.include_router(router)
221 async with self.patch_broker(broker):
222 await publisher.publish(None, queue)
224 mock.publish_inner.assert_called_once()
225 mock.publish_middle.assert_called_once()
226 mock.publish_outer.assert_called_once()
228 assert [c.args[0] for c in mock.call_args_list] == ["outer", "middle", "inner"]
230 async def test_consume_middleware_order(self, queue: str, mock: MagicMock) -> None:
231 class InnerMiddleware(BaseMiddleware):
232 async def consume_scope(
233 self, call_next: Callable[[Any], Awaitable[Any]], cmd: Any
234 ) -> Any:
235 mock.consume_inner()
236 mock("inner")
237 return await call_next(cmd)
239 class MiddleMiddleware(BaseMiddleware):
240 async def consume_scope(
241 self, call_next: Callable[[Any], Awaitable[Any]], cmd: Any
242 ) -> Any:
243 mock.consume_middle()
244 mock("middle")
245 return await call_next(cmd)
247 class OuterMiddleware(BaseMiddleware):
248 async def consume_scope(
249 self, call_next: Callable[[Any], Awaitable[Any]], cmd: Any
250 ) -> Any:
251 mock.consume_outer()
252 mock("outer")
253 return await call_next(cmd)
255 broker = self.get_broker(
256 middlewares=[OuterMiddleware, MiddleMiddleware, InnerMiddleware],
257 )
259 args, kwargs = self.get_subscriber_params(queue)
261 @broker.subscriber(*args, **kwargs)
262 async def handler(msg: Any) -> None:
263 pass
265 async with self.patch_broker(broker) as br:
266 await br.publish(None, queue)
268 mock.consume_inner.assert_called_once()
269 mock.consume_middle.assert_called_once()
270 mock.consume_outer.assert_called_once()
272 assert [c.args[0] for c in mock.call_args_list] == ["outer", "middle", "inner"]
274 async def test_consume_with_router_middleware_order(
275 self,
276 queue: str,
277 mock: MagicMock,
278 ) -> None:
279 class InnerMiddleware(BaseMiddleware):
280 async def consume_scope(
281 self, call_next: Callable[[Any], Awaitable[Any]], cmd: Any
282 ) -> Any:
283 mock("inner")
284 return await call_next(cmd)
286 class MiddleMiddleware(BaseMiddleware):
287 async def consume_scope(
288 self, call_next: Callable[[Any], Awaitable[Any]], cmd: Any
289 ) -> Any:
290 mock("middle")
291 return await call_next(cmd)
293 class OuterMiddleware(BaseMiddleware):
294 async def consume_scope(
295 self, call_next: Callable[[Any], Awaitable[Any]], cmd: Any
296 ) -> Any:
297 mock("outer")
298 return await call_next(cmd)
300 broker = self.get_broker(middlewares=[OuterMiddleware])
301 router = self.get_router(middlewares=[MiddleMiddleware])
302 router2 = self.get_router(middlewares=[InnerMiddleware])
304 args, kwargs = self.get_subscriber_params(queue)
306 @router2.subscriber(*args, **kwargs)
307 async def handler(msg: Any) -> None:
308 pass
310 router.include_router(router2)
311 broker.include_router(router)
312 async with self.patch_broker(broker) as br:
313 await br.publish(None, queue)
315 call_order = [c.args[0] for c in mock.call_args_list]
316 assert call_order == ["outer", "middle", "inner"], call_order
319@pytest.mark.asyncio()
320class LocalMiddlewareTestcase(BaseTestcaseConfig[Any]):
321 async def test_subscriber_middleware(
322 self,
323 queue: str,
324 mock: MagicMock,
325 event: asyncio.Event,
326 ) -> None:
327 class TapMiddleware(BaseMiddleware):
328 async def consume_scope(
329 self, call_next: Callable[[Any], Awaitable[Any]], msg: Any
330 ) -> Any:
331 mock.start(await msg.decode())
332 result = await call_next(msg)
333 mock.end()
334 event.set()
335 return result
337 broker = self.get_broker(middlewares=(TapMiddleware,))
339 args, kwargs = self.get_subscriber_params(queue)
341 @broker.subscriber(*args, **kwargs)
342 async def handler(m: Any) -> str:
343 mock.inner(m)
344 return "end"
346 async with self.patch_broker(broker) as br:
347 await br.start()
348 await asyncio.wait(
349 (
350 asyncio.create_task(br.publish("start", queue)),
351 asyncio.create_task(event.wait()),
352 ),
353 timeout=self.timeout,
354 )
356 mock.start.assert_called_once_with("start")
357 mock.inner.assert_called_once_with("start")
359 assert event.is_set()
360 mock.end.assert_called_once()
362 async def test_error_traceback(
363 self,
364 queue: str,
365 mock: MagicMock,
366 event: asyncio.Event,
367 ) -> None:
368 class ErrorTraceMiddleware(BaseMiddleware):
369 async def consume_scope(
370 self, call_next: Callable[[Any], Awaitable[Any]], msg: Any
371 ) -> Any:
372 try:
373 return await call_next(msg)
374 except Exception as e:
375 mock(isinstance(e, ValueError))
376 raise
378 broker = self.get_broker(middlewares=(ErrorTraceMiddleware,))
380 args, kwargs = self.get_subscriber_params(queue)
382 @broker.subscriber(*args, **kwargs)
383 async def handler2(m: Any) -> None:
384 event.set()
385 raise ValueError
387 async with self.patch_broker(broker) as br:
388 await br.start()
390 await asyncio.wait(
391 (
392 asyncio.create_task(br.publish("", queue)),
393 asyncio.create_task(event.wait()),
394 ),
395 timeout=self.timeout,
396 )
398 assert event.is_set()
399 mock.assert_called_once_with(True)
402@pytest.mark.asyncio()
403class MiddlewareTestcase(LocalMiddlewareTestcase):
404 async def test_global_middleware(
405 self,
406 queue: str,
407 mock: MagicMock,
408 event: asyncio.Event,
409 ) -> None:
410 class mid(BaseMiddleware): # ruff: ignore[invalid-class-name]
411 async def on_receive(self) -> Any:
412 mock.start(self.msg)
413 return await super().on_receive()
415 async def after_processed(
416 self,
417 exc_type: type[BaseException] | None = None,
418 exc_val: BaseException | None = None,
419 exc_tb: TracebackType | None = None,
420 ) -> Any:
421 mock.end()
422 return await super().after_processed(exc_type, exc_val, exc_tb)
424 broker = self.get_broker(
425 middlewares=(mid,),
426 )
428 args, kwargs = self.get_subscriber_params(queue)
430 @broker.subscriber(*args, **kwargs)
431 async def handler(m: Any) -> str:
432 event.set()
433 return ""
435 async with self.patch_broker(broker) as br:
436 await br.start()
437 await asyncio.wait(
438 (
439 asyncio.create_task(br.publish("", queue)),
440 asyncio.create_task(event.wait()),
441 ),
442 timeout=self.timeout,
443 )
444 assert event.is_set()
446 mock.start.assert_called_once()
447 mock.end.assert_called_once()
449 async def test_add_global_middleware(
450 self,
451 queue: str,
452 mock: MagicMock,
453 event: asyncio.Event,
454 event2: asyncio.Event,
455 ) -> None:
456 class mid(BaseMiddleware): # ruff: ignore[invalid-class-name]
457 async def on_receive(self) -> Any:
458 mock.start(self.msg)
459 return await super().on_receive()
461 async def after_processed(
462 self,
463 exc_type: type[BaseException] | None = None,
464 exc_val: BaseException | None = None,
465 exc_tb: TracebackType | None = None,
466 ) -> Any:
467 mock.end()
468 return await super().after_processed(exc_type, exc_val, exc_tb)
470 broker = self.get_broker()
472 # already registered subscriber
473 args, kwargs = self.get_subscriber_params(queue)
475 @broker.subscriber(*args, **kwargs)
476 async def handler(m: Any) -> str:
477 event.set()
478 return ""
480 # should affect to already registered and a new subscriber both
481 broker.add_middleware(mid)
483 # new subscriber
484 args2, kwargs2 = self.get_subscriber_params(queue + "1")
486 @broker.subscriber(*args2, **kwargs2)
487 async def handler2(m: Any) -> str:
488 event2.set()
489 return ""
491 async with self.patch_broker(broker) as br:
492 await br.start()
493 await asyncio.wait(
494 (
495 asyncio.create_task(br.publish("", queue)),
496 asyncio.create_task(br.publish("", f"{queue}1")),
497 asyncio.create_task(event.wait()),
498 asyncio.create_task(event2.wait()),
499 ),
500 timeout=self.timeout,
501 )
503 assert event.is_set()
504 assert mock.start.call_count == 2, mock.start.call_count
505 assert mock.end.call_count == 2, mock.end.call_count
507 async def test_patch_publish(
508 self,
509 queue: str,
510 mock: MagicMock,
511 event: asyncio.Event,
512 ) -> None:
513 class Mid(BaseMiddleware):
514 async def publish_scope(
515 self, call_next: Callable[[Any], Awaitable[Any]], cmd: Any
516 ) -> Any:
517 cmd.body *= 2
518 return await call_next(cmd)
520 broker = self.get_broker(middlewares=(Mid,))
522 args, kwargs = self.get_subscriber_params(queue)
524 @broker.subscriber(*args, **kwargs)
525 async def handler(m: Any) -> Any:
526 return m
528 args2, kwargs2 = self.get_subscriber_params(queue + "r")
530 @broker.subscriber(*args2, **kwargs2)
531 async def handler_resp(m: Any) -> None:
532 mock(m)
533 event.set()
535 async with self.patch_broker(broker) as br:
536 await br.start()
538 await asyncio.wait(
539 (
540 asyncio.create_task(br.publish("r", queue, reply_to=queue + "r")),
541 asyncio.create_task(event.wait()),
542 ),
543 timeout=self.timeout,
544 )
546 assert event.is_set()
547 mock.assert_called_once_with("rrrr")
549 async def test_global_publisher_middleware(
550 self,
551 queue: str,
552 mock: MagicMock,
553 event: asyncio.Event,
554 ) -> None:
555 class Mid(BaseMiddleware):
556 async def publish_scope(
557 self, call_next: Callable[[Any], Awaitable[Any]], cmd: Any
558 ) -> Any:
559 cmd.body *= 2
560 mock.enter(cmd.body)
561 try:
562 return await call_next(cmd)
563 finally:
564 mock.end()
565 if mock.end.call_count > 2:
566 event.set()
568 broker = self.get_broker(middlewares=(Mid,))
570 args, kwargs = self.get_subscriber_params(queue)
572 @broker.subscriber(*args, **kwargs)
573 @broker.publisher(queue + "1")
574 @broker.publisher(queue + "2")
575 async def handler(m: Any) -> Any:
576 mock.inner(m)
577 return m
579 async with self.patch_broker(broker) as br:
580 await br.start()
581 await asyncio.wait(
582 (
583 asyncio.create_task(br.publish("1", queue)),
584 asyncio.create_task(event.wait()),
585 ),
586 timeout=self.timeout,
587 )
589 assert event.is_set()
590 mock.inner.assert_called_once_with("11")
591 assert mock.enter.call_count == 3
592 mock.enter.assert_called_with("1111")
593 assert mock.end.call_count == 3
596@pytest.mark.asyncio()
597class ExceptionMiddlewareTestcase(BaseTestcaseConfig[Any]):
598 async def test_exception_middleware_default_msg(
599 self,
600 queue: str,
601 mock: MagicMock,
602 event: asyncio.Event,
603 ) -> None:
604 mid = ExceptionMiddleware()
606 @mid.add_handler(ValueError, publish=True)
607 async def value_error_handler(exc: Any) -> str:
608 return "value"
610 broker = self.get_broker(apply_types=True, middlewares=(mid,))
612 args, kwargs = self.get_subscriber_params(queue)
614 @broker.subscriber(*args, **kwargs)
615 @broker.publisher(queue + "1")
616 async def subscriber1(m: Any) -> Any:
617 raise ValueError
619 args, kwargs = self.get_subscriber_params(queue + "1")
621 @broker.subscriber(*args, **kwargs)
622 async def subscriber2(msg: Any = Context("message")) -> None:
623 mock(await msg.decode())
624 event.set()
626 async with self.patch_broker(broker) as br:
627 await br.start()
628 await asyncio.wait(
629 (
630 asyncio.create_task(br.publish("", queue)),
631 asyncio.create_task(event.wait()),
632 ),
633 timeout=self.timeout,
634 )
636 assert event.is_set()
637 assert mock.call_count == 1
638 mock.assert_called_once_with("value")
640 async def test_exception_middleware_skip_msg(
641 self,
642 queue: str,
643 mock: MagicMock,
644 event: asyncio.Event,
645 ) -> None:
646 mid = ExceptionMiddleware()
648 @mid.add_handler(ValueError, publish=True)
649 async def value_error_handler(exc: Any) -> None:
650 event.set()
651 raise SkipMessage
653 broker = self.get_broker(middlewares=(mid,))
654 args, kwargs = self.get_subscriber_params(queue)
656 @broker.subscriber(*args, **kwargs)
657 @broker.publisher(queue + "1")
658 async def subscriber1(m: Any) -> Any:
659 raise ValueError
661 args2, kwargs2 = self.get_subscriber_params(queue + "1")
663 @broker.subscriber(*args2, **kwargs2)
664 async def subscriber2(msg: Any = Context("message")) -> None:
665 mock(await msg.decode())
667 async with self.patch_broker(broker) as br:
668 await br.start()
669 await asyncio.wait(
670 (
671 asyncio.create_task(br.publish("", queue)),
672 asyncio.create_task(event.wait()),
673 ),
674 timeout=self.timeout,
675 )
677 assert event.is_set()
678 assert mock.call_count == 0
680 async def test_exception_middleware_do_not_catch_skip_msg(
681 self,
682 queue: str,
683 mock: MagicMock,
684 event: asyncio.Event,
685 ) -> None:
686 mid = ExceptionMiddleware()
688 @mid.add_handler(Exception)
689 async def value_error_handler(exc: Any) -> None:
690 mock()
692 broker = self.get_broker(middlewares=(mid,))
693 args, kwargs = self.get_subscriber_params(queue)
695 @broker.subscriber(*args, **kwargs)
696 async def subscriber(m: Any) -> None:
697 event.set()
698 raise SkipMessage
700 async with self.patch_broker(broker) as br:
701 await br.start()
702 await asyncio.wait(
703 (
704 asyncio.create_task(br.publish("", queue)),
705 asyncio.create_task(event.wait()),
706 ),
707 timeout=self.timeout,
708 )
709 await asyncio.sleep(0.001)
711 assert event.is_set()
712 assert mock.call_count == 0
714 async def test_exception_middleware_reraise(
715 self,
716 queue: str,
717 mock: MagicMock,
718 event: asyncio.Event,
719 ) -> None:
720 mid = ExceptionMiddleware()
722 @mid.add_handler(ValueError, publish=True)
723 async def value_error_handler(exc: Any) -> None:
724 event.set()
725 raise exc
727 broker = self.get_broker(middlewares=(mid,))
728 args, kwargs = self.get_subscriber_params(queue)
730 @broker.subscriber(*args, **kwargs)
731 @broker.publisher(queue + "1")
732 async def subscriber1(m: Any) -> Any:
733 raise ValueError
735 args2, kwargs2 = self.get_subscriber_params(queue + "1")
737 @broker.subscriber(*args2, **kwargs2)
738 async def subscriber2(msg: Any = Context("message")) -> None:
739 mock(await msg.decode())
741 async with self.patch_broker(broker) as br:
742 await br.start()
743 await asyncio.wait(
744 (
745 asyncio.create_task(br.publish("", queue)),
746 asyncio.create_task(event.wait()),
747 ),
748 timeout=self.timeout,
749 )
751 assert event.is_set()
752 assert mock.call_count == 0
754 async def test_exception_middleware_different_handler(
755 self,
756 queue: str,
757 mock: MagicMock,
758 event: asyncio.Event,
759 ) -> None:
760 mid = ExceptionMiddleware()
762 @mid.add_handler(ZeroDivisionError, publish=True)
763 async def zero_error_handler(exc: Any) -> str:
764 return "zero"
766 @mid.add_handler(ValueError, publish=True)
767 async def value_error_handler(exc: Any) -> str:
768 return "value"
770 broker = self.get_broker(apply_types=True, middlewares=(mid,))
771 args, kwargs = self.get_subscriber_params(queue)
773 publisher = broker.publisher(queue + "2")
775 @broker.subscriber(*args, **kwargs)
776 @publisher
777 async def subscriber1(m: Any) -> Any:
778 raise ZeroDivisionError
780 args2, kwargs2 = self.get_subscriber_params(queue + "1")
782 @broker.subscriber(*args2, **kwargs2)
783 @publisher
784 async def subscriber2(m: Any) -> Any:
785 raise ValueError
787 args3, kwargs3 = self.get_subscriber_params(queue + "2")
789 @broker.subscriber(*args3, **kwargs3)
790 async def subscriber3(msg: Any = Context("message")) -> None:
791 mock(await msg.decode())
792 if mock.call_count > 1:
793 event.set()
795 async with self.patch_broker(broker) as br:
796 await br.start()
797 await asyncio.wait(
798 (
799 asyncio.create_task(br.publish("", queue)),
800 asyncio.create_task(br.publish("", queue + "1")),
801 asyncio.create_task(event.wait()),
802 ),
803 timeout=self.timeout,
804 )
806 assert event.is_set()
807 assert mock.call_count == 2
808 mock.assert_has_calls([call("zero"), call("value")], any_order=True)
810 async def test_exception_middleware_init_handler_same(self) -> None:
811 mid1 = ExceptionMiddleware()
813 @mid1.add_handler(ValueError)
814 async def value_error_handler(exc: Any) -> None: ...
816 mid2 = ExceptionMiddleware(handlers={ValueError: value_error_handler})
818 assert list(mid1._handlers.keys()) == list(mid2._handlers.keys())
820 async def test_exception_middleware_init_publish_handler_same(self) -> None:
821 mid1 = ExceptionMiddleware()
823 @mid1.add_handler(ValueError, publish=True)
824 async def value_error_handler(exc: Any) -> str:
825 return "value"
827 mid2 = ExceptionMiddleware(publish_handlers={ValueError: value_error_handler})
829 assert list(mid1._publish_handlers.keys()) == list(mid2._publish_handlers.keys())
831 async def test_exception_middleware_decoder_error(
832 self,
833 queue: str,
834 event: asyncio.Event,
835 ) -> None:
836 async def decoder(
837 msg: Any,
838 original_decoder: Any,
839 ) -> DecodedMessage:
840 raise ValueError
842 mid = ExceptionMiddleware()
844 @mid.add_handler(ValueError)
845 async def value_error_handler(exc: Any) -> None:
846 event.set()
848 broker = self.get_broker(middlewares=(mid,), decoder=decoder)
850 args, kwargs = self.get_subscriber_params(queue)
852 @broker.subscriber(*args, **kwargs)
853 async def subscriber1(m: Any) -> Any:
854 raise ZeroDivisionError
856 async with self.patch_broker(broker) as br:
857 await br.start()
858 await asyncio.wait(
859 (
860 asyncio.create_task(br.publish("", queue)),
861 asyncio.create_task(event.wait()),
862 ),
863 timeout=self.timeout,
864 )
866 assert event.is_set()
868 async def test_exception_middleware_mro_resolution(
869 self,
870 queue: str,
871 mock: MagicMock,
872 event: asyncio.Event,
873 ) -> None:
874 """Test MRO-based resolution picks the most specific handler."""
876 class ExcAError(Exception):
877 pass
879 class ExcBError(ExcAError):
880 pass
882 mid = ExceptionMiddleware()
884 # Register parent handler BEFORE child handler
885 @mid.add_handler(ExcAError, publish=True)
886 async def handle_a(exc: Any) -> str:
887 return "parent"
889 @mid.add_handler(ExcBError, publish=True)
890 async def handle_b(exc: Any) -> str:
891 return "child"
893 broker = self.get_broker(apply_types=True, middlewares=(mid,))
894 args, kwargs = self.get_subscriber_params(queue)
896 @broker.subscriber(*args, **kwargs)
897 @broker.publisher(queue + "1")
898 async def subscriber1(m: Any) -> Any:
899 raise ExcBError
901 args2, kwargs2 = self.get_subscriber_params(queue + "1")
903 @broker.subscriber(*args2, **kwargs2)
904 async def subscriber2(msg: Any = Context("message")) -> None:
905 mock(await msg.decode())
906 event.set()
908 async with self.patch_broker(broker) as br:
909 await br.start()
910 await asyncio.wait(
911 (
912 asyncio.create_task(br.publish("", queue)),
913 asyncio.create_task(event.wait()),
914 ),
915 timeout=self.timeout,
916 )
918 assert event.is_set()
919 mock.assert_called_once_with("child")