async def test_load_json(mocker, event_loop):
# arrange
message1 = Message(
body='{"hello": "world"}',
channel=mocker.sentinel.channel,
envelope=mocker.sentinel.envelope,
properties=mocker.sentinel.properties,
)
message2 = Message(
body='invalid json',
channel=mocker.sentinel.channel,
envelope=mocker.sentinel.envelope,
properties=mocker.sentinel.properties,
)
mocker.patch.object(message2, 'reject', return_value=future())
inp = make_iterator([message1, message2])
# act
out = load_json.func(inp, event_loop)
# assert
result = await collect_iterator(out)
message_arg = Arg()
assert result == [message_arg]
assert message_arg.value.body == {'hello': 'world'}
message2.reject.assert_called_once_with(requeue=False)
async def test_run__func_raised_exception__reject_all_messages(
self, mocker):
# arrange
message1 = Message(
body='message1',
channel=mocker.sentinel.channel,
envelope=mocker.sentinel.envelope,
properties=mocker.sentinel.properties,
)
mocker.patch.object(message1, 'reject', return_value=future())
message2 = Message(
body='message2',
channel=mocker.sentinel.channel,
envelope=mocker.sentinel.envelope,
properties=mocker.sentinel.properties,
)
mocker.patch.object(
message2,
'reject',
return_value=future(exception=MessageAlreadyResolved()))
middleware = ProcessBulk(
lambda messages: future(exception=Exception()))
inp = make_iterator([[message1, message2]])
# act
out = middleware(inp)
# assert
assert await collect_iterator(out) == [None]
message1.reject.assert_called_once_with()
message2.reject.assert_called_once_with()
async def test__call__(self):
# arrange
middleware = _FromCallable(self._foo)
inp = make_iterator([1, 2])
# act
out = middleware(inp)
# assert
assert await collect_iterator(out) == [2, 3]
async def test__call__(self):
# arrange
middleware = SkipAll()
inp = make_iterator([1, 2, 3])
# act
out = middleware(inp)
# assert
assert await collect_iterator(out) == []
async def test__call__(self):
# arrange
middleware = FilterNones()
inp = make_iterator([1, None, 3])
# act
out = middleware(inp)
# assert
assert await collect_iterator(out) == [1, 3]
async def test__call__(self):
# arrange
middleware = Map(self._func)
inp = make_iterator([1, 2, 3, 4, 5])
# act
out = middleware(inp)
# assert
assert await collect_iterator(out) == [2, 3, 4, 5, 6]
async def test__call__(self):
# arrange
middleware = Filter(self._predicate)
inp = make_iterator([1, 2, 3, 4, 5])
# act
out = middleware(inp)
# assert
assert await collect_iterator(out) == [2, 4]
async def test__call__(self, mocker):
# arrange
mid1 = mocker.Mock(spec=Middleware, return_value=mocker.sentinel.it1)
mid2 = mocker.Mock(spec=Middleware,
return_value=make_iterator([mocker.sentinel.item]))
middleware = _Composition(mid1, mid2)
# act
out = middleware(mocker.sentinel.inp)
# assert
assert await collect_iterator(out) == [mocker.sentinel.item]
mid1.assert_called_once_with(mocker.sentinel.inp)
mid2.assert_called_once_with(mocker.sentinel.it1)
async def test_run__callback_cancelled__should_cancel(self, mocker):
# arrange
message = Message(
body='message',
channel=mocker.sentinel.channel,
envelope=mocker.sentinel.envelope,
properties=mocker.sentinel.properties,
)
inp = make_iterator([message])
middleware = Process(
lambda _: future(exception=asyncio.CancelledError()))
# act
with pytest.raises(asyncio.CancelledError):
await collect_iterator(middleware(inp))
async def test_run__success__ack_message(self, mocker, ack_result):
# arrange
message = Message(
body='message',
channel=mocker.sentinel.channel,
envelope=mocker.sentinel.envelope,
properties=mocker.sentinel.properties,
)
mocker.patch.object(message, 'ack', return_value=ack_result)
inp = make_iterator([message])
middleware = Process(lambda _: future(None))
# act
out = middleware(inp)
# assert
assert await collect_iterator(out) == [None]
message.ack.assert_called_once_with()
async def test_run__callback_raised_exception__reject_message(
self, mocker, reject_result):
# arrange
message = Message(
body='message',
channel=mocker.sentinel.channel,
envelope=mocker.sentinel.envelope,
properties=mocker.sentinel.properties,
)
mocker.patch.object(message, 'reject', return_value=reject_result)
inp = make_iterator([message])
middleware = Process(lambda _: future(exception=Exception()))
# act
out = middleware(inp)
# assert
assert await collect_iterator(out) == [None]
message.reject.assert_called_once_with()
async def test__process_queue(self, mocker, event_loop):
# arrange
consumer = Consumer(
middleware=Process(lambda _: future(None)),
queue=Queue('queue_name'),
connection_params=[mocker.sentinel.connection_params],
prefetch_count=mocker.sentinel.prefetch_count,
default_reconnect_timeout=3.0,
max_reconnect_timeout=5.0,
tag='tag',
)
consumer._middleware = mocker.Mock(spec=Middleware)
consumer._middleware.return_value = make_iterator([])
consumer._channel = mocker.Mock(spec=Channel)
consumer._channel.basic_consume.return_value = future()
queue_to_iterator_mock = mocker.patch(
'aioamqp_consumer_best.consumer.queue_to_iterator',
autospec=True,
return_value=mocker.sentinel.inp,
)
Message = mocker.patch('aioamqp_consumer_best.consumer.Message')
# act
await consumer._process_queue(loop=event_loop)
# assert
callback_arg = Arg()
consumer._channel.basic_consume.assert_called_once_with(
callback=callback_arg,
queue_name='queue_name',
consumer_tag='tag',
)
arg = Arg()
queue_to_iterator_mock.assert_called_once_with(arg)
input_queue = arg.value
assert isinstance(input_queue, asyncio.Queue)
consumer._middleware.assert_called_once_with(
inp=mocker.sentinel.inp,
loop=event_loop,
)
await callback_arg.value(
channel=mocker.sentinel.channel,
body=mocker.sentinel.body,
envelope=mocker.sentinel.envelope,
properties=mocker.sentinel.properties,
)
message = input_queue.get_nowait()
assert message is Message.return_value
Message.assert_called_once_with(
channel=mocker.sentinel.channel,
body=mocker.sentinel.body,
envelope=mocker.sentinel.envelope,
properties=mocker.sentinel.properties,
)
