Coverage for tests/brokers/base/codec.py: 98%

128 statements  

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

1from collections.abc import Sequence 

2from typing import TYPE_CHECKING, Any 

3from unittest.mock import MagicMock 

4 

5import pytest 

6 

7from faststream._internal.parser import BatchCodecProto, DefaultCodec 

8from faststream.message.utils import encode_message 

9from tests.brokers.base.basic import BaseTestcaseConfig 

10 

11if TYPE_CHECKING: 

12 from faststream._internal.basic_types import SendableMessage 

13 

14 

15@pytest.mark.asyncio() 

16class CodecTestcase(BaseTestcaseConfig[Any]): 

17 async def test_codec_decode_called( 

18 self, 

19 mock: MagicMock, 

20 queue: str, 

21 ) -> None: 

22 class TrackingCodec(DefaultCodec): 

23 async def decode(self, msg: Any) -> Any: 

24 mock() 

25 return await super().decode(msg) 

26 

27 codec = TrackingCodec() 

28 broker = self.get_broker() 

29 

30 args, kwargs = self.get_subscriber_params(queue, codec=codec) 

31 

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

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

34 pass 

35 

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

37 await br.publish(b"hello", queue) 

38 

39 mock.assert_called_once() 

40 

41 async def test_codec_not_set_uses_default( 

42 self, 

43 mock: MagicMock, 

44 queue: str, 

45 ) -> None: 

46 broker = self.get_broker() 

47 

48 args, kwargs = self.get_subscriber_params(queue) 

49 

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

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

52 mock(m) 

53 

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

55 await br.publish({"key": "value"}, queue) 

56 

57 mock.assert_called_once_with({"key": "value"}) 

58 

59 async def test_codec_survives_building_the_model_twice( 

60 self, 

61 mock: MagicMock, 

62 queue: str, 

63 ) -> None: 

64 class TrackingCodec(DefaultCodec): 

65 async def decode(self, msg: Any) -> Any: 

66 mock() 

67 return await super().decode(msg) 

68 

69 broker = self.get_broker() 

70 

71 args, kwargs = self.get_subscriber_params(queue, codec=TrackingCodec()) 

72 

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

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

75 pass 

76 

77 # Rendering the schema composes the model once; starting composes it again 

78 subscriber = next(iter(broker.subscribers)) 

79 subscriber.schema() 

80 

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

82 await br.publish(b"hello", queue) 

83 

84 mock.assert_called_once() 

85 

86 async def test_codec_and_decoder_conflict_raises( 

87 self, 

88 queue: str, 

89 ) -> None: 

90 broker = self.get_broker() 

91 codec = DefaultCodec() 

92 

93 async def my_decoder(msg: Any, original: Any) -> Any: 

94 return await original(msg) 

95 

96 args, kwargs = self.get_subscriber_params(queue, codec=codec, decoder=my_decoder) 

97 

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

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

100 pass # pragma: no cover 

101 

102 # ValueError raised inside _get_parser_and_decoder() during start(), 

103 # which TestBroker.__aenter__ calls before yielding — hence it propagates 

104 # from the "async with" expression rather than from the body. 

105 with pytest.raises(ValueError, match="codec"): 

106 async with self.patch_broker(broker): 

107 pass # pragma: no cover 

108 

109 async def test_broker_level_codec( 

110 self, 

111 mock: MagicMock, 

112 queue: str, 

113 ) -> None: 

114 class TrackingCodec(DefaultCodec): 

115 async def decode(self, msg: Any) -> Any: 

116 mock() 

117 return await super().decode(msg) 

118 

119 broker = self.get_broker(codec=TrackingCodec()) 

120 

121 args, kwargs = self.get_subscriber_params(queue) 

122 

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

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

125 pass 

126 

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

128 await br.publish(b"hello", queue) 

129 

130 mock.assert_called_once() 

131 

132 async def test_codec_encode_called(self, queue: str) -> None: 

133 mock = MagicMock() 

134 

135 class TrackingCodec(DefaultCodec): 

136 async def encode(self, msg: Any, serializer: Any = None) -> Any: 

137 mock() 

138 return await super().encode(msg, serializer) 

139 

140 broker = self.get_broker(codec=TrackingCodec()) 

141 

142 args, kwargs = self.get_subscriber_params(queue) 

143 

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

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

146 pass 

