Coverage for tests/brokers/nats/test_consume.py: 99%

457 statements  

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

1import asyncio 

2import gc 

3import warnings 

4from typing import Any 

5from unittest.mock import MagicMock, patch 

6 

7import anyio 

8import pytest 

9from nats.aio.msg import Msg 

10 

11from faststream import AckPolicy 

12from faststream.exceptions import AckMessage 

13from faststream.nats import ConsumerConfig, JStream, NatsBroker, PubAck, PullSub 

14from faststream.nats.annotations import NatsMessage 

15from faststream.nats.message import NatsMessage as StreamMessage 

16from faststream.nats.subscriber.usecases import ConcurrentPullStreamSubscriber 

17from tests.brokers.base.consume import BrokerRealConsumeTestcase 

18from tests.tools import spy_decorator 

19 

20from .basic import NatsTestcaseConfig 

21 

22 

23@pytest.mark.nats() 

24def test_concurrent_subscriber_opens_no_stream_before_start(queue: str) -> None: 

25 # Earlier tests on this worker may leave their own garbage to collect 

26 gc.collect() 

27 

28 with warnings.catch_warnings(record=True) as caught: 

29 warnings.simplefilter("always", ResourceWarning) 

30 NatsBroker().subscriber(queue, max_workers=2) 

31 gc.collect() 

32 

33 assert [str(w.message) for w in caught if "MemoryObject" in str(w.message)] == [] 

34 

35 

36@pytest.mark.connected() 

37@pytest.mark.nats() 

38class TestConsume(NatsTestcaseConfig, BrokerRealConsumeTestcase): 

39 async def test_concurrent_subscriber_closes_its_queue_on_stop( 

40 self, 

41 queue: str, 

42 ) -> None: 

43 broker = self.get_broker() 

44 

45 args, kwargs = self.get_subscriber_params(queue, max_workers=2) 

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

47 

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

49 await br.start() 

50 

51 with pytest.raises(anyio.ClosedResourceError): 

52 subscriber.receive_stream.receive_nowait() 

53 

54 async def test_concurrent_subscriber( 

55 self, 

56 queue: str, 

57 mock: MagicMock, 

58 event: asyncio.Event, 

59 event2: asyncio.Event, 

60 ) -> None: 

61 broker = self.get_broker() 

62 

63 args, kwargs = self.get_subscriber_params(queue, max_workers=2) 

64 

65 @broker.subscriber(*args, **kwargs) # type: ignore[untyped-decorator] 

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

67 mock() 

68 

69 if event.is_set(): 

70 event2.set() 

71 else: 

72 event.set() 

73 

74 await asyncio.sleep(1.0) 

75 

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

77 await br.start() 

78 

79 for i in range(5): 

80 await br.publish(i, queue) 

81 

82 await asyncio.wait( 

83 ( 

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

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

86 ), 

87 timeout=3, 

88 ) 

89 

90 assert event.is_set() 

91 assert event2.is_set() 

92 assert mock.call_count == 2, mock.call_count 

93 

94 @pytest.mark.parametrize( 

95 ("fetch_timeout", "publish_interval"), 

96 ((0.05, 0.0), (0.05, 0.002), (None, 0.002)), 

97 ) 

98 async def test_concurrent_pull_respects_worker_capacity( 

99 self, 

100 queue: str, 

101 stream: JStream, 

102 event: asyncio.Event, 

103 event2: asyncio.Event, 

104 fetch_timeout: float | None, 

105 publish_interval: float, 

106 ) -> None: 

107 """Fixes https://github.com/ag2ai/faststream/issues/2563.""" 

108 broker = self.get_broker() 

109 release_handlers = asyncio.Event() 

110 

111 subscriber = broker.subscriber( 

112 queue, 

113 durable=queue, 

114 stream=stream, 

115 pull_sub=PullSub(batch_size=2, timeout=fetch_timeout), 

116 max_workers=2, 

117 ) 

118 assert isinstance(subscriber, ConcurrentPullStreamSubscriber) 

119 

120 @subscriber 

121 async def handler(msg: str) -> None: 

122 if event.is_set(): 

