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

1import asyncio 

2from collections.abc import AsyncGenerator, Iterator 

3from contextlib import asynccontextmanager 

4from typing import Annotated, Any 

5from unittest.mock import Mock 

6 

7import pytest 

8from fastapi import BackgroundTasks, Depends, FastAPI, Header 

9from fastapi.exceptions import RequestValidationError 

10from fastapi.testclient import TestClient 

11 

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 

20 

21from .basic import BaseTestcaseConfig 

22 

23 

24@pytest.mark.asyncio() 

25class FastAPITestcase(BaseTestcaseConfig[Any]): 

26 router_class: Any 

27 broker_router_class: Any 

28 

29 async def test_base_real(self, mock: Mock, queue: str, event: asyncio.Event) -> None: 

30 router = self.router_class() 

31 

32 args, kwargs = self.get_subscriber_params(queue) 

33 

34 @router.subscriber(*args, **kwargs) 

35 async def hello(msg: Any) -> Any: 

36 event.set() 

37 return mock(msg) 

38 

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 ) 

48 

49 assert event.is_set() 

50 mock.assert_called_with("hi") 

51 

52 async def test_background( 

53 self, 

54 mock: Mock, 

55 queue: str, 

56 event: asyncio.Event, 

57 ) -> None: 

58 router = self.router_class() 

59 

60 def task(msg: Any) -> None: 

61 event.set() 

62 mock(msg) 

63 

64 args, kwargs = self.get_subscriber_params(queue) 

65 

66 @router.subscriber(*args, **kwargs) 

67 async def hello(msg: Any, tasks: BackgroundTasks) -> None: 

68 tasks.add_task(task, msg) 

69 

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 ) 

79 

80 mock.assert_called_with("hi") 

81 

82 async def test_context(self, mock: Mock, queue: str, event: asyncio.Event) -> None: 

83 router = self.router_class() 

84 context = router.context 

85 

86 context_key = "message.headers" 

87 

88 args, kwargs = self.get_subscriber_params(queue) 

89 

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() 

96 

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 ) 

108 

109 assert event.is_set() 

110 mock.assert_called_with(True) 

111 

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 

120 

121 context_key = "message.headers" 

122 

123 args, kwargs = self.get_subscriber_params(queue) 

124 

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() 

131 

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 ) 

143 

144 assert event.is_set() 

145 mock.assert_called_with(True) 

146 

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 

151 

152 args, kwargs = self.get_subscriber_params(queue) 

153 

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() 

159 

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 ) 

170 

171 assert context.get(queue) == {1, 2} 

172 context.reset_global(queue) 

173 

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() 

178 

179 args, kwargs = self.get_subscriber_params(queue) 

180 sub1 = router.subscriber(*args, **kwargs) 

181 

182 args2, kwargs2 = self.get_subscriber_params(queue + "2") 

183 

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() 

192 

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 ) 

204 

205 assert event.is_set() 

206 assert event2.is_set() 

207 assert mock.call_count == 2 

208 

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() 

216 

217 args, kwargs = self.get_subscriber_params(queue) 

218 

219 @router.subscriber(*args, **kwargs) 

220 @router.publisher(queue + "resp") 

221 async def m() -> str: 

222 return "hi" 

223 

224 args2, kwargs2 = self.get_subscriber_params(queue + "resp") 

225 

226 @router.subscriber(*args2, **kwargs2) 

227 async def resp(msg: Any) -> None: 

228 event.set() 

229 mock(msg) 

230 

231 async with router.broker: 

232 await router.broker.start() 

233 

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 ) 

241 

242 assert event.is_set() 

243 mock.assert_called_once_with("hi") 

244 

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() 

252 

253 args, kwargs = self.get_subscriber_params(queue) 

254 

255 @router.subscriber(*args, **kwargs) 

256 async def subscriber(msg: StreamMessage) -> None: 

257 mock("app" in msg.scope) 

258 event.set() 

259 

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 ) 

269 

270 mock.assert_called_once_with(True) 

271 

272 

273@pytest.mark.asyncio() 

274class FastAPILocalTestcase(BaseTestcaseConfig[Any]): 

275 router_class: Any 

276 broker_router_class: Any 

277 

