Coverage for faststream/nats/testing.py: 97%
102 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
1from collections.abc import Generator, Iterable, Sequence
2from contextlib import ExitStack, contextmanager
3from typing import TYPE_CHECKING, Any, Optional, cast, overload
4from unittest.mock import AsyncMock
6import anyio
7from nats.aio.msg import Msg
8from typing_extensions import override
10from faststream._internal.endpoint.utils import ParserComposition
11from faststream._internal.parser import DefaultCodec
12from faststream._internal.testing.broker import EnterType, TestBroker
13from faststream._internal.types import IdGenerator
14from faststream.exceptions import SubscriberNotFound
15from faststream.message import gen_cor_id
16from faststream.nats.broker import NatsBroker
17from faststream.nats.parser import NatsParser
18from faststream.nats.publisher.producer import NatsFastProducer
19from faststream.nats.schemas.js_stream import is_subject_match_wildcard
21if TYPE_CHECKING:
22 from fast_depends.library.serializer import SerializerProto
24 from faststream._internal.basic_types import SendableMessage
25 from faststream._internal.configs.broker import ConfigComposition
26 from faststream._internal.parser import CodecProto
27 from faststream.nats.configs import NatsBrokerConfig
28 from faststream.nats.publisher.usecase import LogicPublisher
29 from faststream.nats.response import NatsPublishCommand
30 from faststream.nats.subscriber.usecases.basic import LogicSubscriber
32__all__ = ("TestNatsBroker",)
35@contextmanager
36def change_producer(
37 config: "ConfigComposition[NatsBrokerConfig]",
38 producer: "NatsFastProducer",
39) -> Generator[None, None, None]:
40 old_producer, config.broker_config.producer = (
41 config.broker_config.producer,
42 producer,
43 )
44 old_js_producer, config.broker_config.js_producer = (
45 config.broker_config.js_producer,
46 producer,
47 )
48 try:
49 yield
50 finally:
51 config.broker_config.producer = old_producer
52 config.broker_config.js_producer = old_js_producer
55class TestNatsBroker(
56 TestBroker[NatsBroker, EnterType],
57 broker=NatsBroker,
58):
59 """A class to test NATS brokers."""
61 @overload
62 def __init__(
63 self: "TestNatsBroker[NatsBroker]",
64 broker: NatsBroker,
65 /,
66 *,
67 with_real: bool = False,
68 connect_only: bool | None = None,
69 ) -> None: ...
71 @overload
72 def __init__(
73 self: "TestNatsBroker[tuple[NatsBroker, ...]]",
74 *brokers: NatsBroker,
75 with_real: bool = False,
76 connect_only: bool | None = None,
77 ) -> None: ...
79 def __init__(
80 self,
81 *brokers: NatsBroker,
82 with_real: bool = False,
83 connect_only: bool | None = None,
84 ) -> None:
85 super().__init__(
86 *brokers,
87 with_real=with_real,
88 connect_only=connect_only,
89 )
91 def create_publisher_fake_subscriber(
92 self,
93 broker: NatsBroker,
94 publisher: "LogicPublisher",
95 ) -> tuple["LogicSubscriber[Any]", bool]:
96 publisher_stream = publisher.stream.name if publisher.stream else None
98 sub: LogicSubscriber[Any] | None = None
99 for handler in (s for b in self.brokers for s in b.subscribers):
100 handler = cast("LogicSubscriber[Any]", handler)
101 if _is_handler_matches(handler, publisher.subject.template, publisher_stream):
102 sub = handler
103 break
105 if sub is None:
106 is_real = False
107 sub = broker.subscriber(
108 publisher.subject.template,
109 persistent=False,
110 stream=publisher_stream,
111 )
112 else:
113 is_real = True
115 return sub, is_real
117 @contextmanager
118 def _patch_producer(self, broker: NatsBroker) -> Generator[None, None, None]:
119 fake_producer = FakeProducer(broker, self.brokers)
121 with ExitStack() as es:
122 es.enter_context(change_producer(broker.config, fake_producer))
123 yield
125 @override
126 async def _fake_connect(
127 self,
128 broker: NatsBroker,
129 *args: Any,
130 **kwargs: Any,
131 ) -> None:
132 if not broker.config.connection_state:
133 broker.config.connection_state.connect(AsyncMock(), AsyncMock())
135 def _fake_start(self, broker: NatsBroker, *args: Any, **kwargs: Any) -> None:
136 if not broker.config.connection_state:
137 broker.config.connection_state.connect(AsyncMock(), AsyncMock())
138 return super()._fake_start(broker, *args, **kwargs)
141class FakeProducer(NatsFastProducer):
142 def __init__(
143 self,
144 broker: NatsBroker,
145 brokers: Sequence[NatsBroker],
146 ) -> None:
147 self.broker = broker
148 self.brokers = brokers
150 default = NatsParser(pattern="", is_ack_disabled=True)
151 self._parser = ParserComposition(broker._parser, default.parse_message)
152 self._decoder = ParserComposition(broker._decoder, default.decode_message)
153 self.codec = broker.config.broker_codec or DefaultCodec()
155 @property
156 def subscribers(self) -> Iterable["LogicSubscriber[Any]"]:
157 return (
158 cast("LogicSubscriber[Any]", s) for b in self.brokers for s in b.subscribers
159 )
161 @override
162 async def publish(self, cmd: "NatsPublishCommand") -> None:
163 incoming = await build_message(
164 message=cmd.body,
165 subject=cmd.destination,
166 headers=cmd.headers,
167 correlation_id=cmd.correlation_id,
168 reply_to=cmd.reply_to,
169 serializer=self.broker.config.fd_config._serializer,
170 codec=self.codec,
171 id_generator=self.broker.config.id_generator,
172 )
174 for handler in _find_handler(
175 self.subscribers,
176 cmd.destination,
177 cmd.stream,
178 ):
179 msg: list[PatchedMessage] | PatchedMessage
181 if (pull := getattr(handler, "pull_sub", None)) and pull.batch:
182 msg = [incoming]
183 else:
184 msg = incoming
186 await self._execute_handler(msg, cmd.destination, handler)
188 @override
189 async def request(self, cmd: "NatsPublishCommand") -> "PatchedMessage":
190 incoming = await build_message(
191 message=cmd.body,
192 subject=cmd.destination,
193 headers=cmd.headers,
194 correlation_id=cmd.correlation_id,
195 serializer=self.broker.config.fd_config._serializer,
196 codec=self.codec,
197 id_generator=self.broker.config.id_generator,
198 )
200 for handler in _find_handler(
201 self.subscribers,
202 cmd.destination,
203 cmd.stream,
204 ):
205 msg: list[PatchedMessage] | PatchedMessage
207 if (pull := getattr(handler, "pull_sub", None)) and pull.batch:
208 msg = [incoming]
209 else:
210 msg = incoming
212 with anyio.fail_after(cmd.timeout):
213 return await self._execute_handler(msg, cmd.destination, handler)
215 raise SubscriberNotFound
217 async def _execute_handler(
218 self,
219 msg: Any,
220 subject: str,
221 handler: "LogicSubscriber[Any]",
222 ) -> "PatchedMessage":
223 result = await handler.process_message(msg)
225 return await build_message(
226 subject=subject,
227 message=result.body,
228 headers=result.headers,
229 correlation_id=result.correlation_id,
230 serializer=self.broker.config.fd_config._serializer,
231 codec=self.codec,
232 id_generator=self.broker.config.id_generator,
233 )
236def _find_handler(
237 subscribers: Iterable["LogicSubscriber[Any]"],
238 subject: str,
239 stream: str | None = None,
240) -> Generator["LogicSubscriber[Any]", None, None]:
241 published_queues = set()
242 for handler in subscribers:
243 if _is_handler_matches(handler, subject, stream):
244 if queue := getattr(handler, "queue", None):
245 if queue in published_queues:
246 continue
247 else:
248 published_queues.add(queue)
249 yield handler
252def _is_handler_matches(
253 handler: "LogicSubscriber[Any]",
254 subject: str,
255 stream: str | None = None,
256) -> bool:
257 if stream:
258 if not (handler_stream := getattr(handler, "stream", None)):
259 return False
261 if stream != handler_stream.name: 261 ↛ 262line 261 didn't jump to line 262 because the condition on line 261 was never true
262 return False
264 if is_subject_match_wildcard(subject, handler.subject.broker_address):
265 return True
267 for filter_subject in handler.filter_subjects or ():
268 if is_subject_match_wildcard(subject, filter_subject):
269 return True
271 return False
274async def build_message(
275 message: "SendableMessage",
276 subject: str,
277 *,
278 reply_to: str = "",
279 correlation_id: str | None = None,
280 headers: dict[str, str] | None = None,
281 serializer: Optional["SerializerProto"] = None,
282 codec: Optional["CodecProto"] = None,
283 id_generator: IdGenerator = gen_cor_id,
284) -> "PatchedMessage":
285 if codec is None: 285 ↛ 286line 285 didn't jump to line 286 because the condition on line 285 was never true
286 codec = DefaultCodec()
287 msg, content_type = await codec.encode(message, serializer=serializer)
288 return PatchedMessage(
289 _client=None, # type: ignore[arg-type]
290 subject=subject,
291 reply=reply_to,
292 data=msg,
293 headers={
294 "content-type": content_type or "",
295 "correlation_id": correlation_id or id_generator(),
296 **(headers or {}),
297 },
298 )
301class PatchedMessage(Msg):
302 async def ack(self) -> None:
303 pass
305 async def ack_sync(
306 self,
307 timeout: float = 1,
308 ) -> "PatchedMessage": # pragma: no cover
309 return self
311 async def nak(self, delay: float | None = None) -> None:
312 pass
314 async def term(self) -> None:
315 pass
317 async def in_progress(self) -> None:
318 pass