Coverage for tests / brokers / base / fastapi.py: 99%

1import asyncio (empty)

2from contextlib import asynccontextmanager (empty)

3from typing import Annotated, Any, TypeVar (empty)

4from unittest.mock import Mock (empty)

5 

6import pytest (empty)

7from fastapi import BackgroundTasks, Depends, FastAPI, Header (empty)

8from fastapi.exceptions import RequestValidationError (empty)

9from fastapi.testclient import TestClient (empty)

10 

11from faststream import ( (empty)

12 Context as FSContext, 

13 Depends as FSDepends, 

14 Response, 

15) 

16from faststream._internal.broker import BrokerUsecase (empty)

17from faststream._internal.broker.router import BrokerRouter (empty)

18from faststream._internal.fastapi.context import Context (empty)

19from faststream._internal.fastapi.route import StreamMessage (empty)

20from faststream._internal.fastapi.router import StreamRouter (empty)

21from faststream.exceptions import SetupError (empty)

22 

23from .basic import BaseTestcaseConfig (empty)

24 

25Broker = TypeVar("Broker", bound=BrokerUsecase) (empty)

26 

27 

28@pytest.mark.asyncio() (empty)

29class FastAPITestcase(BaseTestcaseConfig): (empty)

30 router_class: type[StreamRouter[BrokerUsecase]] (empty)

31 broker_router_class: type[BrokerRouter[Any]] (empty)

32 

33 async def test_base_real(self, mock: Mock, queue: str) -> None: (empty)

34 event = asyncio.Event() (empty)

35 

36 router = self.router_class() (empty)

37 

38 args, kwargs = self.get_subscriber_params(queue) (empty)

39 

40 @router.subscriber(*args, **kwargs) (empty)

41 async def hello(msg): (empty)

42 event.set() (empty)

43 return mock(msg) (empty)

44 

45 async with router.broker: (empty)

46 await router.broker.start() (empty)

47 await asyncio.wait( (empty)

48 ( 

49 asyncio.create_task(router.broker.publish("hi", queue)), 

50 asyncio.create_task(event.wait()), 

51 ), 

52 timeout=self.timeout, 

53 ) 

54 

55 assert event.is_set() (empty)

56 mock.assert_called_with("hi") (empty)

57 

58 async def test_background( (empty)

59 self, 

60 mock: Mock, 

61 queue: str, 

62 event: asyncio.Event, 

63 ) -> None: 

64 router = self.router_class() (empty)

65 

66 def task(msg: Any) -> None: (empty)

67 event.set() (empty)

68 return mock(msg) (empty)

69 

70 args, kwargs = self.get_subscriber_params(queue) (empty)

71 

72 @router.subscriber(*args, **kwargs) (empty)

73 async def hello(msg, tasks: BackgroundTasks) -> None: (empty)

74 tasks.add_task(task, msg) (empty)

75 

76 async with router.broker: (empty)

77 await router.broker.start() (empty)

78 await asyncio.wait( (empty)

79 ( 

80 asyncio.create_task(router.broker.publish("hi", queue)), 

81 asyncio.create_task(event.wait()), 

82 ), 

83 timeout=self.timeout, 

84 ) 

85 

86 mock.assert_called_with("hi") (empty)

87 

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

89 router = self.router_class() (empty)

90 context = router.context (empty)

91 

92 context_key = "message.headers" (empty)

93 

94 args, kwargs = self.get_subscriber_params(queue) (empty)

95 

96 @router.subscriber(*args, **kwargs) (empty)

97 async def hello(msg: Any = Context(context_key)) -> None: (empty)

98 try: (empty)

99 mock(msg == context.resolve(context_key) and msg["1"] == "1") (empty)

100 finally: 

101 event.set() (empty)

102 

103 async with router.broker: (empty)

104 await router.broker.start() (empty)

105 await asyncio.wait( (empty)

106 ( 

107 asyncio.create_task( 

108 router.broker.publish("", queue, headers={"1": "1"}), 

109 ), 

110 asyncio.create_task(event.wait()), 

111 ), 

112 timeout=self.timeout, 

113 ) 

114 

115 assert event.is_set() (empty)

116 mock.assert_called_with(True) (empty)

117 

118 async def test_context_annotated( (empty)

119 self, 

120 mock: Mock, 

121 queue: str, 

122 event: asyncio.Event, 

123 ) -> None: 

124 router = self.router_class() (empty)

125 context = router.context (empty)

126 

127 context_key = "message.headers" (empty)

128 

