comments and tests

Kinto · Feb 1, 2017 · 2941b5c · 2941b5c
1 parent 044ea62
commit 2941b5c
Show file tree

Hide file tree

Showing 3 changed files with 124 additions and 79 deletions.
diff --git a/kinto/core/resource/schema.py b/kinto/core/resource/schema.py
@@ -290,7 +290,7 @@ def deserialize(self, cstruct=colander.null):
 
 
 class CollectionQuerySchema(QuerySchema):
-    """Querystring validated fields used with collections."""
+    """Querystring schema used with collections."""
 
     _limit = QueryField(colander.Integer())
     _sort = FieldList()
@@ -303,13 +303,13 @@ class CollectionQuerySchema(QuerySchema):
 
 
 class RecordGetQuerySchema(QuerySchema):
-    """Querystring validated fields for GET record requests."""
+    """Querystring schema for GET record requests."""
 
     _fields = FieldList()
 
 
 class CollectionGetQuerySchema(CollectionQuerySchema):
-    """Querystring validated fields for GET collection requests."""
+    """Querystring schema for GET collection requests."""
 
     _fields = FieldList()
 

diff --git a/tests/core/resource/test_schema.py b/tests/core/resource/test_schema.py
@@ -195,102 +195,94 @@ def test_empty_raises_invalid(self):
                           value)
 
 
-class RequestSchemaTest(unittest.TestCase):
+class RecordSchemaTest(unittest.TestCase):
 
     def setUp(self):
-        self.schema = schema.RequestSchema()
+        self.schema = schema.RecordSchema()
 
-    def test_header_preserve_unkown_fields(self):
-        value = {'header': {'foo': 'bar'}}
-        deserialized = self.schema.deserialize(value)
+    def test_binds_data(self):
+        bound = self.schema.bind(data=schema.ResourceSchema())
+        value = {'data': {'foo': 'bar'}}
+        deserialized = bound.deserialize(value)
         self.assertEquals(deserialized, value)
 
-    def test_querystring_preserve_unkown_fields(self):
-        value = {'querystring': {'foo': 'bar'}}
-        deserialized = self.schema.deserialize(value)
+    def test_binds_permissions(self):
+        permissions = schema.PermissionsSchema(permissions=('sleep', ))
+        bound = self.schema.bind(permissions=permissions)
+        value = {'permissions': {'sleep': []}}
+        deserialized = bound.deserialize(value)
         self.assertEquals(deserialized, value)
 
-    def test_drops(self):
-        deserialized = self.schema.deserialize({})
-        self.assertEquals(deserialized, {})
-
-
-class GetRequestSchemaTest(unittest.TestCase):
-
-    def setUp(self):
-        self.schema = schema.RequestSchema().bind(
-            querystring=schema.RecordGetQuerySchema())
-
-    def test_get_deserialize_fields(self):
-        value = {'querystring': {'_fields': 'foo,bar'}}
-        deserialized = self.schema.deserialize(value)
-        expected = {'querystring': {'_fields': ['foo', 'bar']}}
-        self.assertEquals(deserialized, expected)
-
-
-class PatchRequestSchemaTest(unittest.TestCase):
-
-    def setUp(self):
-        self.schema = schema.RequestSchema().bind(
-            header=schema.PatchHeaderSchema())
-
-    def test_patch_deserialize_response_behavior(self):
-        value = {'header': {'Response-Behavior': 'diff'}}
-        deserialized = self.schema.deserialize(value)
+    def test_allow_binding_perms_after_data(self):
+        bound = self.schema.bind(data=schema.ResourceSchema())
+        permissions = schema.PermissionsSchema(permissions=('sleep', ))
+        bound = bound.bind(permissions=permissions)
+        value = {'data': {'foo': 'bar'}, 'permissions': {'sleep': []}}
+        deserialized = bound.deserialize(value)
         self.assertEquals(deserialized, value)
 
