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