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

294 statements  

« prev     ^ index     » next       coverage.py v7.17.3, created at 2026-11-17 21:20 +0000

1import asyncio 

2from contextlib import suppress 

3from typing import Any 

4from unittest.mock import MagicMock, call, patch 

5 

6import anyio 

7import pytest 

8from pydantic import BaseModel 

9 

10from faststream import AckPolicy, BaseMiddleware, Context, Depends, FastStream, TestApp 

11from faststream.exceptions import StopConsume 

12from faststream.message import StreamMessage 

13from tests.tools import spy_decorator 

14 

15from .basic import BaseTestcaseConfig 

16 

17 

18@pytest.mark.asyncio() 

19class MultibrokerTestcase(BaseTestcaseConfig[Any]): 

20 async def test_multi_consume( 

21 self, queue: str, mock: MagicMock, event: asyncio.Event, event2: asyncio.Event 

22 ) -> None: 

23 broker1, broker2 = self.get_broker(), self.get_broker() 

24 

25 args, kwargs = self.get_subscriber_params(queue) 

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

27 

28 # A sync handler runs in a thread per broker, and two threads racing 

29 # between `mock()` and the count check leave `event` unset 

30 @broker1.subscriber(*args, **kwargs) 

31 @broker2.subscriber(*args2, **kwargs2) 

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

33 mock() 

34 if mock.call_count == 1: 

35 event.set() 

36 else: 

37 event2.set() 

38 

39 app = FastStream(broker1, broker2) 

40 

41 async with ( 

42 self.patch_broker(broker1) as br1, 

43 self.patch_broker(broker2) as br2, 

44 TestApp(app), 

45 ): 

46 await asyncio.wait( 

47 ( 

48 asyncio.create_task(br1.publish("hello", queue)), 

49 asyncio.create_task(br2.publish("hello", queue + "1")), 

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

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

52 ), 

53 timeout=self.timeout, 

54 ) 

55 

56 assert event.is_set() 

57 assert event2.is_set() 

58 assert mock.call_count == 2 

59 

60 async def test_another_broker_publisher( 

61 self, queue: str, mock: MagicMock, event: asyncio.Event 

62 ) -> None: 

63 broker1, broker2 = self.get_broker(), self.get_broker() 

64 

65 args, kwargs = self.get_subscriber_params(queue) 

66 

67 @broker1.subscriber(*args, **kwargs) 

68 @broker2.publisher(queue + "1") 

69 def subscriber(m: Any) -> Any: 

70 return m 

71 

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

73 

74 # publisher sends message to the same broker 

75 @broker2.subscriber(*args2, **kwargs2) 

76 def subscriber2(m: Any) -> None: 

77 mock(m) 

78 event.set() 

79 

80 app = FastStream(broker1, broker2) 

81 

82 async with ( 

83 self.patch_broker(broker1) as br1, 

84 self.patch_broker(broker2), 

85 TestApp(app), 

86 ): 

87 await asyncio.wait( 

88 ( 

89 asyncio.create_task(br1.publish("hello", queue)), 

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

91 ), 

92 timeout=self.timeout, 

93 ) 

94 

95 assert event.is_set() 

96 mock.assert_called_once_with("hello") 

97 

98 async def test_crossbroker_publisher( 

99 self, queue: str, mock: MagicMock, event: asyncio.Event 

100 ) -> None: 

101 broker1, broker2 = self.get_broker(), self.get_broker() 

102 

103 args, kwargs = self.get_subscriber_params(queue) 

104 

105 @broker1.subscriber(*args, **kwargs) 

106 @broker2.publisher(queue + "1") 

107 def subscriber(m: Any) -> Any: 

108 return m 

109 

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

111 

112 # publisher sends message to another broker 

113 @broker1.subscriber(*args2, **kwargs2) 

114 def subscriber2(m: Any) -> None: 

115 mock(m) 

116 event.set() 

117 

118 app = FastStream(broker1, broker2) 

119 

120 async with ( 

121 self.patch_broker(broker1, broker2) as (br1, _), 

122 TestApp(app), 

123 ): 

