def test_activity_timeouts(monkeypatch, generators):
"""Test the creation of an activity timeouts.
More details: the timeout of a task is 120s, the schedule to start is 1000,
100 activities are going to be scheduled when the generator is set. The
schedule_to_start for all activities instance is: 10000 * 100 = 100k. The
schedule to close is 100k + duration of an activity (which is 120s * 2).
"""
timeout = 120
start_timeout = 1000
@task.decorate(timeout=timeout)
def local_task():
return
monkeypatch.setattr(activity.Activity, '__init__', lambda self: None)
current_activity = activity.Activity()
current_activity.hydrate(dict(schedule_to_start=start_timeout))
current_activity.generators = generators
current_activity.runner = runner.Sync(local_task.fill(), local_task.fill())
total_generators = pow(10, len(current_activity.generators))
schedule_to_start = start_timeout * total_generators
for instance in current_activity.instances({}):
assert current_activity.pool_size == total_generators
assert instance.schedule_to_start == schedule_to_start
assert instance.timeout == timeout * 2
assert instance.schedule_to_close == (schedule_to_start +
instance.timeout)
def test_aynchronous_tasks(monkeypatch):
"""Test asynchronous tasks.
"""
monkeypatch.setattr(activity.Activity, '__init__', lambda self: None)
monkeypatch.setattr(activity.Activity, 'heartbeat', lambda self: None)
tasks = [MagicMock() for i in range(5)]
tasks[2].return_value = dict(oi='mondo')
tasks[4].return_value = dict(bonjour='monde')
expected_response = dict(
list(tasks[2].return_value.items()) +
list(tasks[4].return_value.items()))
workers = 2
current_runner = runner.Async(*tasks, max_workers=workers)
assert current_runner.max_workers == workers
assert len(current_runner.tasks) == len(tasks)
current_activity = activity.Activity()
current_activity.hydrate(dict(runner=current_runner))
context = dict(hello='world')
resp = current_runner.execute(current_activity, context)
for current_task in tasks:
assert current_task.called
assert resp == expected_response
def test_instances_creation(monkeypatch, generators):
"""Test the creation of an activity instance id with the use of a local
context.
"""
monkeypatch.setattr(activity.Activity, '__init__', lambda self: None)
local_activity = activity.Activity()
external_activity = activity.ExternalActivity(timeout=60)
for current_activity in [local_activity, external_activity]:
current_activity.generators = generators
if len(current_activity.generators):
instances = list(current_activity.instances(dict()))
assert len(instances) == pow(10, len(generators))
for instance in instances:
assert isinstance(instance.local_context.get('i'), int)
if len(generators) == 2:
assert isinstance(instance.local_context.get('d'), int)
else:
instances = list(current_activity.instances(dict()))
assert len(instances) == 1
assert isinstance(instances[0].local_context, dict)
# Context is empty since no generator was used.
assert not instances[0].local_context
def test_hydrate_activity(monkeypatch, boto_client):
"""Test the hydratation of an activity.
"""
current_activity = activity.Activity(boto_client)
current_activity.hydrate(
dict(name='activity',
domain='domain',
requires=[],
on_exception=lambda actor, exception: print(exception),
tasks=[lambda: dict('val')]))
def test_hydrate_activity(monkeypatch):
"""Test the hydratation of an activity.
"""
monkeypatch.setattr(activity.Activity, '__init__', lambda self: None)
current_activity = activity.Activity()
current_activity.hydrate(
dict(name='activity',
domain='domain',
requires=[],
tasks=[lambda: dict('val')]))
def test_execute_activity(monkeypatch):
"""Test the execution of an activity.
"""
monkeypatch.setattr(activity.Activity, '__init__', lambda self: None)
resp = dict(task_resp='something')
custom_task = MagicMock(return_value=resp)
current_activity = activity.Activity()
current_activity.tasks = task.SyncTasks(custom_task)
val = current_activity.execute_activity(dict(foo='bar'))
assert custom_task.called
assert val == resp
def activity_run(monkeypatch,
poll=None,
complete=None,
fail=None,
execute=None):
"""Create an activity.
"""
monkeypatch.setattr(activity.Activity, '__init__', lambda self: None)
current_activity = activity.Activity()
poll = poll or dict()
monkeypatch.setattr(current_activity, 'execute_activity', execute
or MagicMock(return_value=dict()))
monkeypatch.setattr(current_activity, 'poll', MagicMock(return_value=poll))
monkeypatch.setattr(current_activity, 'complete', complete or MagicMock())
monkeypatch.setattr(current_activity, 'fail', fail or MagicMock())
return current_activity
def test_execute_activity(monkeypatch, boto_client):
"""Test the execution of an activity.
"""
monkeypatch.setattr(activity.ActivityExecution, 'heartbeat',
lambda self: None)
resp = dict(task_resp='something')
custom_task = MagicMock(return_value=resp)
current_activity = activity.Activity(boto_client)
current_activity.runner = runner.Sync(custom_task)
val = current_activity.execute_activity(
activity.ActivityExecution(boto_client, 'activityId', 'taskToken',
'{"context": "value"}'))
assert custom_task.called
assert val == resp
def test_synchronous_tasks(monkeypatch):
"""Test synchronous tasks.
"""
monkeypatch.setattr(activity.Activity, '__init__', lambda self: None)
monkeypatch.setattr(activity.Activity, 'heartbeat', lambda self: None)
resp = dict(foo='bar')
current_runner = runner.Sync(MagicMock(), MagicMock(return_value=resp))
current_activity = activity.Activity()
current_activity.hydrate(dict(runner=current_runner))
result = current_runner.execute(current_activity, EMPTY_CONTEXT)
assert len(current_runner.tasks) == 2
for current_task in task.flatten(current_runner.tasks, EMPTY_CONTEXT):
assert current_task.called
assert resp == result
def activity_run(monkeypatch,
boto_client,
poll=None,
complete=None,
fail=None,
execute=None):
"""Create an activity.
"""
current_activity = activity.Activity(boto_client)
poll = poll or dict()
monkeypatch.setattr(current_activity, 'execute_activity', execute
or MagicMock(return_value=dict()))
monkeypatch.setattr(boto_client, 'poll_for_activity_task',
MagicMock(return_value=poll))
monkeypatch.setattr(boto_client, 'respond_activity_task_completed',
complete or MagicMock())
monkeypatch.setattr(boto_client, 'respond_activity_task_failed', fail
or MagicMock())
return current_activity