123 event2.set() 

124 else: 

125 event.set() 

126 await release_handlers.wait() 

127 

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

129 await br.start() 

130 

131 try: 

132 if publish_interval: 

133 if fetch_timeout is not None: 

134 # Let a pull expire before messages arrive (see issue #2563). 

135 await asyncio.sleep(fetch_timeout * 1.1) 

136 for i in range(4): 

137 await br.publish(i, queue) 

138 await asyncio.sleep(publish_interval) 

139 else: 

140 await asyncio.gather(*(br.publish(i, queue) for i in range(4))) 

141 await asyncio.wait_for( 

142 asyncio.gather(event.wait(), event2.wait()), 

143 timeout=3, 

144 ) 

145 

146 assert subscriber.subscription 

147 max_ack_pending = 0 

148 

149 for _ in range(20): 

150 consumer_info = await subscriber.subscription.consumer_info() 

151 max_ack_pending = max( 

152 max_ack_pending, 

153 consumer_info.num_ack_pending or 0, 

154 ) 

155 await asyncio.sleep(0.05) 

156 

157 assert max_ack_pending == 2 

158 

159 finally: 

160 release_handlers.set() 

161 

162 async def test_consume_js( 

163 self, queue: str, stream: JStream, event: asyncio.Event 

164 ) -> None: 

165 consume_broker = self.get_broker() 

166 

167 args, kwargs = self.get_subscriber_params(queue, stream=stream) 

168 

169 @consume_broker.subscriber(*args, **kwargs) # type: ignore[untyped-decorator] 

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

171 event.set() 

172 

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

174 await br.start() 

175 

176 result = await br.publish("hello", queue, stream=stream.name) 

177 

178 await asyncio.wait( 

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

180 timeout=3, 

181 ) 

182 

183 assert isinstance(result, PubAck), result 

184 assert event.is_set() 

185 

186 async def test_consume_with_filter( # type: ignore[override] 

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

188 ) -> None: 

189 consume_broker = self.get_broker() 

190 

191 @consume_broker.subscriber( 

192 config=ConsumerConfig(filter_subjects=[f"{queue}.a"]), 

193 stream=JStream(queue, subjects=[f"{queue}.*"]), 

194 ) 

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

196 mock(m) 

197 event.set() 

198 

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

200 await br.start() 

201 await asyncio.wait( 

202 ( 

203 asyncio.create_task(br.publish(2, f"{queue}.a")), 

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

205 ), 

206 timeout=3, 

207 ) 

208 

209 assert event.is_set() 

210 mock.assert_called_once_with(2) 

211 

212 async def test_consume_pull( 

213 self, queue: str, stream: JStream, mock: MagicMock, event: asyncio.Event 

214 ) -> None: 

215 consume_broker = self.get_broker() 

216 

217 @consume_broker.subscriber( 

218 queue, 

219 stream=stream, 

220 pull_sub=PullSub(1), 

221 ) 

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

223 mock(m) 

224 event.set() 

225 

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

227 await br.start() 

228 

229 await asyncio.wait( 

230 ( 

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

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

233 ), 

234 timeout=3, 

235 ) 

236 

237 assert event.is_set() 

238 mock.assert_called_once_with("hello") 

239 

240 async def test_consume_batch( 

241 self, queue: str, stream: JStream, mock: MagicMock, event: asyncio.Event 

242 ) -> None: 

243 consume_broker = self.get_broker() 

244 

245 @consume_broker.subscriber( 

246 queue, 

247 stream=stream, 

248 pull_sub=PullSub(1, batch=True), 

249 ) 

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

251 mock(m) 

252 event.set() 

253 

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

255 await br.start() 

256 

257 await asyncio.wait( 

258 ( 

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

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

261 ), 

262 timeout=3, 

263 ) 

264 

265 assert event.is_set() 

266 mock.assert_called_once_with([b"hello"]) 

267 

268 async def test_core_consume_no_ack( 

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

270 ) -> None: 

271 consume_broker = self.get_broker(apply_types=True) 

272 

273 args, kwargs = self.get_subscriber_params( 

274 queue, 

275 ack_policy=AckPolicy.MANUAL, 

276 ) 