124 await asyncio.wait( 

125 ( 

126 asyncio.create_task(br1.publish("hello", queue)), 

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

128 ), 

129 timeout=self.timeout, 

130 ) 

131 

132 assert event.is_set() 

133 mock.assert_called_once_with("hello") 

134 

135 

136@pytest.mark.asyncio() 

137class BrokerConsumeTestcase(MultibrokerTestcase, BaseTestcaseConfig[Any]): 

138 async def test_consume(self, queue: str, event: asyncio.Event) -> None: 

139 consume_broker = self.get_broker() 

140 

141 args, kwargs = self.get_subscriber_params(queue) 

142 

143 @consume_broker.subscriber(*args, **kwargs) 

144 def subscriber(m: Any) -> None: 

145 event.set() 

146 

147 async with self.patch_broker(consume_broker) as br: 

148 await br.start() 

149 await asyncio.wait( 

150 ( 

151 asyncio.create_task(br.publish("hello", queue)), 

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

153 ), 

154 timeout=self.timeout, 

155 ) 

156 

157 assert event.is_set() 

158 

159 async def test_consume_from_multi( 

160 self, 

161 queue: str, 

162 mock: MagicMock, 

163 event: asyncio.Event, 

164 event2: asyncio.Event, 

165 ) -> None: 

166 consume_broker = self.get_broker() 

167 

168 args, kwargs = self.get_subscriber_params(queue) 

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

170 

171 @consume_broker.subscriber(*args, **kwargs) 

172 @consume_broker.subscriber(*args2, **kwargs2) 

173 def subscriber(m: Any) -> None: 

174 mock() 

175 if not event.is_set(): 

176 event.set() 

177 else: 

178 event2.set() 

179 

180 async with self.patch_broker(consume_broker) as br: 

181 await br.start() 

182 await asyncio.wait( 

183 ( 

184 asyncio.create_task(br.publish("hello", queue)), 

185 asyncio.create_task(br.publish("hello", queue + "1")), 

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

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

188 ), 

189 timeout=self.timeout, 

190 ) 

191 

192 assert event.is_set() 

193 assert event2.is_set() 

194 assert mock.call_count == 2 

195 

196 async def test_consume_double( 

197 self, 

198 queue: str, 

199 mock: MagicMock, 

200 event: asyncio.Event, 

201 event2: asyncio.Event, 

202 ) -> None: 

203 consume_broker = self.get_broker() 

204 

205 args, kwargs = self.get_subscriber_params(queue) 

206 

207 @consume_broker.subscriber(*args, **kwargs) 

208 async def handler(m: Any) -> None: 

209 mock() 

210 if not event.is_set(): 

211 event.set() 

212 else: 

213 event2.set() 

214 

215 async with self.patch_broker(consume_broker) as br: 

216 await br.start() 

217 await asyncio.wait( 

218 ( 

219 asyncio.create_task(br.publish("hello", queue)), 

220 asyncio.create_task(br.publish("hello", queue)), 

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

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

223 ), 

224 timeout=self.timeout, 

225 ) 

226 

227 assert event2.is_set() 

228 assert event.is_set() 

229 assert mock.call_count == 2 

230 

231 async def test_different_consume( 

232 self, 

233 queue: str, 

234 mock: MagicMock, 

235 event: asyncio.Event, 

236 event2: asyncio.Event, 

237 ) -> None: 

238 consume_broker = self.get_broker() 

239 

240 args, kwargs = self.get_subscriber_params(queue) 

241 

242 @consume_broker.subscriber(*args, **kwargs) 

243 def handler(m: Any) -> None: 

244 mock.handler() 

245 event.set() 

246 

247 another_topic = queue + "1" 

248 args, kwargs = self.get_subscriber_params(another_topic) 

249 

250 @consume_broker.subscriber(*args, **kwargs) 

251 def handler2(m: Any) -> None: 

252 mock.handler2() 

253 event2.set() 

254 

255 async with self.patch_broker(consume_broker) as br: 

256 await br.start() 

