async def test_simple(event_loop, caplog):
"""Send message to output backend and check no errors happens.
"""
backend = QueueBackend()
await backend.connect()
output_queue = await backend.output_queue('example_event', 'sns')
router = Router(output_pipeline=example_pipeline)
queue = await backend.messages_queue('example_event')
consumer = MessageConsumer(event_type='example_event',
router=router,
output_queue=output_queue,
queue=queue,
loop=event_loop)
await consumer.start()
message = Message(event_type='example_event', event_id='1')
await queue.publish(message.to_dict())
await wait_messages(consumer)
await consumer.stop()
await backend.close()
assert not has_log_message(caplog, level='ERROR')
def test_failing_action():
"""Test that failing output properly handled.
"""
message = Message(id='test_send_simple', event_type="test_event")
effect = SendEffect(FailingOutput())
with pytest.raises(Exception):
effect.apply(message)
async def test_simple(event_loop, caplog):
backend = QueueBackend()
await backend.connect()
messages_queue = await backend.messages_queue('example_event')
consumer = GenerationConsumer(
messages_queue=messages_queue, loop=event_loop,
cleanup_timeout=0
)
await consumer.start()
queue = await backend.generation_queue(name='example_queue')
consumer.consume(queue)
queue2 = await backend.generation_queue(name='example_queue2')
consumer.consume(queue2)
event = Event('example_event')
message = Message(event_type=event.type, event_id=event.id)
await send_test_message(
backend.connection,
queue_name=queue.name,
body=message.to_dict()
)
await wait_messages(consumer)
# TODO: replace with a separate and specific test (tmp queue deletion)
# wait tmp queue deletion
await asyncio.sleep(0.1)
await consumer.stop()
await backend.close()
assert not has_log_message(caplog, level='ERROR')
def test_string_configuration():
"""Test string output pipeline configuration allowed.
"""
message = Message(event_id='test_sequence', event_type='example_event')
router = Router(
output_pipeline='aiomessaging.contrib.dummy.pipelines.simple_pipeline'
)
router.get_pipeline(message)
def test_send_simple():
"""Check that SendEffect returns provided output.
"""
effect = SendEffect(NullOutput())
message = Message(id='test_send_simple', event_type="test_event")
assert isinstance(effect.next_action(), SendOutputAction)
state = effect.apply(message)
assert effect.next_action(state) is None
def test_string_list_init():
"""Test pipeline initialization from string (class) list.
"""
message = Message(event_id='test_sequence', event_type='example_event')
router = Router(['aiomessaging.contrib.dummy.NullOutput'])
pipeline = router.get_pipeline(message)
effect = pipeline.send(None)
action = effect.next_action()
assert isinstance(action, SendOutputAction)
assert isinstance(action.output, NullOutput)
def test_next_action(caplog):
message = Message(id='test_send_simple', event_type="test_event")
effect = SendEffect(CheckOutput())
state = effect.apply(message)
assert state == [OutputStatus.CHECK]
message.set_route_state(effect, state)
action = effect.next_action(state)
assert isinstance(action, CheckOutputAction)
state = effect.apply(message)
assert state == [OutputStatus.SUCCESS]
def test_simple_pipeline():
"""Test router constructor and simple pipeline
"""
router = Router(output_pipeline=simple_pipeline)
message = Message(event_id='test_simple', event_type='example_event')
effect = router.next_effect(message)
assert isinstance(effect, SendEffect)
router.apply_next_effect(message)
assert message.route
assert isinstance(message.route[0], Route)
assert message.route[0].effect == effect
def test_sequence_send():
"""Test sequence pipeline flow.
"""
router = Router(output_pipeline=sequence_pipeline)
message = Message(event_id='test_sequence', event_type='example_event')
effect = router.next_effect(message)
assert isinstance(effect, SendEffect)
assert effect.next_action().get_output().kwargs == {'test_arg': 2}
router.apply_next_effect(message)
assert message.route
assert isinstance(message.route[0], Route)
assert message.route[0].status == EffectStatus.FINISHED
effect = router.next_effect(message)
assert isinstance(effect, SendEffect)
assert effect.next_action().get_output().kwargs == {'test_arg': 1}
router.apply_next_effect(message)
assert router.next_effect(message) is None
async def test_any_output_available(event_loop, caplog):
backend = QueueBackend()
await backend.connect()
output_queue = await backend.output_queue('example_event', 'sns')
router = Router(output_pipeline=example_pipeline)
queue = await backend.messages_queue('example_event')
consumer = MessageConsumer(event_type='example_event',
router=router,
output_queue=output_queue,
queue=queue,
loop=event_loop)
await consumer.start()
message = Message(event_type='example_event', event_id='1')
await queue.publish(message.to_dict())
await wait_messages(consumer)
await consumer.stop()
await backend.close()
# Skip output logs
assert log_count(caplog, level='ERROR') == 0
def test_never_delivered():
"""Test send through NeverDeliveredOutput
"""
message = Message(id='test_send_simple', event_type="test_event")
effect = SendEffect(NeverDeliveredOutput())
effect.apply(message)