129 args, kwargs = self.get_subscriber_params(queue) (empty)

130 

131 @router.subscriber(*args, **kwargs) (empty)

132 async def hello(msg: Annotated[Any, Context(context_key)]) -> None: (empty)

133 try: (empty)

134 mock(msg == context.resolve(context_key) and msg["1"] == "1") (empty)

135 finally: 

136 event.set() (empty)

137 

138 async with router.broker: (empty)

139 await router.broker.start() (empty)

140 await asyncio.wait( (empty)

141 ( 

142 asyncio.create_task( 

143 router.broker.publish("", queue, headers={"1": "1"}), 

144 ), 

145 asyncio.create_task(event.wait()), 

146 ), 

147 timeout=self.timeout, 

148 ) 

149 

150 assert event.is_set() (empty)

151 mock.assert_called_with(True) (empty)

152 

153 @pytest.mark.flaky(reruns=3, reruns_delay=1) (empty)

154 async def test_initial_context(self, queue: str, event: asyncio.Event) -> None: (empty)

155 router = self.router_class() (empty)

156 context = router.context (empty)

157 

158 args, kwargs = self.get_subscriber_params(queue) (empty)

159 

160 @router.subscriber(*args, **kwargs) (empty)

161 async def hello(msg: int, data: set[int] = Context(queue, initial=set)) -> None: (empty)

162 data.add(msg) (empty)

163 if len(data) == 2: (empty)

164 event.set() (empty)

165 

166 async with router.broker: (empty)

167 await router.broker.start() (empty)

168 await asyncio.wait( (empty)

169 ( 

170 asyncio.create_task(router.broker.publish(1, queue)), 

171 asyncio.create_task(router.broker.publish(2, queue)), 

172 asyncio.create_task(event.wait()), 

173 ), 

174 timeout=self.timeout, 

175 ) 

176 

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

178 context.reset_global(queue) (empty)

179 

180 async def test_double_real(self, mock: Mock, queue: str) -> None: (empty)

181 event = asyncio.Event() (empty)

182 event2 = asyncio.Event() (empty)

183 

184 router = self.router_class() (empty)

185 

186 args, kwargs = self.get_subscriber_params(queue) (empty)

187 sub1 = router.subscriber(*args, **kwargs) (empty)

188 

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

190 

191 @sub1 (empty)

192 @router.subscriber(*args2, **kwargs2) (empty)

193 async def hello(msg: str) -> None: (empty)

194 if event.is_set(): (empty)

195 event2.set() (empty)

196 else: 

197 event.set() (empty)

198 mock() (empty)

199 

200 async with router.broker: (empty)

201 await router.broker.start() (empty)

202 await asyncio.wait( (empty)

203 ( 

204 asyncio.create_task(router.broker.publish("hi", queue)), 

205 asyncio.create_task(router.broker.publish("hi", queue + "2")), 

206 asyncio.create_task(event.wait()), 

207 asyncio.create_task(event2.wait()), 

208 ), 

209 timeout=self.timeout, 

210 ) 

211 

212 assert event.is_set() (empty)

213 assert event2.is_set() (empty)

214 assert mock.call_count == 2 (empty)

215 

216 async def test_base_publisher_real( (empty)

217 self, 

218 mock: Mock, 

219 queue: str, 

220 ) -> None: 

221 event = asyncio.Event() (empty)

222 

223 router = self.router_class() (empty)

224 

225 args, kwargs = self.get_subscriber_params(queue) (empty)

226 

227 @router.subscriber(*args, **kwargs) (empty)

228 @router.publisher(queue + "resp") (empty)

229 async def m() -> str: (empty)

230 return "hi" (empty)

231 

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

233 

234 @router.subscriber(*args2, **kwargs2) (empty)

235 async def resp(msg) -> None: (empty)

236 event.set() (empty)

237 mock(msg) (empty)

238 

239 async with router.broker: (empty)

240 await router.broker.start() (empty)

241 

242 await asyncio.wait( (empty)

243 ( 

244 asyncio.create_task(router.broker.publish("", queue)), 

245 asyncio.create_task(event.wait()), 

246 ), 

247 timeout=self.timeout, 

248 ) 

249 

250 assert event.is_set() (empty)

251 mock.assert_called_once_with("hi") (empty)

252 

253 async def test_injection_fastapi( (empty)

254 self, 

255 mock: Mock, 

256 queue: str, 

257 event: asyncio.Event, 

258 ) -> None: 

259 router = self.router_class() (empty)

260 

261 args, kwargs = self.get_subscriber_params(queue) (empty)

