def _check_return_type(self, type_hint, procedure_result):
try:
deserialize_meta(type_hint, serialize_meta(procedure_result))
except ValueError:
return False
else:
return True
def _check_return_type(self, type_hint, procedure_result):
if procedure_result is None:
none_type = type(None)
return type_hint is none_type or is_optional_type(type_hint)
try:
deserialize_meta(type_hint, serialize_meta(procedure_result))
except ValueError:
return False
else:
return True
def test_deserialize_meta_unboxed(fx_unboxed_type, fx_record_type, fx_point,
fx_token_type):
v = 3.14
meta = deserialize_meta(fx_unboxed_type, v)
unboxed = fx_unboxed_type(v)
assert meta == unboxed
v = uuid.uuid4()
meta = deserialize_meta(fx_token_type, str(v))
unboxed = fx_token_type(v)
assert meta == unboxed
def test_deserialize_meta_union(fx_rectangle_type, fx_point, fx_shape_type):
d = {
'_type': 'shape',
'_tag': 'rectangle',
'upper_left': serialize_record_type(fx_point),
'lower_right': serialize_record_type(fx_point),
}
meta = deserialize_meta(fx_rectangle_type, d)
union = deserialize_union_type(fx_rectangle_type, d)
assert meta == union
meta_from_shape = deserialize_meta(fx_shape_type, d)
assert meta_from_shape == meta
def _parse_procedure_arguments(self, method_facial_name, request_json):
type_hints = self.service.__nirum_service_methods__[method_facial_name]
arguments = {}
version = type_hints.get('_v', 1)
name_map = type_hints['_names']
errors = MethodArgumentError()
for argument_name, type_ in type_hints.items():
if argument_name.startswith('_'):
continue
if version >= 2:
type_ = type_()
behind_name = name_map[argument_name]
try:
data = request_json[behind_name]
except KeyError:
if is_optional_type(type_):
arguments[argument_name] = None
else:
errors.on_error('.' + behind_name, 'Expected to exist.')
continue
try:
arguments[argument_name] = deserialize_meta(type_, data)
except ValueError:
errors.on_error(
'.' + behind_name,
'Expected {0}, but {1} was given.'.format(
typing._type_repr(type_),
typing._type_repr(type(data))))
errors.raise_if_errored()
return arguments
def test_deserialize_meta_record(fx_unboxed_type, fx_record_type, fx_point):
left = fx_unboxed_type(1.1)
top = fx_unboxed_type(2.2)
d = {'_type': 'point', 'x': left.value, 'top': top.value}
meta = deserialize_meta(fx_record_type, d)
record = deserialize_record_type(fx_record_type, d)
assert meta == record
def _parse_procedure_arguments(self, type_hints, request_json):
arguments = {}
version = type_hints.get('_v', 1)
name_map = type_hints['_names']
for argument_name, type_ in type_hints.items():
if argument_name.startswith('_'):
continue
if version >= 2:
type_ = type_()
behind_name = name_map[argument_name]
try:
data = request_json[behind_name]
except KeyError:
raise NirumProcedureArgumentRequiredError(
"A argument named '{}' is missing, it is required.".format(
behind_name))
try:
arguments[argument_name] = deserialize_meta(type_, data)
except ValueError:
raise NirumProcedureArgumentValueError(
"Incorrect type '{0}' for '{1}'. "
"expected '{2}'.".format(typing._type_repr(data.__class__),
behind_name,
typing._type_repr(type_)))
return arguments
def test_deserialize_meta_iterable(
primitive_type, iter_, abstract_type, python_type, expect_iter
):
deserialized = deserialize_meta(abstract_type[primitive_type], iter_)
if expect_iter is None:
expect_iter = iter_
assert deserialized == python_type(expect_iter)
def get_artist_by_music(self, music):
meta = self.__nirum_service_methods__['get_artist_by_music']
payload = {meta['_names']['music']: serialize_meta(music)}
return deserialize_meta(
meta['_return'],
json.loads(
self.remote_call(
self.__nirum_method_names__['get_artist_by_music'],
payload=payload)))
def _respond_with_result(self, method_facial_name, result):
type_hints = self.service.__nirum_service_methods__[method_facial_name]
return_type = type_hints['_return']
if type_hints.get('_v', 1) >= 2:
return_type = return_type()
none_type = type(None)
if return_type is none_type or is_optional_type(return_type):
if result is None:
return True, None
return False, None
if result is None:
return False, TypeError('the return type cannot be None')
try:
serialized = serialize_meta(result)
deserialize_meta(return_type, serialized)
except ValueError as e:
return False, e
else:
return True, serialized
def test_resolve_querystring(qs, expected):
app = WsgiApp(StatisticsServiceImpl(),
allowed_origins=frozenset(['example.com']))
client = Client(app, Response)
url = '/statistics/purchases/?' + urllib.parse.urlencode(qs)
response = client.get(url)
assert response.status_code == 200, response.get_data(as_text=True)
return_result = deserialize_meta(
typing.Sequence[int], json.loads(response.get_data(as_text=True)))
assert return_result == expected
def get_music_by_artist_name(self,
artist_name: str) -> typing.Sequence[str]:
meta = self.__nirum_service_methods__['get_music_by_artist_name']
payload = {meta['_names']['artist_name']: serialize_meta(artist_name)}
return deserialize_meta(
meta['_return'],
json.loads(
self.remote_call(
self.__nirum_method_names__['get_music_by_artist_name'],
payload=payload)))
def test_deserialize_meta_error():
with raises(TypeError):
deserialize_meta(None, {})
def test_deserialize_meta_map(fx_record_type, fx_unboxed_type):
map_type = typing.Mapping[fx_record_type, fx_record_type]
with raises(ValueError):
deserialize_meta(map_type, {})
with raises(ValueError):
deserialize_meta(map_type, {'_type': 'hello'})
empty = deserialize_meta(map_type, [])
assert isinstance(empty, collections.Mapping)
assert not isinstance(empty, collections.MutableMapping)
assert not list(empty)
with raises(ValueError):
deserialize_meta(map_type, [{}])
with raises(ValueError):
deserialize_meta(map_type, [{
'key': {
'_type': 'point',
'x': 1.0,
'top': 1.0
}
}])
with raises(ValueError):
deserialize_meta(map_type, [{
'value': {
'_type': 'point',
'x': 1.0,
'top': 1.0
}
}])
with raises(ValueError):
deserialize_meta(map_type, [{
'key': {
'_type': 'point',
'x': 1.0,
'top': 1.0
},
'value': 'V'
}])
with raises(ValueError):
deserialize_meta(map_type, [{
'key': 'K',
'value': {
'_type': 'point',
'x': 1.0,
'top': 1.0
}
}])
map_ = deserialize_meta(map_type, [
{
'key': {
'_type': 'point',
'x': 1.0,
'top': 2.0
},
'value': {
'_type': 'point',
'x': 3.0,
'top': 4.0
},
},
])
assert isinstance(map_, collections.Mapping)
assert not isinstance(map_, collections.MutableMapping)
assert list(map_.items()) == [
(
fx_record_type(left=fx_unboxed_type(1.0),
top=fx_unboxed_type(2.0)),
fx_record_type(left=fx_unboxed_type(3.0),
top=fx_unboxed_type(4.0)),
),
]
map2 = deserialize_meta(map_type, [
{
'key': {
'_type': 'point',
'x': 1.0,
'top': 2.0
},
'value': {
'_type': 'point',
'x': 3.0,
'top': 4.0
},
},
{
'key': {
'_type': 'point',
'x': 5.0,
'top': 6.0
},
'value': {
'_type': 'point',
'x': 7.0,
'top': 8.0
},
},
])
assert sorted(map2.items(),
key=lambda item: item[0].left.value) == [
(
fx_record_type(left=fx_unboxed_type(1.0),
top=fx_unboxed_type(2.0)),
fx_record_type(left=fx_unboxed_type(3.0),
top=fx_unboxed_type(4.0)),
),
(
fx_record_type(left=fx_unboxed_type(5.0),
top=fx_unboxed_type(6.0)),
fx_record_type(left=fx_unboxed_type(7.0),
top=fx_unboxed_type(8.0)),
),
]
