Coverage for tests/brokers/base/parser.py: 99%

157 statements  

« prev     ^ index     » next       coverage.py v7.17.3, created at 2026-11-17 21:20 +0000

1import asyncio 

2from typing import Any 

3from unittest.mock import MagicMock 

4 

5import anyio 

6import pytest 

7 

8from .basic import BaseTestcaseConfig 

9 

10 

11@pytest.mark.asyncio() 

12class LocalCustomParserTestcase(BaseTestcaseConfig[Any]): 

13 async def test_local_parser( 

14 self, 

15 mock: MagicMock, 

16 event: asyncio.Event, 

17 queue: str, 

18 ) -> None: 

19 broker = self.get_broker() 

20 

21 async def custom_parser(msg: Any, original: Any) -> Any: 

22 msg = await original(msg) 

23 mock(msg.body) 

24 return msg 

25 

26 args, kwargs = self.get_subscriber_params(queue, parser=custom_parser) 

27 

28 @broker.subscriber(*args, **kwargs) 

29 async def handle(m: Any) -> None: 

30 event.set() 

31 

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

33 await br.start() 

34 

35 await asyncio.wait( 

36 ( 

37 asyncio.create_task(br.publish(b"hello", queue)), 

38 asyncio.create_task(event.wait()), 

39 ), 

40 timeout=self.timeout, 

41 ) 

42 

43 assert event.is_set() 

44 mock.assert_called_once_with(b"hello") 

45 

46 async def test_local_sync_decoder( 

47 self, 

48 mock: MagicMock, 

49 event: asyncio.Event, 

50 queue: str, 

51 ) -> None: 

52 broker = self.get_broker() 

53 

54 def custom_decoder(msg: Any) -> Any: 

55 mock(msg.body) 

56 return msg 

57 

58 args, kwargs = self.get_subscriber_params(queue, decoder=custom_decoder) 

59 

60 @broker.subscriber(*args, **kwargs) 

61 async def handle(m: Any) -> None: 

62 event.set() 

63 

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

65 await br.start() 

66 

67 await asyncio.wait( 

68 ( 

69 asyncio.create_task(br.publish(b"hello", queue)), 

70 asyncio.create_task(event.wait()), 

71 ), 

72 timeout=self.timeout, 

73 ) 

74 

75 assert event.is_set() 

76 mock.assert_called_once_with(b"hello") 

77 

78 async def test_global_sync_decoder( 

79 self, 

80 mock: MagicMock, 

81 event: asyncio.Event, 

82 queue: str, 

83 ) -> None: 

84 def custom_decoder(msg: Any) -> Any: 

85 mock(msg.body) 

86 return msg 

87 

88 broker = self.get_broker(decoder=custom_decoder) 

89 

90 args, kwargs = self.get_subscriber_params(queue) 

91 

92 @broker.subscriber(*args, **kwargs) 

93 async def handle(m: Any) -> None: 

94 event.set() 

95 

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

97 await br.start() 

98 

99 await asyncio.wait( 

100 ( 

101 asyncio.create_task(br.publish(b"hello", queue)), 

102 asyncio.create_task(event.wait()), 

103 ), 

104 timeout=self.timeout, 

105 ) 

106 

107 assert event.is_set() 

108 mock.assert_called_once_with(b"hello") 

109 

110 async def test_local_parser_no_share_between_subscribers( 

111 self, 

112 mock: MagicMock, 

113 queue: str, 

114 event: asyncio.Event, 

115 event2: asyncio.Event, 

116 ) -> None: 

117 broker = self.get_broker() 

118 

119 async def custom_parser(msg: Any, original: Any) -> Any: 

120 msg = await original(msg) 

121 mock(msg.body) 

122 return msg 

123 

124 args, kwargs = self.get_subscriber_params(queue, parser=custom_parser) 

125 args2, kwargs2 = self.get_subscriber_params(queue + "1") 

126 

127 @broker.subscriber(*args, **kwargs) 

128 @broker.subscriber(*args2, **kwargs2) 

129 async def handle(m: Any) -> None: 

130 if event.is_set(): 

131 event2.set() 

132 else: 

133 event.set() 

134 

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

136 await br.start() 

137 

138 await asyncio.wait( 

139 ( 

140 asyncio.create_task(br.publish(b"hello", queue)), 

141 asyncio.create_task(br.publish(b"hello", queue + "1")), 

142 asyncio.create_task(event.wait()), 

143 asyncio.create_task(event2.wait()), 

144 ), 

145 timeout=self.timeout, 

146 ) 

147 

148 assert event.is_set() 

149 assert event2.is_set() 

150 mock.assert_called_once_with(b"hello") 

151 

152 async def test_local_parser_no_share_between_handlers( 

153 self, 

154 mock: MagicMock, 

155 queue: str, 

156 event: asyncio.Event, 

157 event2: asyncio.Event, 

158 ) -> None: 

159 broker = self.get_broker() 

