def test_failing_receiver(base_app, event_entrypoints, caplog):
"""Test failing signal receiver function."""
try:
_signals = Namespace()
my_signal = _signals.signal('my-signal')
def failing_event_builder(event, sender_app):
raise Exception('builder-exception')
base_app.config.update(
dict(STATS_EVENTS=dict(event_0=dict(
signal=my_signal, event_builders=[failing_event_builder]))))
InvenioStats(base_app)
current_queues.declare()
with caplog.at_level(logging.ERROR):
my_signal.send(base_app)
error_logs = [r for r in caplog.records if r.levelno == logging.ERROR]
assert len(error_logs) == 1
assert error_logs[0].msg == 'Error building event'
assert error_logs[0].exc_info[1].args[0] == 'builder-exception'
# Check that no event was sent to the queue
assert get_queue_size('stats-event_0') == 0
finally:
current_queues.delete()
def test_register_receivers(base_app, event_entrypoints):
"""Test signal-receiving/event-emitting functions registration."""
try:
_signals = Namespace()
my_signal = _signals.signal('my-signal')
def event_builder1(event, sender_app, signal_param, *args, **kwargs):
event.update(dict(event_param1=signal_param))
return event
def event_builder2(event, sender_app, signal_param, *args, **kwargs):
event.update(dict(event_param2=event['event_param1'] + 1))
return event
base_app.config.update(dict(
STATS_EVENTS=dict(
event_0=dict(
signal=my_signal,
event_builders=[event_builder1, event_builder2]
)
)
))
InvenioStats(base_app)
current_queues.declare()
my_signal.send(base_app, signal_param=42)
my_signal.send(base_app, signal_param=42)
events = [event for event in current_stats.consume('event_0')]
# two events should have been created from the sent events. They should
# have been both processed by the two event builders.
assert events == [{'event_param1': 42, 'event_param2': 43}] * 2
finally:
current_queues.delete()
def test_register_receivers(base_app, event_entrypoints):
"""Test signal-receiving/event-emitting functions registration."""
try:
_signals = Namespace()
my_signal = _signals.signal('my-signal')
def event_builder1(event, sender_app, signal_param, *args, **kwargs):
event.update(dict(event_param1=signal_param))
return event
def event_builder2(event, sender_app, signal_param, *args, **kwargs):
event.update(dict(event_param2=event['event_param1'] + 1))
return event
base_app.config.update(
dict(STATS_EVENTS=dict(event_0=dict(
signal=my_signal,
event_builders=[event_builder1, event_builder2]))))
InvenioStats(base_app)
current_queues.declare()
my_signal.send(base_app, signal_param=42)
my_signal.send(base_app, signal_param=42)
events = [event for event in current_stats.consume('event_0')]
# two events should have been created from the sent events. They should
# have been both processed by the two event builders.
assert events == [{'event_param1': 42, 'event_param2': 43}] * 2
finally:
current_queues.delete()
def clean_app(request, base_app):
"""Application with database and elasticsearch cleaned."""
with base_app.app_context():
try:
db.session.remove()
drop_database(db.engine.url)
except ProgrammingError:
pass
create_database(db.engine.url)
# reset elasticsearch
for deleted in current_search.delete(ignore=[404]):
pass
# reset queues
current_queues.delete()
current_queues.declare()
yield base_app
def finalize():
with base_app.app_context():
db.session.remove()
drop_database(db.engine.url)
# Dispose the engine in order to close all connections. This is
# needed for sqlite in memory databases.
db.engine.dispose()
current_queues.delete()
request.addfinalizer(finalize)
return base_app
def clean_app(request, base_app):
"""Application with database and elasticsearch cleaned."""
with base_app.app_context():
try:
db.session.remove()
drop_database(db.engine.url)
except ProgrammingError:
pass
create_database(db.engine.url)
# reset elasticsearch
for deleted in current_search.delete(ignore=[404]):
pass
# reset queues
current_queues.delete()
current_queues.declare()
yield base_app
def finalize():
with base_app.app_context():
db.session.remove()
drop_database(db.engine.url)
# Dispose the engine in order to close all connections. This is
# needed for sqlite in memory databases.
db.engine.dispose()
current_queues.delete()
request.addfinalizer(finalize)
return base_app
def test_failing_receiver(base_app, caplog):
"""Test failing signal receiver function."""
try:
_signals = Namespace()
my_signal = _signals.signal('my-signal')
def failing_event_builder(event, sender_app):
raise Exception('builder-exception')
# NOTE: event_0 already exists from the mocked events decorate further.
base_app.config['STATS_EVENTS']['event_0'].update({
'signal':
my_signal,
'event_builders': [failing_event_builder]
})
InvenioStats(base_app)
current_queues.declare()
with caplog.at_level(logging.ERROR):
my_signal.send(base_app)
error_logs = [r for r in caplog.records if r.levelno == logging.ERROR]
assert len(error_logs) == 1
assert error_logs[0].msg == 'Error building event'
assert error_logs[0].exc_info[1].args[0] == 'builder-exception'
# Check that no event was sent to the queue
assert get_queue_size('stats-event_0') == 0
finally:
current_queues.delete()
def test_list(app, test_queues):
"""Test the "list" CLI"""
with app.app_context():
# Test listing all queues
configured = [conf['name'] for conf in test_queues]
configured.sort()
deleted = configured[0:2]
declared = configured[2:]
current_queues.delete(queues=deleted)
runner = CliRunner()
script_info = ScriptInfo(create_app=lambda info: app)
result = runner.invoke(
queues, ['list'], obj=script_info)
assert result.exit_code == 0
assert result.output.split('\n')[0:-1] == configured
# Test listing only undeclared queues
result = runner.invoke(
queues, ['list', '--undeclared'], obj=script_info)
assert result.exit_code == 0
assert result.output.split('\n')[0:-1] == deleted
# Test listing only declared queues
result = runner.invoke(
queues, ['list', '--declared'], obj=script_info)
assert result.exit_code == 0
assert result.output.split('\n')[0:-1] == declared
def finalize():
with base_app.app_context():
db.session.remove()
drop_database(db.engine.url)
# Dispose the engine in order to close all connections. This is
# needed for sqlite in memory databases.
db.engine.dispose()
current_queues.delete()
def event_queues(app, event_entrypoints):
"""Delete and declare test queues."""
current_queues.delete()
try:
current_queues.declare()
yield
finally:
current_queues.delete()
def event_queues(app):
"""Delete and declare test queues."""
current_queues.delete()
try:
current_queues.declare()
yield current_queues.queues
finally:
current_queues.delete()
def finalize():
with base_app.app_context():
db.session.remove()
drop_database(db.engine.url)
# Dispose the engine in order to close all connections. This is
# needed for sqlite in memory databases.
db.engine.dispose()
current_queues.delete()
def event_queues(app):
"""Delete and declare test queues."""
current_queues.delete()
try:
current_queues.declare()
yield current_queues.queues
finally:
current_queues.delete()
def event_queues(app, event_entrypoints):
"""Delete and declare test queues."""
current_queues.delete()
try:
current_queues.declare()
yield
finally:
current_queues.delete()
def test_publish_and_consume_events(app, event_entrypoints):
"""Test that events are published and consumed properly."""
try:
event_type = 'file-download'
events = [{"payload": "test {}".format(idx)} for idx in range(3)]
current_queues.declare()
current_stats.publish(event_type, events)
assert list(current_stats.consume(event_type)) == events
finally:
current_queues.delete()
def test_event_queues_declare(app, event_entrypoints):
"""Test that event queues are declared properly."""
try:
for event in current_stats.events.values():
assert not event.queue.exists
current_queues.declare()
for event in current_stats.events.values():
assert event.queue.exists
finally:
current_queues.delete()
def test_publish_and_consume_events(app, event_entrypoints):
"""Test that events are published and consumed properly."""
try:
event_type = 'file-download'
events = [{"payload": "test {}".format(idx)} for idx in range(3)]
current_queues.declare()
current_stats.publish(event_type, events)
assert list(current_stats.consume(event_type)) == events
finally:
current_queues.delete()
def test_event_queues_declare(app, event_entrypoints):
"""Test that event queues are declared properly."""
try:
for event in current_stats.events.values():
assert not event.queue.exists
current_queues.declare()
for event in current_stats.events.values():
assert event.queue.exists
finally:
current_queues.delete()