147 

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

149 await br.publish({"key": "value"}, queue) 

150 

151 assert mock.called, "codec.encode was not called on publish" 

152 

153 async def test_default_codec_encode_matches_encode_message(self) -> None: 

154 codec = DefaultCodec() 

155 

156 test_cases: list[SendableMessage] = [ 

157 None, 

158 b"raw bytes", 

159 "hello string", 

160 {"json": True, "value": 42}, 

161 ] 

162 

163 for msg in test_cases: 

164 codec_result = await codec.encode(msg, None) 

165 direct_result = encode_message(msg, None) 

166 assert codec_result == direct_result, ( 

167 f"DefaultCodec.encode({msg!r}) = {codec_result!r} " 

168 f"but encode_message({msg!r}) = {direct_result!r}" 

169 ) 

170 

171 

172@pytest.mark.asyncio() 

173class BatchCodecTestcase(BaseTestcaseConfig[Any]): 

174 async def test_batch_codec_decode_batch_called( 

175 self, 

176 mock: MagicMock, 

177 queue: str, 

178 ) -> None: 

179 decode_batch_mock = MagicMock() 

180 

181 class TrackingBatchCodec(DefaultCodec): 

182 async def encode_batch( 

183 self, 

184 msgs: Sequence[Any], 

185 serializer: Any = None, 

186 ) -> list[tuple[bytes, str | None]]: 

187 return [await DefaultCodec.encode(self, m, serializer) for m in msgs] 

188 

189 async def decode_batch(self, msg: Any) -> list[Any]: 

190 decode_batch_mock() 

191 return [b.decode() if isinstance(b, bytes) else b for b in msg.body] 

192 

193 codec = TrackingBatchCodec() 

194 broker = self.get_broker(codec=codec) 

195 

196 @broker.subscriber(queue, batch=True) 

197 async def handle(m: list[str]) -> None: 

198 mock(m) 

199 

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

201 await br.publish_batch("a", "b", "c", topic=queue) 

202 

203 assert decode_batch_mock.called, "decode_batch was not called" 

204 mock.assert_called_once_with(["a", "b", "c"]) 

205 

206 async def test_batch_codec_encode_batch_called( 

207 self, 

208 queue: str, 

209 ) -> None: 

210 encode_batch_mock = MagicMock() 

211 

212 class TrackingBatchCodec(DefaultCodec): 

213 async def encode_batch( 

214 self, 

215 msgs: Sequence[Any], 

216 serializer: Any = None, 

217 ) -> list[tuple[bytes, str | None]]: 

218 encode_batch_mock() 

219 return [await DefaultCodec.encode(self, m, serializer) for m in msgs] 

220 

221 async def decode_batch(self, msg: Any) -> list[Any]: 

222 return [b.decode() if isinstance(b, bytes) else b for b in msg.body] 

223 

224 broker = self.get_broker(codec=TrackingBatchCodec()) 

225 

226 @broker.subscriber(queue, batch=True) 

227 async def handle(m: list[str]) -> None: 

228 pass 

229 

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

231 await br.publish_batch("a", "b", "c", topic=queue) 

232 

233 assert encode_batch_mock.called, "encode_batch was not called on publish" 

234 

235 async def test_batch_codec_without_batch_proto_raises( 

236 self, 

237 queue: str, 

238 ) -> None: 

239 broker = self.get_broker(codec=DefaultCodec()) 

240 

241 @broker.subscriber(queue, batch=True) 

242 async def handle(m: list[str]) -> None: 

243 pass 

244 

245 with pytest.raises(ValueError, match="BatchCodecProto"): 

246 async with self.patch_broker(broker): 

247 pass 

248 

249 async def test_batch_codec_isinstance_dispatch(self) -> None: 

250 class WithBatch(DefaultCodec): 

251 async def encode_batch( 

252 self, 

253 msgs: Sequence[Any], 

254 serializer: Any = None, 

255 ) -> list[tuple[bytes, str | None]]: 

256 return [await super().encode(m, serializer) for m in msgs] 

257 

258 async def decode_batch(self, msg: Any) -> list[Any]: 

259 return [] 

260 

261 class WithoutBatch(DefaultCodec): 

262 pass 

263 

264 assert isinstance(WithBatch(), BatchCodecProto) 

265 assert not isinstance(WithoutBatch(), BatchCodecProto)