277 

278 @consume_broker.subscriber(*args, **kwargs) # type: ignore[untyped-decorator] 

279 async def handler(msg: NatsMessage) -> None: 

280 mock(msg.raw_message._ackd) 

281 event.set() 

282 

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

284 await br.start() 

285 

286 # Check, that Core Subscriber doesn't call Acknowledgement automatically 

287 with patch.object( 

288 StreamMessage, 

289 "ack", 

290 spy_decorator(StreamMessage.ack), 

291 ) as m: 

292 await asyncio.wait( 

293 ( 

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

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

296 ), 

297 timeout=3, 

298 ) 

299 assert not m.mock.called 

300 

301 assert event.is_set() 

302 mock.assert_called_once_with(True) # True was set by parser 

303 

304 async def test_consume_ack( 

305 self, queue: str, stream: JStream, event: asyncio.Event 

306 ) -> None: 

307 consume_broker = self.get_broker(apply_types=True) 

308 

309 @consume_broker.subscriber(queue, stream=stream) 

310 async def handler(msg: NatsMessage) -> None: 

311 event.set() 

312 

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

314 await br.start() 

315 

316 with patch.object(Msg, "ack", spy_decorator(Msg.ack)) as m: 

317 await asyncio.wait( 

318 ( 

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

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

321 ), 

322 timeout=3, 

323 ) 

324 m.mock.assert_called_once() 

325 

326 assert event.is_set() 

327 

328 async def test_consume_ack_manual( 

329 self, queue: str, stream: JStream, event: asyncio.Event 

330 ) -> None: 

331 consume_broker = self.get_broker(apply_types=True) 

332 

333 @consume_broker.subscriber(queue, stream=stream) 

334 async def handler(msg: NatsMessage) -> None: 

335 await msg.ack() 

336 event.set() 

337 

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

339 await br.start() 

340 

341 with patch.object(Msg, "ack", spy_decorator(Msg.ack)) as m: 

342 await asyncio.wait( 

343 ( 

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

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

346 ), 

347 timeout=3, 

348 ) 

349 m.mock.assert_called_once() 

350 

351 assert event.is_set() 

352 

353 async def test_consume_ack_sync_manual( 

354 self, 

355 queue: str, 

356 event: asyncio.Event, 

357 stream: JStream, 

358 ) -> None: 

359 consume_broker = self.get_broker(apply_types=True) 

360 

361 @consume_broker.subscriber(queue, stream=stream) 

362 async def handler(msg: NatsMessage) -> None: 

363 await msg.ack_sync() 

364 event.set() 

365 

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

367 await br.start() 

368 

369 with patch.object(Msg, "ack_sync", spy_decorator(Msg.ack_sync)) as m: 

370 await asyncio.wait( 

371 ( 

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

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

374 ), 

375 timeout=3, 

376 ) 

377 m.mock.assert_called_once() 

378 

379 assert event.is_set() 

380 

381 async def test_consume_ack_raise( 

382 self, queue: str, stream: JStream, event: asyncio.Event 

383 ) -> None: 

384 consume_broker = self.get_broker(apply_types=True) 

385 

386 @consume_broker.subscriber(queue, stream=stream) 

387 async def handler(msg: NatsMessage) -> None: 

388 event.set() 

389 raise AckMessage 

390 

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

392 await br.start() 

393 

394 with patch.object(Msg, "ack", spy_decorator(Msg.ack)) as m: 

395 await asyncio.wait( 

396 ( 

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

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

399 ), 

400 timeout=3, 

401 ) 

402 m.mock.assert_called_once() 

403 

404 assert event.is_set() 

405 

406 async def test_nack(self, queue: str, stream: JStream, event: asyncio.Event) -> None: 

407 consume_broker = self.get_broker(apply_types=True) 

408 

409 @consume_broker.subscriber(queue, stream=stream) 

410 async def handler(msg: NatsMessage) -> None: 

411 await msg.nack() 

412 event.set() 

413 

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

415 await br.start() 

416 

417 with patch.object(Msg, "nak", spy_decorator(Msg.nak)) as m: 

