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

1import asyncio 

2from collections.abc import Awaitable, Callable 

3from types import TracebackType 

4from typing import Any 

5from unittest.mock import MagicMock, call 

6 

7import pytest 

8from typing_extensions import Self 

9 

10from faststream import Context 

11from faststream._internal.basic_types import DecodedMessage 

12from faststream.exceptions import SkipMessage 

13from faststream.middlewares import BaseMiddleware, ExceptionMiddleware 

14 

15from .basic import BaseTestcaseConfig 

16 

17 

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 

26 

27 async def __aexit__(self, *args: Any) -> None: 

28 mock.exit_inner() 

29 mock.exit("inner") 

30 

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) 

37 

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) 

44 

45 class OuterMiddleware(BaseMiddleware): 

46 async def __aenter__(self) -> Self: 

47 mock.enter_outer() 

48 mock.enter("outer") 

49 return self 

50 

51 async def __aexit__(self, *args: Any) -> None: 

52 mock.exit_outer() 

53 mock.exit("outer") 

54 

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) 

61 

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) 

68 

69 broker = self.get_broker(middlewares=[OuterMiddleware, InnerMiddleware]) 

70 

71 args, kwargs = self.get_subscriber_params(queue) 

72 

73 @broker.subscriber(*args, **kwargs) 

74 async def handler(msg: Any) -> None: 

75 pass 

76 

77 async with self.patch_broker(broker) as br: 

78 await br.publish(None, queue) 

79 

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

88 

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"] 

93 

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) 

108 

109 class InnerMiddleware(BaseMiddleware): 

110 async def on_receive(self) -> None: 

111 error_msg = "Ooops!" 

112 raise ValueError(error_msg) 

113 

114 broker = self.get_broker(middlewares=[OuterMiddleware, InnerMiddleware]) 

115 

116 args, kwargs = self.get_subscriber_params(queue) 

117 

118 @broker.subscriber(*args, **kwargs) 

119 async def handler(msg: Any) -> None: 

120 pass 

121 

122 async with self.patch_broker(broker) as br: 

123 with pytest.raises(ValueError, match="Ooops!"): 

124 await br.publish(None, queue) 

125 

126 mock.exit_outer.assert_called_once_with(ValueError) 

127 

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) 

140 

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) 

148 

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) 

156 

157 broker = self.get_broker( 

158 middlewares=[OuterMiddleware, MiddleMiddleware, InnerMiddleware], 

159 ) 

160 publisher = broker.publisher(queue) 

161 

162 args, kwargs = self.get_subscriber_params(queue) 

163 

164 @broker.subscriber(*args, **kwargs) 

165 async def handler(msg: Any) -> None: 

166 pass 

167 

168 async with self.patch_broker(broker): 

169 await publisher.publish(None, queue) 

170 

171 mock.publish_inner.assert_called_once() 

172 mock.publish_middle.assert_called_once() 

173 mock.publish_outer.assert_called_once() 

174 

175 assert [c.args[0] for c in mock.call_args_list] == ["outer", "middle", "inner"] 

176 

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) 

189 

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) 

197 

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) 

205 

206 broker = self.get_broker(middlewares=[OuterMiddleware]) 

207 router = self.get_router(middlewares=[MiddleMiddleware]) 

208 router2 = self.get_router(middlewares=[InnerMiddleware]) 

209 

210 publisher = router2.publisher(queue) 

211 

212 args, kwargs = self.get_subscriber_params(queue) 

213 

214 @router2.subscriber(*args, **kwargs) 

215 async def handler(msg: Any) -> None: 

216 pass 

217 

218 router.include_router(router2) 

219 broker.include_router(router) 

220 

221 async with self.patch_broker(broker): 

222 await publisher.publish(None, queue) 

223 

224 mock.publish_inner.assert_called_once() 

225 mock.publish_middle.assert_called_once() 

226 mock.publish_outer.assert_called_once() 

227 

