Coverage for tests/brokers/redis/test_test_client.py: 97%
196 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
1import asyncio
2from typing import Any
4import pytest
6from faststream import BaseMiddleware
7from faststream.exceptions import SetupError
8from faststream.redis import ListSub, StreamSub
9from faststream.redis.testing import FakeProducer
10from tests.brokers.base.testclient import BrokerTestclientTestcase
12from .basic import RedisMemoryTestcaseConfig
15@pytest.mark.redis()
16@pytest.mark.asyncio()
17class TestTestclient(RedisMemoryTestcaseConfig, BrokerTestclientTestcase):
18 @pytest.mark.connected()
19 async def test_with_real_testclient(self, queue: str, event: asyncio.Event) -> None:
20 broker = self.get_broker()
22 @broker.subscriber(queue)
23 def subscriber(m: Any) -> None:
24 event.set()
26 async with self.patch_broker(broker, with_real=True) as br:
27 await asyncio.wait(
28 (
29 asyncio.create_task(br.publish("hello", queue)),
30 asyncio.create_task(event.wait()),
31 ),
32 timeout=3,
33 )
35 assert event.is_set()
37 async def test_respect_middleware(self, queue: str) -> None:
38 routes: list[Any] = []
40 class Middleware(BaseMiddleware):
41 async def on_receive(self) -> None:
42 routes.append(None)
43 return await super().on_receive()
45 broker = self.get_broker(middlewares=(Middleware,))
47 @broker.subscriber(queue)
48 async def h1(m: Any) -> None: ...
50 @broker.subscriber(queue + "1")
51 async def h2(m: Any) -> None: ...
53 async with self.patch_broker(broker) as br:
54 await br.publish("", queue)
55 await br.publish("", queue + "1")
57 assert len(routes) == 2
59 @pytest.mark.connected()
60 async def test_real_respect_middleware(self, queue: str) -> None:
61 routes: list[Any] = []
63 class Middleware(BaseMiddleware):
64 async def on_receive(self) -> None:
65 routes.append(None)
66 return await super().on_receive()
68 broker = self.get_broker(middlewares=(Middleware,))
70 @broker.subscriber(queue)
71 async def h1(m: Any) -> None: ...
73 @broker.subscriber(queue + "1")
74 async def h2(m: Any) -> None: ...
76 async with self.patch_broker(broker, with_real=True) as br:
77 await br.publish("", queue)
78 await br.publish("", queue + "1")
79 await h1.wait_call(3)
80 await h2.wait_call(3)
82 assert len(routes) == 2
84 async def test_pub_sub_pattern(self) -> None:
85 broker = self.get_broker()
87 @broker.subscriber("test.{name}")
88 async def handler(msg: Any) -> Any:
89 return msg
91 async with self.patch_broker(broker) as br:
92 assert await (await br.request(1, "test.name.useless")).decode() == 1
93 handler.mock.assert_called_once_with(1)
95 async def test_pub_sub_pattern_matches_whole_channel(self) -> None:
96 broker = self.get_broker()
98 @broker.subscriber("logs.*.error")
99 async def handler(msg: Any) -> None: ...
101 async with self.patch_broker(broker) as br:
102 await br.publish("1", "logs.app.error")
103 await br.publish("2", "logs.app.error.extra")
104 await br.publish("3", "logs.app.errors")
106 handler.mock.assert_called_once_with("1")
108 async def test_list(
109 self,
110 queue: str,
111 ) -> None:
112 broker = self.get_broker()
114 @broker.subscriber(list=queue)
115 async def handler(msg: Any) -> Any:
116 return msg
118 async with self.patch_broker(broker) as br:
119 assert await (await br.request(1, list=queue)).decode() == 1
120 handler.mock.assert_called_once_with(1)
122 async def test_batch_pub_by_default_pub(
123 self,
124 queue: str,
125 ) -> None:
126 broker = self.get_broker()
128 @broker.subscriber(list=ListSub(queue, batch=True))
129 async def m(msg: Any) -> None:
130 pass
132 async with self.patch_broker(broker) as br:
133 await br.publish("hello", list=queue)
134 m.mock.assert_called_once_with(["hello"])
136 async def test_batch_pub_by_pub_batch(
137 self,
138 queue: str,
139 ) -> None:
140 broker = self.get_broker()
142 @broker.subscriber(list=ListSub(queue, batch=True))
143 async def m(msg: Any) -> None:
144 pass
146 async with self.patch_broker(broker) as br:
147 await br.publish_batch("hello", list=queue)
148 m.mock.assert_called_once_with(["hello"])
150 async def test_batch_assert_called_once_with(self, queue: str) -> None:
151 broker = self.get_broker()
153 @broker.subscriber(list=ListSub(queue, batch=True))
154 async def m(msg: Any) -> None: ...
156 async with self.patch_broker(broker) as br:
157 await br.publish_batch({"n": 1}, {"n": 2}, list=queue)
159 await m.assert_called_once_with([{"n": 1}, {"n": 2}])
161 # A batch has one header set per message, so there is no single answer
162 with pytest.raises(SetupError, match="received a batch"):
163 await m.assert_called_once_with(headers={"key": "value"})
165 async def test_publish_batch_to_single_list(self, queue: str) -> None:
166 broker = self.get_broker()
167 received: list[Any] = []
169 @broker.subscriber(list=queue)
170 async def handler(msg: Any) -> None:
171 received.append(msg)
173 async with self.patch_broker(broker) as br:
174 await br.publish_batch(1, "hi", {"n": 2}, list=queue)
176 assert received == [1, "hi", {"n": 2}]
178 async def test_batch_publisher_mock(
179 self,
180 queue: str,
181 ) -> None:
182 broker = self.get_broker()
184 batch_list = ListSub(queue + "1", batch=True)
185 publisher = broker.publisher(list=batch_list)
187 @publisher
188 @broker.subscriber(queue)
189 async def m(msg: Any) -> Any:
190 return 1, 2, 3
192 async with self.patch_broker(broker) as br:
193 await br.publish("hello", queue)
194 m.mock.assert_called_once_with("hello")
195 publisher.mock.assert_called_once_with([1, 2, 3])
197 @pytest.mark.parametrize(
198 "returned",
199 (pytest.param(None, id="None"), pytest.param([], id="Empty Sequence")),
200 )
201 async def test_batch_publisher_empty_result_matches_default_publisher(
202 self,
203 queue: str,
204 returned: Any,
205 ) -> None:
206 """Fixes https://github.com/ag2ai/faststream/issues/3056.
208 An empty result publishes one empty message, exactly as a non-batch
209 publisher does.
210 """
211 broker = self.get_broker()
213 batch_publisher = broker.publisher(list=ListSub(queue + "1", batch=True))
214 default_publisher = broker.publisher(list=queue + "2")
216 @batch_publisher
217 @broker.subscriber(queue)
218 async def batched(msg: Any) -> Any:
219 return returned
221 @default_publisher
222 @broker.subscriber(queue + "3")
223 async def single(msg: Any) -> None:
224 return None
226 async with self.patch_broker(broker) as br:
227 await br.publish("hello", queue)
228 await br.publish("hello", queue + "3")
230 default_publisher.mock.assert_called_once_with(b"")
231 # Redis batch subscribers decode every element to `str`, so the same
232 # empty message on the wire is observed as `""` rather than `b""`.
233 batch_publisher.mock.assert_called_once_with([""])
235 async def test_stream(
236 self,
237 queue: str,
238 ) -> None:
239 broker = self.get_broker()
241 @broker.subscriber(stream=queue)
242 async def handler(msg: Any) -> Any:
243 return msg
245 async with self.patch_broker(broker) as br:
246 assert await (await br.request(1, stream=queue)).decode() == 1
247 handler.mock.assert_called_once_with(1)
249 async def test_stream_batch_pub_by_default_pub(
250 self,
251 queue: str,
252 ) -> None:
253 broker = self.get_broker()
255 @broker.subscriber(stream=StreamSub(queue, batch=True))
256 async def m(msg: Any) -> None:
257 pass
259 async with self.patch_broker(broker) as br:
260 await br.publish("hello", stream=queue)
261 m.mock.assert_called_once_with(["hello"])
263 async def test_stream_publisher(
264 self,
265 queue: str,
266 ) -> None:
267 broker = self.get_broker()
269 batch_stream = StreamSub(queue + "1")
270 publisher = broker.publisher(stream=batch_stream)
272 @publisher
273 @broker.subscriber(queue)
274 async def m(msg: Any) -> Any:
275 return 1, 2, 3
277 async with self.patch_broker(broker) as br:
278 await br.publish("hello", queue)
279 m.mock.assert_called_once_with("hello")
280 publisher.mock.assert_called_once_with([1, 2, 3])
282 async def test_stream_same_group_delivers_to_one_consumer(
283 self,
284 queue: str,
285 ) -> None:
286 broker = self.get_broker()
288 @broker.subscriber(
289 stream=StreamSub(queue, group="workers", consumer="consumer-1"),
290 )
291 async def subscriber1(msg: Any) -> None: ...
293 @broker.subscriber(
294 stream=StreamSub(queue, group="workers", consumer="consumer-2"),
295 )
296 async def subscriber2(msg: Any) -> None: ...
298 async with self.patch_broker(broker) as br:
299 await br.publish("hello", stream=queue)
301 # exactly one consumer of the group handles the message
302 called = [m for m in (subscriber1.mock, subscriber2.mock) if m.call_count]
303 assert len(called) == 1
304 called[0].assert_called_once_with("hello")
306 async def test_stream_different_groups_all_receive(
307 self,
308 queue: str,
309 ) -> None:
310 broker = self.get_broker()
312 @broker.subscriber(
313 stream=StreamSub(queue, group="workers-a", consumer="consumer-1"),
314 )
315 async def subscriber1(msg: Any) -> None: ...
317 @broker.subscriber(
318 stream=StreamSub(queue, group="workers-b", consumer="consumer-1"),
319 )
320 async def subscriber2(msg: Any) -> None: ...
322 async with self.patch_broker(broker) as br:
323 await br.publish("hello", stream=queue)
325 subscriber1.mock.assert_called_once_with("hello")
326 subscriber2.mock.assert_called_once_with("hello")
328 async def test_stream_without_group_always_receives(
329 self,
330 queue: str,
331 ) -> None:
332 broker = self.get_broker()
334 @broker.subscriber(
335 stream=StreamSub(queue, group="workers", consumer="consumer-1"),
336 )
337 async def grouped(msg: Any) -> None: ...
339 @broker.subscriber(stream=queue)
340 async def ungrouped(msg: Any) -> None: ...
342 async with self.patch_broker(broker) as br:
343 await br.publish("hello", stream=queue)
345 grouped.mock.assert_called_once_with("hello")
346 ungrouped.mock.assert_called_once_with("hello")
348 async def test_publish_to_none(self) -> None:
349 broker = self.get_broker()
351 async with self.patch_broker(broker) as br:
352 with pytest.raises(ValueError): # ruff: ignore[pytest-raises-too-broad]
353 await br.publish("hello")
355 @pytest.mark.connected()
356 async def test_broker_gets_patched_attrs_within_cm(self) -> None:
357 await super().test_broker_gets_patched_attrs_within_cm(FakeProducer)
359 @pytest.mark.connected()
360 async def test_broker_with_real_doesnt_get_patched(self) -> None:
361 await super().test_broker_with_real_doesnt_get_patched()
363 @pytest.mark.connected()
364 async def test_broker_with_real_patches_publishers_and_subscribers(
365 self,
366 queue: str,
367 ) -> None:
368 await super().test_broker_with_real_patches_publishers_and_subscribers(queue)
370 @pytest.mark.xfail(reason="https://github.com/ag2ai/faststream/issues/2513")
371 async def test_publisher_without_destination(self) -> None:
372 """Fixes https://github.com/ag2ai/faststream/issues/2513."""
373 broker = self.get_broker()
375 # use two publishers to check that we don't have conflicts
376 channel_publisher = broker.publisher(channel="")
377 another_channel_publisher = broker.publisher(channel="")
379 list_publisher = broker.publisher(list="")
380 stream_publisher = broker.publisher(stream="")
382 async with self.patch_broker(broker):
383 await channel_publisher.publish(None, channel="new-key")
384 channel_publisher.mock.assert_called_once()
386 await another_channel_publisher.publish(None, channel="new-key")
387 another_channel_publisher.mock.assert_called_once()
389 await list_publisher.publish(None, list="new-key")
390 list_publisher.mock.assert_called_once()
392 await stream_publisher.publish(None, stream="new-key")
393 stream_publisher.mock.assert_called_once()