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

1import asyncio 

2from typing import Any 

3from unittest.mock import ANY, MagicMock, patch 

4 

5import pytest 

6from aio_pika import IncomingMessage, Message, RobustQueue 

7from aiormq.abc import ConfirmationFrameType 

8 

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 

17 

18from .basic import RabbitTestcaseConfig 

19 

20 

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() 

29 

30 @consume_broker.subscriber(queue=queue, exchange=exchange) 

31 def h(m: Any) -> None: 

32 event.set() 

33 

34 async with self.patch_broker(consume_broker) as br: 

35 await br.start() 

36 

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] 

43 

44 assert event.is_set() 

45 

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() 

51 

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() 

58 

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) 

63 

64 await br.start() 

65 

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 ) 

79 

80 assert event.is_set() 

81 

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) 

87 

88 @consume_broker.subscriber(queue=queue, exchange=exchange) 

89 async def handler(msg: RabbitMessage) -> None: 

90 event.set() 

91 

92 async with self.patch_broker(consume_broker) as br: 

93 await br.start() 

94 

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() 

110 

111 assert event.is_set() 

112 

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) 

118 

119 @consume_broker.subscriber(queue=queue, exchange=exchange) 

120 async def handler(msg: RabbitMessage) -> None: 

121 await msg.ack() 

122 event.set() 

123 

124 async with self.patch_broker(consume_broker) as br: 

125 await br.start() 

126 

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() 

143 

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) 

149 

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() 

156 

157 async with self.patch_broker(consume_broker) as br: 

158 await br.start() 

159 

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() 

176 

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) 

182 

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 

188 

189 async with self.patch_broker(consume_broker) as br: 

190 await br.start() 

191 

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() 

208 

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) 

214 

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() 

221 

222 async with self.patch_broker(consume_broker) as br: 

223 await br.start() 

224 

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() 

241 

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) 

247 

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 

253 

254 async with self.patch_broker(consume_broker) as br: 

255 await br.start() 

256 

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() 

273 

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) 

279 

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() 

286 

287 async with self.patch_broker(consume_broker) as br: 

288 await br.start() 

289 

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() 

306 

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) 

310 

311 @consume_broker.subscriber(queue) 

312 async def handler(msg: RabbitMessage) -> None: 

313 try: 

314 raise SkipMessage 

315 finally: 

316 event.set() 

317 

318 async with self.patch_broker(consume_broker) as br: 

319 await br.start() 

320 

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 

348 

349 assert event.is_set() 

350 

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) 

356 

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() 

364 

365 async with self.patch_broker(consume_broker) as br: 

366 await br.start() 

367 

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() 

383 

384 assert event.is_set() 

385 

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) 

395 

396 subscriber = consume_broker.subscriber(queue) 

397 

398 @subscriber 

399 async def handler(msg: Any) -> None: 

400 event.set() 

401 await event2.wait() 

402 

403 async with self.patch_broker(consume_broker) as br: 

404 await br.start() 

405 

406 await br.publish("first", queue) 

407 await asyncio.wait_for(event.wait(), timeout=self.timeout) 

408 

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() 

422 

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() 

428 

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) 

433 

434 event2.set() 

435 await asyncio.wait_for(stop_task, timeout=self.timeout) 

436 

437 assert message is not None 

438 assert message.body == b"second" 

439 

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() 

445 

446 subscriber = consume_broker.subscriber( 

447 queue, ack_policy=AckPolicy.REJECT_ON_ERROR 

448 ) 

449 

450 @subscriber 

451 async def handler(msg: Any) -> None: 

452 mock(msg) 

453 

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 

458 

459 with patch.object( 

460 IncomingMessage, 

461 "reject", 

462 spy_decorator(IncomingMessage.reject), 

463 ) as m: 

464 m.mock.side_effect = lambda *_, **__: event.set() 

465 

466 await br.publish("hello", queue) 

467 await asyncio.wait_for(event.wait(), timeout=self.timeout) 

468 

469 m.mock.assert_awaited_with(ANY, requeue=True) 

470 

471 mock.assert_not_called() 

472 

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() 

478 

479 subscriber = consume_broker.subscriber(queue, ack_policy=AckPolicy.ACK_FIRST) 

480 

481 @subscriber 

482 async def handler(msg: Any) -> None: 

483 mock(msg) 

484 

485 with patch.object( 

486 RabbitSubscriber, 

487 "consume", 

488 spy_decorator(RabbitSubscriber.consume), 

489 ) as consume: 

490 consume.mock.side_effect = lambda *_, **__: event.set() 

491 

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 

496 

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) 

504 

505 reject.mock.assert_not_called() 

506 

507 mock.assert_not_called()