-    def test_patch_validate_response_behavior(self):
-        invalid = {'header': {'Response-Behavior': 'impolite'}}
-        self.assertRaises(colander.Invalid, self.schema.deserialize, invalid)
+    def test_doesnt_allow_permissions_unless_bound(self):
+        bound = self.schema.bind(data=schema.ResourceSchema())
+        value = {'permissions': {'sleep': []}}
+        self.assertRaises(colander.UnsupportedFields, bound.deserialize, value)
 
 
-class CollectionRequestSchemaTest(unittest.TestCase):
+class RequestSchemaTest(unittest.TestCase):
 
     def setUp(self):
-        self.schema = schema.RequestSchema().bind(
-            querystring=schema.CollectionQuerySchema())
-
-    def test_collection_deserialize_sort(self):
-        value = {'querystring': {'_sort': 'foo,-bar'}}
-        deserialized = self.schema.deserialize(value)
-        expected = {'querystring': {'_sort': ['foo', '-bar']}}
-        self.assertEquals(deserialized, expected)
+        self.schema = schema.RequestSchema()
 
-    def test_collection_validate_limit(self):
-        invalid = {'querystring': {'_limit': 'foo'}}
-        self.assertRaises(colander.Invalid, self.schema.deserialize, invalid)
+    def test_header_supports_binding(self):
+        header = colander.MappingSchema(missing={'foo': 'bar'})
+        bound = self.schema.bind(header=header)
+        deserialized = bound.deserialize({})
+        self.assertEquals(deserialized['header'], {'foo': 'bar'})
 
-    def test_collection_validate_since(self):
-        invalid = {'querystring': {'_since': 'bar'}}
-        self.assertRaises(colander.Invalid, self.schema.deserialize, invalid)
+    def test_querystring_supports_binding(self):
+        querystring = colander.MappingSchema(missing={'foo': 'bar'})
+        bound = self.schema.bind(querystring=querystring)
+        deserialized = bound.deserialize({})
+        self.assertEquals(deserialized['querystring'], {'foo': 'bar'})
 
-    def test_collection_validate_to(self):
-        invalid = {'querystring': {'_to': 'qux'}}
-        self.assertRaises(colander.Invalid, self.schema.deserialize, invalid)
+    def test_default_header_if_not_bound(self):
+        bound = self.schema.bind()
+        self.assertEquals(type(bound['header']), schema.HeaderSchema)
 
-    def test_collection_validate_before(self):
-        invalid = {'querystring': {'_before': 'bah'}}
-        self.assertRaises(colander.Invalid, self.schema.deserialize, invalid)
+    def test_default_querystring_if_not_bound(self):
+        bound = self.schema.bind()
+        self.assertEquals(type(bound['querystring']), schema.QuerySchema)
 
-    def test_collection_validate_last_modified(self):
-        invalid = {'querystring': {'last_modified': 'yesterday'}}
-        self.assertRaises(colander.Invalid, self.schema.deserialize, invalid)
+    def test_header_preserve_unkown_fields(self):
+        value = {'header': {'foo': 'bar'}}
+        deserialized = self.schema.bind().deserialize(value)
+        self.assertEquals(deserialized, value)
 
+    def test_querystring_preserve_unkown_fields(self):
+        value = {'querystring': {'foo': 'bar'}}
+        deserialized = self.schema.bind().deserialize(value)
+        self.assertEquals(deserialized, value)
 
-class CollectionGetRequestSchemaTest(unittest.TestCase):
+    def test_drops(self):
+        deserialized = self.schema.bind().deserialize({})
+        self.assertEquals(deserialized, {})
 
-    def setUp(self):
-        self.schema = schema.RequestSchema().bind(
-            querystring=schema.CollectionGetQuerySchema())
 
-    def test_deserialize_get_fields(self):
-        value = {'querystring': {'_fields': 'foo,bar'}}
-        deserialized = self.schema.deserialize(value)
-        expected = {'querystring': {'_fields': ['foo', 'bar']}}
-        self.assertEquals(deserialized, expected)
+class PayloadRequestSchemaTest(unittest.TestCase):
 