278 async def test_base(self, queue: str) -> None: 

279 router = self.router_class() 

280 

281 app = FastAPI() 

282 app.include_router(router) 

283 

284 args, kwargs = self.get_subscriber_params(queue) 

285 

286 @router.subscriber(*args, **kwargs) 

287 async def hello() -> str: 

288 return "hi" 

289 

290 async with self.patch_broker(router.broker) as br: 

291 with TestClient(app) as client: 

292 assert client.app_state["broker"] is br 

293 

294 r = await br.request( 

295 "hi", 

296 queue, 

297 timeout=0.5, 

298 ) 

299 assert await r.decode() == "hi", r 

300 

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) 

304 

305 app = FastAPI() 

306 

307 args, kwargs = self.get_subscriber_params(queue) 

308 

309 @router.subscriber(*args, **kwargs) 

310 async def hello() -> Any: 

311 return Response("Hi!", headers={"x-header": "test"}) 

312 

313 async with self.patch_broker(router.broker) as br: 

314 with TestClient(app) as client: 

315 assert not client.app_state.get("broker") 

316 

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" 

324 

325 async def test_base_without_state(self, queue: str) -> None: 

326 router = self.router_class(setup_state=False) 

327 

328 app = FastAPI() 

329 

330 args, kwargs = self.get_subscriber_params(queue) 

331 

332 @router.subscriber(*args, **kwargs) 

333 async def hello() -> str: 

334 return "hi" 

335 

336 async with self.patch_broker(router.broker) as br: 

337 with TestClient(app) as client: 

338 assert not client.app_state.get("broker") 

339 

340 r = await br.request( 

341 "hi", 

342 queue, 

343 timeout=0.5, 

344 ) 

345 assert await r.decode() == "hi", r 

346 

347 async def test_invalid(self, queue: str) -> None: 

348 router = self.router_class() 

349 

350 app = FastAPI() 

351 

352 args, kwargs = self.get_subscriber_params(queue) 

353 

354 @router.subscriber(*args, **kwargs) 

355 async def hello(msg: int) -> None: ... 

356 

357 app.include_router(router) 

358 

359 async with self.patch_broker(router.broker) as br: 

360 with TestClient(app), pytest.raises(RequestValidationError): 

361 await br.publish("hi", queue) 

362 

363 async def test_headers(self, queue: str) -> None: 

364 router = self.router_class() 

365 

366 args, kwargs = self.get_subscriber_params(queue) 

367 

368 @router.subscriber(*args, **kwargs) 

369 async def hello(w: Any = Header()) -> Any: 

370 return w 

371 

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 

380 

381 async def test_depends(self, mock: Mock, queue: str) -> None: 

382 router = self.router_class() 

383 

384 def dep(a: Any) -> Any: 

385 mock(a) 

386 return a 

387 

388 args, kwargs = self.get_subscriber_params(queue) 

389 

390 @router.subscriber(*args, **kwargs) 

391 async def hello(a: Any, w: Any = Depends(dep)) -> Any: 

392 return w 

393 

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 

401 

402 mock.assert_called_once_with("hi") 

403 

404 async def test_mixed_depends(self, mock: Mock, queue: str) -> None: 

405 router = self.router_class() 

406 

407 def dep(a: str) -> str: 

408 mock(a) 

409 return a 

410 

411 args, kwargs = self.get_subscriber_params(queue) 

412 

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 

423 

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 

431 

432 mock.assert_called_once_with("hi") 

433 

434 async def test_depends_from_fastdepends_default(self, queue: str) -> None: 

435 router = self.router_class() 

436 

437 args, kwargs = self.get_subscriber_params(queue) 

438 

439 subscriber = router.subscriber(*args, **kwargs) 

440 

441 @subscriber 

442 def sub(d: Any = FSDepends(lambda: 1)) -> None: ... 

443 

444 app = FastAPI() 

445 app.include_router(router) 

446 

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 ... 

451 

452 async def test_depends_from_fastdepends_annotated(self, queue: str) -> None: 

453 router = self.router_class() 

454 

455 args, kwargs = self.get_subscriber_params(queue) 

456 

457 subscriber = router.subscriber(*args, **kwargs) 

458 

459 @subscriber 

