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_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_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_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_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_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_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_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_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 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)
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_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)
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 _insert_types_registry(request: web.Request): registry = TypesRegistry() request["types_registry"] = registry registry.set(request) return await call_http_handler(request, handler)
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, )