-    def test_deserialize_collection_fields(self):
-        value = {'querystring': {'_sort': 'foo,-bar'}}
-        deserialized = self.schema.deserialize(value)
-        expected = {'querystring': {'_sort': ['foo', '-bar']}}
-        self.assertEquals(deserialized, expected)
+    def setUp(self):
+        self.schema = schema.PayloadRequestSchema()
+
+    def test_body_supports_binding(self):
+        body = colander.MappingSchema(missing={'foo': 'bar'})
+        bound = self.schema.bind(body=body)
+        deserialized = bound.deserialize({})
+        self.assertEquals(deserialized['body'], {'foo': 'bar'})
+
+    def test_body_supports_binding_after_other_binds(self):
+        querystring = colander.MappingSchema(missing={'foo': 'bar'})
+        bound = self.schema.bind(querystring=querystring)
+        body = colander.MappingSchema(missing={'foo': 'beer'})
+        bound = bound.bind(body=body)
+        deserialized = bound.deserialize({})
+        self.assertEquals(deserialized['querystring'], {'foo': 'bar'})
+        self.assertEquals(deserialized['body'], {'foo': 'beer'})
diff --git a/tests/core/resource/test_viewset.py b/tests/core/resource/test_viewset.py
@@ -349,6 +349,59 @@ def test_is_endpoint_enabled_returns_true_for_head_if_readonly(self):
         self.assertTrue(is_enabled)
 
 
+class TestViewsetBindedSchemas(unittest.TestCase):
+
+    def setUp(self):
+        self.viewset = ViewSet()
+        self.resource = mock.MagicMock()
+
+    def test_request_schemas_have_header_and_querystring(self):
+        self.viewset = ViewSet(
+            default_get_arguments={},
+            default_record_arguments={},
+            record_get_arguments={}
+        )
+        arguments = self.viewset.record_arguments(self.resource, 'GET')
+        schema = arguments['schema']
+        self.assertIn('querystring', schema)
+        self.assertIn('header', schema)
+
+    def test_payload_request_schemas_have_a_body(self):
+        arguments = self.viewset.record_arguments(self.resource, 'PUT')
+        schema = arguments['schema']
+        self.assertIn('body', schema)
+
+    def test_collection_deserialize_sort(self):
+        arguments = self.viewset.collection_arguments(self.resource, 'DELETE')
+        schema = arguments['schema']
+        value = {'querystring': {'_sort': 'foo,-bar'}}
+        deserialized = schema.deserialize(value)
+        expected = {'querystring': {'_sort': ['foo', '-bar']}}
+        self.assertEquals(deserialized, expected)
+
+    def test_get_collection_deserialize_fields(self):
+        arguments = self.viewset.collection_arguments(self.resource, 'GET')
+        schema = arguments['schema']
+        value = {'querystring': {'_fields': 'foo,bar'}}
+        deserialized = schema.deserialize(value)
+        expected = {'querystring': {'_fields': ['foo', 'bar']}}
+        self.assertEquals(deserialized, expected)
+
+    def test_get_record_deserialize_fields(self):
+        arguments = self.viewset.record_arguments(self.resource, 'GET')
+        schema = arguments['schema']
+        value = {'querystring': {'_fields': 'foo,bar'}}
+        deserialized = schema.deserialize(value)
+        expected = {'querystring': {'_fields': ['foo', 'bar']}}
+        self.assertEquals(deserialized, expected)
+
+    def test_patch_record_validate_response_behavior(self):
+        arguments = self.viewset.collection_arguments(self.resource, 'PATCH')
+        schema = arguments['schema']
+        invalid = {'header': {'Response-Behavior': 'impolite'}}
+        self.assertRaises(colander.Invalid, schema.deserialize, invalid)
+
+
 class TestViewsetSchemasTest(unittest.TestCase):
 
     def test_partial_schema_ignores_unknown(self):