add jsonschema support and top level input validation

Author: nathancahill

.travis.yml

@@ -4,6 +4,7 @@ python:
 # command to install dependencies
 install:
   - pip install -r requirements.txt
+  - pip install jsonschema
   - pip install coveralls
 # command to run tests
 script: nosetests  --with-coverage --cover-package=flask_inputs

README.md

@@ -56,6 +56,34 @@ def api():
 
 If `validate()` returns `False`, error messages are listed in `inputs.errors`
 
+Alternatively, to validate an entire input (as opposed to single fields like above), validators can be attached directly:
+
+```
+class ApiInputs(Inputs):
+    args = [CustomArgValidator()]
+```
+
+In this case, the raw input data is passed to the validators.
+
+### JSON Validation
+
+Flask-Inputs provides a validator for JSON data. This requires [jsonschema](https://pypi.python.org/pypi/jsonschema).
+
+```
+from flask_inputs.validators import JsonSchema
+
+schema = {
+    'type': 'object',
+    'properties': {
+        'name': {'type': 'string'}
+    }
+}
+
+class JsonInputs(Inputs):
+    json = [JsonSchema(schema=schema)]
+```
+
+
 ### Goals
 
 #### Validate incoming request data

flask_inputs/inputs.py

@@ -1,4 +1,5 @@
 
+import collections
 from itertools import chain
 
 from werkzeug.datastructures import MultiDict
@@ -8,8 +9,8 @@
 
 
 class Inputs(object):
-    valid_attributes = ['args', 'form', 'values', 'cookies',
-                        'headers', 'json', 'rule']
+    _valid_attributes = ['args', 'form', 'values', 'cookies',
+                         'headers', 'json', 'rule']
 
     def __init__(self, request):
         """
@@ -30,28 +31,34 @@ class TellInputs(Inputs):
         self._forms = dict()
 
         for name in dir(self):
-            if not name.startswith('_'):
+            if not name.startswith('_') and name not in ['errors', 'validate']:
                 input = getattr(self, name)
+                fields = dict()
 
                 if isinstance(input, dict):
-                    fields = dict()
-
                     for field, validators in input.iteritems():
                         fields[field] = Field(validators=validators)
+                elif isinstance(input, collections.Iterable):
+                    fields['_input'] = Field(validators=input)
 
-                    self._forms[name] = BaseForm(fields)
+                self._forms[name] = BaseForm(fields)
 
-    def _get_values(self, attribute):
+    def _get_values(self, attribute, coerse=True):
         """
         :param attribute: Request attribute to return values for.
 
         Returns a MultiDict for compatibility with wtforms form data.
         """
-        if attribute in self.valid_attributes:
+        if attribute in self._valid_attributes:
             if attribute == 'rule':
-                return MultiDict(self._request.view_args)
+                ret = self._request.view_args
+            else:
+                ret = getattr(self._request, attribute)
 
-            return MultiDict(getattr(self._request, attribute))
+            if coerse:
+                return MultiDict(ret)
+            else:
+                return MultiDict(dict(_input=ret))
 
     def validate(self):
         """
@@ -60,7 +67,10 @@ def validate(self):
         success = True
 
         for attribute, form in self._forms.iteritems():
-            form.process(self._get_values(attribute))
+            if '_input' in form._fields:
+                form.process(self._get_values(attribute, coerse=False))
+            else:
+                form.process(self._get_values(attribute))
 
             if not form.validate():
                 success = False

flask_inputs/validators.py

@@ -0,0 +1,15 @@
+
+import jsonschema
+from wtforms.validators import ValidationError
+
+
+class JsonSchema(object):
+    def __init__(self, schema, message=None):
+        self.schema = schema
+        self.message = message
+
+    def __call__(self, form, field):
+        try:
+            jsonschema.validate(field.data, self.schema)
+        except jsonschema.ValidationError as e:
+            raise ValidationError(e.message)

tests/test_jsonschema.py

@@ -0,0 +1,45 @@
+
+import unittest
+
+from flask import Flask, request
+from flask_inputs import Inputs
+from flask_inputs.validators import JsonSchema
+
+
+app = Flask(__name__)
+
+schema = {
+    'type': 'object',
+    'properties': {
+        'name': {'type': 'string'}
+    }
+}
+
+
+class JsonInputs(Inputs):
+    json = [JsonSchema(schema=schema)]
+
+
+valid_data = '{"name": "Nathan Cahill"}'
+invalid_data = '{"name": 100}'
+
+
+class JsonSchemaTest(unittest.TestCase):
+    def test_valid(self):
+        with app.test_request_context(method='POST', data=valid_data, content_type='application/json'):
+            inputs = JsonInputs(request)
+
+            self.assertTrue(inputs.validate())
+
+    def test_invalid(self):
+        with app.test_request_context(method='POST', data=invalid_data, content_type='application/json'):
+            inputs = JsonInputs(request)
+
+            self.assertFalse(inputs.validate())
+
+    def test_error_messages(self):
+        with app.test_request_context(method='POST', data=invalid_data, content_type='application/json'):
+            inputs = JsonInputs(request)
+            inputs.validate()
+
+            self.assertEqual(inputs.errors, ["100 is not of type 'string'"])