Merge pull request #167 from labthings/dependabot/pip/webargs-7.0.1

Bump webargs from 6.1.1 to 7.0.1

Author: jtc42

poetry.lock

@@ -16,7 +16,7 @@ include = ["src/labthings/py.typed"]
 python = "^3.6"
 Flask = "^1.1.1"
 marshmallow = "^3.4.0"
-webargs = "^6.0.0"
+webargs = ">=6,<8"
 apispec = ">=3.2,<5.0"
 flask-cors = "^3.0.8"
 zeroconf = ">=0.24.5,<0.29.0"

pyproject.toml

@@ -1,6 +1,6 @@
 import logging
 from functools import update_wrapper, wraps
-from typing import Callable, Dict, Union
+from typing import Callable, Union, Mapping
 
 from flask import abort, request
 from marshmallow.exceptions import ValidationError
@@ -10,15 +10,8 @@
 from ..schema import FieldSchema, Schema
 
 
-class use_body:
-    """Gets the request body as a single value and adds it as a positional argument"""
-
-    def __init__(
-        self, schema: Union[Schema, Field, Dict[str, Union[Field, type]]], **_
-    ):
-        self.schema = schema
-
-    def __call__(self, f: Callable):
+def use_body(schema: Field, **_) -> Callable:
+    def inner(f: Callable):
         # Wrapper function
         @wraps(f)
         def wrapper(*args, **kwargs):
@@ -34,17 +27,17 @@ def wrapper(*args, **kwargs):
             # If no data is there
             if not data:
                 # If data is required
-                if self.schema.required:
+                if schema.required:
                     # Abort
                     return abort(400)
                 # Otherwise, look for the schema fields 'missing' property
-                if self.schema.missing:
-                    data = self.schema.missing
+                if schema.missing:
+                    data = schema.missing
 
             # Serialize data if it exists
             if data:
                 try:
-                    data = FieldSchema(self.schema).deserialize(data)
+                    data = FieldSchema(schema).deserialize(data)
                 except ValidationError as e:
                     logging.error(e)
                     return abort(400)
@@ -54,13 +47,13 @@ def wrapper(*args, **kwargs):
 
         return wrapper
 
+    return inner
+
 
 class use_args:
     """Equivalent to webargs.flask_parser.use_args"""
 
-    def __init__(
-        self, schema: Union[Schema, Field, Dict[str, Union[Field, type]]], **kwargs
-    ):
+    def __init__(self, schema: Union[Schema, Field, Mapping[str, Field]], **kwargs):
         self.schema = schema
 
         if isinstance(schema, Field):

src/labthings/marshalling/args.py

@@ -1,6 +1,6 @@
 from collections.abc import Mapping
 from functools import wraps
-from typing import Callable, Dict, Tuple, Union
+from typing import Callable, Dict, Tuple, Union, Optional
 
 from marshmallow import Schema as _Schema
 from werkzeug.wrappers import Response as ResponseBase
@@ -10,7 +10,9 @@
 from ..utilities import unpack
 
 
-def schema_to_converter(schema: Union[Schema, Field, Dict[str, Union[Field, type]]]):
+def schema_to_converter(
+    schema: Union[Schema, Field, Dict[str, Union[Field, type]]]
+) -> Optional[Callable]:
     """Convert a schema into a converter function,
     which takes a value as an argument and returns
     marshalled data

src/labthings/marshalling/marshalling.py

@@ -11,16 +11,12 @@
 from .names import ACTION_ENDPOINT, EXTENSION_LIST_ENDPOINT
 from .utilities import description_from_view, view_class_from_endpoint
 
-__all__ = [
-    "Schema",
-    "pre_load",
-    "pre_dump",
-    "validate",
-    "FuzzySchemaType"
-]
+__all__ = ["Schema", "pre_load", "pre_dump", "validate", "FuzzySchemaType"]
 
 # Type alias for a Schema, Field, or Dict of Fields or Types
 FuzzySchemaType = Union[Schema, fields.Field, Dict[str, Union[fields.Field, type]]]
+
+
 class FieldSchema(Schema):
     """ "Virtual schema" for handling individual fields treated as schemas.
 

src/labthings/schema.py

@@ -1,6 +1,6 @@
 import datetime
 from collections import OrderedDict
-from typing import Union, Dict, List, Optional, Set
+from typing import Dict, List, Optional, Set
 
 from flask import request
 from flask.views import MethodView
