manage correctly multiple values for query parameters

hapic/decorator.py

 # TODO BS 20171010: bottle specific !  # see #5
 import marshmallow
 from bottle import HTTPResponse
+from multidict import MultiDict
 
 from hapic.data import HapicData
 from hapic.description import ControllerDescription
     ) -> None:
         hapic_data.path = processed_data
 
-    def get_parameters_data(self, request_parameters: RequestParameters) -> dict:
+    def get_parameters_data(self, request_parameters: RequestParameters) -> dict:  # nopep8
         return request_parameters.path_parameters
 
 
 class InputQueryControllerWrapper(InputControllerWrapper):
+    def __init__(
+        self,
+        context: typing.Union[ContextInterface, typing.Callable[[], ContextInterface]],  # nopep8
+        processor: ProcessorInterface,
+        error_http_code: HTTPStatus=HTTPStatus.BAD_REQUEST,
+        default_http_code: HTTPStatus=HTTPStatus.OK,
+        as_list: typing.List[str]=None
+    ) -> None:
+        super().__init__(
+            context,
+            processor,
+            error_http_code,
+            default_http_code,
+        )
+        self.as_list = as_list or []  # FDV
+
     def update_hapic_data(
         self, hapic_data: HapicData,
         processed_data: typing.Any,
     ) -> None:
         hapic_data.query = processed_data
 
-    def get_parameters_data(self, request_parameters: RequestParameters) -> dict:
+    def get_parameters_data(self, request_parameters: RequestParameters) -> MultiDict:  # nopep8
+        # Parameters are updated considering eventual as_list parameters
+        if self.as_list:
+            query_parameters = MultiDict()
+            for parameter_name in request_parameters.query_parameters.keys():
+                if parameter_name in query_parameters:
+                    continue
+
+                if parameter_name in self.as_list:
+                    query_parameters[parameter_name] = \
+                        request_parameters.query_parameters.getall(
+                            parameter_name,
+                        )
+                else:
+                    query_parameters[parameter_name] = \
+                        request_parameters.query_parameters.get(
+                            parameter_name,
+                        )
+            return query_parameters
+
         return request_parameters.query_parameters
 
 
     ) -> None:
         hapic_data.body = processed_data
 
-    def get_parameters_data(self, request_parameters: RequestParameters) -> dict:
+    def get_parameters_data(self, request_parameters: RequestParameters) -> dict:  # nopep8
         return request_parameters.body_parameters
 
 
     ) -> None:
         hapic_data.headers = processed_data
 
-    def get_parameters_data(self, request_parameters: RequestParameters) -> dict:
+    def get_parameters_data(self, request_parameters: RequestParameters) -> dict:  # nopep8
         return request_parameters.header_parameters
 
 
     ) -> None:
         hapic_data.forms = processed_data
 
-    def get_parameters_data(self, request_parameters: RequestParameters) -> dict:
+    def get_parameters_data(self, request_parameters: RequestParameters) -> dict:  # nopep8
         return request_parameters.form_parameters
 
 
     ) -> None:
         hapic_data.files = processed_data
 
-    def get_parameters_data(self, request_parameters: RequestParameters) -> dict:
+    def get_parameters_data(self, request_parameters: RequestParameters) -> dict:  # nopep8
         return request_parameters.files_parameters
 
 

hapic/ext/bottle/context.py

 
 class BottleContext(ContextInterface):
     def get_request_parameters(self, *args, **kwargs) -> RequestParameters:
+        path_parameters = dict(bottle.request.url_args)
+        query_parameters = bottle.MultiDict(bottle.request.query)
+        body_parameters = dict(bottle.request.json)
+        form_parameters = bottle.MultiDict(bottle.request.forms)
+        header_parameters = dict(bottle.request.headers)
+        files_parameters = dict(bottle.request.files)
+
         return RequestParameters(
-            path_parameters=bottle.request.url_args,
-            query_parameters=bottle.request.query.dict,
-            body_parameters=bottle.request.json,
-            form_parameters=bottle.request.forms,
-            header_parameters=bottle.request.headers,
-            files_parameters=bottle.request.files,
+            path_parameters=path_parameters,
+            query_parameters=query_parameters,
+            body_parameters=body_parameters,
+            form_parameters=form_parameters,
+            header_parameters=header_parameters,
+            files_parameters=files_parameters,
         )
 
     def get_response(

hapic/processor.py

 # -*- coding: utf-8 -*-
 import typing
 
+from multidict import MultiDict
+
 from hapic.exception import OutputValidationException
 from hapic.exception import ConfigurationException
 
 class RequestParameters(object):
     def __init__(
         self,
-        path_parameters,
-        query_parameters,
-        body_parameters,
-        form_parameters,
-        header_parameters,
-        files_parameters,
+        path_parameters: dict,
+        query_parameters: MultiDict,
+        body_parameters: dict,
+        form_parameters: MultiDict,
+        header_parameters: dict,
+        files_parameters: dict,
     ):
+        """
+        :param path_parameters:
+
+        TODO Documenter + example pour chaque
+        ex: /api/user/<user_id> -> {'user_id': 'abc'}
+        ex: /api/user/<user_id> -> {'user_id': 'abc'}
+        ?resource_id=abc&resource_id=def ->
+
+        """
+        assert isinstance(query_parameters, MultiDict)
+        assert isinstance(form_parameters, MultiDict)
+
         self.path_parameters = path_parameters
         self.query_parameters = query_parameters
         self.body_parameters = body_parameters

setup.py

     'bottle',
     'marshmallow',
     'apispec==0.25.4-algoo',
+    'multidict'
 ]
 dependency_links = [
     'git+https://github.com/algoo/apispec.git@dev-algoo#egg=apispec-0.25.4-algoo'  # nopep8

tests/base.py

 import typing
 from http import HTTPStatus
 
+from multidict import MultiDict
+
 from hapic.context import ContextInterface
 from hapic.processor import RequestParameters
 from hapic.processor import ProcessValidationError
         fake_files_parameters=None,
     ) -> None:
         self.fake_path_parameters = fake_path_parameters or {}
