async def test_call_chain_one_decorator(self):
registry = TypesRegistry()
resolver = ArgResolver(registry=registry)
def deco_final(_handler):
@wraps(_handler)
async def _wrap(p: str):
registry.set(False)
return await resolver.wrap(_handler)
return _wrap
def _handler_deco(handler):
@wraps(handler)
async def _handler_deco_wrap(x: bool):
registry.set(42)
registry.set(True)
return await resolver.wrap(handler)
return _handler_deco_wrap
@deco_final
@_handler_deco
async def handler(p: int, flag: bool):
return (p, flag)
registry.set("is p")
result = await resolver.wrap(handler)
self.assertEqual((42, True), result)
async def test_raises_ArgumentError_when_unresolved_args_exist(self):
async def my_coro(num: int, value: str):
return 1 / 0
registry = TypesRegistry()
registry.set(42)
resolver = ArgResolver(registry)
with self.assertRaises(TypeError):
await resolver.wrap(my_coro)
async def test_await_for_coro_one_param(self):
class MyObject:
pass
async def my_coro(obj: MyObject):
return obj
instance = MyObject()
registry = TypesRegistry()
registry.set(instance)
resolver = ArgResolver(registry)
result = await resolver.wrap(my_coro)
self.assertEqual(instance, result)
async def test_multiple_resolvers(self):
async def coro(p: int, arg: str, other: bool):
return (p, arg, other)
registry_one = TypesRegistry()
registry_one.set(42)
registry_two = TypesRegistry()
registry_two.set("string")
registry_two.set(True)
resolver = ArgResolver(registry_one, registry_two)
result = await resolver.wrap(coro)
self.assertEqual((42, "string", True), result)
async def test_resolve_multiple_coros_with_same_registry(self):
async def coro(p: int):
return p
registry_one = TypesRegistry()
registry_one.set(42)
resolver = ArgResolver(registry_one)
result = await resolver.wrap(coro)
self.assertEqual(42, await resolver.wrap(coro))
resolver2 = ArgResolver(registry_one)
self.assertEqual(42, await resolver2.wrap(coro))
self.assertEqual(42, registry_one.get(int))
async def test_wraps_coroutine_reference(self):
async def my_coro():
return 42
resolver = ArgResolver(TypesRegistry())
result = await resolver.wrap(my_coro)
self.assertEqual(42, result)
class TypesRegistryTest(TestCase):
async def setUp(self):
self.registry = TypesRegistry()
async def test_simple_set_get_object(self):
class SomeObject:
pass
instance = SomeObject()
self.registry.set(instance)
self.assertEqual(instance, self.registry.get(SomeObject))
async def test_get_object_not_found(self):
class OtherObject:
pass
self.assertIsNone(self.registry.get(OtherObject))
async def test_get_object_of_list_type(self):
"""
Searching for List[Class]
"""
class MyClass:
pass
_list = [MyClass(), MyClass()]
self.registry.set(_list)
self.assertEqual(_list, self.registry.get(List[MyClass]))
async def test_get_object_list_type_empty_list(self):
class MyClass:
pass
_list: List[MyClass] = []
self.registry.set(_list, List[MyClass])
self.assertEqual(_list, self.registry.get(List[MyClass]))
async def test_simple_coroutine_with_typehint(self):
class MyClass:
pass
async def my_coro(p: MyClass):
return p
instance = MyClass()
self.assertTrue(instance)
async def test_raises_if_handler_has_any_missing_annotation(self):
async def handler(other):
return other
wrapper = RequestWrapper(http_request=MagicMock(),
types_registry=TypesRegistry())
with self.assertRaises(MissingTypeAnnotationError):
await call_http_handler(wrapper, handler)
async def test_path_param_from_request(self):
request = make_mocked_request("GET", "/num/42", match_info={"n": "42"})
wrapper = RequestWrapper(
http_request=request, types_registry=TypesRegistry()
)
path_param_instance = await PathParam.from_request(
wrapper, arg_name="n", arg_type=int
)
self.assertEqual(42, await path_param_instance.unpack())
async def test_reolves_args_that_is_falsy(self):
"""
Mesmo o objeto sendo bool(arg) == False temos que conseguir
resolvê-lo
"""
class MyObject:
def __bool__(self):
return False
async def my_coro(obj: MyObject):
return obj
instance = MyObject()
registry = TypesRegistry()
registry.set(instance)
resolver = ArgResolver(registry)
result = await resolver.wrap(my_coro)
self.assertEqual(instance, result)
async def test_resolve_list_argument(self):
async def my_coro(arg0: List[int], value: str):
return arg0, value
registry = TypesRegistry()
registry.set([42, 42])
registry.set("value")
resolver = ArgResolver(registry)
self.assertEqual(([42, 42], "value"), await resolver.wrap(my_coro))
async def test_resolves_coro_with_return_annotation(self):
async def my_coro(arg0: int, value: str) -> Tuple[int, str]:
return arg0, value
registry = TypesRegistry()
registry.set(42)
registry.set("value")
resolver = ArgResolver(registry)
self.assertEqual((42, "value"), await resolver.wrap(my_coro))
async def test_calls_corotine_with_no_arguments(self):
async def my_coro():
return 42
registry = TypesRegistry()
registry.set([42, 42])
registry.set("value")
resolver = ArgResolver(registry)
self.assertEqual(42, await resolver.wrap(my_coro))
async def test_aiohttp_fake_request(self):
async def _get(n: PathParam[int]):
return await n.unpack()
request = make_mocked_request("GET", "/num/42", match_info={"n": "42"})
request_wrapper = RequestWrapper(
http_request=request, types_registry=TypesRegistry()
)
resolver = ArgResolver(request_wrapper.types_registry)
async def _resolve_wrap(_handler, request_wrapper):
p: PathParam[int] = PathParam(10)
request_wrapper.types_registry.set(p, PathParam[int])
return await resolver.wrap(_handler)
self.assertEqual(10, await _resolve_wrap(_get, request_wrapper))
async def test_raise_argument_error_if_coro_has_no_type_annotation(self):
async def my_coro(arg0):
return arg0
registry = TypesRegistry()
registry.set([42, 42])
registry.set("value")
resolver = ArgResolver(registry)
with self.assertRaises(MissingTypeAnnotationError):
await resolver.wrap(my_coro)
async def _insert_types_registry(request: web.Request):
"""
Esse é o único ponto que tem contato direto com o aiohttp. É essa corotina que é efetivament registrada nas rotas do aiohttp. Daqui pra frente tudo é chamado através do ccall_http_handler() e pode receber `RequestWrapper` como parametro.
"""
registry = TypesRegistry()
request["types_registry"] = registry
registry.set(request)
r_wrapper = RequestWrapper(http_request=request,
types_registry=registry)
registry.set(r_wrapper)
return await call_http_handler(request, handler)
async def test_prefer_named_paramteres_before_typed_parameters(self):
"""
Primeiro sempre tentamos pegar o paramtero pelo nome, só depois
pegamos o valor olhando apenas o tipo
"""
async def my_coro(arg0: int, value: int):
return arg0, value
registry = TypesRegistry()
registry.set(42, param_name="arg0")
registry.set(44, param_name="value")
resolver = ArgResolver(registry)
self.assertEqual((42, 44), await resolver.wrap(my_coro))
async def test_await_for_coro_two_params(self):
class MyObject:
pass
async def my_coro(obj: MyObject, num: int):
return obj, num
instance = MyObject()
registry = TypesRegistry()
registry.set(instance)
registry.set(42)
resolver = ArgResolver(registry)
result = await resolver.wrap(my_coro)
self.assertEqual((instance, 42), result)
async def setUp(self):
self.registry = TypesRegistry()
class TypesRegistryTest(TestCase):
async def setUp(self):
self.registry = TypesRegistry()
async def test_simple_set_get_object(self):
class SomeObject:
pass
instance = SomeObject()
self.registry.set(instance)
self.assertEqual(instance, self.registry.get(SomeObject))
async def test_get_object_not_found(self):
class OtherObject:
pass
self.assertIsNone(self.registry.get(OtherObject))
async def test_simple_coroutine_with_typehint(self):
class MyClass:
pass
async def my_coro(p: MyClass):
return p
instance = MyClass()
self.assertTrue(instance)
async def test_register_a_new_type_with_its_name(self):
"""
Um parametro registrado apenas com o tipo é diferente de um
parametro registrado com tipo e nome
"""
class MyClass:
async def my_coro(self, obj_id: int):
return obj_id
self.registry.set(42, param_name="obj_id")
self.registry.set(10)
self.assertEqual(42, self.registry.get(int, param_name="obj_id"))
async def test_register_returns_None_when_name_not_found(self):
"""
Lança uma exception quando tentamos buscar um parametro pelo
tipo e pelo nome mas ele não é encontrado.
"""
class MyClass:
async def my_coro(self, obj_id: int):
return obj_id
self.registry.set(42, param_name="obj_id")
self.assertEqual(None, self.registry.get(str, param_name="obj_id"))
async def test_aceita_tipo_generico_um_arg_tipo_simples(self):
class MyGeneric(Generic[T]):
def __init__(self, val: T) -> None:
self._val: T = val
v: MyGeneric[int] = MyGeneric(10)
self.registry.set(v, MyGeneric[int])
self.assertEqual(v, self.registry.get(MyGeneric[int]))
async def test_aceita_generico_dois_args(self):
P = TypeVar("P")
class MyGenericDoisArgs(Generic[T, P]):
def __init__(self, val: T) -> None:
self._val: T = val
v: MyGenericDoisArgs[int, str] = MyGenericDoisArgs(10)
self.registry.set(v, MyGenericDoisArgs[int, str])
self.assertEquals(v, self.registry.get(MyGenericDoisArgs[int, str]))
async def test_generico_dois_args_ordem_importa(self):
P = TypeVar("P")
class MyGenericDoisArgs(Generic[T, P]):
def __init__(self, val: T) -> None:
self._val: T = val
v: MyGenericDoisArgs[int, str] = MyGenericDoisArgs(10)
self.registry.set(v, MyGenericDoisArgs[int, str])
self.assertIsNone(self.registry.get(MyGenericDoisArgs[str, int]))
async def test_generico_um_arg_tipo_complexo(self):
class MyGeneric(Generic[T]):
def __init__(self, val: T) -> None:
self._val: T = val
class OtherObject:
pass
v: MyGeneric[OtherObject] = MyGeneric(OtherObject())
self.registry.set(v, MyGeneric[OtherObject])
self.assertEquals(v, self.registry.get(MyGeneric[OtherObject]))
async def test_generico_um_arg_get_by_name(self):
class MyGeneric(Generic[T]):
def __init__(self, val: T) -> None:
self._val: T = val
obj = MyGeneric(42)
self.registry.set(obj,
type_definition=MyGeneric[int],
param_name="p_name")
self.assertEqual(
obj, self.registry.get(MyGeneric[int], param_name="p_name"))
async def test_dois_generic_um_arg_get_by_name(self):
class MyGeneric(Generic[T]):
def __init__(self, val: T) -> None:
self._val: T = val
obj = MyGeneric(42)
obj_2 = MyGeneric(99)
self.registry.set(obj,
type_definition=MyGeneric[int],
param_name="p_name")
self.registry.set(obj_2,
type_definition=MyGeneric[int],
param_name="p_name_2")
self.assertEqual(
obj._val,
self.registry.get(MyGeneric[int], param_name="p_name")._val,
)
self.assertEqual(
obj_2._val,
self.registry.get(MyGeneric[int], param_name="p_name_2")._val,
)
class TypesRegistryTest(TestCase):
async def setUp(self):
self.registry = TypesRegistry()
async def test_simple_set_get_object(self):
class SomeObject:
pass
instance = SomeObject()
self.registry.set(instance)
self.assertEqual(instance, self.registry.get(SomeObject))
async def test_get_object_not_found(self):
class OtherObject:
pass
self.assertIsNone(self.registry.get(OtherObject))
async def test_simple_coroutine_with_typehint(self):
class MyClass:
pass
async def my_coro(p: MyClass):
return p
instance = MyClass()
self.assertTrue(instance)
async def test_register_a_new_type_with_its_name(self):
"""
Um parametro registrado apenas com o tipo é diferente de um
parametro registrado com tipo e nome
"""
class MyClass:
async def my_coro(self, obj_id: int):
return obj_id
self.registry.set(42, param_name="obj_id")
self.registry.set(10)
self.assertEqual(42, self.registry.get(int, param_name="obj_id"))
async def test_register_returns_None_when_name_not_found(self):
"""
Lança uma exception quando tentamos buscar um parametro pelo
tipo e pelo nome mas ele não é encontrado.
"""
class MyClass:
async def my_coro(self, obj_id: int):
return obj_id
self.registry.set(42, param_name="obj_id")
self.assertEqual(None, self.registry.get(str, param_name="obj_id"))
async def setUp(self):
self.registry = TypesRegistry()
self.resolver = ArgResolver(registry=self.registry)
async def _insert_types_registry(request: web.Request):
registry = TypesRegistry()
request["types_registry"] = registry
registry.set(request)
return await call_http_handler(request, handler)