262 

263 @router.subscriber(*args, **kwargs) (empty)

264 async def subscriber(msg: StreamMessage) -> None: (empty)

265 mock("app" in msg.scope) (empty)

266 event.set() (empty)

267 

268 async with router.broker: (empty)

269 await router.broker.start() (empty)

270 await asyncio.wait( (empty)

271 ( 

272 asyncio.create_task(router.broker.publish(None, queue)), 

273 asyncio.create_task(event.wait()), 

274 ), 

275 timeout=self.timeout, 

276 ) 

277 

278 mock.assert_called_once_with(True) (empty)

279 

280 

281@pytest.mark.asyncio() (empty)

282class FastAPILocalTestcase(BaseTestcaseConfig): (empty)

283 router_class: type[StreamRouter[BrokerUsecase]] (empty)

284 

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

286 router = self.router_class() (empty)

287 

288 app = FastAPI() (empty)

289 app.include_router(router) (empty)

290 

291 args, kwargs = self.get_subscriber_params(queue) (empty)

292 

293 @router.subscriber(*args, **kwargs) (empty)

294 async def hello() -> str: (empty)

295 return "hi" (empty)

296 

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

298 with TestClient(app) as client: (empty)

299 assert client.app_state["broker"] is br (empty)

300 

301 r = await br.request( (empty)

302 "hi", 

303 queue, 

304 timeout=0.5, 

305 ) 

306 assert await r.decode() == "hi", r (empty)

307 

308 async def test_request(self, queue: str) -> None: (empty)

309 """Local test due request exists in all TestClients.""" 

310 router = self.router_class(setup_state=False) (empty)

311 

312 app = FastAPI() (empty)

313 

314 args, kwargs = self.get_subscriber_params(queue) (empty)

315 

316 @router.subscriber(*args, **kwargs) (empty)

317 async def hello(): (empty)

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

319 

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

321 with TestClient(app) as client: (empty)

322 assert not client.app_state.get("broker") (empty)

323 

324 r = await br.request( (empty)

325 "hi", 

326 queue, 

327 timeout=0.5, 

328 ) 

329 assert await r.decode() == "Hi!" (empty)

330 assert r.headers["x-header"] == "test" (empty)

331 

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

333 router = self.router_class(setup_state=False) (empty)

334 

335 app = FastAPI() (empty)

336 

337 args, kwargs = self.get_subscriber_params(queue) (empty)

338 

339 @router.subscriber(*args, **kwargs) (empty)

340 async def hello() -> str: (empty)

341 return "hi" (empty)

342 

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

344 with TestClient(app) as client: (empty)

345 assert not client.app_state.get("broker") (empty)

346 

347 r = await br.request( (empty)

348 "hi", 

349 queue, 

350 timeout=0.5, 

351 ) 

352 assert await r.decode() == "hi", r (empty)

353 

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

355 router = self.router_class() (empty)

356 

357 app = FastAPI() (empty)

358 

359 args, kwargs = self.get_subscriber_params(queue) (empty)

360 

361 @router.subscriber(*args, **kwargs) (empty)

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

363 

364 app.include_router(router) (empty)

365 

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

367 with TestClient(app): (empty)

368 with pytest.raises(RequestValidationError): (empty)

369 await br.publish("hi", queue) (empty)

370 

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

372 router = self.router_class() (empty)

373 

374 args, kwargs = self.get_subscriber_params(queue) (empty)

375 

376 @router.subscriber(*args, **kwargs) (empty)

377 async def hello(w=Header()): (empty)

378 return w (empty)

379 

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

381 r = await br.request( (empty)

382 "", 

383 queue, 

384 headers={"w": "hi"}, 

385 timeout=0.5, 

386 ) 

387 assert await r.decode() == "hi", r (empty)

388 

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

390 router = self.router_class() (empty)

391 

392 def dep(a): (empty)

393 mock(a) (empty)

394 return a (empty)

395 

396 args, kwargs = self.get_subscriber_params(queue) (empty)

397 

398 @router.subscriber(*args, **kwargs) (empty)

399 async def hello(a, w=Depends(dep)): (empty)

400 return w (empty)

401 

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

403 r = await br.request( (empty)

404 {"a": "hi"}, 

405 queue, 

406 timeout=0.5, 

407 ) 

408 assert await r.decode() == "hi", r (empty)

409 

410 mock.assert_called_once_with("hi") (empty)

411 

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

413 router = self.router_class() (empty)

414 

415 def dep(a: str) -> str: (empty)

416 mock(a) (empty)

