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