418 await asyncio.wait( 

419 ( 

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

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

422 ), 

423 timeout=3, 

424 ) 

425 m.mock.assert_called_once() 

426 

427 assert event.is_set() 

428 

429 async def test_consume_no_ack( 

430 self, queue: str, stream: str, event: asyncio.Event 

431 ) -> None: 

432 consume_broker = self.get_broker(apply_types=True) 

433 

434 @consume_broker.subscriber( 

435 queue, 

436 stream=stream, 

437 ack_policy=AckPolicy.MANUAL, 

438 ) 

439 async def handler(msg: NatsMessage) -> None: 

440 event.set() 

441 

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

443 await br.start() 

444 

445 with patch.object(Msg, "ack", spy_decorator(Msg.ack)) as m: 

446 await asyncio.wait( 

447 ( 

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

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

450 ), 

451 timeout=3, 

452 ) 

453 m.mock.assert_not_called() 

454 

455 assert event.is_set() 

456 

457 async def test_consume_batch_headers( 

458 self, queue: str, stream: JStream, mock: MagicMock, event: asyncio.Event 

459 ) -> None: 

460 consume_broker = self.get_broker(apply_types=True) 

461 

462 @consume_broker.subscriber( 

463 queue, 

464 stream=stream, 

465 pull_sub=PullSub(1, batch=True), 

466 ) 

467 def subscriber(m: Any, msg: NatsMessage) -> None: 

468 check = all( 

469 ( 

470 msg.headers, 

471 [msg.headers] == msg.batch_headers, 

472 msg.headers.get("custom") == "1", 

473 ), 

474 ) 

475 mock(check) 

476 event.set() 

477 

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

479 await br.start() 

480 await asyncio.wait( 

481 ( 

482 asyncio.create_task(br.publish("", queue, headers={"custom": "1"})), 

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

484 ), 

485 timeout=3, 

486 ) 

487 

488 assert event.is_set() 

489 mock.assert_called_once_with(True) 

490 

491 @pytest.mark.asyncio() 

492 async def test_consume_kv( 

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

494 ) -> None: 

495 consume_broker = self.get_broker(apply_types=True) 

496 

497 @consume_broker.subscriber(queue, kv_watch=queue + "1") 

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

499 mock(m) 

500 event.set() 

501 

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

503 await br.start() 

504 bucket = await br.key_value(queue + "1") 

505 

506 await asyncio.wait( 

507 ( 

508 asyncio.create_task( 

509 bucket.put( 

510 queue, 

511 b"world", 

512 ), 

513 ), 

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

515 ), 

516 timeout=3, 

517 ) 

518 

519 assert event.is_set() 

520 mock.assert_called_with(b"world") 

521 

522 @pytest.mark.asyncio() 

523 async def test_consume_os( 

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

525 ) -> None: 

526 consume_broker = self.get_broker(apply_types=True) 

527 

528 @consume_broker.subscriber(queue, obj_watch=True) 

529 async def handler(filename: str) -> None: 

530 event.set() 

531 mock(filename) 

532 

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

534 await br.start() 

535 bucket = await br.object_storage(queue) 

536 

537 await asyncio.wait( 

538 ( 

539 asyncio.create_task( 

540 bucket.put( 

541 "hello", 

542 b"world", 

543 ), 

544 ), 

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

546 ), 

547 timeout=3, 

548 ) 

549 

550 assert event.is_set() 

551 mock.assert_called_once_with("hello") 

552 

553 async def test_get_one_js( 

554 self, 

555 queue: str, 

556 stream: JStream, 

557 ) -> None: 

558 broker = self.get_broker(apply_types=True) 

559 subscriber = broker.subscriber(queue, stream=stream) 

560 

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

562 await br.start() 

563 

564 message = None 

565 

566 async def consume() -> None: 

567 nonlocal message 

568 message = await subscriber.get_one(timeout=5) 

569 

570 async def publish() -> None: 

571 await br.publish("test_message", queue, stream=stream.name) 

572 

