Merge branch 'DamianHeard-issue-73' into dev

Author: sloria

tests/test_aiohttp/test_aiohttpparser.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 from webargs import fields
+from marshmallow import Schema
 
 import asyncio
 
@@ -85,6 +86,25 @@ def echo_cookie(request):
     assert res.status_code == 200
     assert res.json == {'mycookie': 'foo'}
 
+def test_parse_with_callable(app, client):
+
+    class MySchema(Schema):
+        foo = fields.Field(missing=42)
+
+    def make_schema(req):
+        return MySchema(context={'request': req})
+
+    @asyncio.coroutine
+    def echo_parse(request):
+        args = yield from parser.parse(make_schema, request)
+        return jsonify(args)
+
+    app.router.add_route('GET', '/factory', echo_parse)
+
+    res = client.get('/factory')
+    assert res.status_code == 200
+    assert res.json == {'foo': 42}
+
 
 def test_use_args(app, client):
 
@@ -104,6 +124,26 @@ def echo_use_args(request, args):
     assert res.json == {'name': 'Joe'}
 
 
+def test_use_args_with_callable(app, client):
+
+    class MySchema(Schema):
+        foo = fields.Field(missing=42)
+
+    def make_schema(req):
+        return MySchema(context={'request': req})
+
+    @asyncio.coroutine
+    @use_args(make_schema)
+    def echo_use_args(request, args):
+        return jsonify(args)
+
+    app.router.add_route('GET', '/use_args', echo_use_args)
+
+    res = client.get('/use_args')
+    assert res.status_code == 200
+    assert res.json == {'foo': 42}
+
+
 def test_use_kwargs_on_method(app, client):
     class Handler:
 

tests/test_core.py

@@ -3,7 +3,7 @@
 import sys
 
 import pytest
-from marshmallow import Schema
+from marshmallow import Schema, post_load
 from werkzeug.datastructures import MultiDict as WerkMultiDict
 
 PY26 = sys.version_info[0] == 2 and int(sys.version_info[1]) < 7
@@ -278,7 +278,10 @@ def validate2(args):
 def test_required_with_custom_error(web_request):
     web_request.json = {}
     parser = MockRequestParser()
-    args = {'foo': fields.Str(required='We need foo')}
+    args = {'foo': fields.Str(
+        required=True,
+        error_messages={'required': 'We need foo'})
+    }
     with pytest.raises(ValidationError) as excinfo:
         # Test that `validate` receives dictionary of args
         parser.parse(args, web_request, locations=('json', ))
@@ -441,6 +444,50 @@ def viewfunc(args):
     assert viewfunc() == {'username': 'foo', 'password': 'bar'}
 
 
+def test_parse_with_callable(web_request, parser):
+
+    web_request.json = {'foo': 42}
+
+    class MySchema(Schema):
+        foo = fields.Field()
+
+    def make_schema(req):
+        assert req is web_request
+        return MySchema(context={'request': req})
+
+    result = parser.parse(make_schema, web_request)
+
+    assert result == {'foo': 42}
+
+
+def test_use_args_callable(web_request, parser):
+    class HelloSchema(Schema):
+        name = fields.Str()
+
+        class Meta(object):
+            strict = True
+
+        @post_load
+        def request_data(self, item):
+            item['data'] = self.context['request'].data
+            return item
+
+    web_request.json = {'name': 'foo'}
+    web_request.data = 'request-data'
+
+    def make_schema(req):
+        assert req is web_request
+        return HelloSchema(context={'request': req})
+
+    @parser.use_args(
+        make_schema,
+        web_request,
+    )
+    def viewfunc(args):
+        return args
+    assert viewfunc() == {'name': 'foo', 'data': 'request-data'}
+
+
 class TestPassingSchema:
     class UserSchema(Schema):
         id = fields.Int(dump_only=True)

tests/test_pyramidparser.py

@@ -2,6 +2,7 @@
 
 import pytest
 from webtest import TestApp
+from marshmallow import Schema, post_load
 from pyramid.config import Configurator
 
 from webargs import fields
@@ -22,6 +23,19 @@
         error_messages={'validator_failed': "Houston, we've had a problem."}),
 }
 
+
+class HelloSchema(Schema):
+    name = fields.String()
+
+    @post_load
+    def greet(self, item):
+        item['url'] = self.context['request'].url
+        return item
+
+    class Meta(object):
+        strict = True
+
+
 @pytest.fixture
 def testapp():
     def echo(request):
@@ -69,6 +83,10 @@ def baz(request, myvalue):
     def matched(request, args):
         return args
 
+    @parser.use_args(lambda req: HelloSchema(context={'request': req}))
+    def constructor(request, args):
+        return args
+
     config = Configurator()
 
     config.add_route('echo', '/echo')
@@ -81,6 +99,7 @@ def matched(request, args):
     config.add_route('bar', '/bar')
     config.add_route('baz', '/baz')
     config.add_route('matched', '/matched/{mymatch:\d+}')
