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 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()