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

1import asyncio 

2from typing import Any 

3 

4import pytest 

5 

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 

14 

15from .basic import NatsMemoryTestcaseConfig 

16 

17 

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

23 

24 @broker.subscriber(f"{queue}.{{level}}") 

25 async def m(msg: Any) -> None: ... 

26 

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

28 await br.publish("hi", f"{queue}.info") 

29 

30 await m.assert_called_once_with("hi", path={"level": "info"}) 

31 

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={}) 

35 

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) 

42 

43 @pub_broker.subscriber(queue, stream="test") 

44 async def m(msg: Any) -> None: ... 

45 

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!") 

49 

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) 

56 

57 @pub_broker.subscriber(queue) 

58 async def m(msg: Any) -> None: ... 

59 

60 async with self.patch_broker(pub_broker) as br: 

61 await br.publish("Hi!", queue, stream="test") 

62 assert not m.mock.called 

63 

64 @pytest.mark.connected() 

65 async def test_with_real_testclient(self, queue: str, event: asyncio.Event) -> None: 

66 broker = self.get_broker() 

67 

68 @broker.subscriber(queue) 

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

70 event.set() 

71 

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 ) 

80 

81 assert event.is_set() 

82 

83 @pytest.mark.connected() 

84 async def test_inbox_prefix_with_real( 

85 self, 

86 ) -> None: 

87 broker = self.get_broker(inbox_prefix="test") 

88 

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

93 

94 async def test_respect_middleware(self, queue: str) -> None: 

95 routes: list[Any] = [] 

96 

97 class Middleware(BaseMiddleware): 

98 async def on_receive(self) -> None: 

99 routes.append(None) 

100 return await super().on_receive() 

101 

102 broker = self.get_broker(middlewares=(Middleware,)) 

103 

104 @broker.subscriber(queue) 

105 async def h1(m: Any) -> None: ... 

106 

107 @broker.subscriber(queue + "1") 

108 async def h2(m: Any) -> None: ... 

109 

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

111 await br.publish("", queue) 

112 await br.publish("", queue + "1") 

113 

114 assert len(routes) == 2 

115 

116 @pytest.mark.connected() 

117 async def test_real_respect_middleware(self, queue: str) -> None: 

118 routes: list[Any] = [] 

119 

120 class Middleware(BaseMiddleware): 

121 async def on_receive(self) -> None: 

122 routes.append(None) 

123 return await super().on_receive() 

124 

125 broker = self.get_broker(middlewares=(Middleware,)) 

126 

127 @broker.subscriber(queue) 

128 async def h1(m: Any) -> None: ... 

129 

130 @broker.subscriber(queue + "1") 

131 async def h2(m: Any) -> None: ... 

132 

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) 

138 

139 assert len(routes) == 2 

140 

141 async def test_js_subscriber_mock( 

142 self, 

143 queue: str, 

144 stream: JStream, 

145 ) -> None: 

146 broker = self.get_broker() 

147 

148 @broker.subscriber(queue, stream=stream) 

149 async def m(msg: Any) -> None: 

150 pass 

151 

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

155 

156 async def test_js_publisher_mock( 

157 self, 

158 queue: str, 

159 stream: JStream, 

160 ) -> None: 

161 broker = self.get_broker() 

162 

163 publisher = broker.publisher(queue + "resp") 

164 

165 @publisher 

166 @broker.subscriber(queue, stream=stream) 

167 async def m(msg: Any) -> str: 

168 return "response" 

169 

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

173 

174 async def test_any_subject_routing(self) -> None: 

175 broker = self.get_broker() 

176 

177 @broker.subscriber("test.*.subj.*") 

178 def subscriber(msg: Any) -> None: ... 

179 

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

183 

184 async def test_ending_subject_routing(self) -> None: 

185 broker = self.get_broker() 

186 

187 @broker.subscriber("test.>") 

188 def subscriber(msg: Any) -> None: ... 

189 

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

193 

194 async def test_mixed_subject_routing(self) -> None: 

195 broker = self.get_broker() 

196 

197 @broker.subscriber("*.*.subj.>") 

198 def subscriber(msg: Any) -> None: ... 

199 

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

203 

204 async def test_consume_pull( 

205 self, 

206 queue: str, 

207 stream: JStream, 

208 ) -> None: 

209 broker = self.get_broker() 

210 

211 @broker.subscriber(queue, stream=stream, pull_sub=PullSub(1)) 

212 def subscriber(m: Any) -> None: ... 

213 

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

215 await br.publish("hello", queue) 

216 subscriber.mock.assert_called_once_with("hello") 

217 

218 async def test_consume_batch( 

219 self, 

220 queue: str, 

221 stream: JStream, 

222 ) -> None: 

223 broker = self.get_broker() 

224 

225 @broker.subscriber( 

226 queue, 

227 stream=stream, 

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

229 ) 

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

231 pass 

232 

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

234 await br.publish("hello", queue) 

235 subscriber.mock.assert_called_once_with(["hello"]) 

236 

237 async def test_consume_with_subject_filter(self, queue: str) -> None: 

238 broker = self.get_broker() 

239 

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 

246 

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) 

251 

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) 

255 

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

259 

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) 

266 

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

271 

272 # use two publishers to check that we don't have conflicts 

273 publisher = broker.publisher(subject="") 

274 another_publisher = broker.publisher(subject="") 

275 

276 async with self.patch_broker(broker): 

277 await publisher.publish(None, subject="new-key") 

278 publisher.mock.assert_called_once() 

279 

280 await another_publisher.publish(None, subject="new-key") 

281 another_publisher.mock.assert_called_once()