Coverage for tests/brokers/nats/test_test_client.py: 97%
134 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
2from typing import Any
4import pytest
6from faststream import BaseMiddleware
7from faststream.nats import (
8 ConsumerConfig,
9 JStream,
10 PullSub,
11)
12from faststream.nats.testing import FakeProducer
13from tests.brokers.base.testclient import BrokerTestclientTestcase
15from .basic import NatsMemoryTestcaseConfig
18@pytest.mark.nats()
19@pytest.mark.asyncio()
20class TestTestclient(NatsMemoryTestcaseConfig, BrokerTestclientTestcase):
21 async def test_assert_called_once_with_path(self, queue: str) -> None:
22 broker = self.get_broker()
24 @broker.subscriber(f"{queue}.{{level}}")
25 async def m(msg: Any) -> None: ...
27 async with self.patch_broker(broker) as br:
28 await br.publish("hi", f"{queue}.info")
30 await m.assert_called_once_with("hi", path={"level": "info"})
32 # Path matches exactly: a template never leaves stray keys behind
33 with pytest.raises(AssertionError, match="path: expected"):
34 await m.assert_called_once_with(path={})
36 @pytest.mark.asyncio()
37 async def test_stream_publish(
38 self,
39 queue: str,
40 ) -> None:
41 pub_broker = self.get_broker(apply_types=False)
43 @pub_broker.subscriber(queue, stream="test")
44 async def m(msg: Any) -> None: ...
46 async with self.patch_broker(pub_broker) as br:
47 await br.publish("Hi!", queue, stream="test")
48 m.mock.assert_called_once_with("Hi!")
50 @pytest.mark.asyncio()
51 async def test_wrong_stream_publish(
52 self,
53 queue: str,
54 ) -> None:
55 pub_broker = self.get_broker(apply_types=False)
57 @pub_broker.subscriber(queue)
58 async def m(msg: Any) -> None: ...
60 async with self.patch_broker(pub_broker) as br:
61 await br.publish("Hi!", queue, stream="test")
62 assert not m.mock.called
64 @pytest.mark.connected()
65 async def test_with_real_testclient(self, queue: str, event: asyncio.Event) -> None:
66 broker = self.get_broker()
68 @broker.subscriber(queue)
69 def subscriber(m: Any) -> None:
70 event.set()
72 async with self.patch_broker(broker, with_real=True) as br:
73 await asyncio.wait(
74 (
75 asyncio.create_task(br.publish("hello", queue)),
76 asyncio.create_task(event.wait()),
77 ),
78 timeout=3,
79 )
81 assert event.is_set()
83 @pytest.mark.connected()
84 async def test_inbox_prefix_with_real(
85 self,
86 ) -> None:
87 broker = self.get_broker(inbox_prefix="test")
89 async with self.patch_broker(broker, with_real=True) as br:
90 connection = await br.connect()
91 assert connection._inbox_prefix == b"test"
92 assert "test" in str(connection.new_inbox())
94 async def test_respect_middleware(self, queue: str) -> None:
95 routes: list[Any] = []
97 class Middleware(BaseMiddleware):
98 async def on_receive(self) -> None:
99 routes.append(None)
100 return await super().on_receive()
102 broker = self.get_broker(middlewares=(Middleware,))
104 @broker.subscriber(queue)
105 async def h1(m: Any) -> None: ...
107 @broker.subscriber(queue + "1")
108 async def h2(m: Any) -> None: ...
110 async with self.patch_broker(broker) as br:
111 await br.publish("", queue)
112 await br.publish("", queue + "1")
114 assert len(routes) == 2
116 @pytest.mark.connected()
117 async def test_real_respect_middleware(self, queue: str) -> None:
118 routes: list[Any] = []
120 class Middleware(BaseMiddleware):
121 async def on_receive(self) -> None:
122 routes.append(None)
123 return await super().on_receive()
125 broker = self.get_broker(middlewares=(Middleware,))
127 @broker.subscriber(queue)
128 async def h1(m: Any) -> None: ...
130 @broker.subscriber(queue + "1")
131 async def h2(m: Any) -> None: ...
133 async with self.patch_broker(broker, with_real=True) as br:
134 await br.publish("", queue)
135 await br.publish("", queue + "1")
136 await h1.wait_call(3)
137 await h2.wait_call(3)
139 assert len(routes) == 2
141 async def test_js_subscriber_mock(
142 self,
143 queue: str,
144 stream: JStream,
145 ) -> None:
146 broker = self.get_broker()
148 @broker.subscriber(queue, stream=stream)
149 async def m(msg: Any) -> None:
150 pass
152 async with self.patch_broker(broker) as br:
153 await br.publish("hello", queue, stream=stream.name)
154 m.mock.assert_called_once_with("hello")
156 async def test_js_publisher_mock(
157 self,
158 queue: str,
159 stream: JStream,
160 ) -> None:
161 broker = self.get_broker()
163 publisher = broker.publisher(queue + "resp")
165 @publisher
166 @broker.subscriber(queue, stream=stream)
167 async def m(msg: Any) -> str:
168 return "response"
170 async with self.patch_broker(broker) as br:
171 await br.publish("hello", queue, stream=stream.name)
172 publisher.mock.assert_called_with("response")
174 async def test_any_subject_routing(self) -> None:
175 broker = self.get_broker()
177 @broker.subscriber("test.*.subj.*")
178 def subscriber(msg: Any) -> None: ...
180 async with self.patch_broker(broker) as br:
181 await br.publish("hello", "test.a.subj.b")
182 subscriber.mock.assert_called_once_with("hello")
184 async def test_ending_subject_routing(self) -> None:
185 broker = self.get_broker()
187 @broker.subscriber("test.>")
188 def subscriber(msg: Any) -> None: ...
190 async with self.patch_broker(broker) as br:
191 await br.publish("hello", "test.a.subj.b")
192 subscriber.mock.assert_called_once_with("hello")
194 async def test_mixed_subject_routing(self) -> None:
195 broker = self.get_broker()
197 @broker.subscriber("*.*.subj.>")
198 def subscriber(msg: Any) -> None: ...
200 async with self.patch_broker(broker) as br:
201 await br.publish("hello", "test.a.subj.b.c")
202 subscriber.mock.assert_called_once_with("hello")
204 async def test_consume_pull(
205 self,
206 queue: str,
207 stream: JStream,
208 ) -> None:
209 broker = self.get_broker()
211 @broker.subscriber(queue, stream=stream, pull_sub=PullSub(1))
212 def subscriber(m: Any) -> None: ...
214 async with self.patch_broker(broker) as br:
215 await br.publish("hello", queue)
216 subscriber.mock.assert_called_once_with("hello")
218 async def test_consume_batch(
219 self,
220 queue: str,
221 stream: JStream,
222 ) -> None:
223 broker = self.get_broker()
225 @broker.subscriber(
226 queue,
227 stream=stream,
228 pull_sub=PullSub(1, batch=True),
229 )
230 def subscriber(m: Any) -> None:
231 pass
233 async with self.patch_broker(broker) as br:
234 await br.publish("hello", queue)
235 subscriber.mock.assert_called_once_with(["hello"])
237 async def test_consume_with_subject_filter(self, queue: str) -> None:
238 broker = self.get_broker()
240 @broker.subscriber(
241 config=ConsumerConfig(filter_subjects=[f"{queue}.a"]),
242 stream=JStream(queue, subjects=[f"{queue}.*"]),
243 )
244 def subscriber(m: Any) -> None:
245 pass
247 async with self.patch_broker(broker) as br:
248 await br.publish(1, f"{queue}.b")
249 await br.publish(2, f"{queue}.a")
250 subscriber.mock.assert_called_once_with(2)
252 @pytest.mark.connected()
253 async def test_broker_gets_patched_attrs_within_cm(self) -> None:
254 await super().test_broker_gets_patched_attrs_within_cm(FakeProducer)
256 @pytest.mark.connected()
257 async def test_broker_with_real_doesnt_get_patched(self) -> None:
258 await super().test_broker_with_real_doesnt_get_patched()
260 @pytest.mark.connected()
261 async def test_broker_with_real_patches_publishers_and_subscribers(
262 self,
263 queue: str,
264 ) -> None:
265 await super().test_broker_with_real_patches_publishers_and_subscribers(queue)
267 @pytest.mark.xfail(reason="https://github.com/ag2ai/faststream/issues/2513")
268 async def test_publisher_without_destination(self) -> None:
269 """Fixes https://github.com/ag2ai/faststream/issues/2513."""
270 broker = self.get_broker()
272 # use two publishers to check that we don't have conflicts
273 publisher = broker.publisher(subject="")
274 another_publisher = broker.publisher(subject="")
276 async with self.patch_broker(broker):
277 await publisher.publish(None, subject="new-key")
278 publisher.mock.assert_called_once()
280 await another_publisher.publish(None, subject="new-key")
281 another_publisher.mock.assert_called_once()