def test_method_all_with_one_rejected_promise(self):
class MyException(Exception):
pass
p1 = Promise.reject(MyException())
p = Promise.all([p1])
with pytest.raises(MyException):
p.result(0.001)
def test_method_all_with_rejected_promise(self):
class MyException(Exception):
pass
promises = [Promise.resolve(1) for _ in range(0, 5)]
promises += [Promise.reject(MyException())]
promises += [Promise.resolve(1) for _ in range(0, 5)]
p = Promise.all(promises)
with pytest.raises(MyException):
p.result()
def test_add_many_tasks(self):
"""Add 100 new tasks and wait them all."""
promises = []
def task():
yield Promise.resolve(1)
yield Promise.resolve(2)
yield Promise.resolve(3)
yield 1
with task_consumer.Context():
for i in range(40):
promises.append(task_consumer.add_task(task))
result = Promise.all(promises).result(0.1)
print(result)
assert sum(result) is 40
def test_add_concurrent_tasks(self):
"""Add three tasks who are required to run at the same time.
The task A will wait the Task B, then B will wait A.
This test "force" the tasks to be executed in a non-linear order.
"""
p1_a, r1_a, _ = self._make_external_promise()
p1_b, r1_b, _ = self._make_external_promise()
p1_c, r1_c, _ = self._make_external_promise()
p2_a, r2_a, _ = self._make_external_promise()
p2_b, r2_b, _ = self._make_external_promise()
p2_c, r2_c, _ = self._make_external_promise()
def task_A():
r1_a(None)
yield p1_b
r2_a(None)
yield p2_c
yield 'A'
def task_B():
r1_b(None)
yield p1_c
r2_b(None)
yield p2_a
yield 'B'
def task_C():
r1_c(None)
yield p1_a
r2_c(None)
yield p2_b
yield 'C'
with task_consumer.Context():
results = Promise.all([
task_consumer.add_task(task_A),
task_consumer.add_task(task_B),
task_consumer.add_task(task_C)
]).result(0.01)
assert results == list('ABC')
def test_method_all_with_async_promises(self):
promises = [Promise.resolve(1) for _ in range(0, 5)]
_resolve_callback = []
def _init(ok, _error):
_resolve_callback.append(ok)
promises.append(Promise(_init))
p = Promise.all(promises)
# The ALL promise is not yet resolved.
with pytest.raises(TimeoutError):
p.result(0)
_resolve_callback[0]('OK')
# Now, all sub-promises are resolved.
assert len(p.result(0.001)) is 6
def test_method_all_must_keep_order(self):
promises = []
_resolve_callback = []
for i in range(0, 25):
def _promise_init(ok, _error):
# Will resolve with the increment value.
local_i = i
_resolve_callback.append(lambda: ok(local_i))
promises.append(Promise(_promise_init))
# promises are ordered.
p = Promise.all(promises)
# Resolves the promises in a random order
random.shuffle(_resolve_callback)
for callback in _resolve_callback:
callback()
assert p.result(0.001) == list(range(0, 25))
def test_method_all_with_several_promises(self):
promises = [Promise.resolve(1) for _ in range(0, 20)]
p = Promise.all(promises)
assert sum(p.result()) is 20
def test_method_all_with_one_promise(self):
p1 = Promise.resolve('RESULT')
p = Promise.all([p1])
assert p.result(0.001) == ['RESULT']
def test_method_all_with_empty_set(self):
p = Promise.all([])
assert p.result(0.001) == []
