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
« 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
7import anyio
8import pytest
9from nats.aio.msg import Msg
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
20from .basic import NatsTestcaseConfig
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()
28 with warnings.catch_warnings(record=True) as caught:
29 warnings.simplefilter("always", ResourceWarning)
30 NatsBroker().subscriber(queue, max_workers=2)
31 gc.collect()
33 assert [str(w.message) for w in caught if "MemoryObject" in str(w.message)] == []
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()
45 args, kwargs = self.get_subscriber_params(queue, max_workers=2)
46 subscriber = broker.subscriber(*args, **kwargs)
48 async with self.patch_broker(broker) as br:
49 await br.start()
51 with pytest.raises(anyio.ClosedResourceError):
52 subscriber.receive_stream.receive_nowait()
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()
63 args, kwargs = self.get_subscriber_params(queue, max_workers=2)
65 @broker.subscriber(*args, **kwargs) # type: ignore[untyped-decorator]
66 async def handler(msg: Any) -> None:
67 mock()
69 if event.is_set():
70 event2.set()
71 else:
72 event.set()
74 await asyncio.sleep(1.0)
76 async with self.patch_broker(broker) as br:
77 await br.start()
79 for i in range(5):
80 await br.publish(i, queue)
82 await asyncio.wait(
83 (
84 asyncio.create_task(event.wait()),
85 asyncio.create_task(event2.wait()),
86 ),
87 timeout=3,
88 )
90 assert event.is_set()
91 assert event2.is_set()
92 assert mock.call_count == 2, mock.call_count
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()
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)
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()
128 async with self.patch_broker(broker) as br:
129 await br.start()
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 )
146 assert subscriber.subscription
147 max_ack_pending = 0
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)
157 assert max_ack_pending == 2
159 finally:
160 release_handlers.set()
162 async def test_consume_js(
163 self, queue: str, stream: JStream, event: asyncio.Event
164 ) -> None:
165 consume_broker = self.get_broker()
167 args, kwargs = self.get_subscriber_params(queue, stream=stream)
169 @consume_broker.subscriber(*args, **kwargs) # type: ignore[untyped-decorator]
170 def subscriber(m: Any) -> None:
171 event.set()
173 async with self.patch_broker(consume_broker) as br:
174 await br.start()
176 result = await br.publish("hello", queue, stream=stream.name)
178 await asyncio.wait(
179 (asyncio.create_task(event.wait()),),
180 timeout=3,
181 )
183 assert isinstance(result, PubAck), result
184 assert event.is_set()
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()
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()
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 )
209 assert event.is_set()
210 mock.assert_called_once_with(2)
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()
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()
226 async with self.patch_broker(consume_broker) as br:
227 await br.start()
229 await asyncio.wait(
230 (
231 asyncio.create_task(br.publish("hello", queue)),
232 asyncio.create_task(event.wait()),
233 ),
234 timeout=3,
235 )
237 assert event.is_set()
238 mock.assert_called_once_with("hello")
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()
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()
254 async with self.patch_broker(consume_broker) as br:
255 await br.start()
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 )
265 assert event.is_set()
266 mock.assert_called_once_with([b"hello"])
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)
273 args, kwargs = self.get_subscriber_params(
274 queue,
275 ack_policy=AckPolicy.MANUAL,
276 )
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()
283 async with self.patch_broker(consume_broker) as br:
284 await br.start()
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
301 assert event.is_set()
302 mock.assert_called_once_with(True) # True was set by parser
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)
309 @consume_broker.subscriber(queue, stream=stream)
310 async def handler(msg: NatsMessage) -> None:
311 event.set()
313 async with self.patch_broker(consume_broker) as br:
314 await br.start()
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()
326 assert event.is_set()
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)
333 @consume_broker.subscriber(queue, stream=stream)
334 async def handler(msg: NatsMessage) -> None:
335 await msg.ack()
336 event.set()
338 async with self.patch_broker(consume_broker) as br:
339 await br.start()
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()
351 assert event.is_set()
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)
361 @consume_broker.subscriber(queue, stream=stream)
362 async def handler(msg: NatsMessage) -> None:
363 await msg.ack_sync()
364 event.set()
366 async with self.patch_broker(consume_broker) as br:
367 await br.start()
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()
379 assert event.is_set()
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)
386 @consume_broker.subscriber(queue, stream=stream)
387 async def handler(msg: NatsMessage) -> None:
388 event.set()
389 raise AckMessage
391 async with self.patch_broker(consume_broker) as br:
392 await br.start()
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()
404 assert event.is_set()
406 async def test_nack(self, queue: str, stream: JStream, event: asyncio.Event) -> None:
407 consume_broker = self.get_broker(apply_types=True)
409 @consume_broker.subscriber(queue, stream=stream)
410 async def handler(msg: NatsMessage) -> None:
411 await msg.nack()
412 event.set()
414 async with self.patch_broker(consume_broker) as br:
415 await br.start()
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()
427 assert event.is_set()
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)
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()
442 async with self.patch_broker(consume_broker) as br:
443 await br.start()
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()
455 assert event.is_set()
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)
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()
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 )
488 assert event.is_set()
489 mock.assert_called_once_with(True)
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)
497 @consume_broker.subscriber(queue, kv_watch=queue + "1")
498 async def handler(m: Any) -> None:
499 mock(m)
500 event.set()
502 async with self.patch_broker(consume_broker) as br:
503 await br.start()
504 bucket = await br.key_value(queue + "1")
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 )
519 assert event.is_set()
520 mock.assert_called_with(b"world")
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)
528 @consume_broker.subscriber(queue, obj_watch=True)
529 async def handler(filename: str) -> None:
530 event.set()
531 mock(filename)
533 async with self.patch_broker(consume_broker) as br:
534 await br.start()
535 bucket = await br.object_storage(queue)
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 )
550 assert event.is_set()
551 mock.assert_called_once_with("hello")
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)
561 async with self.patch_broker(broker) as br:
562 await br.start()
564 message = None
566 async def consume() -> None:
567 nonlocal message
568 message = await subscriber.get_one(timeout=5)
570 async def publish() -> None:
571 await br.publish("test_message", queue, stream=stream.name)
573 await asyncio.wait(
574 (
575 asyncio.create_task(consume()),
576 asyncio.create_task(publish()),
577 ),
578 timeout=10,
579 )
581 assert message is not None
582 assert await message.decode() == "test_message"
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)
593 async with self.patch_broker(broker) as br:
594 await br.start()
596 mock(await subscriber.get_one(timeout=1e-24))
597 mock.assert_called_once_with(None)
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 )
611 async with self.patch_broker(broker) as br:
612 await br.start()
614 message = None
616 async def consume() -> None:
617 nonlocal message
618 message = await subscriber.get_one(timeout=5)
620 async def publish() -> None:
621 await br.publish("test_message", queue)
623 await asyncio.wait(
624 (
625 asyncio.create_task(consume()),
626 asyncio.create_task(publish()),
627 ),
628 timeout=10,
629 )
631 assert message is not None
632 assert await message.decode() == "test_message"
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 )
647 async with self.patch_broker(broker) as br:
648 await br.start()
650 mock(await subscriber.get_one(timeout=1e-24))
651 mock.assert_called_once_with(None)
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 )
665 async with self.patch_broker(broker) as br:
666 await br.start()
668 message = None
670 async def consume() -> None:
671 nonlocal message
672 message = await subscriber.get_one(timeout=5)
674 async def publish() -> None:
675 await br.publish("test_message", queue)
677 await asyncio.wait(
678 (
679 asyncio.create_task(consume()),
680 asyncio.create_task(publish()),
681 ),
682 timeout=10,
683 )
685 assert message is not None
686 assert await message.decode() == ["test_message"]
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 )
701 async with self.patch_broker(broker) as br:
702 await br.start()
704 mock(await subscriber.get_one(timeout=1e-24))
705 mock.assert_called_once_with(None)
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 )
717 async with self.patch_broker(broker) as br:
718 await br.start()
720 message = None
722 async def consume() -> None:
723 nonlocal message
724 message = await subscriber.get_one(timeout=5)
726 async def publish() -> None:
727 await br.publish("test_message", f"{queue}.a")
729 await asyncio.wait(
730 (
731 asyncio.create_task(publish()),
732 asyncio.create_task(consume()),
733 ),
734 timeout=10,
735 )
737 assert message is not None
738 assert await message.decode() == "test_message"
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")
747 async with self.patch_broker(broker) as br:
748 await br.start()
749 bucket = await br.key_value(queue + "1")
751 message = None
753 async def consume() -> None:
754 nonlocal message
755 message = await subscriber.get_one(timeout=5)
757 async def publish() -> None:
758 await bucket.put(queue, b"test_message")
760 await asyncio.wait(
761 (
762 asyncio.create_task(consume()),
763 asyncio.create_task(publish()),
764 ),
765 timeout=10,
766 )
768 assert message is not None
769 assert await message.decode() == b"test_message"
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")
779 async with self.patch_broker(broker) as br:
780 await br.start()
782 mock(await subscriber.get_one(timeout=1e-24))
783 mock.assert_called_once_with(None)
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)
792 async with self.patch_broker(broker) as br:
793 await br.start()
794 bucket = await br.object_storage(queue)
796 new_object_id: Any = None
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()
804 async def publish() -> None:
805 await bucket.put(queue, b"test_message")
807 await asyncio.wait(
808 (
809 asyncio.create_task(consume()),
810 asyncio.create_task(publish()),
811 ),
812 timeout=10,
813 )
815 new_object = await bucket.get(new_object_id)
816 assert new_object.data == b"test_message"
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)
826 async with self.patch_broker(broker) as br:
827 await br.start()
829 mock(await subscriber.get_one(timeout=1e-24))
830 mock.assert_called_once_with(None)
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")
839 broker = self.get_broker(apply_types=True)
840 subscriber = broker.subscriber(queue, stream=stream)
842 async with self.patch_broker(broker) as br:
843 await br.start()
845 async def publish_test_message() -> None:
846 for msg in expected_messages:
847 await br.publish(msg, queue)
849 _ = await asyncio.create_task(publish_test_message())
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()
855 assert result_message == expected_messages[index_message]
857 index_message += 1
858 if index_message >= len(expected_messages):
859 break
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")
868 broker = self.get_broker(apply_types=True)
869 subscriber = broker.subscriber(
870 queue,
871 stream=stream,
872 pull_sub=PullSub(1),
873 )
875 async with self.patch_broker(broker) as br:
876 await br.start()
878 async def publish_test_message() -> None:
879 for msg in expected_messages:
880 await br.publish(msg, queue)
882 _ = await asyncio.create_task(publish_test_message())
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()
888 assert result_message == expected_messages[index_message]
890 index_message += 1
891 if index_message >= len(expected_messages):
892 break
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")
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 )
908 async with self.patch_broker(broker) as br:
909 await br.start()
911 async def publish_test_message() -> None:
912 for msg in expected_messages:
913 await br.publish(msg, queue)
915 _ = await asyncio.create_task(publish_test_message())
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()
921 assert result_message == [expected_messages[index_message]]
923 index_message += 1
924 if index_message >= len(expected_messages):
925 break
927 async def test_iterator_with_filter(
928 self,
929 queue: str,
930 ) -> None:
931 expected_messages = ("test_message_1", "test_message_2")
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 )
939 async with self.patch_broker(broker) as br:
940 await br.start()
942 async def publish_test_message() -> None:
943 for msg in expected_messages:
944 await br.publish(msg, f"{queue}.a")
946 _ = await asyncio.create_task(publish_test_message())
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()
952 assert result_message == expected_messages[index_message]
954 index_message += 1
955 if index_message >= len(expected_messages):
956 break
958 async def test_iterator_kv(
959 self,
960 queue: str,
961 ) -> None:
962 expected_messages = (b"test_message_1", b"test_message_2")
964 broker = self.get_broker(apply_types=True)
965 subscriber = broker.subscriber(queue, kv_watch=queue + "1")
967 async with self.patch_broker(broker) as br:
968 await br.start()
969 bucket = await br.key_value(queue + "1")
971 async def publish_test_message() -> None:
972 await bucket.put(queue, expected_messages[0])
974 _ = await asyncio.create_task(publish_test_message())
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()
980 assert result_message == expected_messages[index_message]
982 index_message += 1
983 if index_message >= len(expected_messages):
984 break
986 await bucket.put(queue, expected_messages[index_message])
988 async def test_iterator_os(
989 self,
990 queue: str,
991 ) -> None:
992 expected_messages = (b"test_message_1", b"test_message_2")
994 broker = self.get_broker(apply_types=True)
995 subscriber = broker.subscriber(queue, obj_watch=True)
997 async with self.patch_broker(broker) as br:
998 await br.start()
999 bucket = await br.object_storage(queue)
1001 async def publish_test_message() -> None:
1002 await bucket.put(queue, expected_messages[0])
1004 _ = await asyncio.create_task(publish_test_message())
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)
1011 assert new_object.data == expected_messages[index_message]
1013 index_message += 1
1014 if index_message >= len(expected_messages):
1015 break
1017 await bucket.put(queue, expected_messages[index_message])