@@ -11,8 +11,12 @@
 from ..find import current_labthing, find_extension
 from ..marshalling import marshal_with, use_args
 from ..representations import DEFAULT_REPRESENTATIONS
-from ..schema import ActionSchema, EventSchema, Schema, FuzzySchemaType, build_action_schema
-from ..fields import Field
+from ..schema import (
+    ActionSchema,
+    EventSchema,
+    FuzzySchemaType,
+    build_action_schema,
+)
 from ..utilities import unpack
 from . import builder, op
 

src/labthings/views/__init__.py

@@ -0,0 +1,29 @@
+from labthings.marshalling import marshalling as ms
+from labthings.schema import Schema
+from labthings import fields
+
+
+def test_schema_to_converter_schema():
+    class TestSchema(Schema):
+        foo = fields.String()
+
+    test_schema = TestSchema()
+    converter = ms.schema_to_converter(test_schema)
+    assert converter == test_schema.dump
+    assert converter({"foo": 5}) == {"foo": "5"}
+
+
+def test_schema_to_converter_map():
+    test_schema = {"foo": fields.String()}
+    converter = ms.schema_to_converter(test_schema)
+    assert converter({"foo": 5}) == {"foo": "5"}
+
+
+def test_schema_to_converter_field():
+    field = fields.String()
+    converter = ms.schema_to_converter(field)
+    assert converter(5) == "5"
+
+
+def test_schema_to_converter_none():
+    assert ms.schema_to_converter(object()) is None

tests/test_marshalling.py

@@ -0,0 +1,97 @@
+from labthings import views, fields
+from labthings.schema import Schema
+from labthings.marshalling.args import use_args, use_body
+
+
+def test_use_body_string(app, client):
+    class Index(views.MethodView):
+        @use_body(fields.String(required=True))
+        def post(self, args):
+            return args
+
+    app.add_url_rule("/", view_func=Index.as_view("index"))
+
+    with client:
+        res = client.post("/", data="string", content_type="application/json")
+        assert res.data.decode() == "string"
+
+
+def test_use_body_no_data_error(app, client):
+    class Index(views.MethodView):
+        @use_body(fields.String(required=True))
+        def post(self, args):
+            return args
+
+    app.add_url_rule("/", view_func=Index.as_view("index"))
+
+    with client:
+        res = client.post("/", content_type="application/json")
+        assert res.status_code == 400
+
+
+def test_use_body_no_data_missing(app, client):
+    class Index(views.MethodView):
+        @use_body(fields.String(missing="default"))
+        def post(self, args):
+            return args
+
+    app.add_url_rule("/", view_func=Index.as_view("index"))
+
+    with client:
+        res = client.post("/", content_type="application/json")
+        assert res.data.decode() == "default"
+
+
+def test_use_body_validation_error(app, client):
+    class Index(views.MethodView):
+        @use_body(fields.String(required=True))
+        def post(self, args):
+            return args
+
+    app.add_url_rule("/", view_func=Index.as_view("index"))
+
+    with client:
+        res = client.post("/", json={"foo": "bar"}, content_type="application/json")
+        assert res.status_code == 400
+
+
+def test_use_args_field(app, client):
+    class Index(views.MethodView):
+        @use_args(fields.String(required=True))
+        def post(self, args):
+            return args
+
+    app.add_url_rule("/", view_func=Index.as_view("index"))
+
+    with client:
+        res = client.post("/", data="string", content_type="application/json")
+        assert res.data.decode() == "string"
+
+
+def test_use_args_map(app, client):
+    class Index(views.MethodView):
+        @use_args({"foo": fields.String(required=True)})
+        def post(self, args):
+            return args
+
+    app.add_url_rule("/", view_func=Index.as_view("index"))
+
+    with client:
+        res = client.post("/", json={"foo": "bar"}, content_type="application/json")
+        assert res.json == {"foo": "bar"}
+
+
+def test_use_args_schema(app, client):
+    class TestSchema(Schema):
+        foo = fields.String(required=True)
+
+    class Index(views.MethodView):
+        @use_args(TestSchema())
+        def post(self, args):
+            return args
+
+    app.add_url_rule("/", view_func=Index.as_view("index"))
+
+    with client:
+        res = client.post("/", json={"foo": "bar"}, content_type="application/json")
+        assert res.json == {"foo": "bar"}