Coverage for tests/brokers/base/fastapi.py: 99%
402 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 AsyncGenerator, Iterator
3from contextlib import asynccontextmanager
4from typing import Annotated, Any
5from unittest.mock import Mock
7import pytest
8from fastapi import BackgroundTasks, Depends, FastAPI, Header
9from fastapi.exceptions import RequestValidationError
10from fastapi.testclient import TestClient
12from faststream import (
13 Context as FSContext,
14 Depends as FSDepends,
15 Response,
16)
17from faststream._internal.fastapi.context import Context
18from faststream._internal.fastapi.route import StreamMessage
19from faststream.exceptions import SetupError
21from .basic import BaseTestcaseConfig
24@pytest.mark.asyncio()
25class FastAPITestcase(BaseTestcaseConfig[Any]):
26 router_class: Any
27 broker_router_class: Any
29 async def test_base_real(self, mock: Mock, queue: str, event: asyncio.Event) -> None:
30 router = self.router_class()
32 args, kwargs = self.get_subscriber_params(queue)
34 @router.subscriber(*args, **kwargs)
35 async def hello(msg: Any) -> Any:
36 event.set()
37 return mock(msg)
39 async with router.broker:
40 await router.broker.start()
41 await asyncio.wait(
42 (
43 asyncio.create_task(router.broker.publish("hi", queue)),
44 asyncio.create_task(event.wait()),
45 ),
46 timeout=self.timeout,
47 )
49 assert event.is_set()
50 mock.assert_called_with("hi")
52 async def test_background(
53 self,
54 mock: Mock,
55 queue: str,
56 event: asyncio.Event,
57 ) -> None:
58 router = self.router_class()
60 def task(msg: Any) -> None:
61 event.set()
62 mock(msg)
64 args, kwargs = self.get_subscriber_params(queue)
66 @router.subscriber(*args, **kwargs)
67 async def hello(msg: Any, tasks: BackgroundTasks) -> None:
68 tasks.add_task(task, msg)
70 async with router.broker:
71 await router.broker.start()
72 await asyncio.wait(
73 (
74 asyncio.create_task(router.broker.publish("hi", queue)),
75 asyncio.create_task(event.wait()),
76 ),
77 timeout=self.timeout,
78 )
80 mock.assert_called_with("hi")
82 async def test_context(self, mock: Mock, queue: str, event: asyncio.Event) -> None:
83 router = self.router_class()
84 context = router.context
86 context_key = "message.headers"
88 args, kwargs = self.get_subscriber_params(queue)
90 @router.subscriber(*args, **kwargs)
91 async def hello(msg: Any = Context(context_key)) -> None:
92 try:
93 mock(msg == context.resolve(context_key) and msg["1"] == "1")
94 finally:
95 event.set()
97 async with router.broker:
98 await router.broker.start()
99 await asyncio.wait(
100 (
101 asyncio.create_task(
102 router.broker.publish("", queue, headers={"1": "1"}),
103 ),
104 asyncio.create_task(event.wait()),
105 ),
106 timeout=self.timeout,
107 )
109 assert event.is_set()
110 mock.assert_called_with(True)
112 async def test_context_annotated(
113 self,
114 mock: Mock,
115 queue: str,
116 event: asyncio.Event,
117 ) -> None:
118 router = self.router_class()
119 context = router.context
121 context_key = "message.headers"
123 args, kwargs = self.get_subscriber_params(queue)
125 @router.subscriber(*args, **kwargs)
126 async def hello(msg: Annotated[Any, Context(context_key)]) -> None:
127 try:
128 mock(msg == context.resolve(context_key) and msg["1"] == "1")
129 finally:
130 event.set()
132 async with router.broker:
133 await router.broker.start()
134 await asyncio.wait(
135 (
136 asyncio.create_task(
137 router.broker.publish("", queue, headers={"1": "1"}),
138 ),
139 asyncio.create_task(event.wait()),
140 ),
141 timeout=self.timeout,
142 )
144 assert event.is_set()
145 mock.assert_called_with(True)
147 @pytest.mark.flaky(reruns=3, reruns_delay=1)
148 async def test_initial_context(self, queue: str, event: asyncio.Event) -> None:
149 router = self.router_class()
150 context = router.context
152 args, kwargs = self.get_subscriber_params(queue)
154 @router.subscriber(*args, **kwargs)
155 async def hello(msg: int, data: set[int] = Context(queue, initial=set)) -> None:
156 data.add(msg)
157 if len(data) == 2:
158 event.set()
160 async with router.broker:
161 await router.broker.start()
162 await asyncio.wait(
163 (
164 asyncio.create_task(router.broker.publish(1, queue)),
165 asyncio.create_task(router.broker.publish(2, queue)),
166 asyncio.create_task(event.wait()),
167 ),
168 timeout=self.timeout,
169 )
171 assert context.get(queue) == {1, 2}
172 context.reset_global(queue)
174 async def test_double_real(
175 self, mock: Mock, queue: str, event: asyncio.Event, event2: asyncio.Event
176 ) -> None:
177 router = self.router_class()
179 args, kwargs = self.get_subscriber_params(queue)
180 sub1 = router.subscriber(*args, **kwargs)
182 args2, kwargs2 = self.get_subscriber_params(queue + "2")
184 @sub1
185 @router.subscriber(*args2, **kwargs2)
186 async def hello(msg: str) -> None:
187 if event.is_set():
188 event2.set()
189 else:
190 event.set()
191 mock()
193 async with router.broker:
194 await router.broker.start()
195 await asyncio.wait(
196 (
197 asyncio.create_task(router.broker.publish("hi", queue)),
198 asyncio.create_task(router.broker.publish("hi", queue + "2")),
199 asyncio.create_task(event.wait()),
200 asyncio.create_task(event2.wait()),
201 ),
202 timeout=self.timeout,
203 )
205 assert event.is_set()
206 assert event2.is_set()
207 assert mock.call_count == 2
209 async def test_base_publisher_real(
210 self,
211 mock: Mock,
212 queue: str,
213 event: asyncio.Event,
214 ) -> None:
215 router = self.router_class()
217 args, kwargs = self.get_subscriber_params(queue)
219 @router.subscriber(*args, **kwargs)
220 @router.publisher(queue + "resp")
221 async def m() -> str:
222 return "hi"
224 args2, kwargs2 = self.get_subscriber_params(queue + "resp")
226 @router.subscriber(*args2, **kwargs2)
227 async def resp(msg: Any) -> None:
228 event.set()
229 mock(msg)
231 async with router.broker:
232 await router.broker.start()
234 await asyncio.wait(
235 (
236 asyncio.create_task(router.broker.publish("", queue)),
237 asyncio.create_task(event.wait()),
238 ),
239 timeout=self.timeout,
240 )
242 assert event.is_set()
243 mock.assert_called_once_with("hi")
245 async def test_injection_fastapi(
246 self,
247 mock: Mock,
248 queue: str,
249 event: asyncio.Event,
250 ) -> None:
251 router = self.router_class()
253 args, kwargs = self.get_subscriber_params(queue)
255 @router.subscriber(*args, **kwargs)
256 async def subscriber(msg: StreamMessage) -> None:
257 mock("app" in msg.scope)
258 event.set()
260 async with router.broker:
261 await router.broker.start()
262 await asyncio.wait(
263 (
264 asyncio.create_task(router.broker.publish(None, queue)),
265 asyncio.create_task(event.wait()),
266 ),
267 timeout=self.timeout,
268 )
270 mock.assert_called_once_with(True)
273@pytest.mark.asyncio()
274class FastAPILocalTestcase(BaseTestcaseConfig[Any]):
275 router_class: Any
276 broker_router_class: Any
278 async def test_base(self, queue: str) -> None:
279 router = self.router_class()
281 app = FastAPI()
282 app.include_router(router)
284 args, kwargs = self.get_subscriber_params(queue)
286 @router.subscriber(*args, **kwargs)
287 async def hello() -> str:
288 return "hi"
290 async with self.patch_broker(router.broker) as br:
291 with TestClient(app) as client:
292 assert client.app_state["broker"] is br
294 r = await br.request(
295 "hi",
296 queue,
297 timeout=0.5,
298 )
299 assert await r.decode() == "hi", r
301 async def test_request(self, queue: str) -> None:
302 """Local test due request exists in all TestClients."""
303 router = self.router_class(setup_state=False)
305 app = FastAPI()
307 args, kwargs = self.get_subscriber_params(queue)
309 @router.subscriber(*args, **kwargs)
310 async def hello() -> Any:
311 return Response("Hi!", headers={"x-header": "test"})
313 async with self.patch_broker(router.broker) as br:
314 with TestClient(app) as client:
315 assert not client.app_state.get("broker")
317 r = await br.request(
318 "hi",
319 queue,
320 timeout=0.5,
321 )
322 assert await r.decode() == "Hi!"
323 assert r.headers["x-header"] == "test"
325 async def test_base_without_state(self, queue: str) -> None:
326 router = self.router_class(setup_state=False)
328 app = FastAPI()
330 args, kwargs = self.get_subscriber_params(queue)
332 @router.subscriber(*args, **kwargs)
333 async def hello() -> str:
334 return "hi"
336 async with self.patch_broker(router.broker) as br:
337 with TestClient(app) as client:
338 assert not client.app_state.get("broker")
340 r = await br.request(
341 "hi",
342 queue,
343 timeout=0.5,
344 )
345 assert await r.decode() == "hi", r
347 async def test_invalid(self, queue: str) -> None:
348 router = self.router_class()
350 app = FastAPI()
352 args, kwargs = self.get_subscriber_params(queue)
354 @router.subscriber(*args, **kwargs)
355 async def hello(msg: int) -> None: ...
357 app.include_router(router)
359 async with self.patch_broker(router.broker) as br:
360 with TestClient(app), pytest.raises(RequestValidationError):
361 await br.publish("hi", queue)
363 async def test_headers(self, queue: str) -> None:
364 router = self.router_class()
366 args, kwargs = self.get_subscriber_params(queue)
368 @router.subscriber(*args, **kwargs)
369 async def hello(w: Any = Header()) -> Any:
370 return w
372 async with self.patch_broker(router.broker) as br:
373 r = await br.request(
374 "",
375 queue,
376 headers={"w": "hi"},
377 timeout=0.5,
378 )
379 assert await r.decode() == "hi", r
381 async def test_depends(self, mock: Mock, queue: str) -> None:
382 router = self.router_class()
384 def dep(a: Any) -> Any:
385 mock(a)
386 return a
388 args, kwargs = self.get_subscriber_params(queue)
390 @router.subscriber(*args, **kwargs)
391 async def hello(a: Any, w: Any = Depends(dep)) -> Any:
392 return w
394 async with self.patch_broker(router.broker) as br:
395 r = await br.request(
396 {"a": "hi"},
397 queue,
398 timeout=0.5,
399 )
400 assert await r.decode() == "hi", r
402 mock.assert_called_once_with("hi")
404 async def test_mixed_depends(self, mock: Mock, queue: str) -> None:
405 router = self.router_class()
407 def dep(a: str) -> str:
408 mock(a)
409 return a
411 args, kwargs = self.get_subscriber_params(queue)
413 @router.subscriber(*args, **kwargs)
414 async def hello(
415 a: str,
416 w: Annotated[
417 str,
418 Depends(dep),
419 FSDepends(dep), # will be ignored
420 ],
421 ) -> str:
422 return w
424 async with self.patch_broker(router.broker) as br:
425 r = await br.request(
426 {"a": "hi"},
427 queue,
428 timeout=0.5,
429 )
430 assert await r.decode() == "hi", r
432 mock.assert_called_once_with("hi")
434 async def test_depends_from_fastdepends_default(self, queue: str) -> None:
435 router = self.router_class()
437 args, kwargs = self.get_subscriber_params(queue)
439 subscriber = router.subscriber(*args, **kwargs)
441 @subscriber
442 def sub(d: Any = FSDepends(lambda: 1)) -> None: ...
444 app = FastAPI()
445 app.include_router(router)
447 with pytest.raises(SetupError): # ruff: ignore[pytest-raises-with-multiple-statements]
448 async with self.patch_broker(router.broker):
449 with TestClient(app):
450 ...
452 async def test_depends_from_fastdepends_annotated(self, queue: str) -> None:
453 router = self.router_class()
455 args, kwargs = self.get_subscriber_params(queue)
457 subscriber = router.subscriber(*args, **kwargs)
459 @subscriber
460 def sub(d: Annotated[Any, FSDepends(lambda: 1)]) -> None: ...
462 app = FastAPI()
463 app.include_router(router)
465 with pytest.raises(SetupError): # ruff: ignore[pytest-raises-with-multiple-statements]
466 async with self.patch_broker(router.broker):
467 with TestClient(app):
468 ...
470 async def test_depends_combined_annotated(self, queue: str) -> None:
471 router = self.router_class()
473 args, kwargs = self.get_subscriber_params(queue)
475 subscriber = router.subscriber(*args, **kwargs)
477 @subscriber
478 def sub(
479 d: Annotated[Any, FSDepends(lambda: 1), Depends(lambda: 1)],
480 ) -> None: ...
482 app = FastAPI()
483 app.include_router(router)
485 async with self.patch_broker(router.broker):
486 with TestClient(app):
487 ...
489 async def test_faststream_context(self, queue: str) -> None:
490 router = self.router_class()
492 args, kwargs = self.get_subscriber_params(queue)
494 @router.subscriber(*args, **kwargs)
495 async def hello(msg: Any = FSContext()) -> None: ...
497 app = FastAPI()
498 app.include_router(router)
500 with pytest.raises(SetupError): # ruff: ignore[pytest-raises-with-multiple-statements]
501 async with self.patch_broker(router.broker):
502 with TestClient(app):
503 ...
505 async def test_faststream_context_annotated(self, queue: str) -> None:
506 router = self.router_class()
508 args, kwargs = self.get_subscriber_params(queue)
510 @router.subscriber(*args, **kwargs)
511 async def hello(msg: Annotated[Any, FSContext()]) -> None: ...
513 app = FastAPI()
514 app.include_router(router)
516 with pytest.raises(SetupError): # ruff: ignore[pytest-raises-with-multiple-statements]
517 async with self.patch_broker(router.broker):
518 with TestClient(app):
519 ...
521 async def test_combined_context_annotated(self, queue: str) -> None:
522 router = self.router_class()
524 args, kwargs = self.get_subscriber_params(queue)
526 @router.subscriber(*args, **kwargs)
527 async def hello(
528 msg: Annotated[
529 Any,
530 Context("message.headers"),
531 FSContext("message.headers"),
532 ],
533 ) -> None: ...
535 app = FastAPI()
536 app.include_router(router)
538 async with self.patch_broker(router.broker):
539 with TestClient(app):
540 ...
542 async def test_nested_combined_context_annotated(self, queue: str) -> None:
543 router = self.router_class()
545 args, kwargs = self.get_subscriber_params(queue)
547 @router.subscriber(*args, **kwargs)
548 async def hello(
549 msg: Annotated[
550 Annotated[Any, FSContext("message.headers")],
551 Context("message.headers"),
552 ],
553 ) -> None: ...
555 app = FastAPI()
556 app.include_router(router)
558 async with self.patch_broker(router.broker):
559 with TestClient(app):
560 ...
562 async def test_yield_depends(self, mock: Mock, queue: str) -> None:
563 router = self.router_class()
565 def dep(a: Any) -> Iterator[Any]:
566 mock.start()
567 yield a
568 mock.close()
570 args, kwargs = self.get_subscriber_params(queue)
572 @router.subscriber(*args, **kwargs)
573 async def hello(a: Any, w: Any = Depends(dep)) -> Any:
574 mock.inside(started=mock.start.call_count, closed=mock.close.call_count)
575 return w
577 async with self.patch_broker(router.broker) as br:
578 r = await br.request(
579 {"a": "hi"},
580 queue,
581 timeout=0.5,
582 )
583 assert await r.decode() == "hi", r
585 # the dependency is open while the handler runs and closed after it
586 mock.inside.assert_called_once_with(started=1, closed=0)
587 mock.start.assert_called_once()
588 mock.close.assert_called_once()
590 async def test_router_depends(self, mock: Mock, queue: str) -> None:
591 def mock_dep() -> None:
592 mock()
594 router = self.router_class(dependencies=(Depends(mock_dep, use_cache=False),))
596 args, kwargs = self.get_subscriber_params(queue)
598 @router.subscriber(*args, **kwargs)
599 async def hello(a: Any) -> Any:
600 return a
602 async with self.patch_broker(router.broker) as br:
603 r = await br.request("hi", queue, timeout=0.5)
604 assert await r.decode() == "hi", r
606 mock.assert_called_once()
608 async def test_subscriber_depends(self, mock: Mock, queue: str) -> None:
609 def mock_dep() -> None:
610 mock()
612 router = self.router_class()
614 args, kwargs = self.get_subscriber_params(
615 queue,
616 dependencies=(Depends(mock_dep, use_cache=False),),
617 )
619 @router.subscriber(*args, **kwargs)
620 async def hello(a: Any) -> Any:
621 return a
623 async with self.patch_broker(router.broker) as br:
624 r = await br.request(
625 "hi",
626 queue,
627 timeout=0.5,
628 )
629 assert await r.decode() == "hi", r
631 mock.assert_called_once()
633 async def test_hooks(self, mock: Mock) -> None:
634 router = self.router_class()
636 app = FastAPI()
637 app.include_router(router)
639 @router.after_startup
640 def test_sync(app: Any) -> None:
641 mock.sync_called()
643 @router.after_startup
644 async def test_async(app: Any) -> None:
645 mock.async_called()
647 @router.on_broker_shutdown
648 def test_shutdown_sync(app: Any) -> None:
649 mock.sync_shutdown_called()
651 @router.on_broker_shutdown
652 async def test_shutdown_async(app: Any) -> None:
653 mock.async_shutdown_called()
655 async with self.patch_broker(router.broker), router.lifespan_context(app):
656 pass
658 mock.sync_called.assert_called_once()
659 mock.async_called.assert_called_once()
660 mock.sync_shutdown_called.assert_called_once()
661 mock.async_shutdown_called.assert_called_once()
663 async def test_existed_lifespan_startup(self, mock: Mock) -> None:
664 @asynccontextmanager
665 async def lifespan(app: Any) -> AsyncGenerator[Any, None]:
666 mock.start()
667 try:
668 yield {"lifespan": True}
669 finally:
670 mock.close()
672 router = self.router_class(lifespan=lifespan)
674 app = FastAPI()
675 app.include_router(router)
677 async with (
678 self.patch_broker(router.broker),
679 router.lifespan_context(
680 app,
681 ) as context,
682 ):
683 assert context["lifespan"]
685 mock.start.assert_called_once()
686 mock.close.assert_called_once()
688 async def test_subscriber_mock(self, queue: str) -> None:
689 router = self.router_class()
691 args, kwargs = self.get_subscriber_params(queue)
693 @router.subscriber(*args, **kwargs)
694 async def m() -> str:
695 return "hi"
697 async with self.patch_broker(router.broker) as rb:
698 await rb.publish("hello", queue)
699 m.mock.assert_called_once_with("hello")
701 async def test_publisher_mock(self, queue: str) -> None:
702 router = self.router_class()
704 publisher = router.publisher(queue + "resp")
706 args, kwargs = self.get_subscriber_params(queue)
707 sub = router.subscriber(*args, **kwargs)
709 @publisher
710 @sub
711 async def m() -> str:
712 return "response"
714 async with self.patch_broker(router.broker) as rb:
715 await rb.publish("hello", queue)
716 publisher.mock.assert_called_with("response")
718 async def test_include(self, queue: str) -> None:
719 router = self.router_class()
720 router2 = self.broker_router_class()
722 app = FastAPI()
724 args, kwargs = self.get_subscriber_params(queue)
726 @router.subscriber(*args, **kwargs)
727 async def hello() -> str:
728 return "hi"
730 args2, kwargs2 = self.get_subscriber_params(queue + "1")
732 @router2.subscriber(*args2, **kwargs2)
733 async def hello_router2() -> str:
734 return "hi"
736 router.include_router(router2)
737 app.include_router(router)
739 async with self.patch_broker(router.broker) as br:
740 with TestClient(app) as client:
741 assert client.app_state["broker"] is br
743 r = await br.request(
744 "hi",
745 queue,
746 timeout=0.5,
747 )
748 assert await r.decode() == "hi", r
750 r = await br.request(
751 "hi",
752 queue + "1",
753 timeout=0.5,
754 )
755 assert await r.decode() == "hi", r
757 async def test_dependency_overrides(self, mock: Mock, queue: str) -> None:
758 router = self.router_class()
760 def dep1() -> None:
761 raise AssertionError
763 def dep2() -> None:
764 mock()
766 app = FastAPI()
767 app.dependency_overrides[dep1] = dep2
769 args, kwargs = self.get_subscriber_params(queue)
771 @router.subscriber(*args, **kwargs)
772 async def hello_router2(dep: None = Depends(dep1)) -> str:
773 return "hi"
775 app.include_router(router)
777 async with self.patch_broker(router.broker) as br:
778 with TestClient(app) as client:
779 assert client.app_state["broker"] is br
781 r = await br.request(
782 "hi",
783 queue,
784 timeout=0.5,
785 )
786 assert await r.decode() == "hi", r
788 mock.assert_called_once()
790 async def test_nested_stream_router_raises(self) -> None:
791 """Including a StreamRouter into another StreamRouter must raise TypeError.
793 This pattern is unsupported (issue #2657). Users should include a regular
794 broker router (e.g. KafkaRouter) into the StreamRouter instead.
795 """
796 router = self.router_class()
797 router2 = self.router_class()
799 with pytest.raises(
800 TypeError,
801 match="Including a StreamRouter into another StreamRouter is not supported",
802 ):
803 router.include_router(router2)