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_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 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_get_if(): p1 = Promise() p1.do_resolve(5) v = p1.get() assert p1.is_fulfilled assert 5 == v