160 

161 args, kwargs = self.get_subscriber_params(queue) 

162 sub = broker.subscriber(*args, **kwargs) 

163 

164 @sub(filter=lambda m: m.content_type == "application/json") 

165 async def handle(m: Any) -> None: 

166 event.set() 

167 

168 async def custom_parser(msg: Any, original: Any) -> Any: 

169 msg = await original(msg) 

170 mock(msg.body) 

171 return msg 

172 

173 @sub(parser=custom_parser) 

174 async def handle2(m: Any) -> None: 

175 event2.set() 

176 

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

178 await br.start() 

179 

180 await asyncio.wait( 

181 ( 

182 asyncio.create_task(br.publish({"msg": "hello"}, queue)), 

183 asyncio.create_task(br.publish(b"hello", queue)), 

184 asyncio.create_task(event.wait()), 

185 asyncio.create_task(event2.wait()), 

186 ), 

187 timeout=self.timeout, 

188 ) 

189 

190 assert event.is_set() 

191 assert event2.is_set() 

192 assert mock.call_count == 1 

193 

194 @pytest.mark.connected() 

195 async def test_iterator_respect_decoder( 

196 self, 

197 mock: MagicMock, 

198 queue: str, 

199 event: asyncio.Event, 

200 event2: asyncio.Event, 

201 event3: asyncio.Event, 

202 ) -> None: 

203 """Fixes https://github.com/ag2ai/faststream/issues/2554.""" 

204 start_event, consumed_event, stopped_event = event, event2, event3 

205 

206 broker = self.get_broker() 

207 

208 async def custom_decoder(msg: Any, original: Any) -> Any: 

209 mock() 

210 consumed_event.set() 

211 return await original(msg) 

212 

213 args, kwargs = self.get_subscriber_params(queue, decoder=custom_decoder) 

214 sub = broker.subscriber(*args, **kwargs) 

215 

216 async def iter_messages() -> Any: 

217 await sub.start() 

218 start_event.set() 

219 

220 msg: Any = None 

221 async for m in sub: 221 ↛ 227line 221 didn't jump to line 227 because the loop on line 221 didn't complete

222 assert not mock.called 

223 msg = await m.decode() 

224 mock.assert_called_once() 

225 break 

226 

227 await sub.stop() 

228 stopped_event.set() 

229 return msg 

230 

231 async with broker: 

232 t = asyncio.create_task(iter_messages()) 

233 

234 with anyio.move_on_after(self.timeout): 

235 await start_event.wait() 

236 await broker.publish(b"hello", queue) 

237 await consumed_event.wait() 

238 await stopped_event.wait() 

239 

240 await t 

241 data = t.result() 

242 assert data == b"hello", data 

243 

244 @pytest.mark.connected() 

245 async def test_get_one_respect_decoder( 

246 self, 

247 queue: str, 

248 event: asyncio.Event, 

249 mock: MagicMock, 

250 ) -> None: 

251 """Fixes https://github.com/ag2ai/faststream/issues/2554.""" 

252 broker = self.get_broker() 

253 

254 async def custom_decoder(msg: Any, original: Any) -> Any: 

255 mock() 

256 return await original(msg) 

257 

258 args, kwargs = self.get_subscriber_params(queue, decoder=custom_decoder) 

259 sub = broker.subscriber(*args, **kwargs) 

260 

261 async def get_msg() -> Any: 

262 await sub.start() 

263 event.set() 

264 msg = await sub.get_one(timeout=self.timeout) 

265 await sub.stop() 

266 return msg 

267 

268 async with broker: 

269 task = asyncio.create_task(get_msg()) 

270 

271 with anyio.move_on_after(self.timeout): 

272 await event.wait() 

273 await broker.publish(b"hello", queue) 

274 

275 await task 

276 msg = task.result() 

277 

278 assert not mock.called, mock.call_count 

279 await msg.decode() 

280 mock.assert_called_once() 

281 

282 

283class CustomParserTestcase(LocalCustomParserTestcase): 

284 async def test_global_parser( 

285 self, 

286 mock: MagicMock, 

287 event: asyncio.Event, 

288 queue: str, 

289 ) -> None: 

290 async def custom_parser(msg: Any, original: Any) -> Any: 

291 msg = await original(msg) 

292 mock(msg.body) 

293 return msg 

294 

295 broker = self.get_broker(parser=custom_parser) 

296 

297 args, kwargs = self.get_subscriber_params(queue) 

298 

299 @broker.subscriber(*args, **kwargs) 

300 async def handle(m: Any) -> None: 

301 event.set() 

302 

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

304 await br.start() 

305 

306 await asyncio.wait( 

307 ( 

308 asyncio.create_task(br.publish(b"hello", queue)), 

309 asyncio.create_task(event.wait()), 

310 ), 

311 timeout=self.timeout, 

312 ) 

313 

314 assert event.is_set() 

315 mock.assert_called_once_with(b"hello")