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.do_reject(Exception("Error"))
pending = Promise()
pending.do_resolve(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.do_reject(Exception("Error"))
bad = Promise()
bad.do_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_3_2_6_3_if_fulfilled():
"""
Testing return of pending promises to make
sure they are properly chained.
This covers the case where the root promise
is fulfilled before the chaining is defined.
"""
p1 = Promise()
p1.do_resolve(10)
pending = Promise()
pending.do_resolve(5)
pf = p1.then(lambda r: pending)
pending._wait()
assert pending.is_fulfilled
assert 5 == pending.get()
pf._wait()
assert pf.is_fulfilled
assert 5 == pf.get()
p2 = Promise()
p2.do_resolve(10)
bad = Promise()
bad.do_reject(Exception("Error"))
pr = p2.then(lambda r: bad)
bad._wait()
assert_exception(bad.reason, Exception, "Error")
pr._wait()
assert pr.is_rejected
assert_exception(pr.reason, Exception, "Error")
def test_3_2_6_3_when_rejected():
"""
Testing return of pending promises to make
sure they are properly chained.
This covers the case where the root promise
is rejected after the chaining is defined.
"""
p1 = Promise()
pending = Promise()
pr = p1.then(None, lambda r: pending)
assert pending.is_pending
assert pr.is_pending
p1.do_reject(Exception("Error"))
pending.do_resolve(10)
pending._wait()
assert pending.is_fulfilled
assert 10 == pending.get()
assert 10 == pr.get()
p2 = Promise()
bad = Promise()
pr = p2.then(None, lambda r: bad)
assert bad.is_pending
assert pr.is_pending
p2.do_reject(Exception("Error"))
bad.do_reject(Exception("Assertion"))
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_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)
assert pending.is_fulfilled
assert 5 == pending.value
assert pf.is_fulfilled
assert 5 == pf.value
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"))
assert bad.is_rejected
assert_exception(bad.reason, Exception, "Error")
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)
assert pending.is_fulfilled
assert 10 == pending.value
assert pr.is_fulfilled
assert 10 == pr.value
p2 = Promise()
p2.reject(Exception("Error"))
bad = Promise()
bad.reject(Exception("Assertion"))
pr = p2.then(None, lambda r: bad)
assert bad.is_rejected
assert_exception(bad.reason, Exception, "Assertion")
assert pr.is_rejected
assert_exception(pr.reason, Exception, "Assertion")
def add_task(self, func, *args, **kargs):
""" Add a task to the queue """
print("adding task to queue")
p = Promise(lambda resolve, reject: self.tasks.put(
(resolve, reject, func, args, kargs)))
# set a post task
p.then(lambda res: self.remove_worker(self._find_workers_to_remove()),
lambda res: self.remove_worker(self._find_workers_to_remove()))
return p
def test_3_2_1():
"""
Test that the arguments to 'then' are optional.
"""
p1 = Promise()
p2 = p1.then()
p3 = Promise()
p4 = p3.then()
p1.do_resolve(5)
p3.do_reject(Exception("How dare you!"))
def test_3_2_1():
"""
Test that the arguments to 'then' are optional.
"""
p1 = Promise()
p2 = p1.then()
p3 = Promise()
p4 = p3.then()
p1.fulfill(5)
p3.reject(Exception("How dare you!"))
def test_exceptions():
def throws(v):
assert False
p1 = Promise()
p1.then(throws)
p1.do_resolve(5)
p2 = Promise()
p2.catch(throws)
p2.do_reject(Exception())
with raises(Exception) as excinfo:
p2.get()
def test_exceptions():
def throws(v):
assert False
p1 = Promise()
p1.then(throws)
p1.do_resolve(5)
p2 = Promise()
p2.catch(throws)
p2.do_reject(Exception())
with raises(Exception) as excinfo:
p2.get()
class PromiseTest(unittest.TestCase):
def setUp(self):
self.promise = Promise()
def testOnFulfilledCallback(self): # 2.2.2.1
self.called_ = False
def resolveCallback(val):
self.called_ = True
self.assertEqual(10, val)
self.promise.then(resolveCallback)
self.promise.resolve(10)
def testResolveCannotBeCalledTwice(self): # 2.2.2.2/2.2.2.3
self.promise.resolve(10)
with self.assertRaises(PromiseException):
self.promise.resolve(10)
def testOnRejectedCallback(self): # 2.2.3.1
self.called_ = False
def rejectCallback(error):
self.called_ = True
self.assertIsInstance(error, Exception)
self.promise.then(lambda _: _, rejectCallback)
self.promise.reject(Exception('test'))
def testRejectCannotBeCalledTwice(self): # 2.2.3.2/2.2.3.3
self.promise.reject(Exception('test'))
with self.assertRaises(PromiseException):
self.promise.reject(Exception('test'))
def testFulfilledCallbacksOrder(self): # 2.2.6.1
self.index = 0
def callback1():
self.index += 1
self.assertEqual(self.index, 1)
def callback2():
self.index += 1
self.assertEqual(self.index, 2)
self.promise.resolve(10)
def testRejectedCallbacksOrder(self): # 2.2.6.2
pass
def test_issue_26():
context = {"success": False}
promise1 = Promise(
lambda resolve, reject: context.update({"promise1_reject": reject}))
promise1.then(lambda x: None)
promise1.then(lambda x: None)
context["promise1_reject"](RuntimeError("Ooops!"))
promise2 = Promise(
lambda resolve, reject: context.update({"promise2_resolve": resolve}))
promise3 = promise2.then(lambda x: context.update({"success": True}))
context["promise2_resolve"](None)
# We wait so it works in asynchronous envs
promise3._wait(timeout=.1)
assert context["success"]
def testNonFunction(nonFunction):
def foo(k, r):
results[k] = r
p1 = Promise()
p2 = p1.then(lambda r: foo(str(nonFunction), r), nonFunction)
p1.fulfill("Error: " + str(nonFunction))
def test_3_2_6_1():
"""
Promises returned by then must be fulfilled when the promise
they are chained from is fulfilled IF the fulfillment value
is not a promise.
"""
p1 = Promise()
pf = p1.then(lambda v: v * v)
p1.fulfill(5)
assert pf.value == 25
p2 = Promise()
pr = p2.then(None, lambda r: 5)
p2.reject(Exception("Error"))
assert 5 == pr.value
def test_catch():
p1 = Promise(lambda resolve, reject: resolve(0))
p2 = p1.then(lambda value: 1 / value) \
.catch(lambda e: e) \
.then(lambda e: type(e))
assert p2.is_fulfilled
assert p2.value == ZeroDivisionError
def testNonFunction(nonFunction):
def foo(k, r):
results[k] = r
p1 = Promise()
p2 = p1.then(nonFunction, lambda r: foo(str(nonFunction), r))
p1.reject(Exception("Error: " + str(nonFunction)))
def test_catch():
p1 = Promise(lambda resolve, reject: resolve(0))
p2 = p1.then(lambda value: 1 / value) \
.catch(lambda e: e) \
.then(lambda e: type(e))
assert p2.get() == ZeroDivisionError
assert p2.is_fulfilled
def test_chain_with_promise(self):
def worker_async(resolve_fn):
sublime.set_timeout_async(lambda: resolve_fn(999), 100)
def worker_async2(resolve_fn):
sublime.set_timeout_async(lambda: resolve_fn(888), 100)
def callback(async_value):
self.assertEqual(async_value, 999)
return Promise(worker_async2)
def verify_async2_value(value):
self.assertEqual(value, 888)
promise = Promise(worker_async)
self.assertFalse(promise._is_resolved())
promise2 = promise.then(callback)
self.assertFalse(promise2._is_resolved())
promise2.then(verify_async2_value)
# Let both promises resolve.
time.sleep(0.500)
self.assertTrue(promise._is_resolved())
self.assertEqual(promise._get_value(), 999)
self.assertTrue(promise2._is_resolved())
self.assertEqual(promise2._get_value(), 888)
def test_issue_26():
context = {"success": False}
promise1 = Promise(
lambda resolve, reject: context.update({"promise1_reject": reject})
)
promise1.then(lambda x: None)
promise1.then(lambda x: None)
context["promise1_reject"](RuntimeError("Ooops!"))
promise2 = Promise(
lambda resolve, reject: context.update({"promise2_resolve": resolve})
)
promise3 = promise2.then(lambda x: context.update({"success": True}))
context["promise2_resolve"](None)
# We wait so it works in asynchronous envs
promise3._wait(timeout=.1)
assert context["success"]
def test_3_2_6_4_fulfilled():
"""
Handles the case where the arguments to then
are values, not functions or promises.
"""
p1 = Promise()
p1.fulfill(10)
p2 = p1.then(5)
assert 10 == p1.value
assert p2.is_fulfilled
assert 10 == p2.value
def test_3_2_6_2_if():
"""
Promises returned by then must be rejected when any of their
callbacks throw an exception.
"""
def fail(v):
raise AssertionError("Exception Message")
p1 = Promise()
p1.fulfill(5)
pf = p1.then(fail)
assert pf.is_rejected
assert_exception(pf.reason, AssertionError, "Exception Message")
p2 = Promise()
p2.reject(Exception("Error"))
pr = p2.then(None, fail)
assert pr.is_rejected
assert_exception(pr.reason, AssertionError, "Exception Message")
def test_3_2_6_5_rejected():
"""
Handles the case where the arguments to then
are values, not functions or promises.
"""
p1 = Promise()
p1.reject(Exception("Error"))
p2 = p1.then(None, 5)
assert_exception(p1.reason, Exception, "Error")
assert p2.is_rejected
assert_exception(p2.reason, Exception, "Error")
def test_chain_with_resolved(self):
def worker(resolve_fn):
resolve_fn(999)
def assertResult(result):
self.assertEqual(result, 999)
promise = Promise(worker)
self.assertTrue(promise._is_resolved())
promise2 = promise.then(assertResult)
self.assertTrue(promise2._is_resolved())
def test_3_2_3_3():
"""
Make sure rejected callback never called if promise is fulfilled
"""
cf = Counter()
cr = Counter()
p1 = Promise()
p2 = p1.then(lambda v: cf.tick(), lambda r: cr.tick())
p1.fulfill(5)
assert 0 == cr.value()
assert 1 == cf.value()
def test_3_2_2_3():
"""
Make sure fulfilled callback never called if promise is rejected
"""
cf = Counter()
cr = Counter()
p1 = Promise()
p2 = p1.then(lambda v: cf.tick(), lambda r: cr.tick())
p1.reject(Exception("Error"))
assert 0 == cf.value()
assert 1 == cr.value()
def test_3_2_6_4_pending():
"""
Handles the case where the arguments to then
are not functions or promises.
"""
p1 = Promise()
p2 = p1.then(5)
p1.fulfill(10)
assert 10 == p1.get()
p2.wait()
assert p2.is_fulfilled
assert 10 == p2.get()
def test_3_2_6_5_rejected():
"""
Handles the case where the arguments to then
are values, not functions or promises.
"""
p1 = Promise()
p1.do_reject(Exception("Error"))
p2 = p1.then(None, 5)
assert_exception(p1.reason, Exception, "Error")
p2._wait()
assert p2.is_rejected
assert_exception(p2.reason, Exception, "Error")
def test_promises_with_only_then():
context = {"success": False}
error = RuntimeError("Ooops!")
promise1 = Promise(lambda resolve, reject: context.update({"promise1_reject": reject}))
promise2 = promise1.then(lambda x: None)
promise3 = promise1.then(lambda x: None)
context["promise1_reject"](error)
promise2._wait()
promise3._wait()
assert promise2.reason == error
assert promise3.reason == error
def test_3_2_6_4_fulfilled():
"""
Handles the case where the arguments to then
are values, not functions or promises.
"""
p1 = Promise()
p1.do_resolve(10)
p2 = p1.then(5)
assert 10 == p1.get()
p2._wait()
assert p2.is_fulfilled
assert 10 == p2.get()
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()
def p1_resolved(v):
return pending
pf = p1.then(p1_resolved)
assert pending.is_pending
assert pf.is_pending
p1.do_resolve(10)
pending.do_resolve(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.do_resolve(10)
bad._reject_callback(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 check_url(url):
try:
options = webdriver.ChromeOptions()
for _ in [
'headless', 'window-size=1920x1080', 'disable-gpu',
'no-sandbox', 'disable-dev-shm-usage'
]:
options.add_argument(_)
driver = webdriver.Chrome('./chromedriver', options=options)
driver.implicitly_wait(3)
driver.set_page_load_timeout(3)
driver_promise = Promise(driver.get('http://localhost:80/signin'))
driver_promise.then(
driver.find_element_by_name("uid").send_keys(str(ADMIN_USERNAME)))
driver_promise.then(
driver.find_element_by_name("upw").send_keys(str(ADMIN_PASSWORD)))
driver_promise = Promise(driver.find_element_by_id("submit").click())
driver_promise.then(driver.get(url))
except Exception as e:
driver.quit()
return False
finally:
driver.quit()
return True
def test_chain_with_pending(self):
def worker_async(resolve_fn):
sublime.set_timeout_async(lambda: resolve_fn(999), 100)
def assertResult(result):
self.assertEqual(result, 999)
promise = Promise(worker_async)
self.assertFalse(promise._is_resolved())
promise2 = promise.then(assertResult)
self.assertFalse(promise2._is_resolved())
# Let promises resolve.
time.sleep(0.2)
self.assertTrue(promise._is_resolved())
def test_promises_with_only_then():
context = {"success": False}
error = RuntimeError("Ooops!")
promise1 = Promise(
lambda resolve, reject: context.update({"promise1_reject": reject})
)
promise2 = promise1.then(lambda x: None)
promise3 = promise1.then(lambda x: None)
context["promise1_reject"](error)
promise2._wait()
promise3._wait()
assert promise2.reason == error
assert promise3.reason == error
def test_3_2_3_1():
"""
The second argument to 'then' must be called when a promise is
rejected.
"""
c = Counter()
def check(r, c):
assert_exception(r, Exception, "Error")
c.tick()
p1 = Promise()
p2 = p1.then(None, lambda r: check(r, c))
p1.reject(Exception("Error"))
assert 1 == c.value()
def test_3_2_2_1():
"""
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.fulfill(5)
assert 1 == c.value()
def test_3_2_3_2():
"""
Make sure callbacks are never called more than once.
"""
c = Counter()
p1 = Promise()
p2 = p1.then(None, lambda v: c.tick())
p1.reject(Exception("Error"))
try:
# I throw an exception
p1.reject(Exception("Error"))
assert False # Should not get here!
except AssertionError:
# This is expected
pass
assert 1 == c.value()
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_3_2_5_1_if():
"""
Then can be called multiple times on the same promise
and callbacks must be called in the order of the
then calls.
"""
def add(l, v):
l.append(v)
p1 = Promise()
p1.fulfill(2)
order = []
p2 = p1.then(lambda v: add(order, "p2"))
p3 = p1.then(lambda v: add(order, "p3"))
assert 2 == len(order)
assert "p2" == order[0]
assert "p3" == order[1]
def test_3_2_5_2_if():
"""
Then can be called multiple times on the same promise
and callbacks must be called in the order of the
then calls.
"""
def add(l, v):
l.append(v)
p1 = Promise()
p1.reject(Exception("Error"))
order = []
p2 = p1.then(None, lambda v: add(order, "p2"))
p3 = p1.then(None, lambda v: add(order, "p3"))
assert 2 == len(order)
assert "p2" == order[0]
assert "p3" == order[1]
def __queue_command(self, command, input): promise = Promise(lambda resolve, reject: self.__command_queue.append( ClientQueryCommand(command, input, resolve, reject))) promise.then(lambda res: self.__on_command_done(), lambda err: self.__on_command_done()) self.__process_command_queue() return promise
from promise import Promise
from threading import Timer
def twoArgs(resolve):
return resolve("Resolved from twoArgs")
promise = Promise(
lambda resolve, reject: t = Timer(5.0, twoArgs, (resolver) t.start())
)
promise.then(lambda data: print(data))
print("I am ")
from promise import Promise
promise = Promise (lambda resolve, reject: 2)
a = promise.then()
print(a.value)
def test_rest(res):
return res == ['a', 'b', 'c']
p = Promise.all([Promise.resolve('a'), 'b', Promise.resolve('c')]) \
.then(test_rest)
print(p.value)
assert p.value is True
p = Promise.resolve('a')
print(p.value)
def promessaHandler(resolve, reject):
return reject('RESOLVIDO!')
p = Promise(promessaHandler)
print(p.value)