417 return a (empty)

418 

419 args, kwargs = self.get_subscriber_params(queue) (empty)

420 

421 @router.subscriber(*args, **kwargs) (empty)

422 async def hello( (empty)

423 a: str, 

424 w: Annotated[ 

425 str, 

426 Depends(dep), 

427 FSDepends(dep), # will be ignored 

428 ], 

429 ) -> str: 

430 return w (empty)

431 

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

433 r = await br.request( (empty)

434 {"a": "hi"}, 

435 queue, 

436 timeout=0.5, 

437 ) 

438 assert await r.decode() == "hi", r (empty)

439 

440 mock.assert_called_once_with("hi") (empty)

441 

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

443 router = self.router_class() (empty)

444 

445 args, kwargs = self.get_subscriber_params(queue) (empty)

446 

447 subscriber = router.subscriber(*args, **kwargs) (empty)

448 

449 @subscriber (empty)

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

451 

452 app = FastAPI() (empty)

453 app.include_router(router) (empty)

454 

455 with pytest.raises(SetupError): # noqa: PT012 (empty)

456 async with self.patch_broker(router.broker): (empty)

457 with TestClient(app): 

458 ... 

459 

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

461 router = self.router_class() (empty)

462 

463 args, kwargs = self.get_subscriber_params(queue) (empty)

464 

465 subscriber = router.subscriber(*args, **kwargs) (empty)

466 

467 @subscriber (empty)

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

469 

470 app = FastAPI() (empty)

471 app.include_router(router) (empty)

472 

473 with pytest.raises(SetupError): # noqa: PT012 (empty)

474 async with self.patch_broker(router.broker): (empty)

475 with TestClient(app): 

476 ... 

477 

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

479 router = self.router_class() (empty)

480 

481 args, kwargs = self.get_subscriber_params(queue) (empty)

482 

483 subscriber = router.subscriber(*args, **kwargs) (empty)

484 

485 @subscriber (empty)

486 def sub( (empty)

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

488 ) -> None: ... (empty)

489 

490 app = FastAPI() (empty)

491 app.include_router(router) (empty)

492 

493 async with self.patch_broker(router.broker): (empty)

494 with TestClient(app): (empty)

495 ... (empty)

496 

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

498 router = self.router_class() (empty)

499 

500 args, kwargs = self.get_subscriber_params(queue) (empty)

501 

502 @router.subscriber(*args, **kwargs) (empty)

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

504 

505 app = FastAPI() (empty)

506 app.include_router(router) (empty)

507 

508 with pytest.raises(SetupError): # noqa: PT012 (empty)

509 async with self.patch_broker(router.broker): (empty)

510 with TestClient(app): 

511 ... 

512 

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

514 router = self.router_class() (empty)

515 

516 args, kwargs = self.get_subscriber_params(queue) (empty)

517 

518 @router.subscriber(*args, **kwargs) (empty)

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

520 

521 app = FastAPI() (empty)

522 app.include_router(router) (empty)

523 

524 with pytest.raises(SetupError): # noqa: PT012 (empty)

525 async with self.patch_broker(router.broker): (empty)

526 with TestClient(app): 

527 ... 

528 

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

530 router = self.router_class() (empty)

531 

532 args, kwargs = self.get_subscriber_params(queue) (empty)

533 

534 @router.subscriber(*args, **kwargs) (empty)

535 async def hello( (empty)

536 msg: Annotated[ (empty)

537 Any, (empty)

538 Context("message.headers"), (empty)

539 FSContext("message.headers"), (empty)

540 ], 

541 ) -> None: ... (empty)

542 

543 app = FastAPI() (empty)

544 app.include_router(router) (empty)

545 

546 async with self.patch_broker(router.broker): (empty)

547 with TestClient(app): (empty)

548 ... (empty)

549 

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

551 router = self.router_class() (empty)

552 

553 args, kwargs = self.get_subscriber_params(queue) (empty)

554 

555 @router.subscriber(*args, **kwargs) (empty)

556 async def hello( (empty)

557 msg: Annotated[ (empty)

558 Annotated[Any, FSContext("message.headers")], (empty)

559 Context("message.headers"), (empty)

560 ], 

561 ) -> None: ... (empty)

562 

563 app = FastAPI() (empty)

564 app.include_router(router) (empty)

565 

566 async with self.patch_broker(router.broker): (empty)

567 with TestClient(app): (empty)

568 ... (empty)

569 

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

571 router = self.router_class() (empty)

572 

573 def dep(a): (empty)

