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_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_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 pytest.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()
def test_chained_promises():
"""
Handles the case where the arguments to then
are values, not functions or promises.
"""
p1 = Promise(lambda resolve, reject: resolve(Promise.resolve(True)))
assert p1.get() == True
def execute(schema, document_ast, root_value=None, context_value=None,
variable_values=None, operation_name=None, executor=None):
assert schema, 'Must provide schema'
assert isinstance(schema, GraphQLSchema), (
'Schema must be an instance of GraphQLSchema. Also ensure that there are ' +
'not multiple versions of GraphQL installed in your node_modules directory.'
)
if executor is None:
executor = SyncExecutor()
context = ExecutionContext(
schema,
document_ast,
root_value,
context_value,
variable_values,
operation_name,
executor
)
def executor(resolve, reject):
return resolve(execute_operation(context, context.operation, root_value))
def on_rejected(error):
context.errors.append(error)
return None
def on_resolve(data):
return ExecutionResult(data=data, errors=context.errors)
p = Promise(executor).catch(on_rejected).then(on_resolve)
context.executor.wait_until_finished()
return p.get()
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_promise_loop():
def by_two(result):
return result * 2
def executor(resolve, reject):
resolve(Promise.resolve(1).then(lambda v: Promise.resolve(v).then(by_two)))
p = Promise(executor)
assert p.get(.1) == 2
def test_resolve_promise_subclass():
class MyPromise(Promise):
pass
p = Promise()
p.do_resolve(10)
m_p = MyPromise.resolve(p)
assert isinstance(m_p, MyPromise)
assert m_p.get() == p.get()
def execute(schema,
document_ast,
root_value=None,
context_value=None,
variable_values=None,
operation_name=None,
executor=None,
return_promise=False,
middleware=None):
if use_experimental_executor:
return experimental_execute(schema, document_ast, root_value,
context_value, variable_values,
operation_name, executor, return_promise,
middleware)
assert schema, 'Must provide schema'
assert isinstance(schema, GraphQLSchema), (
'Schema must be an instance of GraphQLSchema. Also ensure that there are '
+
'not multiple versions of GraphQL installed in your node_modules directory.'
)
if middleware:
if not isinstance(middleware, MiddlewareManager):
middleware = MiddlewareManager(*middleware)
assert isinstance(middleware, MiddlewareManager), (
'middlewares have to be an instance'
' of MiddlewareManager. Received "{}".'.format(middleware))
if executor is None:
executor = SyncExecutor()
context = ExecutionContext(schema, document_ast, root_value, context_value,
variable_values, operation_name, executor,
middleware)
def executor(resolve, reject):
return resolve(
execute_operation(context, context.operation, root_value))
def on_rejected(error):
context.errors.append(error)
return None
def on_resolve(data):
if not context.errors:
return ExecutionResult(data=data)
return ExecutionResult(data=data, errors=context.errors)
promise = Promise(executor).catch(on_rejected).then(on_resolve)
if return_promise:
return promise
context.executor.wait_until_finished()
return promise.get()
def test_dict_promise_if(promise_for_dict):
p1 = Promise()
p2 = Promise()
d = {"a": p1, "b": p2}
pd = promise_for_dict(d)
assert p1.is_pending
assert p2.is_pending
assert pd.is_pending
p1.fulfill(5)
assert p1.is_fulfilled
assert p2.is_pending
assert pd.is_pending
p2.fulfill(10)
assert p1.is_fulfilled
assert p2.is_fulfilled
assert pd.is_fulfilled
assert 5 == p1.get()
assert 10 == p2.get()
assert 5 == pd.get()["a"]
assert 10 == pd.get()["b"]
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.do_resolve(10)
assert 10 == p1.get()
p2._wait()
assert p2.is_fulfilled
assert 10 == p2.get()
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_promise_all_when_mixed_promises():
p1 = Promise()
p2 = Promise()
pl = Promise.all([p1, 32, p2, False, True])
assert p1.is_pending
assert p2.is_pending
assert pl.is_pending
p1.do_resolve(5)
p1._wait()
assert p1.is_fulfilled
assert p2.is_pending
assert pl.is_pending
p2.do_resolve(10)
p2._wait()
pl._wait()
assert p1.is_fulfilled
assert p2.is_fulfilled
assert pl.is_fulfilled
assert 5 == p1.get()
assert 10 == p2.get()
assert pl.get() == [5, 32, 10, False, True]
def test_promise_all_when_mixed_promises():
p1 = Promise()
p2 = Promise()
pl = Promise.all([p1, 32, p2, False, True])
assert p1.is_pending
assert p2.is_pending
assert pl.is_pending
p1.do_resolve(5)
p1._wait()
assert p1.is_fulfilled
assert p2.is_pending
assert pl.is_pending
p2.do_resolve(10)
p2._wait()
pl._wait()
assert p1.is_fulfilled
assert p2.is_fulfilled
assert pl.is_fulfilled
assert 5 == p1.get()
assert 10 == p2.get()
assert pl.get() == [5, 32, 10, False, True]
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.get()
p2.wait()
assert p2.is_fulfilled
assert 10 == p2.get()
def make_channel_request(self, data, packet_type, response_type=None):
seq = ChannelPack.make_seq32()
request_pack = ChannelPack(packet_type, seq, 0, data)
self.send_pack(request_pack)
onresponse_emitter_str = ChannelHandler.getEmitterStr(
self.onResponsePrefix, seq, response_type)
# register onResponse emitter
self.lock.acquire()
self.callbackEmitter.on(onresponse_emitter_str, self.onResponse)
self.lock.release()
self.requests.append(onresponse_emitter_str)
# register onResponse emitter of RPC
rpc_onresponse_emitter_str = None
rpc_result_emitter_str = None
if response_type is ChannelPack.TYPE_TX_COMMITTED \
or response_type is ChannelPack.CLIENT_REGISTER_EVENT_LOG:
rpc_onresponse_emitter_str = ChannelHandler.getEmitterStr(
self.onResponsePrefix, seq, packet_type)
self.requests.append(rpc_onresponse_emitter_str)
rpc_result_emitter_str = ChannelHandler.getEmitterStr(
self.getResultPrefix, seq, packet_type)
self.lock.acquire()
self.callbackEmitter.on(rpc_onresponse_emitter_str,
self.onResponse)
self.lock.release()
emitter_str = ChannelHandler.getEmitterStr(self.getResultPrefix, seq,
response_type)
def resolve_promise(resolve, reject):
"""
resolve promise
"""
# register getResult emitter
self.lock.acquire()
self.callbackEmitter.on(emitter_str,
(lambda result, is_error: resolve(result)))
# 1. if send transaction failed, return the error message directly
# and erase the registered 0x1002 emitter
# 2. if send transaction success, remove the registered 0x12 emitter
if rpc_result_emitter_str is not None:
self.callbackEmitter.on(
rpc_result_emitter_str,
(lambda result, is_error: resolve(result) and self.requests
.remove(onresponse_emitter_str) if is_error is True else
self.requests.remove(rpc_onresponse_emitter_str) if self.
requests.count(rpc_onresponse_emitter_str) else None))
self.lock.release()
p = Promise(resolve_promise)
# default timeout is 60s
return p.get(60)
def test_promise_all_when():
p1 = Promise()
p2 = Promise()
pl = Promise.all([p1, p2])
assert p1.is_pending
assert p2.is_pending
assert pl.is_pending
p1.do_resolve(5)
p1._wait()
assert p1.is_fulfilled
assert p2.is_pending
assert pl.is_pending
p2.do_resolve(10)
p2._wait()
pl._wait()
assert p1.is_fulfilled
assert p2.is_fulfilled
assert pl.is_fulfilled
assert 5 == p1.get()
assert 10 == p2.get()
assert 5 == pl.get()[0]
assert 10 == pl.get()[1]
def test_promise_all_when():
p1 = Promise()
p2 = Promise()
pl = Promise.all([p1, p2])
assert p1.is_pending
assert p2.is_pending
assert pl.is_pending
p1.do_resolve(5)
p1._wait()
assert p1.is_fulfilled
assert p2.is_pending
assert pl.is_pending
p2.do_resolve(10)
p2._wait()
pl._wait()
assert p1.is_fulfilled
assert p2.is_fulfilled
assert pl.is_fulfilled
assert 5 == p1.get()
assert 10 == p2.get()
assert 5 == pl.get()[0]
assert 10 == pl.get()[1]
def execute(schema, document_ast, root_value=None, context_value=None,
variable_values=None, operation_name=None, executor=None,
return_promise=False, middleware=None):
assert schema, 'Must provide schema'
assert isinstance(schema, GraphQLSchema), (
'Schema must be an instance of GraphQLSchema. Also ensure that there are ' +
'not multiple versions of GraphQL installed in your node_modules directory.'
)
if middleware:
if not isinstance(middleware, MiddlewareManager):
middleware = MiddlewareManager(*middleware)
assert isinstance(middleware, MiddlewareManager), (
'middlewares have to be an instance'
' of MiddlewareManager. Received "{}".'.format(middleware)
)
if executor is None:
executor = SyncExecutor()
context = ExecutionContext(
schema,
document_ast,
root_value,
context_value,
variable_values,
operation_name,
executor,
middleware
)
def executor(resolve, reject):
return resolve(execute_operation(context, context.operation, root_value))
def on_rejected(error):
context.errors.append(error)
return None
def on_resolve(data):
return ExecutionResult(data=data, errors=context.errors)
promise = Promise(executor).catch(on_rejected).then(on_resolve)
if return_promise:
return promise
context.executor.wait_until_finished()
return promise.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 execute(schema,
document_ast,
root_value=None,
context_value=None,
variable_values=None,
operation_name=None,
executor=None,
return_promise=False):
assert schema, 'Must provide schema'
assert isinstance(schema, GraphQLSchema), (
'Schema must be an instance of GraphQLSchema. Also ensure that there are '
+
'not multiple versions of GraphQL installed in your node_modules directory.'
)
if executor is None:
executor = SyncExecutor()
context = ExecutionContext(schema, document_ast, root_value, context_value,
variable_values, operation_name, executor)
def executor(resolve, reject):
return resolve(
execute_operation(context, context.operation, root_value))
def on_rejected(error):
context.errors.append(error)
return None
def on_resolve(data):
return ExecutionResult(data=data, errors=context.errors)
promise = Promise(executor).catch(on_rejected).then(on_resolve)
if return_promise:
return promise
context.executor.wait_until_finished()
return promise.get()
def test_do_resolve():
p1 = Promise(lambda resolve, reject: resolve(0))
assert p1.get() == 0
assert p1.is_fulfilled
def test_fulfill_self():
p = Promise()
with raises(TypeError) as excinfo:
p.do_resolve(p)
p.get()
def test_await_time():
def resolve_or_reject(resolve, reject):
time.sleep(.1)
resolve(True)
p = Promise(resolve_or_reject)
assert p.get() is True
def test_get_if():
p1 = Promise()
p1.fulfill(5)
v = p1.get()
assert p1.is_fulfilled
assert 5 == v
def test_fulfill_self():
p = Promise()
with raises(TypeError) as excinfo:
p.do_resolve(p)
p.get()
def test_do_resolve():
p1 = Promise(lambda resolve, reject: resolve(0))
assert p1.get() == 0
assert p1.is_fulfilled
def test_get_if():
p1 = Promise()
p1.do_resolve(5)
v = p1.get()
assert p1.is_fulfilled
assert 5 == v