460 def sub(d: Annotated[Any, FSDepends(lambda: 1)]) -> None: ... 

461 

462 app = FastAPI() 

463 app.include_router(router) 

464 

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 ... 

469 

470 async def test_depends_combined_annotated(self, queue: str) -> None: 

471 router = self.router_class() 

472 

473 args, kwargs = self.get_subscriber_params(queue) 

474 

475 subscriber = router.subscriber(*args, **kwargs) 

476 

477 @subscriber 

478 def sub( 

479 d: Annotated[Any, FSDepends(lambda: 1), Depends(lambda: 1)], 

480 ) -> None: ... 

481 

482 app = FastAPI() 

483 app.include_router(router) 

484 

485 async with self.patch_broker(router.broker): 

486 with TestClient(app): 

487 ... 

488 

489 async def test_faststream_context(self, queue: str) -> None: 

490 router = self.router_class() 

491 

492 args, kwargs = self.get_subscriber_params(queue) 

493 

494 @router.subscriber(*args, **kwargs) 

495 async def hello(msg: Any = FSContext()) -> None: ... 

496 

497 app = FastAPI() 

498 app.include_router(router) 

499 

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 ... 

504 

505 async def test_faststream_context_annotated(self, queue: str) -> None: 

506 router = self.router_class() 

507 

508 args, kwargs = self.get_subscriber_params(queue) 

509 

510 @router.subscriber(*args, **kwargs) 

511 async def hello(msg: Annotated[Any, FSContext()]) -> None: ... 

512 

513 app = FastAPI() 

514 app.include_router(router) 

515 

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 ... 

520 

521 async def test_combined_context_annotated(self, queue: str) -> None: 

522 router = self.router_class() 

523 

524 args, kwargs = self.get_subscriber_params(queue) 

525 

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: ... 

534 

535 app = FastAPI() 

536 app.include_router(router) 

537 

538 async with self.patch_broker(router.broker): 

539 with TestClient(app): 

540 ... 

541 

542 async def test_nested_combined_context_annotated(self, queue: str) -> None: 

543 router = self.router_class() 

544 

545 args, kwargs = self.get_subscriber_params(queue) 

546 

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: ... 

554 

555 app = FastAPI() 

556 app.include_router(router) 

557 

558 async with self.patch_broker(router.broker): 

559 with TestClient(app): 

560 ... 

561 

562 async def test_yield_depends(self, mock: Mock, queue: str) -> None: 

563 router = self.router_class() 

564 

565 def dep(a: Any) -> Iterator[Any]: 

566 mock.start() 

567 yield a 

568 mock.close() 

569 

570 args, kwargs = self.get_subscriber_params(queue) 

571 

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 

576 

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 

584 

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() 

589 

590 async def test_router_depends(self, mock: Mock, queue: str) -> None: 

591 def mock_dep() -> None: 

592 mock() 

593 

594 router = self.router_class(dependencies=(Depends(mock_dep, use_cache=False),)) 

595 

596 args, kwargs = self.get_subscriber_params(queue) 

597 

598 @router.subscriber(*args, **kwargs) 

599 async def hello(a: Any) -> Any: 

600 return a 

601 

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 

605 

606 mock.assert_called_once() 

607 

608 async def test_subscriber_depends(self, mock: Mock, queue: str) -> None: 

609 def mock_dep() -> None: 

610 mock() 

611 

612 router = self.router_class() 

613 

614 args, kwargs = self.get_subscriber_params( 

615 queue, 

616 dependencies=(Depends(mock_dep, use_cache=False),), 

617 ) 

618 

619 @router.subscriber(*args, **kwargs) 

620 async def hello(a: Any) -> Any: 

621 return a 

622 

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 

630 

631 mock.assert_called_once() 

632 

633 async def test_hooks(self, mock: Mock) -> None: 

634 router = self.router_class() 

635 

636 app = FastAPI() 

637 app.include_router(router) 

638 

639 @router.after_startup 

640 def test_sync(app: Any) -> None: 

641 mock.sync_called() 

642 

643 @router.after_startup 

644 async def test_async(app: Any) -> None: 

645 mock.async_called() 

646 

647 @router.on_broker_shutdown 