+    config.add_route('constructor', '/constructor')
 
     config.add_view(echo, route_name='echo', renderer='json')
     config.add_view(echomulti, route_name='echomulti', renderer='json')
@@ -92,6 +111,7 @@ def matched(request, args):
     config.add_view(Bar, route_name='bar', renderer='json')
     config.add_view(baz, route_name='baz', renderer='json')
     config.add_view(matched, route_name='matched', renderer='json')
+    config.add_view(constructor, route_name='constructor', renderer='json')
 
     app = config.make_wsgi_app()
 
@@ -153,3 +173,8 @@ def test_user_kwargs_decorator(testapp):
 def test_parse_matchdict(testapp):
     res = testapp.get('/matched/1')
     assert res.json == {'mymatch': 1}
+
+
+def test_use_args_callable(testapp):
+    res = testapp.post('/constructor', {'name': 'Jean-Luc Picard'})
+    assert res.json == {'name': 'Jean-Luc Picard', 'url': 'http://localhost/constructor'}

webargs/async.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 """Asynchronous request parser. Compatible with Python>=3.4."""
 import asyncio
+import collections
 import inspect
 import functools
 
@@ -15,8 +16,8 @@ class AsyncParser(core.Parser):
     """
 
     @asyncio.coroutine
-    def _parse_request(self, argmap, req, locations):
-        argdict = argmap.fields if isinstance(argmap, ma.Schema) else argmap
+    def _parse_request(self, schema, req, locations):
+        argdict = schema.fields
         parsed = {}
         for argname, field_obj in iteritems(argdict):
             parsed_value = yield from self.parse_arg(argname, field_obj, req,
@@ -35,9 +36,10 @@ def parse(self, argmap, req=None, locations=None, validate=None, force_all=False
         assert req is not None, 'Must pass req object'
         ret = None
         validators = core._ensure_list_of_callables(validate)
+        schema = self._get_schema(argmap, req)
         try:
-            parsed = yield from self._parse_request(argmap, req, locations)
-            result = self.load(parsed, argmap)
+            parsed = yield from self._parse_request(schema=schema, req=req, locations=locations)
+            result = self.load(parsed, schema)
             self._validate_arguments(result.data, validators)
         except ma.exceptions.ValidationError as error:
             self._on_validation_error(error)
@@ -60,11 +62,11 @@ def use_args(self, argmap, req=None, locations=None, as_kwargs=False, validate=N
         Receives the same arguments as `webargs.core.Parser.use_args`.
         """
         locations = locations or self.locations
-        if isinstance(argmap, ma.Schema):
-            schema = argmap
-        else:
-            schema = core.argmap2schema(argmap)()
         request_obj = req
+        # Optimization: If argmap is passed as a dictionary, we only need
+        # to generate a Schema once
+        if isinstance(argmap, collections.Mapping):
+            argmap = core.argmap2schema(argmap)()
 
         def decorator(func):
             req_ = request_obj
@@ -78,8 +80,10 @@ def wrapper(*args, **kwargs):
 
                 if not req_obj:
                     req_obj = self.get_request_from_view_args(func, args, kwargs)
-                parsed_args = yield from self.parse(schema, req=req_obj, locations=locations,
-                                         validate=validate, force_all=force_all)
+                # NOTE: At this point, argmap may be a Schema, callable, or dict
+                parsed_args = yield from self.parse(argmap,
+                                                    req=req_obj, locations=locations,
+                                                    validate=validate, force_all=force_all)
                 if as_kwargs:
                     kwargs.update(parsed_args)
                     return func(*args, **kwargs)

webargs/core.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 from __future__ import unicode_literals
 
+import collections
 import functools
 import inspect
 import logging
@@ -220,8 +221,9 @@ def parse_arg(self, name, field, req, locations=None):
                 return value
         return missing
 
