def test_message_acknowledgement_original_message(event_loop, coroutine,
cancelled_future, queue):
"""Test that original message is acknowledged."""
actual = ''
expected = 'original'
queue.put_nowait(expected)
app = Application('testing', callback=coroutine)
@app.message_preprocessor
@asyncio.coroutine
def preprocess(app, message):
return 'changed'
@app.message_acknowledgement
@asyncio.coroutine
def acknowledge(app, message):
nonlocal actual
actual = message
event_loop.run_until_complete(
app._process(cancelled_future, queue, event_loop))
assert actual == expected
def test_abort_callback(event_loop, cancelled_future, queue):
"""Test that aborted callbacks stop execution."""
# This test sets up a callback and a postprocessor. The callback
# will raise an Abort exception. The postprocessor shouldn't be
# called.
callback_called = False
postprocess_called = False
queue.put_nowait({'a': 1})
async def callback(app, message):
nonlocal callback_called
callback_called = True
raise exceptions.Abort('testing', message)
app = Application('testing', callback=callback)
@app.result_postprocessor
async def postprocess(app, result):
nonlocal postprocess_called
postprocess_called = True
return result
event_loop.run_until_complete(
app._process(cancelled_future, queue, event_loop))
assert callback_called
assert not postprocess_called
def test_abort_error(event_loop, cancelled_future, queue):
"""Test that aborted error callbacks stop execution."""
# This test sets up a callback and two error callbacks. The callback
# will raise an exception and the first error callback will an raise
# Abort exception. The second error callback shouldn't be called.
callback_called = False
error1_called = False
error2_called = False
queue.put_nowait({'a': 1})
async def callback(app, message):
nonlocal callback_called
callback_called = True
raise TypeError('testing')
app = Application('testing', callback=callback)
@app.error
async def error1(app, message, exc):
nonlocal error1_called
error1_called = True
raise exceptions.Abort('testing', message)
@app.error
async def error2(app, message, exc):
nonlocal error2_called
error2_called = True
event_loop.run_until_complete(
app._process(cancelled_future, queue, event_loop))
assert callback_called
assert error1_called
assert not error2_called
def test_abort_postprocess(event_loop, cancelled_future, queue):
"""Test that aborted postprocessors stop execution of the result."""
# This test sets up a callback and two postprocessors. The first
# will raise an Abort exception for one of the two results returned
# by the callback.
postprocess1_called_count = 0
postprocess2_called_count = 0
queue.put_nowait({'a': 1})
async def callback(app, message):
return [True, False]
app = Application('testing', callback=callback)
@app.result_postprocessor
async def postprocess1(app, result):
nonlocal postprocess1_called_count
postprocess1_called_count += 1
if result:
raise exceptions.Abort('testing', result)
return result
@app.result_postprocessor
async def postprocess2(app, result):
nonlocal postprocess2_called_count
postprocess2_called_count += 1
return result
event_loop.run_until_complete(
app._process(cancelled_future, queue, event_loop))
assert postprocess1_called_count == 2
assert postprocess2_called_count == 1
def test_abort_callback(event_loop, cancelled_future, queue):
"""Test that aborted callbacks stop execution."""
# This test sets up a callback and a postprocessor. The callback
# will raise an Abort exception. The postprocessor shouldn't be
# called.
callback_called = False
postprocess_called = False
queue.put_nowait({'a': 1})
@asyncio.coroutine
def callback(app, message):
nonlocal callback_called
callback_called = True
raise exceptions.Abort('testing', message)
app = Application('testing', callback=callback)
@app.result_postprocessor
@asyncio.coroutine
def postprocess(app, result):
nonlocal postprocess_called
postprocess_called = True
return result
event_loop.run_until_complete(
app._process(cancelled_future, queue, event_loop))
assert callback_called
assert not postprocess_called
def test_abort_preprocessor(event_loop, cancelled_future, queue):
"""Test that aborted preprocessors stop execution."""
# This test sets up two preprocessors, a callback, and a
# postprocessor. The first preprocessor will raise an Abort
# exception. None of the others should be called.
preprocess1_called = False
preprocess2_called = False
callback_called = False
postprocess_called = False
queue.put_nowait({'a': 1})
@asyncio.coroutine
def callback(app, message):
nonlocal callback_called
callback_called = True
return message
app = Application('testing', callback=callback)
@app.message_preprocessor
@asyncio.coroutine
def preprocess1(app, message):
nonlocal preprocess1_called
preprocess1_called = True
raise exceptions.Abort('testing', message)
@app.message_preprocessor
@asyncio.coroutine
def preprocess2(app, message):
nonlocal preprocess2_called
preprocess2_called = True
return message
@app.result_postprocessor
@asyncio.coroutine
def postprocess(app, result):
nonlocal postprocess_called
postprocess_called = True
return result
event_loop.run_until_complete(
app._process(cancelled_future, queue, event_loop))
assert preprocess1_called
assert not preprocess2_called
assert not callback_called
assert not postprocess_called
def test_abort_error(event_loop, cancelled_future, queue):
"""Test that aborted error callbacks stop execution."""
# This test sets up a callback and two error callbacks. The callback
# will raise an exception and the first error callback will an raise
# Abort exception. The second error callback shouldn't be called.
callback_called = False
error1_called = False
error2_called = False
queue.put_nowait({'a': 1})
@asyncio.coroutine
def callback(app, message):
nonlocal callback_called
callback_called = True
raise TypeError('testing')
app = Application('testing', callback=callback)
@app.error
@asyncio.coroutine
def error1(app, message, exc):
nonlocal error1_called
error1_called = True
raise exceptions.Abort('testing', message)
@app.error
@asyncio.coroutine
def error2(app, message, exc):
nonlocal error2_called
error2_called = True
event_loop.run_until_complete(
app._process(cancelled_future, queue, event_loop))
assert callback_called
assert error1_called
assert not error2_called
def test_abort_postprocess(event_loop, cancelled_future, queue):
"""Test that aborted postprocessors stop execution of the result."""
# This test sets up a callback and two postprocessors. The first
# will raise an Abort exception for one of the two results returned
# by the callback.
postprocess1_called_count = 0
postprocess2_called_count = 0
queue.put_nowait({'a': 1})
@asyncio.coroutine
def callback(app, message):
return [True, False]
app = Application('testing', callback=callback)
@app.result_postprocessor
@asyncio.coroutine
def postprocess1(app, result):
nonlocal postprocess1_called_count
postprocess1_called_count += 1
if result:
raise exceptions.Abort('testing', result)
return result
@app.result_postprocessor
@asyncio.coroutine
def postprocess2(app, result):
nonlocal postprocess2_called_count
postprocess2_called_count += 1
return result
event_loop.run_until_complete(
app._process(cancelled_future, queue, event_loop))
assert postprocess1_called_count == 2
assert postprocess2_called_count == 1
