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 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 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()
