Coverage for tests/brokers/rabbit/test_consume.py: 99%
208 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
3from unittest.mock import ANY, MagicMock, patch
5import pytest
6from aio_pika import IncomingMessage, Message, RobustQueue
7from aiormq.abc import ConfirmationFrameType
9from faststream import AckPolicy
10from faststream._internal.endpoint.subscriber.utils import MultiLock
11from faststream.exceptions import AckMessage, NackMessage, RejectMessage, SkipMessage
12from faststream.rabbit import RabbitExchange, RabbitQueue
13from faststream.rabbit.annotations import RabbitMessage
14from faststream.rabbit.subscriber.usecase import RabbitSubscriber
15from tests.brokers.base.consume import BrokerRealConsumeTestcase
16from tests.tools import spy_decorator
18from .basic import RabbitTestcaseConfig
21@pytest.mark.connected()
22@pytest.mark.rabbit()
23class TestConsume(RabbitTestcaseConfig, BrokerRealConsumeTestcase):
24 @pytest.mark.asyncio()
25 async def test_consume_from_exchange(
26 self, queue: str, exchange: RabbitExchange, event: asyncio.Event
27 ) -> None:
28 consume_broker = self.get_broker()
30 @consume_broker.subscriber(queue=queue, exchange=exchange)
31 def h(m: Any) -> None:
32 event.set()
34 async with self.patch_broker(consume_broker) as br:
35 await br.start()
37 result = await br.publish("hello", queue=queue, exchange=exchange)
38 await asyncio.wait(
39 (asyncio.create_task(event.wait()),),
40 timeout=3,
41 )
42 assert isinstance(result, ConfirmationFrameType), result # type: ignore[arg-type]
44 assert event.is_set()
46 @pytest.mark.asyncio()
47 async def test_consume_with_get_old(
48 self, queue: str, exchange: RabbitExchange, event: asyncio.Event
49 ) -> None:
50 consume_broker = self.get_broker()
52 @consume_broker.subscriber(
53 queue=RabbitQueue(name=queue, declare=False),
54 exchange=RabbitExchange(name=exchange.name, declare=False),
55 )
56 def h(m: Any) -> None:
57 event.set()
59 async with self.patch_broker(consume_broker, connect_only=True) as br:
60 q = await br.declare_queue(RabbitQueue(queue))
61 ex = await br.declare_exchange(exchange)
62 await q.bind(ex, routing_key=queue)
64 await br.start()
66 await asyncio.wait(
67 (
68 asyncio.create_task(
69 br.publish(
70 Message(b"hello"),
71 queue=queue,
72 exchange=exchange.name,
73 ),
74 ),
75 asyncio.create_task(event.wait()),
76 ),
77 timeout=3,
78 )
80 assert event.is_set()
82 @pytest.mark.asyncio()
83 async def test_consume_ack(
84 self, queue: str, exchange: RabbitExchange, event: asyncio.Event
85 ) -> None:
86 consume_broker = self.get_broker(apply_types=True)
88 @consume_broker.subscriber(queue=queue, exchange=exchange)
89 async def handler(msg: RabbitMessage) -> None:
90 event.set()
92 async with self.patch_broker(consume_broker) as br:
93 await br.start()
95 with patch.object(
96 IncomingMessage,
97 "ack",
98 spy_decorator(IncomingMessage.ack),
99 ) as m:
100 await asyncio.wait(
101 (
102 asyncio.create_task(
103 br.publish("hello", queue=queue, exchange=exchange),
104 ),
105 asyncio.create_task(event.wait()),
106 ),
107 timeout=3,
108 )
109 m.mock.assert_called_once()
111 assert event.is_set()
113 @pytest.mark.asyncio()
114 async def test_consume_manual_ack(
115 self, queue: str, exchange: RabbitExchange, event: asyncio.Event
116 ) -> None:
117 consume_broker = self.get_broker(apply_types=True)
119 @consume_broker.subscriber(queue=queue, exchange=exchange)
120 async def handler(msg: RabbitMessage) -> None:
121 await msg.ack()
122 event.set()
124 async with self.patch_broker(consume_broker) as br:
125 await br.start()
127 with patch.object(
128 IncomingMessage,
129 "ack",
130 spy_decorator(IncomingMessage.ack),
131 ) as m:
132 await asyncio.wait(
133 (
134 asyncio.create_task(
135 br.publish("hello", queue=queue, exchange=exchange),
136 ),
137 asyncio.create_task(event.wait()),
138 ),
139 timeout=3,
140 )
141 m.mock.assert_called_once()
142 assert event.is_set()
144 @pytest.mark.asyncio()
145 async def test_consume_exception_ack(
146 self, queue: str, exchange: RabbitExchange, event: asyncio.Event
147 ) -> None:
148 consume_broker = self.get_broker(apply_types=True)
150 @consume_broker.subscriber(queue=queue, exchange=exchange)
151 async def handler(msg: RabbitMessage) -> None:
152 try:
153 raise AckMessage
154 finally:
155 event.set()
157 async with self.patch_broker(consume_broker) as br:
158 await br.start()
160 with patch.object(
161 IncomingMessage,
162 "ack",
163 spy_decorator(IncomingMessage.ack),
164 ) as m:
165 await asyncio.wait(
166 (
167 asyncio.create_task(
168 br.publish("hello", queue=queue, exchange=exchange),
169 ),
170 asyncio.create_task(event.wait()),
171 ),
172 timeout=3,
173 )
174 m.mock.assert_called_once()
175 assert event.is_set()
177 @pytest.mark.asyncio()
178 async def test_consume_manual_nack(
179 self, queue: str, exchange: RabbitExchange, event: asyncio.Event
180 ) -> None:
181 consume_broker = self.get_broker(apply_types=True)
183 @consume_broker.subscriber(queue=queue, exchange=exchange)
184 async def handler(msg: RabbitMessage) -> None:
185 await msg.nack()
186 event.set()
187 raise ValueError
189 async with self.patch_broker(consume_broker) as br:
190 await br.start()
192 with patch.object(
193 IncomingMessage,
194 "nack",
195 spy_decorator(IncomingMessage.nack),
196 ) as m:
197 await asyncio.wait(
198 (
199 asyncio.create_task(
200 br.publish("hello", queue=queue, exchange=exchange),
201 ),
202 asyncio.create_task(event.wait()),
203 ),
204 timeout=3,
205 )
206 m.mock.assert_called_once()
207 assert event.is_set()
209 @pytest.mark.asyncio()
210 async def test_consume_exception_nack(
211 self, queue: str, exchange: RabbitExchange, event: asyncio.Event
212 ) -> None:
213 consume_broker = self.get_broker(apply_types=True)
215 @consume_broker.subscriber(queue=queue, exchange=exchange)
216 async def handler(msg: RabbitMessage) -> None:
217 try:
218 raise NackMessage
219 finally:
220 event.set()
222 async with self.patch_broker(consume_broker) as br:
223 await br.start()
225 with patch.object(
226 IncomingMessage,
227 "nack",
228 spy_decorator(IncomingMessage.nack),
229 ) as m:
230 await asyncio.wait(
231 (
232 asyncio.create_task(
233 br.publish("hello", queue=queue, exchange=exchange),
234 ),
235 asyncio.create_task(event.wait()),
236 ),
237 timeout=3,
238 )
239 m.mock.assert_called_once()
240 assert event.is_set()
242 @pytest.mark.asyncio()
243 async def test_consume_manual_reject(
244 self, queue: str, exchange: RabbitExchange, event: asyncio.Event
245 ) -> None:
246 consume_broker = self.get_broker(apply_types=True)
248 @consume_broker.subscriber(queue=queue, exchange=exchange)
249 async def handler(msg: RabbitMessage) -> None:
250 await msg.reject()
251 event.set()
252 raise ValueError
254 async with self.patch_broker(consume_broker) as br:
255 await br.start()
257 with patch.object(
258 IncomingMessage,
259 "reject",
260 spy_decorator(IncomingMessage.reject),
261 ) as m:
262 await asyncio.wait(
263 (
264 asyncio.create_task(
265 br.publish("hello", queue=queue, exchange=exchange),
266 ),
267 asyncio.create_task(event.wait()),
268 ),
269 timeout=3,
270 )
271 m.mock.assert_called_once()
272 assert event.is_set()
274 @pytest.mark.asyncio()
275 async def test_consume_exception_reject(
276 self, queue: str, exchange: RabbitExchange, event: asyncio.Event
277 ) -> None:
278 consume_broker = self.get_broker(apply_types=True)
280 @consume_broker.subscriber(queue=queue, exchange=exchange)
281 async def handler(msg: RabbitMessage) -> None:
282 try:
283 raise RejectMessage
284 finally:
285 event.set()
287 async with self.patch_broker(consume_broker) as br:
288 await br.start()
290 with patch.object(
291 IncomingMessage,
292 "reject",
293 spy_decorator(IncomingMessage.reject),
294 ) as m:
295 await asyncio.wait(
296 (
297 asyncio.create_task(
298 br.publish("hello", queue=queue, exchange=exchange),
299 ),
300 asyncio.create_task(event.wait()),
301 ),
302 timeout=3,
303 )
304 m.mock.assert_called_once()
305 assert event.is_set()
307 @pytest.mark.asyncio()
308 async def test_consume_skip_message(self, queue: str, event: asyncio.Event) -> None:
309 consume_broker = self.get_broker(apply_types=True)
311 @consume_broker.subscriber(queue)
312 async def handler(msg: RabbitMessage) -> None:
313 try:
314 raise SkipMessage
315 finally:
316 event.set()
318 async with self.patch_broker(consume_broker) as br:
319 await br.start()
321 with (
322 patch.object(
323 IncomingMessage,
324 "reject",
325 spy_decorator(IncomingMessage.reject),
326 ) as m,
327 patch.object(
328 IncomingMessage,
329 "reject",
330 spy_decorator(IncomingMessage.reject),
331 ) as m1,
332 patch.object(
333 IncomingMessage,
334 "reject",
335 spy_decorator(IncomingMessage.reject),
336 ) as m2,
337 ):
338 await asyncio.wait(
339 (
340 asyncio.create_task(br.publish("hello", queue)),
341 asyncio.create_task(event.wait()),
342 ),
343 timeout=3,
344 )
345 assert not m.mock.called
346 assert not m1.mock.called
347 assert not m2.mock.called
349 assert event.is_set()
351 @pytest.mark.asyncio()
352 async def test_consume_no_ack(
353 self, queue: str, exchange: RabbitExchange, event: asyncio.Event
354 ) -> None:
355 consume_broker = self.get_broker(apply_types=True)
357 @consume_broker.subscriber(
358 queue,
359 exchange=exchange,
360 ack_policy=AckPolicy.MANUAL,
361 )
362 async def handler(msg: RabbitMessage) -> None:
363 event.set()
365 async with self.patch_broker(consume_broker) as br:
366 await br.start()
368 with patch.object(
369 IncomingMessage,
370 "ack",
371 spy_decorator(IncomingMessage.ack),
372 ) as m:
373 await asyncio.wait(
374 (
375 asyncio.create_task(
376 br.publish("hello", queue=queue, exchange=exchange),
377 ),
378 asyncio.create_task(event.wait()),
379 ),
380 timeout=3,
381 )
382 m.mock.assert_not_called()
384 assert event.is_set()
386 @pytest.mark.asyncio()
387 async def test_stop_leaves_new_messages_in_queue(
388 self,
389 queue: str,
390 event: asyncio.Event,
391 event2: asyncio.Event,
392 event3: asyncio.Event,
393 ) -> None:
394 consume_broker = self.get_broker(graceful_timeout=10.0)
396 subscriber = consume_broker.subscriber(queue)
398 @subscriber
399 async def handler(msg: Any) -> None:
400 event.set()
401 await event2.wait()
403 async with self.patch_broker(consume_broker) as br:
404 await br.start()
406 await br.publish("first", queue)
407 await asyncio.wait_for(event.wait(), timeout=self.timeout)
409 with (
410 patch.object(
411 RobustQueue,
412 "cancel",
413 spy_decorator(RobustQueue.cancel),
414 ) as cancel,
415 patch.object(
416 MultiLock,
417 "wait_release",
418 spy_decorator(MultiLock.wait_release),
419 ) as wait_release,
420 ):
421 wait_release.mock.side_effect = lambda *_, **__: event3.set()
423 stop_task = asyncio.create_task(subscriber.stop())
424 # "first" is still in flight when `stop` starts waiting for it,
425 # and the consumer is cancelled by then
426 await asyncio.wait_for(event3.wait(), timeout=self.timeout)
427 cancel.mock.assert_awaited_once()
429 # without a consumer, "second" stays in the queue for the other consumers
430 await br.publish("second", queue)
431 q = await br.declare_queue(RabbitQueue(queue))
432 message = await q.get(no_ack=True, fail=False)
434 event2.set()
435 await asyncio.wait_for(stop_task, timeout=self.timeout)
437 assert message is not None
438 assert message.body == b"second"
440 @pytest.mark.asyncio()
441 async def test_consume_after_stop_requeues_message(
442 self, queue: str, mock: MagicMock, event: asyncio.Event
443 ) -> None:
444 consume_broker = self.get_broker()
446 subscriber = consume_broker.subscriber(
447 queue, ack_policy=AckPolicy.REJECT_ON_ERROR
448 )
450 @subscriber
451 async def handler(msg: Any) -> None:
452 mock(msg)
454 async with self.patch_broker(consume_broker) as br:
455 await br.start()
456 # a delivery that arrives while `stop` cancels the consumer
457 subscriber.running = False
459 with patch.object(
460 IncomingMessage,
461 "reject",
462 spy_decorator(IncomingMessage.reject),
463 ) as m:
464 m.mock.side_effect = lambda *_, **__: event.set()
466 await br.publish("hello", queue)
467 await asyncio.wait_for(event.wait(), timeout=self.timeout)
469 m.mock.assert_awaited_with(ANY, requeue=True)
471 mock.assert_not_called()
473 @pytest.mark.asyncio()
474 async def test_consume_after_stop_skips_no_ack_message(
475 self, queue: str, mock: MagicMock, event: asyncio.Event
476 ) -> None:
477 consume_broker = self.get_broker()
479 subscriber = consume_broker.subscriber(queue, ack_policy=AckPolicy.ACK_FIRST)
481 @subscriber
482 async def handler(msg: Any) -> None:
483 mock(msg)
485 with patch.object(
486 RabbitSubscriber,
487 "consume",
488 spy_decorator(RabbitSubscriber.consume),
489 ) as consume:
490 consume.mock.side_effect = lambda *_, **__: event.set()
492 async with self.patch_broker(consume_broker) as br:
493 await br.start()
494 # a delivery that arrives while `stop` cancels the consumer
495 subscriber.running = False
497 with patch.object(
498 IncomingMessage,
499 "reject",
500 spy_decorator(IncomingMessage.reject),
501 ) as reject:
502 await br.publish("hello", queue)
503 await asyncio.wait_for(event.wait(), timeout=self.timeout)
505 reject.mock.assert_not_called()
507 mock.assert_not_called()