648 def test_shutdown_sync(app: Any) -> None: 

649 mock.sync_shutdown_called() 

650 

651 @router.on_broker_shutdown 

652 async def test_shutdown_async(app: Any) -> None: 

653 mock.async_shutdown_called() 

654 

655 async with self.patch_broker(router.broker), router.lifespan_context(app): 

656 pass 

657 

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() 

662 

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() 

671 

672 router = self.router_class(lifespan=lifespan) 

673 

674 app = FastAPI() 

675 app.include_router(router) 

676 

677 async with ( 

678 self.patch_broker(router.broker), 

679 router.lifespan_context( 

680 app, 

681 ) as context, 

682 ): 

683 assert context["lifespan"] 

684 

685 mock.start.assert_called_once() 

686 mock.close.assert_called_once() 

687 

688 async def test_subscriber_mock(self, queue: str) -> None: 

689 router = self.router_class() 

690 

691 args, kwargs = self.get_subscriber_params(queue) 

692 

693 @router.subscriber(*args, **kwargs) 

694 async def m() -> str: 

695 return "hi" 

696 

697 async with self.patch_broker(router.broker) as rb: 

698 await rb.publish("hello", queue) 

699 m.mock.assert_called_once_with("hello") 

700 

701 async def test_publisher_mock(self, queue: str) -> None: 

702 router = self.router_class() 

703 

704 publisher = router.publisher(queue + "resp") 

705 

706 args, kwargs = self.get_subscriber_params(queue) 

707 sub = router.subscriber(*args, **kwargs) 

708 

709 @publisher 

710 @sub 

711 async def m() -> str: 

712 return "response" 

713 

714 async with self.patch_broker(router.broker) as rb: 

715 await rb.publish("hello", queue) 

716 publisher.mock.assert_called_with("response") 

717 

718 async def test_include(self, queue: str) -> None: 

719 router = self.router_class() 

720 router2 = self.broker_router_class() 

721 

722 app = FastAPI() 

723 

724 args, kwargs = self.get_subscriber_params(queue) 

725 

726 @router.subscriber(*args, **kwargs) 

727 async def hello() -> str: 

728 return "hi" 

729 

730 args2, kwargs2 = self.get_subscriber_params(queue + "1") 

731 

732 @router2.subscriber(*args2, **kwargs2) 

733 async def hello_router2() -> str: 

734 return "hi" 

735 

736 router.include_router(router2) 

737 app.include_router(router) 

738 

739 async with self.patch_broker(router.broker) as br: 

740 with TestClient(app) as client: 

741 assert client.app_state["broker"] is br 

742 

743 r = await br.request( 

744 "hi", 

745 queue, 

746 timeout=0.5, 

747 ) 

748 assert await r.decode() == "hi", r 

749 

750 r = await br.request( 

751 "hi", 

752 queue + "1", 

753 timeout=0.5, 

754 ) 

755 assert await r.decode() == "hi", r 

756 

757 async def test_dependency_overrides(self, mock: Mock, queue: str) -> None: 

758 router = self.router_class() 

759 

760 def dep1() -> None: 

761 raise AssertionError 

762 

763 def dep2() -> None: 

764 mock() 

765 

766 app = FastAPI() 

767 app.dependency_overrides[dep1] = dep2 

768 

769 args, kwargs = self.get_subscriber_params(queue) 

770 

771 @router.subscriber(*args, **kwargs) 

772 async def hello_router2(dep: None = Depends(dep1)) -> str: 

773 return "hi" 

774 

775 app.include_router(router) 

776 

777 async with self.patch_broker(router.broker) as br: 

778 with TestClient(app) as client: 

779 assert client.app_state["broker"] is br 

780 

781 r = await br.request( 

782 "hi", 

783 queue, 

784 timeout=0.5, 

785 ) 

786 assert await r.decode() == "hi", r 

787 

788 mock.assert_called_once() 

789 

790 async def test_nested_stream_router_raises(self) -> None: 

791 """Including a StreamRouter into another StreamRouter must raise TypeError. 

792 

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() 

798 

799 with pytest.raises( 

800 TypeError, 

801 match="Including a StreamRouter into another StreamRouter is not supported", 

802 ): 

803 router.include_router(router2)