573 await asyncio.wait( 

574 ( 

575 asyncio.create_task(consume()), 

576 asyncio.create_task(publish()), 

577 ), 

578 timeout=10, 

579 ) 

580 

581 assert message is not None 

582 assert await message.decode() == "test_message" 

583 

584 async def test_get_one_timeout_js( 

585 self, 

586 queue: str, 

587 stream: JStream, 

588 mock: MagicMock, 

589 ) -> None: 

590 broker = self.get_broker(apply_types=True) 

591 subscriber = broker.subscriber(queue, stream=stream) 

592 

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

594 await br.start() 

595 

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

597 mock.assert_called_once_with(None) 

598 

599 async def test_get_one_pull( 

600 self, 

601 queue: str, 

602 stream: JStream, 

603 ) -> None: 

604 broker = self.get_broker(apply_types=True) 

605 subscriber = broker.subscriber( 

606 queue, 

607 stream=stream, 

608 pull_sub=PullSub(1), 

609 ) 

610 

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

612 await br.start() 

613 

614 message = None 

615 

616 async def consume() -> None: 

617 nonlocal message 

618 message = await subscriber.get_one(timeout=5) 

619 

620 async def publish() -> None: 

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

622 

623 await asyncio.wait( 

624 ( 

625 asyncio.create_task(consume()), 

626 asyncio.create_task(publish()), 

627 ), 

628 timeout=10, 

629 ) 

630 

631 assert message is not None 

632 assert await message.decode() == "test_message" 

633 

634 async def test_get_one_pull_timeout( 

635 self, 

636 queue: str, 

637 stream: JStream, 

638 mock: MagicMock, 

639 ) -> None: 

640 broker = self.get_broker(apply_types=True) 

641 subscriber = broker.subscriber( 

642 queue, 

643 stream=stream, 

644 pull_sub=PullSub(1), 

645 ) 

646 

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

648 await br.start() 

649 

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

651 mock.assert_called_once_with(None) 

652 

653 async def test_get_one_batch( 

654 self, 

655 queue: str, 

656 stream: JStream, 

657 ) -> None: 

658 broker = self.get_broker(apply_types=True) 

659 subscriber = broker.subscriber( 

660 queue, 

661 stream=stream, 

662 pull_sub=PullSub(1, batch=True), 

663 ) 

664 

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

666 await br.start() 

667 

668 message = None 

669 

670 async def consume() -> None: 

671 nonlocal message 

672 message = await subscriber.get_one(timeout=5) 

673 

674 async def publish() -> None: 

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

676 

677 await asyncio.wait( 

678 ( 

679 asyncio.create_task(consume()), 

680 asyncio.create_task(publish()), 

681 ), 

682 timeout=10, 

683 ) 

684 

685 assert message is not None 

686 assert await message.decode() == ["test_message"] 

687 

688 async def test_get_one_batch_timeout( 

689 self, 

690 queue: str, 

691 stream: JStream, 

692 mock: MagicMock, 

693 ) -> None: 

694 broker = self.get_broker(apply_types=True) 

695 subscriber = broker.subscriber( 

696 queue, 

697 stream=stream, 

698 pull_sub=PullSub(1, batch=True), 

699 ) 

700 

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

702 await br.start() 

703 

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

705 mock.assert_called_once_with(None) 

706 

707 async def test_get_one_with_filter( 

708 self, 

709 queue: str, 

710 ) -> None: 

711 broker = self.get_broker(apply_types=True) 

712 subscriber = broker.subscriber( 

713 config=ConsumerConfig(filter_subjects=[f"{queue}.a"]), 

714 stream=JStream(queue, subjects=[f"{queue}.*"]), 

715 ) 

716 

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

718 await br.start() 

719 

720 message = None 

721 

722 async def consume() -> None: 

723 nonlocal message 

724 message = await subscriber.get_one(timeout=5) 

725 

726 async def publish() -> None: 

727 await br.publish("test_message", f"{queue}.a") 

728 

729 await asyncio.wait( 

730 ( 

731 asyncio.create_task(publish()), 

732 asyncio.create_task(consume()), 

733 ), 

734 timeout=10, 

735 ) 

736 

737 assert message is not None 