257 await asyncio.wait( 

258 ( 

259 asyncio.create_task(br.publish("hello", queue)), 

260 asyncio.create_task(br.publish("hello", another_topic)), 

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

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

263 ), 

264 timeout=self.timeout, 

265 ) 

266 

267 assert event.is_set() 

268 assert event2.is_set() 

269 mock.handler.assert_called_once() 

270 mock.handler2.assert_called_once() 

271 

272 async def test_consume_with_filter( 

273 self, 

274 queue: str, 

275 mock: MagicMock, 

276 event: asyncio.Event, 

277 event2: asyncio.Event, 

278 ) -> None: 

279 consume_broker = self.get_broker() 

280 

281 args, kwargs = self.get_subscriber_params( 

282 queue, 

283 ) 

284 

285 sub = consume_broker.subscriber(*args, **kwargs) 

286 

287 @sub(filter=lambda m: m.content_type == "application/json") 

288 async def handler(m: Any) -> None: 

289 mock.handler(m) 

290 event.set() 

291 

292 @sub 

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

294 mock.handler2(m) 

295 event2.set() 

296 

297 async with self.patch_broker(consume_broker) as br: 

298 await br.start() 

299 await asyncio.wait( 

300 ( 

301 asyncio.create_task(br.publish({"msg": "hello"}, queue)), 

302 asyncio.create_task(br.publish("hello", queue)), 

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

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

305 ), 

306 timeout=self.timeout, 

307 ) 

308 

309 assert event.is_set() 

310 assert event2.is_set() 

311 mock.handler.assert_called_once_with({"msg": "hello"}) 

312 mock.handler2.assert_called_once_with("hello") 

313 

314 async def test_consume_validate_false( 

315 self, queue: str, mock: MagicMock, event: asyncio.Event 

316 ) -> None: 

317 consume_broker = self.get_broker( 

318 apply_types=True, 

319 serializer=None, 

320 ) 

321 

322 class Foo(BaseModel): 

323 x: int 

324 

325 def dependency() -> str: 

326 return "100" 

327 

328 args, kwargs = self.get_subscriber_params(queue) 

329 

330 @consume_broker.subscriber(*args, **kwargs) 

331 async def handler( 

332 m: Foo, 

333 dep: int = Depends(dependency), 

334 broker: Any = Context(), 

335 ) -> None: 

336 mock(m, dep, broker) 

337 event.set() 

338 

339 async with self.patch_broker(consume_broker) as br: 

340 await br.start() 

341 

342 await asyncio.wait( 

343 ( 

344 asyncio.create_task(br.publish({"x": 1}, queue)), 

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

346 ), 

347 timeout=self.timeout, 

348 ) 

349 

350 assert event.is_set() 

351 mock.assert_called_once_with({"x": 1}, "100", consume_broker) 

352 

353 async def test_dynamic_sub(self, queue: str, event: asyncio.Event) -> None: 

354 consume_broker = self.get_broker() 

355 

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

357 event.set() 

358 

359 async with self.patch_broker(consume_broker) as br: 

360 await br.start() 

361 

362 args, kwargs = self.get_subscriber_params(queue) 

363 sub = br.subscriber(*args, **kwargs) 

364 sub(subscriber) 

365 await sub.start() 

366 

367 await br.publish("hello", queue) 

368 

369 with anyio.move_on_after(self.timeout): 

370 await event.wait() 

371 

372 await sub.stop() 

373 

374 assert event.is_set() 

375 

376 async def test_sub_start_use_context_manager( 

377 self, queue: str, event: asyncio.Event 

378 ) -> None: 

379 consume_broker = self.get_broker() 

380 

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

382 event.set() 

383 

384 async with self.patch_broker(consume_broker) as br: 

385 await br.start() 

386 

387 args, kwargs = self.get_subscriber_params(queue) 

388 sub = br.subscriber(*args, **kwargs) 

389 sub(subscriber) 

390 

391 async with sub: 

392 await br.publish("hello", queue) 

393 

394 with anyio.move_on_after(self.timeout): 

395 await event.wait() 

396 

397 assert event.is_set() 