228 assert [c.args[0] for c in mock.call_args_list] == ["outer", "middle", "inner"] 

229 

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) 

238 

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) 

246 

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) 

254 

255 broker = self.get_broker( 

256 middlewares=[OuterMiddleware, MiddleMiddleware, InnerMiddleware], 

257 ) 

258 

259 args, kwargs = self.get_subscriber_params(queue) 

260 

261 @broker.subscriber(*args, **kwargs) 

262 async def handler(msg: Any) -> None: 

263 pass 

264 

265 async with self.patch_broker(broker) as br: 

266 await br.publish(None, queue) 

267 

268 mock.consume_inner.assert_called_once() 

269 mock.consume_middle.assert_called_once() 

270 mock.consume_outer.assert_called_once() 

271 

272 assert [c.args[0] for c in mock.call_args_list] == ["outer", "middle", "inner"] 

273 

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) 

285 

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) 

292 

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) 

299 

300 broker = self.get_broker(middlewares=[OuterMiddleware]) 

301 router = self.get_router(middlewares=[MiddleMiddleware]) 

302 router2 = self.get_router(middlewares=[InnerMiddleware]) 

303 

304 args, kwargs = self.get_subscriber_params(queue) 

305 

306 @router2.subscriber(*args, **kwargs) 

307 async def handler(msg: Any) -> None: 

308 pass 

309 

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) 

314 

315 call_order = [c.args[0] for c in mock.call_args_list] 

316 assert call_order == ["outer", "middle", "inner"], call_order 

317 

318 

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 

336 

337 broker = self.get_broker(middlewares=(TapMiddleware,)) 

338 

339 args, kwargs = self.get_subscriber_params(queue) 

340 

341 @broker.subscriber(*args, **kwargs) 

342 async def handler(m: Any) -> str: 

343 mock.inner(m) 

344 return "end" 

345 

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 ) 

355 

356 mock.start.assert_called_once_with("start") 

357 mock.inner.assert_called_once_with("start") 

358 

359 assert event.is_set() 

360 mock.end.assert_called_once() 

361 

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 

377 

378 broker = self.get_broker(middlewares=(ErrorTraceMiddleware,)) 

379 

380 args, kwargs = self.get_subscriber_params(queue) 

381 

382 @broker.subscriber(*args, **kwargs) 

383 async def handler2(m: Any) -> None: 

384 event.set() 

385 raise ValueError 

386 

387 async with self.patch_broker(broker) as br: 

388 await br.start() 

389 

390 await asyncio.wait( 

391 ( 

392 asyncio.create_task(br.publish("", queue)), 

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

394 ), 

395 timeout=self.timeout, 

396 ) 

397 

398 assert event.is_set() 

399 mock.assert_called_once_with(True) 

400 

401 

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

414 

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) 

423 

424 broker = self.get_broker( 

425 middlewares=(mid,), 

426 ) 

427 

428 args, kwargs = self.get_subscriber_params(queue) 

429 

430 @broker.subscriber(*args, **kwargs) 

431 async def handler(m: Any) -> str: 

432 event.set() 

433 return "" 

434 

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

445 

446 mock.start.assert_called_once() 

447 mock.end.assert_called_once() 

448 

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

460 

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) 

469 

470 broker = self.get_broker() 

471 

472 # already registered subscriber 

473 args, kwargs = self.get_subscriber_params(queue) 

474 

475 @broker.subscriber(*args, **kwargs) 

476 async def handler(m: Any) -> str: 

477 event.set() 

478 return "" 

479 

480 # should affect to already registered and a new subscriber both 

481 broker.add_middleware(mid) 

482 

483 # new subscriber 

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

485 

486 @broker.subscriber(*args2, **kwargs2) 

487 async def handler2(m: Any) -> str: 

488 event2.set() 

489 return "" 

490 

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 ) 

502 

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 

506 

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) 

519 

520 broker = self.get_broker(middlewares=(Mid,)) 