574 mock.start() (empty)

575 yield a (empty)

576 mock.close() (empty)

577 

578 args, kwargs = self.get_subscriber_params(queue) (empty)

579 

580 @router.subscriber(*args, **kwargs) (empty)

581 async def hello(a, w=Depends(dep)): (empty)

582 mock.start.assert_called_once() (empty)

583 assert not mock.close.call_count (empty)

584 return w (empty)

585 

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

587 r = await br.request( (empty)

588 {"a": "hi"}, 

589 queue, 

590 timeout=0.5, 

591 ) 

592 assert await r.decode() == "hi", r (empty)

593 

594 mock.start.assert_called_once() (empty)

595 mock.close.assert_called_once() (empty)

596 

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

598 def mock_dep() -> None: (empty)

599 mock() (empty)

600 

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

602 

603 args, kwargs = self.get_subscriber_params(queue) (empty)

604 

605 @router.subscriber(*args, **kwargs) (empty)

606 async def hello(a): (empty)

607 return a (empty)

608 

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

610 r = await br.request("hi", queue, timeout=0.5) (empty)

611 assert await r.decode() == "hi", r (empty)

612 

613 mock.assert_called_once() (empty)

614 

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

616 def mock_dep() -> None: (empty)

617 mock() (empty)

618 

619 router = self.router_class() (empty)

620 

621 args, kwargs = self.get_subscriber_params( (empty)

622 queue, 

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

624 ) 

625 

626 @router.subscriber(*args, **kwargs) (empty)

627 async def hello(a): (empty)

628 return a (empty)

629 

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

631 r = await br.request( (empty)

632 "hi", 

633 queue, 

634 timeout=0.5, 

635 ) 

636 assert await r.decode() == "hi", r (empty)

637 

638 mock.assert_called_once() (empty)

639 

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

641 router = self.router_class() (empty)

642 

643 app = FastAPI() (empty)

644 app.include_router(router) (empty)

645 

646 @router.after_startup (empty)

647 def test_sync(app) -> None: (empty)

648 mock.sync_called() (empty)

649 

650 @router.after_startup (empty)

651 async def test_async(app) -> None: (empty)

652 mock.async_called() (empty)

653 

654 @router.on_broker_shutdown (empty)

655 def test_shutdown_sync(app) -> None: (empty)

656 mock.sync_shutdown_called() (empty)

657 

658 @router.on_broker_shutdown (empty)

659 async def test_shutdown_async(app) -> None: (empty)

660 mock.async_shutdown_called() (empty)

661 

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

663 pass (empty)

664 

665 mock.sync_called.assert_called_once() (empty)

666 mock.async_called.assert_called_once() (empty)

667 mock.sync_shutdown_called.assert_called_once() (empty)

668 mock.async_shutdown_called.assert_called_once() (empty)

669 

670 async def test_existed_lifespan_startup(self, mock: Mock) -> None: (empty)

671 @asynccontextmanager (empty)

672 async def lifespan(app): (empty)

673 mock.start() (empty)

674 yield {"lifespan": True} (empty)

675 mock.close() (empty)

676 

677 router = self.router_class(lifespan=lifespan) (empty)

678 

679 app = FastAPI() (empty)

680 app.include_router(router) (empty)

681 

682 async with ( (empty)

683 self.patch_broker(router.broker), 

684 router.lifespan_context( 

685 app, 

686 ) as context, 

687 ): 

688 assert context["lifespan"] (empty)

689 

690 mock.start.assert_called_once() (empty)

691 mock.close.assert_called_once() (empty)

692 

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

694 router = self.router_class() (empty)

695 

696 args, kwargs = self.get_subscriber_params(queue) (empty)

697 

698 @router.subscriber(*args, **kwargs) (empty)

699 async def m() -> str: (empty)

700 return "hi" (empty)

701 

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

703 await rb.publish("hello", queue) (empty)

704 m.mock.assert_called_once_with("hello") (empty)

705 

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

707 router = self.router_class() (empty)

708 

709 publisher = router.publisher(queue + "resp") (empty)

710 

711 args, kwargs = self.get_subscriber_params(queue) (empty)

712 sub = router.subscriber(*args, **kwargs) (empty)

713 

714 @publisher (empty)

715 @sub (empty)

716 async def m() -> str: (empty)

717 return "response" (empty)

718 

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

720 await rb.publish("hello", queue) (empty)

721 publisher.mock.assert_called_with("response") (empty)

722 

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

724 router = self.router_class() (empty)

725 router2 = self.broker_router_class() (empty)

726