398 

399 async def test_get_one_conflicts_with_handler(self, queue: str) -> None: 

400 broker = self.get_broker(apply_types=True) 

401 args, kwargs = self.get_subscriber_params(queue) 

402 subscriber = broker.subscriber(*args, **kwargs) 

403 

404 @subscriber 

405 async def t() -> None: ... 

406 

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

408 await br.start() 

409 

410 with pytest.raises(AssertionError): 

411 await subscriber.get_one(timeout=1e-24) 

412 

413 @pytest.mark.parametrize( 

414 "ack_policy", 

415 ( 

416 pytest.param(AckPolicy.ACK, id="ack"), 

417 pytest.param( 

418 AckPolicy.REJECT_ON_ERROR, 

419 id="reject_on_error", 

420 marks=[ 

421 pytest.mark.filterwarnings( 

422 "ignore:AckPolicy.REJECT_ON_ERROR has the same effect" 

423 ) 

424 ], 

425 ), 

426 pytest.param(AckPolicy.NACK_ON_ERROR, id="nack_on_error"), 

427 ), 

428 ) 

429 async def test_consume_cancel_skips_ack_nack_reject( 

430 self, 

431 queue: str, 

432 ack_policy: AckPolicy, 

433 event: asyncio.Event, 

434 ) -> None: 

435 if not self.supports_cancel_ack_skip: 

436 pytest.skip("broker default subscriber has no acknowledgement middleware") 

437 

438 broker = self.get_broker(graceful_timeout=0.2) 

439 args, kwargs = self.get_subscriber_params( 

440 queue, 

441 ack_policy=ack_policy, 

442 **self.get_cancel_ack_subscriber_kwargs(queue), 

443 ) 

444 

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

446 async def handler(_msg: Any) -> None: 

447 event.set() 

448 await asyncio.sleep(60) 

449 

450 with ( 

451 patch.object( 

452 StreamMessage, 

453 "nack", 

454 spy_decorator(StreamMessage.nack), 

455 ) as nack, 

456 patch.object( 

457 StreamMessage, 

458 "ack", 

459 spy_decorator(StreamMessage.ack), 

460 ) as ack, 

461 patch.object( 

462 StreamMessage, 

463 "reject", 

464 spy_decorator(StreamMessage.reject), 

465 ) as reject, 

466 ): 

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

468 await br.start() 

469 publish_task = asyncio.create_task(br.publish("hello", queue)) 

470 await asyncio.wait_for(event.wait(), timeout=self.timeout) 

471 

472 # TestBroker awaits the handler inside publish; real brokers 

473 # return after enqueue, so cancel publish when still running. 

474 # Otherwise broker context exit stops and cancels after 

475 # graceful_timeout. 

476 if not publish_task.done(): 

477 publish_task.cancel() 

478 with pytest.raises(asyncio.CancelledError): 

479 await publish_task 

480 else: 

481 await publish_task 

482 

483 nack.mock.assert_not_awaited() 

484 ack.mock.assert_not_awaited() 

485 reject.mock.assert_not_awaited() 

486 

487 async def test_consume_acks_on_middleware_error( 

488 self, 

489 queue: str, 

490 event: asyncio.Event, 

491 ) -> None: 

492 if not self.supports_cancel_ack_skip: 

493 pytest.skip("broker default subscriber has no acknowledgement middleware") 

494 

495 class FailingMiddleware(BaseMiddleware): 

496 async def on_receive(self) -> None: 

497 raise ValueError 

498 

499 broker = self.get_broker() 

500 broker.add_middleware(FailingMiddleware) 

501 args, kwargs = self.get_subscriber_params( 

502 queue, 

503 ack_policy=AckPolicy.ACK, 

504 **self.get_cancel_ack_subscriber_kwargs(queue), 

505 ) 

506 

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

508 async def handler(_msg: Any) -> None: ... 

509 

510 with patch.object(StreamMessage, "ack", spy_decorator(StreamMessage.ack)) as ack: 

511 ack.mock.side_effect = lambda *_, **__: event.set() 

512 

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

