def test_promise_all_follows_indifentely(): promises = Promise.all( [ Promise.resolve("A"), Promise.resolve(None) .then(Promise.resolve) .then(lambda v: Promise.resolve(None).then(lambda v: Promise.resolve("B"))), ] ) assert promises.get() == ["A", "B"]
def test_promise_follows_indifentely(): a = Promise.resolve(None) b = a.then(lambda x: Promise.resolve("X")) e = Event() def b_then(v): c = Promise.resolve(None) d = c.then(lambda v: Promise.resolve("B")) return d promise = b.then(b_then) assert promise.get() == "B"
def wrapper(cls, root, info, password, **kwargs): def on_resolve(values): user, payload = values payload.token = get_token(user, info.context) return payload username = kwargs.get(get_user_model().USERNAME_FIELD) user = authenticate( request=info.context, username=username, password=password) if user is None: raise exceptions.GraphQLJWTError( _('Please, enter valid credentials')) if hasattr(info.context, 'user'): info.context.user = user result = f(cls, root, info, **kwargs) values = (user, result) # Improved mutation with thenable check if is_thenable(result): return Promise.resolve(values).then(on_resolve) return on_resolve(values)
def test_issue_33(): def do(x): v = Promise.resolve("ok").then(lambda x: x).get() return v p = Promise.resolve(None).then(do) assert p.get() == "ok"
def resolver(source, info, **args): # type: (Optional[Any], ResolveInfo, **Any) -> Promise extensions = info.extensions or {} extensions["test_extensions"] = extensions.get("test_extensions", {}) extensions["test_extensions"].update({"foo": "bar"}) return Promise.resolve( ExecutionResult(data="foobar", extensions=extensions))
def batch_load_fn(self, keys): keys = [ObjectId(k) for k in keys] users = {} for result in db().users.find({'_id': {'$in': keys}}): if result.get('join_info') is None: join_info = None else: join_info = JoinInfo.from_dict({ **result['join_info'], 'user_id': result['_id'], }) users[result['_id']] = user.User(id=result['_id'], google_id=result['google_id'], email=result['email'], avatar=nstr(result.get('avatar')), is_admin=result['is_admin'], name=result['name'], faction=result['faction'], created_at=str( result['created_at']), join_info=join_info) return Promise.resolve([users.get(key) for key in keys])
def batch_load_fn(self, models): return Promise.resolve( self._group_results( models, self._make_query(models).all(), return_child=True, ))
def execute(self, *args, **kwargs): executed = self.schema.execute(*args, **dict(self.execute_options, **kwargs)) if is_thenable(executed): return Promise.resolve(executed).then(self.format_result) return self.format_result(executed)
def batch_load_fn(self, keys): current_app.logger.debug("load %s", keys) with db.engine.begin() as conn: sql = text( """ select s.id as id, s.match_id as match_id, s.name as name, g.name as group from btb_data.skill s, btb_data.skill_group g where s.skill_group_id = g.id and s.match_id = any(:keys) and s.is_active = True and g.is_active = True """ ) data = conn.execute(sql, keys=list(map(lambda k: int(k), keys))) d = {str(i["match_id"]): i for i in data} # must return result in same order return Promise.resolve([d.get(str(id), None) for id in keys])
def wrapper(cls, root, info, password, **kwargs): def on_resolve(values): user, payload = values payload.token = get_token(user, info.context) if jwt_settings.JWT_LONG_RUNNING_REFRESH_TOKEN: payload.refresh_token = create_refresh_token(user).get_token() return payload username = kwargs.get(get_user_model().USERNAME_FIELD) if get_authorization_header(info.context) is not None: del info.context.META[jwt_settings.JWT_AUTH_HEADER_NAME] user = authenticate(request=info.context, username=username, password=password) if user is None: raise exceptions.JSONWebTokenError( _('Please, enter valid credentials')) if hasattr(info.context, 'user'): info.context.user = user user_logged_in.send(sender=user.__class__, request=info.context, user=user) result = f(cls, root, info, **kwargs) values = (user, result) if is_thenable(result): return Promise.resolve(values).then(on_resolve) return on_resolve(values)
def batch_load_fn(self, keys): results = defaultdict(list) for result in Submission.objects.filter(assignment_id__in=keys).iterator(): results[result.assignment_id].append(result) return Promise.resolve([results.get(key, []) for key in keys])
def batch_load_fn(self, keys): results = defaultdict(None) for result in AcademicTerms.objects.filter(id__in=keys).iterator(): results[result.id] = result return Promise.resolve([results.get(key, None) for key in keys])
def batch_load_fn(self, keys): results = defaultdict(None) for result in AssignmentWeightConsideration.objects.filter(course_id__in=keys).iterator(): results[result.course_id] = result return Promise.resolve([results.get(key, None) for key in keys])
def batch_load_fn(self, keys): group_labels_qs = EntryGroupLabel.get_stat_for_entry( EntryGroupLabel.objects.filter(entry__in=keys)) group_labels = defaultdict(list) for group_label in group_labels_qs: group_labels[group_label['entry']].append(group_label) return Promise.resolve([group_labels.get(key) for key in keys])
def batch_load_fn(self, keys: 'List[tuple]') -> Promise: """ Load related objects. Args: keys: Primary key values of parent model. Returns: Lists of related orm objects. """ if len(self.parent_model_pk_fields) == 1: left_hand_side = self.parent_model_pk_fields[0] right_hand_side = [k[0] for k in keys] else: left_hand_side = tuple_(*self.parent_model_pk_fields) right_hand_side = keys query: 'Query' = self._get_query().filter( left_hand_side.in_(right_hand_side)) objects: 'Dict[tuple, Any]' = { self.parent_model_object_to_key(parent_object): getattr(parent_object, self.model_relation_field) for parent_object in query } return Promise.resolve( [objects.get(object_id, []) for object_id in keys])
def wrapper(cls, root, info, password, **kwargs): def on_resolve(values): user, payload = values payload.token = get_token(user, info.context) return payload username = kwargs.get(get_user_model().USERNAME_FIELD) if get_authorization_header(info.context) is not None: del info.context.Meta[jwt_settings.JWT_AUTH_HEADER] user = authenticate(request=info.context, username=username, password=password) if user is None: raise exceptions.GraphQLJWTError( _('Please, enter valid credentials')) if hasattr(info.context, 'user'): info.context.user = user result = f(cls, root, info, **kwargs) values = (user, result) if is_thenable(result): return Promise.resolve(values).then(on_resolve) return on_resolve(values)
def batch_load_fn(self, product_ids): # Query the database product_tags = [] tag_id_set = set() for product_tag in TagModel.products.through.objects.filter( productmodel_id__in=product_ids).iterator(): product_tags.append( (product_tag.productmodel_id, product_tag.tagmodel_id)) tag_id_set.add(product_tag.tagmodel_id) tags = defaultdict(None) for tag in TagModel.objects.filter(pk__in=list(tag_id_set)).iterator(): tags[tag.id] = tag # Build the defaultdict to make sure it returns None when the product id does not exist tags_by_product_ids = defaultdict(list) for i in range(0, len(product_tags)): product_id = product_tags[i][0] tag_id = product_tags[i][1] tags_by_product_ids[product_id].append(tags[tag_id]) # Construct the result (same order as the request "product_ids") result = [ tags_by_product_ids.get(product_id, []) for product_id in product_ids ] return Promise.resolve(result)
def test_promised_list_slice_respects_a_smaller_first(): letters_promise_slice = Promise.resolve(letters[:3]) c = connection_from_promised_list_slice( letters_promise_slice, dict(first=2), slice_start=0, list_length=5 ) expected = { 'edges': [ { 'node': 'A', 'cursor': 'YXJyYXljb25uZWN0aW9uOjA=', }, { 'node': 'B', 'cursor': 'YXJyYXljb25uZWN0aW9uOjE=', }, ], 'pageInfo': { 'startCursor': 'YXJyYXljb25uZWN0aW9uOjA=', 'endCursor': 'YXJyYXljb25uZWN0aW9uOjE=', 'hasPreviousPage': False, 'hasNextPage': True, } } assert c.value.to_dict() == expected
def execute(self, fn, *args, **kwargs): result = fn(*args, **kwargs) if isinstance(result, Future) or iscoroutine(result): future = ensure_future(result, loop=self.loop) self.futures.append(future) return Promise.resolve(future) return result
def execute_fields_serially(exe_context, parent_type, source_value, fields): def execute_field_callback(results, response_name): field_asts = fields[response_name] result = resolve_field(exe_context, parent_type, source_value, field_asts, None) if result is Undefined: return results if is_thenable(result): def collect_result(resolved_result): results[response_name] = resolved_result return results return result.then(collect_result, None) results[response_name] = result return results def execute_field(prev_promise, response_name): return prev_promise.then( lambda results: execute_field_callback(results, response_name)) return functools.reduce(execute_field, fields.keys(), Promise.resolve(collections.OrderedDict()))
def connection_resolver(cls, resolver, connection, default_manager, max_limit, enforce_first_or_last, root, args, context, info): first = args.get('first') last = args.get('last') if enforce_first_or_last: assert first or last, ( 'You must provide a `first` or `last` value to properly paginate the `{}` connection.' ).format(info.field_name) if max_limit: if first: assert first <= max_limit, ( 'Requesting {} records on the `{}` connection exceeds the `first` limit of {} records.' ).format(first, info.field_name, max_limit) args['first'] = min(first, max_limit) if last: assert last <= max_limit, ( 'Requesting {} records on the `{}` connection exceeds the `last` limit of {} records.' ).format(first, info.field_name, max_limit) args['last'] = min(last, max_limit) iterable = resolver(root, args, context, info) on_resolve = partial(cls.resolve_connection, connection, default_manager, args) if Promise.is_thenable(iterable): return Promise.resolve(iterable).then(on_resolve) return on_resolve(iterable)
def execute(self, fn, *args, **kwargs): result = fn(*args, **kwargs) if is_future(result): future = convert_yielded(result) self.futures.append(future) return Promise.resolve(future) return result
def testNonFunction(nonFunction): def foo(k, r): results[k] = r p1 = Promise.resolve("Error: " + str(nonFunction)) p2 = p1.then(lambda r: foo(str(nonFunction), r), nonFunction) p2._wait()
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 wrapper(cls, root, info, password, **kwargs): context = info.context context._jwt_token_auth = True def on_resolve(values): user, payload = values payload.token = get_token(user, context) if jwt_settings.JWT_LONG_RUNNING_REFRESH_TOKEN: payload.refresh_token = refresh_token_lazy(user) return payload username = kwargs.get(get_user_model().USERNAME_FIELD) user = authenticate(request=context, username=username, password=password) if user is None: raise exceptions.JSONWebTokenError( _('Please, enter valid credentials')) if hasattr(context, 'user'): context.user = user result = f(cls, root, info, **kwargs) values = (user, result) signals.token_issued.send(sender=cls, request=context, user=user) if is_thenable(result): return Promise.resolve(values).then(on_resolve) return on_resolve(values)
def __init__(self, preproc_pipeline, nlu_model, policy_model: GraphBasedSberdemoPolicy, user: User, debug=False, patience=3, timeout=5): self.pipeline = preproc_pipeline self.nlu_model = nlu_model self.policy_model = policy_model self.user = user self.logger = logging.getLogger('router') self.logger.info("{user.id}:{user.name} : started new dialog".format( user=self.user)) self.debug = debug self.executor = ThreadPoolExecutor(max_workers=2) self.patience = patience self.impatience = 0 self.timeout = timeout self.promise = Promise.resolve(None) try: init_chat(self.user.id, self.timeout) except: self.logger.error('Could not init CHIT-CHAT')
def wrapper(cls, root, info, password, **kwargs): def on_resolve(values): user, payload = values payload.token = get_token(user) return payload username = kwargs.get(get_user_model().USERNAME_FIELD) user = authenticate(request=info.context, username=username, password=password) if user is None: raise exceptions.GraphQLJWTError( _('Please, enter valid credentials')) if hasattr(info.context, 'user'): info.context.user = user result = f(cls, root, info, **kwargs) values = (user, result) # Improved mutation with thenable check if is_thenable(result): return Promise.resolve(values).then(on_resolve) return on_resolve(values)
def execute_fields_serially(exe_context, parent_type, source_value, fields): def execute_field_callback(results, response_name): field_asts = fields[response_name] result = resolve_field( exe_context, parent_type, source_value, field_asts ) if result is Undefined: return results if is_thenable(result): def collect_result(resolved_result): results[response_name] = resolved_result return results return promisify(result).then(collect_result, None) results[response_name] = result return results def execute_field(prev_promise, response_name): return prev_promise.then(lambda results: execute_field_callback(results, response_name)) return functools.reduce(execute_field, fields.keys(), Promise.resolve(collections.OrderedDict()))
def connection_resolver(cls, resolver, connection, default_manager, max_limit, enforce_first_or_last, root, info, **args): first = args.get('first') last = args.get('last') if enforce_first_or_last: assert first or last, ( 'You must provide a `first` or `last` value to properly paginate the `{}` connection.' ).format(info.field_name) if max_limit: if first: assert first <= max_limit, ( 'Requesting {} records on the `{}` connection exceeds the `first` limit of {} records.' ).format(first, info.field_name, max_limit) args['first'] = min(first, max_limit) if last: assert last <= max_limit, ( 'Requesting {} records on the `{}` connection exceeds the `last` limit of {} records.' ).format(last, info.field_name, max_limit) args['last'] = min(last, max_limit) iterable = resolver(root, info, **args) on_resolve = partial(cls.resolve_connection, connection, default_manager, args) if Promise.is_thenable(iterable): return Promise.resolve(iterable).then(on_resolve) return on_resolve(iterable)
def load_sets(set_ids): sets = { item_set.uuid: item_set for item_set in db.session.query(ModelSet).filter( ModelSet.uuid.in_(set_ids)) } return Promise.resolve([sets.get(set_id) for set_id in set_ids])
def load_set_bonuses(set_ids): bonuses_by_set_id = defaultdict(list) for bonus in db.session.query(ModelSetBonus).filter( ModelSetBonus.set_id.in_(set_ids)): bonuses_by_set_id[bonus.set_id].append(bonus) return Promise.resolve( [bonuses_by_set_id.get(set_id, []) for set_id in set_ids])
def load_item_stats(item_ids): stats_by_item_id = defaultdict(list) for stats_list in db.session.query(ModelItemStat).filter( ModelItemStat.item_id.in_(item_ids)): stats_by_item_id[stats_list.item_id].append(stats_list) return Promise.resolve( [stats_by_item_id.get(item_id, []) for item_id in item_ids])
def load_weapon_stats(item_ids): weapon_stat_by_item_id = {} for stat in db.session.query(ModelWeaponStat).filter( ModelWeaponStat.item_id.in_(item_ids)): weapon_stat_by_item_id[stat.item_id] = stat return Promise.resolve( [weapon_stat_by_item_id.get(item_id, None) for item_id in item_ids])
def connection_resolver( cls, resolver: 'Any', connection_type: 'Any', model: 'Any', root: 'Any', info: 'ResolveInfo', **kwargs: dict, ) -> 'Union[Promise, Connection]': """ Resolve nested connection. Args: resolver: Default resolver. connection_type: Connection class. model: SQLAlchemy model. root: Parent SQLAlchemy object. info: Graphene resolve info object. **kwargs: Request args: filters, sort, ... Returns: Connection object. """ data_loader: ModelLoader = cls._get_or_create_data_loader( root, info, kwargs) root_pk_value: tuple = data_loader.parent_model_object_to_key(root) resolved: Promise = data_loader.load(root_pk_value) on_resolve = partial(cls.resolve_connection, connection_type, model, info, kwargs) return Promise.resolve(resolved).then(on_resolve)
def mutate(cls, root, info, input): """ Most code derived one-to-one from base class :return: """ def on_resolve(payload): try: payload.client_mutation_id = input.get("client_mutation_id") except Exception: raise Exception( "Cannot set client_mutation_id in the payload object {}".format( repr(payload) ) ) return payload result = cls.mutate_and_get_payload(root, info, **input) if result.errors: err_msg = '' for err in result.errors: err_msg += f"Field '{err.field}': {err.messages[0]} " raise GraphQLError(err_msg.strip()) if is_thenable(result): return Promise.resolve(result).then(on_resolve) return on_resolve(result)
def test_promised_list_slice_respects_a_smaller_first(): letters_promise_slice = Promise.resolve(letters[:3]) c = connection_from_promised_list_slice(letters_promise_slice, dict(first=2), slice_start=0, list_length=5) expected = { 'edges': [ { 'node': 'A', 'cursor': 'YXJyYXljb25uZWN0aW9uOjA=', }, { 'node': 'B', 'cursor': 'YXJyYXljb25uZWN0aW9uOjE=', }, ], 'pageInfo': { 'startCursor': 'YXJyYXljb25uZWN0aW9uOjA=', 'endCursor': 'YXJyYXljb25uZWN0aW9uOjE=', 'hasPreviousPage': False, 'hasNextPage': True, } } assert c.value.to_dict() == expected
def test_promise_coroutine(): @coroutine def my_coro(): yield from Promise.resolve(True) promise = Promise.resolve(my_coro()) assert isinstance(promise, Promise)
def input_sequence(self, actions, data=None) -> Promise: return reduce( lambda prev, action: prev.then( lambda data: self.input(action, data) ), actions, Promise.resolve(data) )
def connection_resolver(cls, resolver, connection_type, root, info, **args): resolved = resolver(root, info, **args) on_resolve = partial(cls.resolve_connection, connection_type, args) if is_thenable(resolved): return Promise.resolve(resolved).then(on_resolve) return on_resolve(resolved)
def state_sequence(self, states, data=None) -> Promise: return reduce( lambda promise, state: promise.then( lambda data: self.transition(state, data) ), states, Promise.resolve(data) )
def connection_resolver( cls, resolver, connection, default_manager, max_limit, enforce_first_or_last, filterset_class, filters_name, root, info, **args, ): # Disable `enforce_first_or_last` if not querying for `edges`. values = [ field.name.value for field in info.field_asts[0].selection_set.selections ] if "edges" not in values: enforce_first_or_last = False first = args.get("first") last = args.get("last") if enforce_first_or_last: assert first or last, ( "You must provide a `first` or `last` value to properly " "paginate the `{}` connection." ).format(info.field_name) if max_limit: if first: assert first <= max_limit, ( "Requesting {} records on the `{}` connection exceeds the " "`first` limit of {} records." ).format(first, info.field_name, max_limit) args["first"] = min(first, max_limit) if last: assert last <= max_limit, ( "Requesting {} records on the `{}` connection exceeds the " "`last` limit of {} records." ).format(last, info.field_name, max_limit) args["last"] = min(last, max_limit) iterable = resolver(root, info, **args) on_resolve = partial(cls.resolve_connection, connection, default_manager, args) filter_input = args.get(filters_name) if filter_input and filterset_class: iterable = filterset_class( data=dict(filter_input), queryset=iterable, request=info.context ).qs if Promise.is_thenable(iterable): return Promise.resolve(iterable).then(on_resolve) return on_resolve(iterable)
def get_info(self): # Using placeholder values in promise resolution # TO-DO: What should these values be return Promise.resolve({ 'precision': '15', 'scale': '15', 'currencyCode': 'GBP', 'currencySymbol': '$' })
def _handle_transfer_then(stored_transfer): def _repeat_transfer(): raise Exception('repeat transfer id') if stored_transfer: self.emit('_repeateTransfer', transfer) return self._reject_transfer(transfer, 'repeat transfer id') \ .then(_repeat_transfer) else: return Promise.resolve(None)
def test_thrown_exceptions_have_stacktrace(): def throws(v): assert False p3 = Promise.resolve("a").then(throws) with raises(AssertionError) as assert_exc: p3.get() assert assert_exc.traceback[-1].path.strpath == __file__
def promise_factorial(n): if n < 2: return 1 sleep(.02) a = executor.submit(promise_factorial, n - 1) def promise_then(r): return mul(r, n) return Promise.resolve(a).then(promise_then)
def test_benchmark_promise_all_promise(benchmark): values = [Promise.resolve(i) for i in range(100000)] def create_promise(): # unnecessary function call return Promise.all(values) result = benchmark(create_promise) assert isinstance(result, Promise) assert result.get() == list(range(100000))
def execute(schema, document_ast, root_value=None, context_value=None, variable_values=None, operation_name=None, executor=None, return_promise=False, middleware=None, allow_subscriptions=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 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, allow_subscriptions ) def executor(v): return execute_operation(context, context.operation, root_value) def on_rejected(error): context.errors.append(error) return None def on_resolve(data): if isinstance(data, Observable): return data if not context.errors: return ExecutionResult(data=data) return ExecutionResult(data=data, errors=context.errors) promise = Promise.resolve(None).then( executor).catch(on_rejected).then(on_resolve) if not return_promise: context.executor.wait_until_finished() return promise.get() return promise
def resolver(__, args, *_): input = args.get('input') def on_resolve(payload): try: payload.clientMutationId = input['clientMutationId'] except: raise GraphQLError('Cannot set clientMutationId in the payload object {}'.format(repr(payload))) return payload return Promise.resolve(mutate_and_get_payload(input, *_)).then(on_resolve)
def _fulfill_transfer_then(): # potential problem here: figure out how to get transaction_type # into the scope of this callback if transaction_type == self.transfer_log.incoming: return self.connection.send({ 'type': 'reject', 'transfer': transfer, 'message': 'timed out' }) else: return Promise.resolve(None)
def connection_resolver(cls, resolver, connection_type, root, info, **args): resolved = resolver(root, info, **args) if isinstance(connection_type, NonNull): connection_type = connection_type.of_type on_resolve = partial(cls.resolve_connection, connection_type, args) if is_thenable(resolved): return Promise.resolve(resolved).then(on_resolve) return on_resolve(resolved)
def test_3_2_3_3(): """ Make sure rejected callback never called if promise is fulfilled """ cf = Counter() cr = Counter() p1 = Promise.resolve(5) p2 = p1.then(lambda v: cf.tick(), lambda r: cr.tick()) p2._wait() assert 0 == cr.value() assert 1 == cf.value()
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_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.resolve(5) pf = p1.then(lambda v: v * v) assert pf.get() == 25 p2 = Promise.reject(Exception("Error")) pr = p2.then(None, lambda r: 5) assert 5 == pr.get()
def mutate(cls, root, args, context, info): input = args.get('input') def on_resolve(payload): try: payload.client_mutation_id = input.get('clientMutationId') except: raise Exception(( 'Cannot set client_mutation_id in the payload object {}' ).format(repr(payload))) return payload return Promise.resolve( cls.mutate_and_get_payload(input, context, info) ).then(on_resolve)
def mutate(cls, root, info, input): def on_resolve(payload): try: payload.client_mutation_id = input.get('client_mutation_id') except: raise Exception( ('Cannot set client_mutation_id in the payload object {}' ).format(repr(payload))) return payload result = cls.mutate_and_get_payload(root, info, **input) if is_thenable(result): return Promise.resolve(result).then(on_resolve) return on_resolve(result)
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.resolve(5) p2 = p1.then(lambda v: check(v, c)) p2._wait() assert 1 == c.value()
def test_3_2_2_2(): """ Make sure callbacks are never called more than once. """ c = Counter() p1 = Promise.resolve(5) p2 = p1.then(lambda v: c.tick()) p2._wait() try: # I throw an exception p1.do_resolve(5) assert False # Should not get here! except AssertionError: # This is expected pass assert 1 == c.value()