def test_all_attributes():
winter_app = WinterApplication()
argument_type = int
argument_name = 'number'
method_name = 'method'
class SimpleComponent:
@component_method
def method(self, number: argument_type):
return self, number
winter_app.add_component(SimpleComponent)
simple_component = SimpleComponent()
cls_method = SimpleComponent.method
assert cls_method.component == winter_app.components[SimpleComponent]
assert cls_method.name == method_name
assert inspect.ismethod(simple_component.method)
assert cls_method.func == simple_component.method.__func__
assert cls_method(simple_component, 123) == (simple_component, 123)
assert simple_component.method(123) == (simple_component, 123)
number_argument = ComponentMethodArgument(cls_method, argument_name,
argument_type)
assert cls_method.arguments == (number_argument, )
assert number_argument == cls_method.get_argument(argument_name)
def resolve_argument(
self,
argument: ComponentMethodArgument,
request: Request,
response_headers: MutableMapping[str, str],
):
query_parameters = request.query_params
query_parameter = self._get_query_parameter(argument)
if query_parameter is None:
raise ArgumentNotSupported(argument)
parameter_name = query_parameter.name
explode = query_parameter.explode
is_iterable = is_iterable_type(argument.type_)
if parameter_name not in query_parameters:
try:
return argument.get_default()
except ArgumentDoesNotHaveDefault:
raise JSONDecodeException(
f'Missing required query parameter "{parameter_name}"')
value = self._get_value(query_parameters, parameter_name, is_iterable,
explode)
return json_decode(value, argument.type_)
def test_generic_argument_resolver_resolve_argument():
resolve_argument_mock = Mock()
generic_argument_resolver = GenericArgumentResolver('a', int, resolve_argument_mock)
argument = ComponentMethodArgument(Mock(), 'a', int)
request = Mock()
response_headers = Mock()
# Act
generic_argument_resolver.resolve_argument(argument, request, response_headers)
# Assert
resolve_argument_mock.assert_called_once_with(argument, request, response_headers)
def test_generic_argument_resolver_is_supported(arg_name, arg_type, resolver_arg_name, resolver_arg_type,
expected_supported):
resolve_argument_mock = Mock()
generic_argument_resolver = GenericArgumentResolver(resolver_arg_name, resolver_arg_type, resolve_argument_mock)
argument = ComponentMethodArgument(Mock(), arg_name, arg_type)
# Act
is_supported = generic_argument_resolver.is_supported(argument)
# Assert
assert is_supported is expected_supported
resolve_argument_mock.assert_not_called()
def resolve_argument(
self,
argument: ComponentMethodArgument,
request: Request,
response_headers: MutableMapping[str, str],
):
resolver_match = self._url_resolver.resolve(request.path_info)
callback, callback_args, callback_kwargs = resolver_match
if argument.name not in callback_kwargs:
raise ArgumentNotSupported(argument)
return argument.type_(callback_kwargs[argument.name])
def resolve_argument(
self,
argument: ComponentMethodArgument,
request: Request,
response_headers: MutableMapping[str, str],
):
annotations = argument.method.annotations.get(ResponseHeaderAnnotation)
annotation = [
annotation for annotation in annotations
if annotation.argument_name == argument.name
][0]
header_name = annotation.header_name
header = argument.type_(response_headers, header_name)
return header
def get_argument_info(argument: ComponentMethodArgument) -> dict:
try:
type_info = inspect_type(argument.type_)
invalid_hype_hint = False
except InspectorNotFound:
type_info = TypeInfo(openapi.TYPE_STRING)
invalid_hype_hint = True
type_info_data = type_info.as_dict()
description = argument.description
if invalid_hype_hint:
description = update_doc_with_invalid_hype_hint(description)
default = argument.get_default(None)
type_info_data['description'] = description
type_info_data['default'] = default
return type_info_data