514 await br.start() 

515 

516 with suppress(ValueError): 

517 await br.publish("hello", queue) 

518 

519 await asyncio.wait_for(event.wait(), timeout=self.timeout) 

520 

521 ack.mock.assert_awaited_once() 

522 

523 

524@pytest.mark.asyncio() 

525class BrokerRealConsumeTestcase(BrokerConsumeTestcase): 

526 async def test_get_one( 

527 self, 

528 queue: str, 

529 mock: MagicMock, 

530 ) -> None: 

531 broker = self.get_broker(apply_types=True) 

532 

533 args, kwargs = self.get_subscriber_params(queue) 

534 subscriber = broker.subscriber(*args, **kwargs) 

535 

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

537 await br.start() 

538 

539 async def consume() -> None: 

540 mock(await subscriber.get_one(timeout=self.timeout)) 

541 

542 async def publish() -> None: 

543 await anyio.sleep(1e-24) 

544 await br.publish("test_message", queue) 

545 

546 await asyncio.wait( 

547 ( 

548 asyncio.create_task(consume()), 

549 asyncio.create_task(publish()), 

550 ), 

551 timeout=self.timeout, 

552 ) 

553 

554 mock.assert_called_once() 

555 message = mock.call_args[0][0] 

556 assert message 

557 assert await message.decode() == "test_message", await message.decode() 

558 

559 async def test_get_one_timeout( 

560 self, 

561 queue: str, 

562 mock: MagicMock, 

563 ) -> None: 

564 broker = self.get_broker(apply_types=True) 

565 args, kwargs = self.get_subscriber_params(queue) 

566 subscriber = broker.subscriber(*args, **kwargs) 

567 

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

569 await br.start() 

570 

571 mock(await subscriber.get_one(timeout=1e-24)) 

572 mock.assert_called_once_with(None) 

573 

574 @pytest.mark.slow() 

575 async def test_stop_consume_exc( 

576 self, queue: str, mock: MagicMock, event: asyncio.Event 

577 ) -> None: 

578 consume_broker = self.get_broker() 

579 

580 args, kwargs = self.get_subscriber_params(queue) 

581 

582 @consume_broker.subscriber(*args, **kwargs) 

583 def subscriber(m: Any) -> None: 

584 mock() 

585 event.set() 

586 raise StopConsume 

587 

588 async with self.patch_broker(consume_broker) as br: 

589 await br.start() 

590 await asyncio.wait( 

591 ( 

592 asyncio.create_task(br.publish("hello", queue)), 

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

594 ), 

595 timeout=self.timeout, 

596 ) 

597 await asyncio.sleep(0.5) 

598 await br.publish("hello", queue) 

599 await asyncio.sleep(0.5) 

600 

601 assert event.is_set() 

602 mock.assert_called_once() 

603 

604 @pytest.mark.asyncio() 

605 async def test_iteration( 

606 self, 

607 queue: str, 

608 mock: MagicMock, 

609 ) -> None: 

610 expected_messages = ("test_message_1", "test_message_2") 

611 

612 broker = self.get_broker(apply_types=True) 

613 

614 args, kwargs = self.get_subscriber_params(queue) 

615 subscriber = broker.subscriber(*args, **kwargs) 

616 

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

618 await br.start() 

619 

620 async def publish_test_message() -> None: 

621 for msg in expected_messages: 

622 await br.publish(msg, queue) 

623 

624 async def consume() -> None: 

625 index_message = 0 

626 async for msg in subscriber: 626 ↛ exitline 626 didn't return from function 'consume' because the loop on line 626 didn't complete

627 result_message = await msg.decode() 

628 

629 mock(result_message) 

630 

631 index_message += 1 

632 if index_message >= len(expected_messages): 

633 break 

634 

635 await asyncio.wait( 

636 ( 

637 asyncio.create_task(consume()), 

638 asyncio.create_task(publish_test_message()), 

639 ), 

640 timeout=self.timeout, 

641 ) 

642 

643 calls = [call(msg) for msg in expected_messages] 

644 mock.assert_has_calls(calls=calls)