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()
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)