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

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 

5 

6import anyio 

7from nats.aio.msg import Msg 

8from typing_extensions import override 

9 

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 

20 

21if TYPE_CHECKING: 

22 from fast_depends.library.serializer import SerializerProto 

23 

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 

31 

32__all__ = ("TestNatsBroker",) 

33 

34 

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 

53 

54 

55class TestNatsBroker( 

56 TestBroker[NatsBroker, EnterType], 

57 broker=NatsBroker, 

58): 

59 """A class to test NATS brokers.""" 

60 

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: ... 

70 

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: ... 

78 

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 ) 

90 

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 

97 

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 

104 

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 

114 

115 return sub, is_real 

116 

117 @contextmanager 

118 def _patch_producer(self, broker: NatsBroker) -> Generator[None, None, None]: 

119 fake_producer = FakeProducer(broker, self.brokers) 

120 

121 with ExitStack() as es: 

122 es.enter_context(change_producer(broker.config, fake_producer)) 

123 yield 

124 

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()) 

134 

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) 

139 

140 

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 

149 

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() 

154 

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 ) 

160 

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 ) 

173 

174 for handler in _find_handler( 

175 self.subscribers, 

176 cmd.destination, 

177 cmd.stream, 

178 ): 

179 msg: list[PatchedMessage] | PatchedMessage 

180 

181 if (pull := getattr(handler, "pull_sub", None)) and pull.batch: 

182 msg = [incoming] 

183 else: 

184 msg = incoming 

185 

186 await self._execute_handler(msg, cmd.destination, handler) 

187 

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 ) 

199 

200 for handler in _find_handler( 

201 self.subscribers, 

202 cmd.destination, 

203 cmd.stream, 

204 ): 

205 msg: list[PatchedMessage] | PatchedMessage 

206 

207 if (pull := getattr(handler, "pull_sub", None)) and pull.batch: 

208 msg = [incoming] 

209 else: 

210 msg = incoming 

211 

212 with anyio.fail_after(cmd.timeout): 

213 return await self._execute_handler(msg, cmd.destination, handler) 

214 

215 raise SubscriberNotFound 

216 

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) 

224 

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 ) 

234 

235 

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 

250 

251 

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 

260 

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 

263 

264 if is_subject_match_wildcard(subject, handler.subject.broker_address): 

265 return True 

266 

267 for filter_subject in handler.filter_subjects or (): 

268 if is_subject_match_wildcard(subject, filter_subject): 

269 return True 

270 

271 return False 

272 

273 

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 ) 

299 

300 

301class PatchedMessage(Msg): 

302 async def ack(self) -> None: 

303 pass 

304 

305 async def ack_sync( 

306 self, 

307 timeout: float = 1, 

308 ) -> "PatchedMessage": # pragma: no cover 

309 return self 

310 

311 async def nak(self, delay: float | None = None) -> None: 

312 pass 

313 

314 async def term(self) -> None: 

315 pass 

316 

317 async def in_progress(self) -> None: 

318 pass