-    def _parse_request(self, argmap, req, locations):
-        argdict = argmap.fields if isinstance(argmap, ma.Schema) else argmap
+    def _parse_request(self, schema, req, locations):
+        """Return a parsed arguments dictionary for the current request."""
+        argdict = schema.fields
         parsed = {}
         for argname, field_obj in iteritems(argdict):
             parsed_value = self.parse_arg(argname, field_obj, req,
@@ -262,11 +264,28 @@ def _validate_arguments(self, data, validators):
                 msg = self.DEFAULT_VALIDATION_MESSAGE
                 raise ValidationError(msg, data=data)
 
+    def _get_schema(self, argmap, req):
+        """Return a `marshmallow.Schema` for the given argmap and request.
+
+        :param argmap: Either a `marshmallow.Schema`, `dict`, or callable that returns
+            a `marshmallow.Schema` instance.
+        :param req: The request object being parsed.
+        :rtype: marshmallow.Schema
+        """
+        if isinstance(argmap, ma.Schema):
+            schema = argmap
+        elif callable(argmap):
+            schema = argmap(req)
+        else:
+            schema = argmap2schema(argmap)()
+        return schema
+
     def parse(self, argmap, req=None, locations=None, validate=None, force_all=False):
         """Main request parsing method.
 
-        :param dict argmap: Either a `marshmallow.Schema` or a `dict`
-            of argname -> `marshmallow.fields.Field` pairs.
+        :param argmap: Either a `marshmallow.Schema`, `dict`
+            of argname -> `marshmallow.fields.Field` pairs, or a callable that returns
+            a `marshmallow.Schema` instance.
         :param req: The request object to parse.
         :param tuple locations: Where on the request to search for values.
             Can include one or more of ``('json', 'querystring', 'form',
@@ -281,9 +300,10 @@ def parse(self, argmap, req=None, locations=None, validate=None, force_all=False
         assert req is not None, 'Must pass req object'
         ret = None
         validators = _ensure_list_of_callables(validate)
+        schema = self._get_schema(argmap, req)
         try:
-            parsed = self._parse_request(argmap, req, locations)
-            result = self.load(parsed, argmap)
+            parsed = self._parse_request(schema=schema, req=req, locations=locations)
+            result = self.load(parsed, schema)
             self._validate_arguments(result.data, validators)
         except ma.exceptions.ValidationError as error:
             self._on_validation_error(error)
@@ -330,20 +350,21 @@ def use_args(self, argmap, req=None, locations=None, as_kwargs=False, validate=N
             def greet(args):
                 return 'Hello ' + args['name']
 
-        :param dict argmap: Either a `marshmallow.Schema` or a `dict`
-            of argname -> `marshmallow.fields.Field` pairs.
+        :param dict argmap: Either a `marshmallow.Schema`, a `dict`
+            of argname -> `marshmallow.fields.Field` pairs, or a callable
+            which accepts a request and returns a `marshmallow.Schema`.
         :param tuple locations: Where on the request to search for values.
         :param bool as_kwargs: Whether to insert arguments as keyword arguments.
         :param callable validate: Validation function that receives the dictionary
             of parsed arguments. If the function returns ``False``, the parser
             will raise a :exc:`ValidationError`.
         """
         locations = locations or self.locations
-        if isinstance(argmap, ma.Schema):
-            schema = argmap
-        else:
-            schema = argmap2schema(argmap)()
         request_obj = req
+        # Optimization: If argmap is passed as a dictionary, we only need
+        # to generate a Schema once
+        if isinstance(argmap, collections.Mapping):
+            argmap = argmap2schema(argmap)()
 
         def decorator(func):
             req_ = request_obj
@@ -357,8 +378,10 @@ def wrapper(*args, **kwargs):
 
                 if not req_obj:
                     req_obj = self.get_request_from_view_args(func, args, kwargs)
-                parsed_args = self.parse(schema, req=req_obj, locations=locations,
-                                         validate=validate, force_all=force_all)
+                # NOTE: At this point, argmap may be a Schema, callable, or dict
+                parsed_args = self.parse(argmap, req=req_obj,
+                                         locations=locations, validate=validate,
+                                         force_all=force_all)
                 if as_kwargs:
                     kwargs.update(parsed_args)
                     return func(*args, **kwargs)

webargs/pyramidparser.py

@@ -89,8 +89,9 @@ def use_args(self, argmap, req=None, locations=core.Parser.DEFAULT_LOCATIONS,
         Supports the *Class-based View* pattern where `request` is saved as an instance
         attribute on a view class.
 
-        :param dict argmap: Either a `marshmallow.Schema` or a `dict`
-            of argname -> `marshmallow.fields.Field` pairs.
+        :param dict argmap: Either a `marshmallow.Schema`, a `dict`
+            of argname -> `marshmallow.fields.Field` pairs, or a callable
+            which accepts a request and returns a `marshmallow.Schema`.
         :param req: The request object to parse. Pulled off of the view by default.
         :param tuple locations: Where on the request to search for values.
         :param bool as_kwargs: Whether to insert arguments as keyword arguments.
@@ -101,6 +102,8 @@ def use_args(self, argmap, req=None, locations=core.Parser.DEFAULT_LOCATIONS,
         locations = locations or self.locations
         if isinstance(argmap, ma.Schema):
             schema = argmap
+        elif callable(argmap):
+            schema = None
         else:
             schema = core.argmap2schema(argmap)()
 
@@ -112,8 +115,10 @@ def wrapper(obj, *args, **kwargs):
                     request = req or obj.request
                 except AttributeError:  # first arg is request
                     request = obj
-                parsed_args = self.parse(schema, req=request, locations=locations,
-                                         validate=validate, force_all=as_kwargs)
+
+                parsed_args = self.parse(schema or argmap(request), req=request,
+                                         locations=locations, validate=validate,
+                                         force_all=as_kwargs)
                 if as_kwargs:
                     kwargs.update(parsed_args)
                     return func(obj, *args, **kwargs)