def test_done(): counter = [0] e = Event() def inc(_): counter[0] += 1 e.set() def dec(_): counter[0] -= 1 e.set() p = Promise() p.done(inc, dec) p.done(inc, dec) p.do_resolve(4) e.wait() assert counter[0] == 2 counter = [0] p = Promise() e = Event() p.done(inc, dec) p.done(inc, dec) p.do_reject(Exception()) e.wait() assert counter[0] == -2
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 submit(self, *args): if not self._set_state(Task.SUBMITTED, lambda state: state == Task.UNSUBMITTED): return Promise() self._enqueue({'type': Task.SUBMITTED}) # noinspection PyTypeChecker return Promise(self._start)
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_dict_promise_when(promise_for_dict): p1 = Promise() p2 = Promise() d = {"a": p1, "b": p2} pd1 = promise_for_dict(d) pd2 = promise_for_dict({"a": p1}) pd3 = promise_for_dict({}) assert p1.is_pending assert p2.is_pending assert pd1.is_pending assert pd2.is_pending assert pd3.is_fulfilled p1.fulfill(5) assert p1.is_fulfilled assert p2.is_pending assert pd1.is_pending assert pd2.is_fulfilled p2.fulfill(10) assert p1.is_fulfilled assert p2.is_fulfilled assert pd1.is_fulfilled assert pd2.is_fulfilled assert 5 == p1.value assert 10 == p2.value assert 5 == pd1.value["a"] assert 5 == pd2.value["a"] assert 10 == pd1.value["b"] assert {} == pd3.value
def test_promise_all_if(): p1 = Promise() p2 = Promise() pd1 = Promise.all([p1, p2]) pd2 = Promise.all([p1]) pd3 = Promise.all([]) assert p1.is_pending assert p2.is_pending assert pd1.is_pending assert pd2.is_pending assert pd3.is_fulfilled p1.fulfill(5) assert p1.is_fulfilled assert p2.is_pending assert pd1.is_pending assert pd2.is_fulfilled p2.fulfill(10) assert p1.is_fulfilled assert p2.is_fulfilled assert pd1.is_fulfilled assert pd2.is_fulfilled assert 5 == p1.value assert 10 == p2.value assert 5 == pd1.value[0] assert 5 == pd2.value[0] assert 10 == pd1.value[1] assert [] == pd3.value
def test_structure_subscription(self, mock_send_structure_request): def on_change(added, removed): nodes_added.extend(added) nodes_removed.extend(removed) old_children = [] new_children = [] nodes_added = [] nodes_removed = [] node = cdp.Node(None, self._connection, self._root_node) node.subscribe_to_structure_changes(on_change) mock_send_structure_request.return_value = Promise( lambda resolve, reject: resolve(data.app2_node)) node.children().then(lambda n: old_children.extend(n)) #change the structure - remove and add a node node_to_remove = self._root_node.node[0] node_to_add = data.app3_node self._root_node.node.remove(node_to_remove) self._root_node.node.extend([node_to_add]) mock_send_structure_request.return_value = Promise( lambda resolve, reject: resolve(self._root_node)) node._update() #verify mock_send_structure_request.return_value = Promise( lambda resolve, reject: resolve(node_to_add)) node.children().then(lambda n: new_children.extend(n)) self.assertEquals(len(old_children), len(new_children)) found = False for child in new_children: self.assertFalse(child.name() == nodes_removed[0]) if child.name() == nodes_added[0]: found = True self.assertTrue(found)
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_promise_all_if(): p1 = Promise() p2 = Promise() pd1 = Promise.all([p1, p2]) pd2 = Promise.all([p1]) pd3 = Promise.all([]) pd3._wait() assert p1.is_pending assert p2.is_pending assert pd1.is_pending assert pd2.is_pending assert pd3.is_fulfilled p1.do_resolve(5) p1._wait() pd2._wait() assert p1.is_fulfilled assert p2.is_pending assert pd1.is_pending assert pd2.is_fulfilled p2.do_resolve(10) p2._wait() pd1._wait() pd2._wait() assert p1.is_fulfilled assert p2.is_fulfilled assert pd1.is_fulfilled assert pd2.is_fulfilled assert 5 == p1.get() assert 10 == p2.get() assert 5 == pd1.get()[0] assert 5 == pd2.get()[0] assert 10 == pd1.get()[1] assert [] == pd3.get()
def test_then_all(): p = Promise() handlers = [ ((lambda x: x * x), (lambda r: 1)), { 'success': (lambda x: x + x), 'failure': (lambda r: 2) }, ] results = p.then_all() + p.then_all( ((lambda x: x * x), (lambda r: 1))) + p.then_all(handlers) p.fulfill(4) assert [r.value for r in results] == [16, 16, 8] p = Promise() handlers = [ ((lambda x: x * x), (lambda r: 1)), { 'success': (lambda x: x + x), 'failure': (lambda r: 2) }, ] results = p.then_all() + p.then_all( ((lambda x: x * x), (lambda r: 1))) + p.then_all(handlers) p.reject(Exception()) assert [r.value for r in results] == [1, 1, 2]
def test_then_all(): p = Promise() handlers = [ ((lambda x: x * x), (lambda r: 1)), { 'success': (lambda x: x + x), 'failure': (lambda r: 2) }, ] results = p.then_all() + p.then_all([lambda x: x]) + p.then_all( [(lambda x: x * x, lambda r: 1)]) + p.then_all(handlers) p.do_resolve(4) assert [r.get() for r in results] == [4, 16, 16, 8] p = Promise() handlers = [ ((lambda x: x * x), (lambda r: 1)), { 'success': (lambda x: x + x), 'failure': (lambda r: 2) }, ] results = p.then_all() + p.then_all( [(lambda x: x * x, lambda r: 1)]) + p.then_all(handlers) p.do_reject(Exception()) assert [r.get() for r in results] == [1, 1, 2]
def test_dict_promise_when(promise_for_dict): p1 = Promise() p2 = Promise() d = {"a": p1, "b": p2} pd1 = promise_for_dict(d) pd2 = promise_for_dict({"a": p1}) pd3 = promise_for_dict({}) assert p1.is_pending assert p2.is_pending assert pd1.is_pending assert pd2.is_pending pd3._wait() assert pd3.is_fulfilled p1.do_resolve(5) p1._wait() pd2._wait() assert p1.is_fulfilled assert p2.is_pending assert pd1.is_pending assert pd2.is_fulfilled p2.do_resolve(10) p2._wait() pd1._wait() assert p1.is_fulfilled assert p2.is_fulfilled assert pd1.is_fulfilled assert pd2.is_fulfilled assert 5 == p1.get() assert 10 == p2.get() assert 5 == pd1.get()["a"] assert 5 == pd2.get()["a"] assert 10 == pd1.get()["b"] assert {} == pd3.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() 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_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_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 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_clearing_all_requests(self): actual_errors = [] expected_error = cdp.ConnectionError('foo') p1 = Promise() p2 = Promise() p1.catch(lambda error: actual_errors.append(error)) p2.catch(lambda error: actual_errors.append(error)) self._requests.add(1, p1) self._requests.add(2, p2) self._requests.clear(expected_error) self.assertEqual(len(self._requests.get()), 0) self.assertEqual(len(actual_errors), 2) self.assertEqual(actual_errors[0], expected_error) self.assertEqual(actual_errors[1], expected_error)
def test_fetching_root_node_when_root_node_not_existing( self, mock_send_structure_request): nodes = [] system_node = copy(fake_data.system_node) app_node = copy(fake_data.app1_node) app_node.node.extend([fake_data.value1_node]) system_node.node.extend([app_node]) mock_send_structure_request.side_effect = [ Promise(lambda resolve, reject: resolve(system_node)), Promise(lambda resolve, reject: resolve(app_node)) ] self._node_tree.root_node().then(lambda n: nodes.append(n)) self.assertEquals(len(nodes), 1) self.assertEquals(nodes[0]._id(), app_node.info.node_id)
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.add_callback(throws) p1.fulfill(5) p2 = Promise() p2.add_errback(throws) p2.reject(Exception()) with raises(Exception) as excinfo: p2.get()
def child(self, name): def update_node(node, structure): node._update_structure(structure) return Promise(lambda resolve, reject: resolve(node)) for child in self._children: if child.name() == name: if child.is_leaf(): return Promise(lambda resolve, reject: resolve(child)) return self._connection.send_structure_request( child._id(), child.path()).then( lambda structure: update_node(child, structure)) return Promise(lambda resolve, reject: reject( NotFoundError("Could not find any children with name '" + name + "'")))
def test_do_resolve_fail_on_call(): def raises(resolve, reject): raise Exception('Fails') p1 = Promise(raises) assert not p1.is_fulfilled assert str(p1.reason) == 'Fails'
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 send_structure_request(self, node_id, node_path): p = Promise() self._structure_requests.add(node_path, p) if self._is_connected: self._update_time_difference() self._compose_and_send_structure_request(node_id) return p
def execute_in_thread(self, fn, *args, **kwargs): # type: (Callable, *Any, **Any) -> Promise promise = Promise() # type: ignore thread = Thread(target=process, args=(promise, fn, args, kwargs)) thread.start() self.threads.append(thread) return promise
def __init__(self, coro): self.logger = logging.getLogger(cu.MAIN_LOG) self.coro = coro p = Promise() p.set_result(None) self.logger.info("driver initialized, moving the coroutine") self.step(p)
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 get_job_data(self): """ Gets all data related to a given job from Redis. Returns: results {dict} -- Dictionary with project_name, job_id, user, job_parameters, input_params, output_metrics, status, start_time, completed_time. """ from promise import Promise project_name = self._add_decoded_get_to_pipe('project') user = self._add_decoded_get_to_pipe('user') job_parameters = self._add_decoded_get_to_pipe('parameters').then( self._deserialize_dict) input_parameters = Promise() input_parameters.fulfill([]) output_metrics = self._add_lrange_to_pipe_and_deserialize('metrics') status = self._add_decoded_get_to_pipe('state') start_time = self._add_decoded_get_to_pipe('start_time').then( self._make_float) completed_time = self._add_decoded_get_to_pipe('completed_time').then( self._make_float) creation_time = self._add_decoded_get_to_pipe('creation_time').then( self._make_float) tags = self._add_decoded_hgetall_to_pipe('annotations') list_of_properties = Promise.all([ project_name, user, job_parameters, output_metrics, status, start_time, completed_time, creation_time, tags ]) return list_of_properties.then(self._seperate_args)
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_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