521 

522 args, kwargs = self.get_subscriber_params(queue) 

523 

524 @broker.subscriber(*args, **kwargs) 

525 async def handler(m: Any) -> Any: 

526 return m 

527 

528 args2, kwargs2 = self.get_subscriber_params(queue + "r") 

529 

530 @broker.subscriber(*args2, **kwargs2) 

531 async def handler_resp(m: Any) -> None: 

532 mock(m) 

533 event.set() 

534 

535 async with self.patch_broker(broker) as br: 

536 await br.start() 

537 

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 ) 

545 

546 assert event.is_set() 

547 mock.assert_called_once_with("rrrr") 

548 

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

567 

568 broker = self.get_broker(middlewares=(Mid,)) 

569 

570 args, kwargs = self.get_subscriber_params(queue) 

571 

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 

578 

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 ) 

588 

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 

594 

595 

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

605 

606 @mid.add_handler(ValueError, publish=True) 

607 async def value_error_handler(exc: Any) -> str: 

608 return "value" 

609 

610 broker = self.get_broker(apply_types=True, middlewares=(mid,)) 

611 

612 args, kwargs = self.get_subscriber_params(queue) 

613 

614 @broker.subscriber(*args, **kwargs) 

615 @broker.publisher(queue + "1") 

616 async def subscriber1(m: Any) -> Any: 

617 raise ValueError 

618 

619 args, kwargs = self.get_subscriber_params(queue + "1") 

620 

621 @broker.subscriber(*args, **kwargs) 

622 async def subscriber2(msg: Any = Context("message")) -> None: 

623 mock(await msg.decode()) 

624 event.set() 

625 

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 ) 

635 

636 assert event.is_set() 

637 assert mock.call_count == 1 

638 mock.assert_called_once_with("value") 

639 

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

647 

648 @mid.add_handler(ValueError, publish=True) 

649 async def value_error_handler(exc: Any) -> None: 

650 event.set() 

651 raise SkipMessage 

652 

653 broker = self.get_broker(middlewares=(mid,)) 

654 args, kwargs = self.get_subscriber_params(queue) 

655 

656 @broker.subscriber(*args, **kwargs) 

657 @broker.publisher(queue + "1") 

658 async def subscriber1(m: Any) -> Any: 

659 raise ValueError 

660 

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

662 

663 @broker.subscriber(*args2, **kwargs2) 

664 async def subscriber2(msg: Any = Context("message")) -> None: 

665 mock(await msg.decode()) 

666 

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 ) 

676 

677 assert event.is_set() 

678 assert mock.call_count == 0 

679 

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

687 

688 @mid.add_handler(Exception) 

689 async def value_error_handler(exc: Any) -> None: 

690 mock() 

691 

692 broker = self.get_broker(middlewares=(mid,)) 

693 args, kwargs = self.get_subscriber_params(queue) 

694 

695 @broker.subscriber(*args, **kwargs) 

696 async def subscriber(m: Any) -> None: 

697 event.set() 

698 raise SkipMessage 

699 

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) 

710 

711 assert event.is_set() 

712 assert mock.call_count == 0 

713 

714 async def test_exception_middleware_reraise( 

715 self, 

716 queue: str, 

717 mock: MagicMock, 

718 event: asyncio.Event, 

719 ) -> None: 

720 mid = ExceptionMiddleware() 

721 

722 @mid.add_handler(ValueError, publish=True) 

723 async def value_error_handler(exc: Any) -> None: 

724 event.set() 

725 raise exc 

726 

727 broker = self.get_broker(middlewares=(mid,)) 

728 args, kwargs = self.get_subscriber_params(queue) 

729 

730 @broker.subscriber(*args, **kwargs) 

731 @broker.publisher(queue + "1") 

732 async def subscriber1(m: Any) -> Any: 

733 raise ValueError 

734 

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

736 

737 @broker.subscriber(*args2, **kwargs2) 