-        self.fake_query_parameters = fake_query_parameters or {}
+        self.fake_query_parameters = fake_query_parameters or MultiDict()
         self.fake_body_parameters = fake_body_parameters or {}
-        self.fake_form_parameters = fake_form_parameters or {}
+        self.fake_form_parameters = fake_form_parameters or MultiDict()
         self.fake_header_parameters = fake_header_parameters or {}
         self.fake_files_parameters = fake_files_parameters or {}
 

tests/unit/test_decorator.py

 from http import HTTPStatus
 
 import marshmallow
+from multidict import MultiDict
 
 from hapic.data import HapicData
 from hapic.decorator import ExceptionHandlerControllerWrapper
+from hapic.decorator import InputQueryControllerWrapper
 from hapic.decorator import InputControllerWrapper
 from hapic.decorator import InputOutputControllerWrapper
 from hapic.decorator import OutputControllerWrapper
         )
 
 
+class MySimpleProcessor(ProcessorInterface):
+    def process(self, value):
+        return value
+
+    def get_validation_error(
+        self,
+        request_context: RequestParameters,
+    ) -> ProcessValidationError:
+        return ProcessValidationError(
+            details={
+                'original_request_context': request_context,
+            },
+            message='ERROR',
+        )
+
+
 class MyControllerWrapper(InputOutputControllerWrapper):
     def before_wrapped_func(
         self,
 
 class TestInputControllerWrapper(Base):
     def test_unit__input_data_wrapping__ok__nominal_case(self):
-        context = MyContext(fake_query_parameters={
-            'foo': 'bar',
-        })
+        context = MyContext(fake_query_parameters=MultiDict(
+            (
+                ('foo', 'bar',),
+            )
+        ))
         processor = MyProcessor()
         wrapper = MyInputQueryControllerWrapper(context, processor)
 
         result = func(42)
         assert result == 42
 
+    def test_unit__multi_query_param_values__ok__use_as_list(self):
+        context = MyContext(fake_query_parameters=MultiDict(
+            (
+                ('user_id', 'abc'),
+                ('user_id', 'def'),
+            ),
+        ))
+        processor = MySimpleProcessor()
+        wrapper = InputQueryControllerWrapper(
+            context,
+            processor,
+            as_list=['user_id'],
+        )
+
+        @wrapper.get_wrapper
+        def func(hapic_data=None):
+            assert hapic_data
+            assert isinstance(hapic_data, HapicData)
+            # see MyControllerWrapper#before_wrapped_func
+            assert ['abc', 'def'] == hapic_data.query.get('user_id')
+            return hapic_data.query.get('user_id')
+
+        result = func()
+        assert result == ['abc', 'def']
+
+    def test_unit__multi_query_param_values__ok__without_as_list(self):
+        context = MyContext(fake_query_parameters=MultiDict(
+            (
+                ('user_id', 'abc'),
+                ('user_id', 'def'),
+            ),
+        ))
+        processor = MySimpleProcessor()
+        wrapper = InputQueryControllerWrapper(
+            context,
+            processor,
+        )
+
+        @wrapper.get_wrapper
+        def func(hapic_data=None):
+            assert hapic_data
+            assert isinstance(hapic_data, HapicData)
+            # see MyControllerWrapper#before_wrapped_func
+            assert 'abc' == hapic_data.query.get('user_id')
+            return hapic_data.query.get('user_id')
+
+        result = func()
+        assert result == 'abc'
+
 
 class TestOutputControllerWrapper(Base):
     def test_unit__output_data_wrapping__ok__nominal_case(self):