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
« 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
5import pytest
7from faststream._internal.parser import BatchCodecProto, DefaultCodec
8from faststream.message.utils import encode_message
9from tests.brokers.base.basic import BaseTestcaseConfig
11if TYPE_CHECKING:
12 from faststream._internal.basic_types import SendableMessage
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)
27 codec = TrackingCodec()
28 broker = self.get_broker()
30 args, kwargs = self.get_subscriber_params(queue, codec=codec)
32 @broker.subscriber(*args, **kwargs)
33 async def handle(m: Any) -> None:
34 pass
36 async with self.patch_broker(broker) as br:
37 await br.publish(b"hello", queue)
39 mock.assert_called_once()
41 async def test_codec_not_set_uses_default(
42 self,
43 mock: MagicMock,
44 queue: str,
45 ) -> None:
46 broker = self.get_broker()
48 args, kwargs = self.get_subscriber_params(queue)
50 @broker.subscriber(*args, **kwargs)
51 async def handle(m: Any) -> None:
52 mock(m)
54 async with self.patch_broker(broker) as br:
55 await br.publish({"key": "value"}, queue)
57 mock.assert_called_once_with({"key": "value"})
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)
69 broker = self.get_broker()
71 args, kwargs = self.get_subscriber_params(queue, codec=TrackingCodec())
73 @broker.subscriber(*args, **kwargs)
74 async def handle(m: Any) -> None:
75 pass
77 # Rendering the schema composes the model once; starting composes it again
78 subscriber = next(iter(broker.subscribers))
79 subscriber.schema()
81 async with self.patch_broker(broker) as br:
82 await br.publish(b"hello", queue)
84 mock.assert_called_once()
86 async def test_codec_and_decoder_conflict_raises(
87 self,
88 queue: str,
89 ) -> None:
90 broker = self.get_broker()
91 codec = DefaultCodec()
93 async def my_decoder(msg: Any, original: Any) -> Any:
94 return await original(msg)
96 args, kwargs = self.get_subscriber_params(queue, codec=codec, decoder=my_decoder)
98 @broker.subscriber(*args, **kwargs)
99 async def handle(m: Any) -> None:
100 pass # pragma: no cover
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
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)
119 broker = self.get_broker(codec=TrackingCodec())
121 args, kwargs = self.get_subscriber_params(queue)
123 @broker.subscriber(*args, **kwargs)
124 async def handle(m: Any) -> None:
125 pass
127 async with self.patch_broker(broker) as br:
128 await br.publish(b"hello", queue)
130 mock.assert_called_once()
132 async def test_codec_encode_called(self, queue: str) -> None:
133 mock = MagicMock()
135 class TrackingCodec(DefaultCodec):
136 async def encode(self, msg: Any, serializer: Any = None) -> Any:
137 mock()
138 return await super().encode(msg, serializer)
140 broker = self.get_broker(codec=TrackingCodec())
142 args, kwargs = self.get_subscriber_params(queue)
144 @broker.subscriber(*args, **kwargs)
145 async def handle(m: Any) -> None:
146 pass
148 async with self.patch_broker(broker) as br:
149 await br.publish({"key": "value"}, queue)
151 assert mock.called, "codec.encode was not called on publish"
153 async def test_default_codec_encode_matches_encode_message(self) -> None:
154 codec = DefaultCodec()
156 test_cases: list[SendableMessage] = [
157 None,
158 b"raw bytes",
159 "hello string",
160 {"json": True, "value": 42},
161 ]
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 )
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()
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]
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]
193 codec = TrackingBatchCodec()
194 broker = self.get_broker(codec=codec)
196 @broker.subscriber(queue, batch=True)
197 async def handle(m: list[str]) -> None:
198 mock(m)
200 async with self.patch_broker(broker) as br:
201 await br.publish_batch("a", "b", "c", topic=queue)
203 assert decode_batch_mock.called, "decode_batch was not called"
204 mock.assert_called_once_with(["a", "b", "c"])
206 async def test_batch_codec_encode_batch_called(
207 self,
208 queue: str,
209 ) -> None:
210 encode_batch_mock = MagicMock()
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]
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]
224 broker = self.get_broker(codec=TrackingBatchCodec())
226 @broker.subscriber(queue, batch=True)
227 async def handle(m: list[str]) -> None:
228 pass
230 async with self.patch_broker(broker) as br:
231 await br.publish_batch("a", "b", "c", topic=queue)
233 assert encode_batch_mock.called, "encode_batch was not called on publish"
235 async def test_batch_codec_without_batch_proto_raises(
236 self,
237 queue: str,
238 ) -> None:
239 broker = self.get_broker(codec=DefaultCodec())
241 @broker.subscriber(queue, batch=True)
242 async def handle(m: list[str]) -> None:
243 pass
245 with pytest.raises(ValueError, match="BatchCodecProto"):
246 async with self.patch_broker(broker):
247 pass
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]
258 async def decode_batch(self, msg: Any) -> list[Any]:
259 return []
261 class WithoutBatch(DefaultCodec):
262 pass
264 assert isinstance(WithBatch(), BatchCodecProto)
265 assert not isinstance(WithoutBatch(), BatchCodecProto)