738 async def subscriber2(msg: Any = Context("message")) -> None: 

739 mock(await msg.decode()) 

740 

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 ) 

750 

751 assert event.is_set() 

752 assert mock.call_count == 0 

753 

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

761 

762 @mid.add_handler(ZeroDivisionError, publish=True) 

763 async def zero_error_handler(exc: Any) -> str: 

764 return "zero" 

765 

766 @mid.add_handler(ValueError, publish=True) 

767 async def value_error_handler(exc: Any) -> str: 

768 return "value" 

769 

770 broker = self.get_broker(apply_types=True, middlewares=(mid,)) 

771 args, kwargs = self.get_subscriber_params(queue) 

772 

773 publisher = broker.publisher(queue + "2") 

774 

775 @broker.subscriber(*args, **kwargs) 

776 @publisher 

777 async def subscriber1(m: Any) -> Any: 

778 raise ZeroDivisionError 

779 

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

781 

782 @broker.subscriber(*args2, **kwargs2) 

783 @publisher 

784 async def subscriber2(m: Any) -> Any: 

785 raise ValueError 

786 

787 args3, kwargs3 = self.get_subscriber_params(queue + "2") 

788 

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

794 

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 ) 

805 

806 assert event.is_set() 

807 assert mock.call_count == 2 

808 mock.assert_has_calls([call("zero"), call("value")], any_order=True) 

809 

810 async def test_exception_middleware_init_handler_same(self) -> None: 

811 mid1 = ExceptionMiddleware() 

812 

813 @mid1.add_handler(ValueError) 

814 async def value_error_handler(exc: Any) -> None: ... 

815 

816 mid2 = ExceptionMiddleware(handlers={ValueError: value_error_handler}) 

817 

818 assert list(mid1._handlers.keys()) == list(mid2._handlers.keys()) 

819 

820 async def test_exception_middleware_init_publish_handler_same(self) -> None: 

821 mid1 = ExceptionMiddleware() 

822 

823 @mid1.add_handler(ValueError, publish=True) 

824 async def value_error_handler(exc: Any) -> str: 

825 return "value" 

826 

827 mid2 = ExceptionMiddleware(publish_handlers={ValueError: value_error_handler}) 

828 

829 assert list(mid1._publish_handlers.keys()) == list(mid2._publish_handlers.keys()) 

830 

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 

841 

842 mid = ExceptionMiddleware() 

843 

844 @mid.add_handler(ValueError) 

845 async def value_error_handler(exc: Any) -> None: 

846 event.set() 

847 

848 broker = self.get_broker(middlewares=(mid,), decoder=decoder) 

849 

850 args, kwargs = self.get_subscriber_params(queue) 

851 

852 @broker.subscriber(*args, **kwargs) 

853 async def subscriber1(m: Any) -> Any: 

854 raise ZeroDivisionError 

855 

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 ) 

865 

866 assert event.is_set() 

867 

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

875 

876 class ExcAError(Exception): 

877 pass 

878 

879 class ExcBError(ExcAError): 

880 pass 

881 

882 mid = ExceptionMiddleware() 

883 

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" 

888 

889 @mid.add_handler(ExcBError, publish=True) 

890 async def handle_b(exc: Any) -> str: 

891 return "child" 

892 

893 broker = self.get_broker(apply_types=True, middlewares=(mid,)) 

894 args, kwargs = self.get_subscriber_params(queue) 

895 

896 @broker.subscriber(*args, **kwargs) 

897 @broker.publisher(queue + "1") 

898 async def subscriber1(m: Any) -> Any: 

899 raise ExcBError 

900 

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

902 

903 @broker.subscriber(*args2, **kwargs2) 

904 async def subscriber2(msg: Any = Context("message")) -> None: 

905 mock(await msg.decode()) 

906 event.set() 

907 

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 ) 

917 

918 assert event.is_set() 

919 mock.assert_called_once_with("child")