Rewrite with using winter.core (#58)

* Use winter.core

* Delete __eq__ and __hash__

* Fix imports and use get one or none

* Fix input serializer

* Fix get_query_param_mapping

* Fix valiables in tests

* Fix exceptions in annotations

* Fix tests

* Add tests for core

* Add test with serializer

* Changes accotding to review

* Change version

* delete not used variable

* Add tests for SwaggerAutoSchema

Small fixes

* Fix auto_schema

* Fix SwaggerAutoShema

* Fix SwaggerAutoSchema

tests/controllers/__init__.py

@@ -1,5 +1,6 @@
 from .controller_with_exceptions import ControllerWithExceptions
 from .controller_with_media_types_routing import ControllerWithMediaTypesRouting
 from .controller_with_path_parameters import ControllerWithPathParameters
+from .controller_with_serializer import ControllerWithSerializer
 from .no_authentication_controller import NoAuthenticationController
 from .simple_controller import SimpleController

tests/controllers/controller_with_exceptions.py

@@ -5,6 +5,7 @@
 
 
 class CustomException(Exception):
+
     def __init__(self, message: str):
         super().__init__(message)
         self.message = message
@@ -20,6 +21,7 @@ class CustomExceptionDTO:
 
 
 class CustomExceptionHandler(winter.ExceptionHandler):
+
     @winter.response_status(400)
     def handle(self, request: Request, exception: CustomException) -> CustomExceptionDTO:
         return CustomExceptionDTO(exception.message)

tests/controllers/controller_with_path_parameters.py

@@ -14,7 +14,7 @@ class OneTwoEnumWithInt(enum.Enum):
     TWO = 2
 
     @classmethod
-    def _missing_(cls, value): # This is need because of needing of instancing from string
+    def _missing_(cls, value):  # This is need because of needing of instancing from string
         try:
             value = int(value)
         except ValueError:
@@ -27,8 +27,8 @@ def _missing_(cls, value): # This is need because of needing of instancing from
 @winter.route('controller_with_path_parameters/{param1}/')
 class ControllerWithPathParameters:
 
-    @winter.route_get('{param2}/{param3}/{param4}/{param5}/')
     @winter.query_parameter('param6')
+    @winter.route_get('{param2}/{param3}/{param4}/{param5}/')
     def test(
             self,
             param1: str,

tests/controllers/controller_with_serializer.py

@@ -0,0 +1,24 @@
+import dataclasses
+from rest_framework import serializers
+
+import winter
+
+
+@dataclasses.dataclass
+class SimpleDTO:
+    number: int
+
+
+class SimpleSerializer(serializers.Serializer):
+    number = serializers.IntegerField()
+
+
+@winter.controller
+@winter.route('with-serializer')
+class ControllerWithSerializer:
+
+    @winter.route_post('/')
+    @winter.input_serializer(SimpleSerializer, argument_name='input_data')
+    @winter.output_serializer(SimpleSerializer)
+    def simple_method(self, input_data: dict) -> SimpleDTO:
+        return SimpleDTO(input_data['number'] + 1)

tests/controllers/no_authentication_controller.py

@@ -6,7 +6,7 @@
 @winter.no_authentication
 class NoAuthenticationController:
 
-    @winter.route_get('/')
     @winter.query_parameter('name')
+    @winter.route_get('/')
     def hello(self) -> str:
         return f'Hello, World!'

tests/controllers/simple_controller.py

@@ -14,8 +14,8 @@ class Dataclass:
 @winter.route('winter_simple/')
 class SimpleController:
 
-    @winter.route_get()
     @winter.query_parameter('name')
+    @winter.route_get()
     def hello(self, name: str = 'stranger') -> str:
         return f'Hello, {name}!'
 

tests/pagination/test_page_position_argument_inspector.py

@@ -1,6 +1,6 @@
 import pytest
 
-from winter.controller import ControllerMethod
+from winter.core import ComponentMethod
 from winter.pagination import PagePosition
 from winter.pagination import PagePositionArgumentInspector
 from winter.pagination import PagePositionArgumentResolver
@@ -14,7 +14,7 @@ def test_page_position_argument_inspector(argument_type, must_return_parameters)
     def func(arg1: argument_type):
         return arg1
 
-    controller_method = ControllerMethod(func)
+    method = ComponentMethod(func)
     resolver = PagePositionArgumentResolver()
     inspector = PagePositionArgumentInspector(resolver)
 
@@ -27,7 +27,7 @@ def func(arg1: argument_type):
         expected_parameters = []
 
     # Act
-    parameters = inspector.inspect_parameters(controller_method)
+    parameters = inspector.inspect_parameters(method)
 
     # Assert
     assert parameters == expected_parameters

tests/pagination/test_page_position_argument_resolver.py

@@ -5,7 +5,7 @@
 from rest_framework.exceptions import ValidationError
 from rest_framework.request import Request as DRFRequest
 
-from winter.controller import ControllerMethod
+from winter.core import ComponentMethod
 from winter.pagination import PagePosition
 from winter.pagination import PagePositionArgumentResolver
 
@@ -18,8 +18,8 @@ def test_is_supported_in_page_position_argument_resolver(argument_type, expected
     def func(arg1: argument_type):
         return arg1
 
-    controller_method = ControllerMethod(func)
-    argument = controller_method.get_argument('arg1')
+    method = ComponentMethod(func)
+    argument = method.get_argument('arg1')
     resolver = PagePositionArgumentResolver()
 
     # Act
@@ -40,8 +40,8 @@ def test_resolve_argument_in_page_position_argument_resolver(query_string, expec
     def func(arg1: int):
         return arg1
 
-    controller_method = ControllerMethod(func)
-    argument = controller_method.get_argument('arg1')
+    method = ComponentMethod(func)
+    argument = method.get_argument('arg1')
 
     resolver = PagePositionArgumentResolver()
 
@@ -63,8 +63,8 @@ def test_resolve_argument_in_page_position_argument_resolver_with_raises(query_s
     def func(arg1: int):
         return arg1
 
-    controller_method = ControllerMethod(func)
-    argument = controller_method.get_argument('arg1')
+    method = ComponentMethod(func)
+    argument = method.get_argument('arg1')
 
     request = Mock(spec=DRFRequest)
     request.query_params = QueryDict(query_string)

tests/schema/test_argument_type_info.py

@@ -5,7 +5,7 @@
 import pytest
 from drf_yasg import openapi
 
-from winter.controller import ControllerMethod
+from winter.core import ComponentMethod
 
 from winter.schema.generation import get_argument_type_info
 
@@ -44,7 +44,7 @@ def test_get_argument_type_info(type_hint, expected_type_info):
     def func(arg_1: type_hint):
         return arg_1
 
-    argument = ControllerMethod(func).get_argument('arg_1')
+    argument = ComponentMethod(func).get_argument('arg_1')
 
     # Act
     type_info = get_argument_type_info(argument)

tests/schema/test_response_schema.py

@@ -4,7 +4,8 @@
 import pytest
 from drf_yasg import openapi
 
-from winter.controller import get_controller_component
+from winter.controller import get_component
+from winter.routing.routing import get_route
 from winter.schema.generation import build_responses_schemas
 from ..controllers import ControllerWithExceptions
 
@@ -24,11 +25,12 @@
     }),
 ])
 def test_response_schema(controller_class: Type, method_name: str, expected_responses: Dict):
-    controller_component = get_controller_component(controller_class)
-    method = controller_component.get_method(method_name)
+    component = get_component(controller_class)
+    method = component.get_method(method_name)
+    route = get_route(method)
 
     # Act
-    responses = build_responses_schemas(method)
+    responses = build_responses_schemas(route)
 
     # Assert
     assert responses == expected_responses

tests/test_argument_resolver.py

@@ -3,9 +3,11 @@
 import pytest
 from mock import Mock
 
-from winter import GenericArgumentResolver, ArgumentsResolver
+from winter import ArgumentsResolver
+from winter import GenericArgumentResolver
 from winter.argument_resolver import ArgumentNotSupported
-from winter.controller import ControllerMethodArgument, ControllerMethod
+from winter.core import ComponentMethod
+from winter.core import ComponentMethodArgument
 
 
 @pytest.mark.parametrize('arg_name, arg_type, resolver_arg_name, resolver_arg_type, expected_supported', [
@@ -17,7 +19,7 @@
 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 = ControllerMethodArgument(Mock(), arg_name, arg_type)
+    argument = ComponentMethodArgument(Mock(), arg_name, arg_type)
 
     # Act
     is_supported = generic_argument_resolver.is_supported(argument)
@@ -31,7 +33,7 @@ def test_generic_argument_resolver_resolve_argument():
     arg_name = 'a'
     arg_type = int
     expected_result = 1
-    argument = ControllerMethodArgument(Mock(), arg_name, arg_type)
+    argument = ComponentMethodArgument(Mock(), arg_name, arg_type)
     resolve_argument_mock = Mock()
     resolve_argument_mock.return_value = expected_result
     generic_argument_resolver = GenericArgumentResolver(arg_name, arg_type, resolve_argument_mock)
@@ -50,11 +52,11 @@ def func():
         pass
 
     expected_resolved_arguments = {}
-    controller_method = ControllerMethod(func)
+    method = ComponentMethod(func)
     arguments_resolver = ArgumentsResolver()
 
     # Act
-    resolved_arguments = arguments_resolver.resolve_arguments(controller_method, http_request=Mock())
+    resolved_arguments = arguments_resolver.resolve_arguments(method, http_request=Mock())
 
     # Assert
     assert resolved_arguments == expected_resolved_arguments
@@ -66,15 +68,15 @@ def func(a: int):
 
     expected_resolved_value = 1
     expected_resolved_arguments = {'a': expected_resolved_value}
-    controller_method = ControllerMethod(func)
+    method = ComponentMethod(func)
     arguments_resolver = ArgumentsResolver()
     resolver = Mock()
     resolver.is_supported.return_value = True
     resolver.resolve_argument.return_value = expected_resolved_value
     arguments_resolver.add_argument_resolver(resolver)
 
     # Act
-    resolved_arguments = arguments_resolver.resolve_arguments(controller_method, http_request=Mock())
+    resolved_arguments = arguments_resolver.resolve_arguments(method, http_request=Mock())
 
     # Assert
     assert resolved_arguments == expected_resolved_arguments
@@ -86,7 +88,7 @@ def func(a: int):
 
     expected_resolved_value = 1
     expected_resolved_arguments = {'a': expected_resolved_value}
-    controller_method = ControllerMethod(func)
+    method = ComponentMethod(func)
     arguments_resolver = ArgumentsResolver()
     resolver1 = Mock()
     resolver1.is_supported.return_value = False
@@ -97,7 +99,7 @@ def func(a: int):
     arguments_resolver.add_argument_resolver(resolver2)
 
     # Act
-    resolved_arguments = arguments_resolver.resolve_arguments(controller_method, http_request=Mock())
+    resolved_arguments = arguments_resolver.resolve_arguments(method, http_request=Mock())
 
     # Assert
     assert resolved_arguments == expected_resolved_arguments
@@ -108,13 +110,13 @@ def func(a: int):
         pass
 
     arg_name = 'a'
-    controller_method = ControllerMethod(func)
+    method = ComponentMethod(func)
     arguments_resolver = ArgumentsResolver()
 
     # Assert
     with pytest.raises(ArgumentNotSupported, match=f'Unable to resolve argument {arg_name}: int'):
         # Act
-        arguments_resolver.resolve_arguments(controller_method, http_request=Mock())
+        arguments_resolver.resolve_arguments(method, http_request=Mock())
 
 
 @pytest.mark.parametrize('resolver1_supported, resolver2_supported', itertools.product([False, True], repeat=2))

tests/test_controller_with_serializer.py

@@ -0,0 +1,17 @@
+from rest_framework.test import APIClient
+
+from tests.entities import AuthorizedUser
+
+
+def test_controller_with_serializer():
+    client = APIClient()
+    user = AuthorizedUser()
+    client.force_authenticate(user)
+
+    data = {'number': 1}
+    expected_data = {'number': 2}
+
+    response = client.post('/with-serializer/', data=data)
+
+    assert response.status_code == 200
+    assert response.json() == expected_data