def test_3_2_6_3_when_fulfilled():
"""
Testing return of pending promises to make
sure they are properly chained.
This covers the case where the root promise
is fulfilled after the chaining is defined.
"""
p1 = Promise()
pending = Promise()
pf = p1.then(lambda r: pending)
assert pending.is_pending
assert pf.is_pending
p1.fulfill(10)
pending.fulfill(5)
pending.wait()
assert pending.is_fulfilled
assert 5 == pending.get()
pf.wait()
assert pf.is_fulfilled
assert 5 == pf.get()
p2 = Promise()
bad = Promise()
pr = p2.then(lambda r: bad)
assert bad.is_pending
assert pr.is_pending
p2.fulfill(10)
bad.reject(Exception("Error"))
bad.wait()
assert bad.is_rejected
assert_exception(bad.reason, Exception, "Error")
pr.wait()
assert pr.is_rejected
assert_exception(pr.reason, Exception, "Error")
def test_3_2_6_3_if_rejected():
"""
Testing return of pending promises to make
sure they are properly chained.
This covers the case where the root promise
is rejected before the chaining is defined.
"""
p1 = Promise()
p1.reject(Exception("Error"))
pending = Promise()
pending.fulfill(10)
pr = p1.then(None, lambda r: pending)
pending.wait()
assert pending.is_fulfilled
assert 10 == pending.get()
pr.wait()
assert pr.is_fulfilled
assert 10 == pr.get()
p2 = Promise()
p2.reject(Exception("Error"))
bad = Promise()
bad.reject(Exception("Assertion"))
pr = p2.then(None, lambda r: bad)
bad.wait()
assert bad.is_rejected
assert_exception(bad.reason, Exception, "Assertion")
pr.wait()
assert pr.is_rejected
assert_exception(pr.reason, Exception, "Assertion")
def test_done():
counter = [0]
r = Promise()
def inc(_):
counter[0] += 1
def dec(_):
counter[0] -= 1
def end(_):
r.do_resolve(None)
p = Promise()
p.done(inc, dec)
p.done(inc, dec)
p.done(end)
p.do_resolve(4)
Promise.wait(r)
assert counter[0] == 2
r = Promise()
counter = [0]
p = Promise()
p.done(inc, dec)
p.done(inc, dec)
p.done(None, end)
p.do_reject(Exception())
Promise.wait(r)
assert counter[0] == -2
def test_done():
counter = [0]
r = Promise()
def inc(_):
counter[0] += 1
def dec(_):
counter[0] -= 1
def end(_):
r.do_resolve(None)
p = Promise()
p.done(inc, dec)
p.done(inc, dec)
p.done(end)
p.do_resolve(4)
Promise.wait(r)
assert counter[0] == 2
r = Promise()
counter = [0]
p = Promise()
p.done(inc, dec)
p.done(inc, dec)
p.done(None, end)
p.do_reject(Exception())
Promise.wait(r)
assert counter[0] == -2
def test_promise_resolved_after():
"""
The first argument to 'then' must be called when a promise is
fulfilled.
"""
c = Counter()
def check(v, c):
assert v == 5
c.tick()
p1 = Promise()
p2 = p1.then(lambda v: check(v, c))
p1.do_resolve(5)
Promise.wait(p2)
assert 1 == c.value()
def test_done_all():
counter = [0]
def inc(_):
counter[0] += 1
def dec(_):
counter[0] -= 1
p = Promise()
r = Promise()
p.done_all()
p.done_all([(inc, dec)])
p.done_all([
(inc, dec),
(inc, dec),
{
'success': inc,
'failure': dec
},
lambda _: r.do_resolve(None)
])
p.do_resolve(4)
Promise.wait(r)
assert counter[0] == 4
p = Promise()
r = Promise()
p.done_all()
p.done_all([inc])
p.done_all([(inc, dec)])
p.done_all([
(inc, dec),
{
'success': inc,
'failure': dec
},
(None, lambda _: r.do_resolve(None))
])
p.do_reject(Exception("Uh oh!"))
Promise.wait(r)
assert counter[0] == 1
def test_done_all():
counter = [0]
def inc(_):
counter[0] += 1
def dec(_):
counter[0] -= 1
p = Promise()
r = Promise()
p.done_all()
p.done_all([(inc, dec)])
p.done_all(
[
(inc, dec),
(inc, dec),
{"success": inc, "failure": dec},
lambda _: r.do_resolve(None),
]
)
p.do_resolve(4)
Promise.wait(r)
assert counter[0] == 4
p = Promise()
r = Promise()
p.done_all()
p.done_all([inc])
p.done_all([(inc, dec)])
p.done_all(
[
(inc, dec),
{"success": inc, "failure": dec},
(None, lambda _: r.do_resolve(None)),
]
)
p.do_reject(Exception("Uh oh!"))
Promise.wait(r)
assert counter[0] == 1
def create_promise(): # unnecessary function call
p = Promise(do_resolve)
p.wait()
return p
def test_wait_if():
p1 = Promise()
p1.fulfill(5)
p1.wait()
assert p1.is_fulfilled
def test_wait_if():
p1 = Promise()
p1.fulfill(5)
p1.wait()
assert p1.is_fulfilled