738 assert await message.decode() == "test_message" 

739 

740 async def test_get_one_kv( 

741 self, 

742 queue: str, 

743 ) -> None: 

744 broker = self.get_broker(apply_types=True) 

745 subscriber = broker.subscriber(queue, kv_watch=queue + "1") 

746 

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

748 await br.start() 

749 bucket = await br.key_value(queue + "1") 

750 

751 message = None 

752 

753 async def consume() -> None: 

754 nonlocal message 

755 message = await subscriber.get_one(timeout=5) 

756 

757 async def publish() -> None: 

758 await bucket.put(queue, b"test_message") 

759 

760 await asyncio.wait( 

761 ( 

762 asyncio.create_task(consume()), 

763 asyncio.create_task(publish()), 

764 ), 

765 timeout=10, 

766 ) 

767 

768 assert message is not None 

769 assert await message.decode() == b"test_message" 

770 

771 async def test_get_one_kv_timeout( 

772 self, 

773 queue: str, 

774 mock: MagicMock, 

775 ) -> None: 

776 broker = self.get_broker(apply_types=True) 

777 subscriber = broker.subscriber(queue, kv_watch=queue + "1") 

778 

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

780 await br.start() 

781 

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

783 mock.assert_called_once_with(None) 

784 

785 async def test_get_one_os( 

786 self, 

787 queue: str, 

788 ) -> None: 

789 broker = self.get_broker(apply_types=True) 

790 subscriber = broker.subscriber(queue, obj_watch=True) 

791 

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

793 await br.start() 

794 bucket = await br.object_storage(queue) 

795 

796 new_object_id: Any = None 

797 

798 async def consume() -> None: 

799 nonlocal new_object_id 

800 new_object_event = await subscriber.get_one(timeout=5) 

801 assert new_object_event 

802 new_object_id = await new_object_event.decode() 

803 

804 async def publish() -> None: 

805 await bucket.put(queue, b"test_message") 

806 

807 await asyncio.wait( 

808 ( 

809 asyncio.create_task(consume()), 

810 asyncio.create_task(publish()), 

811 ), 

812 timeout=10, 

813 ) 

814 

815 new_object = await bucket.get(new_object_id) 

816 assert new_object.data == b"test_message" 

817 

818 async def test_get_one_os_timeout( 

819 self, 

820 queue: str, 

821 mock: MagicMock, 

822 ) -> None: 

823 broker = self.get_broker(apply_types=True) 

824 subscriber = broker.subscriber(queue, obj_watch=True) 

825 

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

827 await br.start() 

828 

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

830 mock.assert_called_once_with(None) 

831 

832 async def test_iterator_js( 

833 self, 

834 queue: str, 

835 stream: JStream, 

836 ) -> None: 

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

838 

839 broker = self.get_broker(apply_types=True) 

840 subscriber = broker.subscriber(queue, stream=stream) 

841 

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

843 await br.start() 

844 

845 async def publish_test_message() -> None: 

846 for msg in expected_messages: 

847 await br.publish(msg, queue) 

848 

849 _ = await asyncio.create_task(publish_test_message()) 

850 

851 index_message = 0 

852 async for msg in subscriber: 852 ↛ exitline 852 didn't jump to the function exit

853 result_message = await msg.decode() 

854 

855 assert result_message == expected_messages[index_message] 

856 

857 index_message += 1 

858 if index_message >= len(expected_messages): 

859 break 

860 

861 async def test_iterator_pull( 

862 self, 

863 queue: str, 

864 stream: JStream, 

865 ) -> None: 

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

867 

868 broker = self.get_broker(apply_types=True) 

869 subscriber = broker.subscriber( 

870 queue, 

871 stream=stream, 

872 pull_sub=PullSub(1), 

873 ) 

874 

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

876 await br.start() 

877 

878 async def publish_test_message() -> None: 

879 for msg in expected_messages: 

880 await br.publish(msg, queue) 

881 

882 _ = await asyncio.create_task(publish_test_message()) 

883 

884 index_message = 0 

885 async for msg in subscriber: 885 ↛ exitline 885 didn't jump to the function exit

886 result_message = await msg.decode() 

887 

888 assert result_message == expected_messages[index_message] 

889 

890 index_message += 1 

891 if index_message >= len(expected_messages): 

892 break 

893 

894 async def test_iterator_batch( 

895 self, 

896 queue: str, 

897 stream: JStream, 

898 ) -> None: 

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

900 

901 broker = self.get_broker(apply_types=True) 

902 subscriber = broker.subscriber( 

903 queue, 

904 stream=stream, 

905 pull_sub=PullSub(1, batch=True), 

906 ) 

907 

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

909 await br.start() 

910 

911 async def publish_test_message() -> None: 

912 for msg in expected_messages: 

913 await br.publish(msg, queue) 

914 

915 _ = await asyncio.create_task(publish_test_message()) 

916 

917 index_message = 0 

918 async for msg in subscriber: 918 ↛ exitline 918 didn't jump to the function exit

919 result_message = await msg.decode() 

920 

921 assert result_message == [expected_messages[index_message]] 

922 

923 index_message += 1 

924 if index_message >= len(expected_messages): 

925 break 

926 

927 async def test_iterator_with_filter( 

928 self, 

929 queue: str, 

930 ) -> None: 

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

932 

933 broker = self.get_broker(apply_types=True) 

934 subscriber = broker.subscriber( 

935 config=ConsumerConfig(filter_subjects=[f"{queue}.a"]), 

936 stream=JStream(queue, subjects=[f"{queue}.*"]), 

937 ) 

938 

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

940 await br.start() 

941 

942 async def publish_test_message() -> None: 

943 for msg in expected_messages: 

944 await br.publish(msg, f"{queue}.a") 

945 

946 _ = await asyncio.create_task(publish_test_message()) 

947 

948 index_message = 0 

949 async for msg in subscriber: 949 ↛ exitline 949 didn't jump to the function exit

950 result_message = await msg.decode() 

951 

952 assert result_message == expected_messages[index_message] 

953 

954 index_message += 1 

955 if index_message >= len(expected_messages): 

956 break 

957 

958 async def test_iterator_kv( 

959 self, 

960 queue: str, 

961 ) -> None: 

962 expected_messages = (b"test_message_1", b"test_message_2") 

963 

964 broker = self.get_broker(apply_types=True) 

965 subscriber = broker.subscriber(queue, kv_watch=queue + "1") 

966 

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

968 await br.start() 

969 bucket = await br.key_value(queue + "1") 

970 

971 async def publish_test_message() -> None: 

972 await bucket.put(queue, expected_messages[0]) 

973 

974 _ = await asyncio.create_task(publish_test_message()) 

975 

976 index_message = 0 

977 async for msg in subscriber: 977 ↛ exitline 977 didn't jump to the function exit

978 result_message = await msg.decode() 

979 

980 assert result_message == expected_messages[index_message] 

981 

982 index_message += 1 

983 if index_message >= len(expected_messages): 

984 break 

985 

986 await bucket.put(queue, expected_messages[index_message]) 

987 

988 async def test_iterator_os( 

989 self, 

990 queue: str, 

991 ) -> None: 

992 expected_messages = (b"test_message_1", b"test_message_2") 

993 

994 broker = self.get_broker(apply_types=True) 

995 subscriber = broker.subscriber(queue, obj_watch=True) 

996 

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

998 await br.start() 

999 bucket = await br.object_storage(queue) 

1000 

1001 async def publish_test_message() -> None: 

1002 await bucket.put(queue, expected_messages[0]) 

1003 

1004 _ = await asyncio.create_task(publish_test_message()) 

1005 

1006 index_message = 0 

1007 async for new_object_event in subscriber: 1007 ↛ exitline 1007 didn't jump to the function exit

1008 new_object_id: Any = await new_object_event.decode() 

1009 new_object = await bucket.get(new_object_id) 

1010 

1011 assert new_object.data == expected_messages[index_message] 

1012 

1013 index_message += 1 

1014 if index_message >= len(expected_messages): 

1015 break 

1016 

1017 await bucket.put(queue, expected_messages[index_message])