patch existing tests to match changes

kinto/core/resource/schema.py

@@ -1,7 +1,8 @@
+import six
 import colander
 from colander import SchemaNode, String
 
-from kinto.core.utils import strip_whitespace, msec_time
+from kinto.core.utils import strip_whitespace, msec_time, decode_header
 
 
 class ResourceSchema(colander.MappingSchema):
@@ -177,6 +178,12 @@ class HeaderQuotedInteger(colander.SchemaNode):
                              colander.Regex('\*'))
 
     def deserialize(self, cstruct=colander.null):
+        if isinstance(cstruct, six.string_types):
+            try:
+                cstruct = decode_header(cstruct)
+            except:
+                raise colander.Invalid(self, msg=self.error_message)
+
         param = super(HeaderQuotedInteger, self).deserialize(cstruct)
         if param is colander.drop or param == '*':
             return param

tests/core/resource/test_filter.py

@@ -7,6 +7,7 @@
 class FilteringTest(BaseTest):
     def setUp(self):
         super(FilteringTest, self).setUp()
+        self.validated = self.resource.request.validated
         self.patch_known_field.start()
         records = [
             {'title': 'MoFo', 'status': 0, 'favorite': True},
@@ -25,51 +26,51 @@ def test_list_can_be_filtered_on_deleted_with_since(self):
         since = self.model.timestamp()
         r = self.model.create_record({})
         self.model.delete_record(r)
-        self.resource.request.GET = {'_since': '%s' % since, 'deleted': 'true'}
+        self.validated['querystring'] = {'_since': '%s' % since, 'deleted': 'true'}
         result = self.resource.collection_get()
         self.assertEqual(len(result['data']), 1)
         self.assertTrue(result['data'][0]['deleted'])
 
     def test_filter_on_id_is_supported(self):
         self.patch_known_field.stop()
         r = self.model.create_record({})
-        self.resource.request.GET = {'id': '%s' % r['id']}
+        self.validated['querystring'] = {'id': '%s' % r['id']}
         result = self.resource.collection_get()
         self.assertEqual(result['data'][0], r)
 
     def test_list_cannot_be_filtered_on_deleted_without_since(self):
         r = self.model.create_record({})
         self.model.delete_record(r)
-        self.resource.request.GET = {'deleted': 'true'}
+        self.validated['querystring'] = {'deleted': 'true'}
         result = self.resource.collection_get()
         self.assertEqual(len(result['data']), 0)
 
     def test_filter_works_with_empty_list(self):
         self.resource.model.parent_id = 'alice'
-        self.resource.request.GET = {'status': '1'}
+        self.validated['querystring'] = {'status': '1'}
         result = self.resource.collection_get()
         self.assertEqual(len(result['data']), 0)
 
     def test_number_of_records_matches_filter(self):
-        self.resource.request.GET = {'status': '1'}
+        self.validated['querystring'] = {'status': '1'}
         self.resource.collection_get()
         headers = self.last_response.headers
         self.assertEqual(int(headers['Total-Records']), 2)
 
     def test_single_basic_filter_by_attribute(self):
-        self.resource.request.GET = {'status': '1'}
+        self.validated['querystring'] = {'status': '1'}
         result = self.resource.collection_get()
         self.assertEqual(len(result['data']), 2)
 
     def test_filter_on_unknown_attribute_raises_error(self):
         self.patch_known_field.stop()
-        self.resource.request.GET = {'foo': '1'}
+        self.validated['querystring'] = {'foo': '1'}
         self.assertRaises(httpexceptions.HTTPBadRequest,
                           self.resource.collection_get)
 
     def test_filter_errors_are_json_formatted(self):
         self.patch_known_field.stop()
-        self.resource.request.GET = {'foo': '1'}
+        self.validated['querystring'] = {'foo': '1'}
         try:
             self.resource.collection_get()
         except httpexceptions.HTTPBadRequest as e:
@@ -85,119 +86,120 @@ def test_filter_errors_are_json_formatted(self):
 
     def test_regexp_is_strict_for_min_and_max(self):
         self.patch_known_field.stop()
-        self.resource.request.GET = {'madmax_status': '1'}
+        self.validated['querystring'] = {'madmax_status': '1'}
         self.assertRaises(httpexceptions.HTTPBadRequest,
                           self.resource.collection_get)
 
     def test_double_basic_filter_by_attribute(self):
-        self.resource.request.GET = {'status': '1', 'favorite': 'true'}
+        self.validated['querystring'] = {'status': '1', 'favorite': 'true'}
         result = self.resource.collection_get()
         self.assertEqual(len(result['data']), 1)
 
     def test_string_filters_naively_by_value(self):
-        self.resource.request.GET = {'title': 'MoF'}
+        self.validated['querystring'] = {'title': 'MoF'}
         result = self.resource.collection_get()
         self.assertEqual(len(result['data']), 0)
-        self.resource.request.GET = {'title': 'MoFo'}
+        self.validated['querystring'] = {'title': 'MoFo'}
         result = self.resource.collection_get()
         self.assertEqual(len(result['data']), 6)
 
     def test_string_filters_searching_by_value_not_matching(self):
-        self.resource.request.GET = {'like_title': 'MoFoo'}
+        self.validated['querystring'] = {'like_title': 'MoFoo'}
         result = self.resource.collection_get()
         self.assertEqual(len(result['data']), 0)
 
     def test_string_filters_searching_by_value_matching_many(self):
-        self.resource.request.GET = {'like_title': 'Fo'}
+        self.validated['querystring'] = {'like_title': 'Fo'}
         result = self.resource.collection_get()
         self.assertEqual(len(result['data']), 7)
 
     def test_string_filters_searching_by_value_matching_one(self):
-        self.resource.request.GET = {'like_title': 'Bar'}
+        self.validated['querystring'] = {'like_title': 'Bar'}
         result = self.resource.collection_get()
         self.assertEqual(len(result['data']), 1)
 
     def test_string_filters_searching_by_value_matching_vary_case(self):
-        self.resource.request.GET = {'like_title': 'FoO'}
+        self.validated['querystring'] = {'like_title': 'FoO'}
         result = self.resource.collection_get()
         self.assertEqual(len(result['data']), 1)
 
     def test_filter_considers_string_if_syntaxically_invalid(self):
-        self.resource.request.GET = {'status': '1.2.3'}
+        self.validated['querystring'] = {'status': '1.2.3'}
         result = self.resource.collection_get()
         self.assertEqual(len(result['data']), 0)
 
     def test_filter_does_not_fail_with_complex_type_syntax(self):
-        self.resource.request.GET = {'status': '(1,2,3)'}
+        self.validated['querystring'] = {'status': '(1,2,3)'}
         result = self.resource.collection_get()
         self.assertEqual(len(result['data']), 0)
 
     def test_different_value(self):
-        self.resource.request.GET = {'not_status': '2'}
+        self.validated['querystring'] = {'not_status': '2'}
         result = self.resource.collection_get()
         values = [item['status'] for item in result['data']]
         self.assertTrue(all([value != 2 for value in values]))
 
     def test_minimal_value(self):
-        self.resource.request.GET = {'min_status': '2'}
+        self.validated['querystring'] = {'min_status': '2'}
         result = self.resource.collection_get()
         values = [item['status'] for item in result['data']]
         self.assertTrue(all([value >= 2 for value in values]))
 
     def test_gt_value(self):
-        self.resource.request.GET = {'gt_status': '2'}
+        self.validated['querystring'] = {'gt_status': '2'}
         result = self.resource.collection_get()
         values = [item['status'] for item in result['data']]
         self.assertTrue(all([value > 2 for value in values]))
 
     def test_maximal_value(self):
-        self.resource.request.GET = {'max_status': '2'}
+        self.validated['querystring'] = {'max_status': '2'}
         result = self.resource.collection_get()
         values = [item['status'] for item in result['data']]
         self.assertTrue(all([value <= 2 for value in values]))
 
     def test_lt_value(self):
-        self.resource.request.GET = {'lt_status': '2'}
+        self.validated['querystring'] = {'lt_status': '2'}
         result = self.resource.collection_get()
         values = [item['status'] for item in result['data']]
         self.assertTrue(all([value < 2 for value in values]))
 
     def test_in_values(self):
-        self.resource.request.GET = {'in_status': '0,1'}
+        self.validated['querystring'] = {'in_status': '0,1'}
         result = self.resource.collection_get()
         values = [item['status'] for item in result['data']]
         self.assertEqual(sorted(values), [0, 0, 1, 1])
 
     def test_exclude_values(self):
-        self.resource.request.GET = {'exclude_status': '0'}
+        self.validated['querystring'] = {'exclude_status': '0'}
         result = self.resource.collection_get()
         values = [item['status'] for item in result['data']]
         self.assertEqual(sorted(values), [1, 1, 2, 2, 3, 3])
 
     def test_include_returns_400_if_value_has_wrong_type(self):
-        self.resource.request.GET = {'in_id': '0,1'}
+        self.validated['querystring'] = {'in_id': '0,1'}
         with self.assertRaises(httpexceptions.HTTPBadRequest) as cm:
             self.resource.collection_get()
         self.assertIn('in_id', cm.exception.json['message'])
 
-        self.resource.request.GET = {'in_last_modified': 'a,b'}
+        self.validated['querystring'] = {'in_last_modified': 'a,b'}
         self.assertRaises(httpexceptions.HTTPBadRequest,
                           self.resource.collection_get)
 
     def test_exclude_returns_400_if_value_has_wrong_type(self):
-        self.resource.request.GET = {'exclude_id': '0,1'}
+        self.validated['querystring'] = {'exclude_id': '0,1'}
         with self.assertRaises(httpexceptions.HTTPBadRequest) as cm:
             self.resource.collection_get()
         self.assertIn('exclude_id', cm.exception.json['message'])
 
-        self.resource.request.GET = {'exclude_last_modified': 'a,b'}
+        self.validated['querystring'] = {'exclude_last_modified': 'a,b'}
         self.assertRaises(httpexceptions.HTTPBadRequest,
                           self.resource.collection_get)
 
 
 class SubobjectFilteringTest(BaseTest):
     def setUp(self):
         super(SubobjectFilteringTest, self).setUp()
+        self.validated = self.resource.request.validated
         self.patch_known_field.start()
         for i in range(6):
             record = {
@@ -207,18 +209,18 @@ def setUp(self):
             self.model.create_record(record)
 
     def test_records_can_be_filtered_by_subobjects(self):
-        self.resource.request.GET = {'party.voters': '1'}
+        self.validated['querystring'] = {'party.voters': '1'}
         result = self.resource.collection_get()
         values = [item['party']['voters'] for item in result['data']]
         self.assertEqual(sorted(values), [1])
 
     def test_subobjects_filters_are_ignored_if_not_object(self):
-        self.resource.request.GET = {'location.city': 'barcelona'}
+        self.validated['querystring'] = {'location.city': 'barcelona'}
         result = self.resource.collection_get()
         self.assertEqual(len(result['data']), 0)
 
     def test_subobjects_filters_works_with_directives(self):
-        self.resource.request.GET = {'in_party.voters': '1,2,3'}
+        self.validated['querystring'] = {'in_party.voters': '1,2,3'}
         result = self.resource.collection_get()
         values = [item['party']['voters'] for item in result['data']]
         self.assertEqual(sorted(values), [1, 2, 3])

tests/core/resource/test_model.py

@@ -51,9 +51,9 @@ def test_delete_returns_deleted_version_of_records(self):
         self.assertIn('deleted', deleted)
 
     def test_delete_supports_collection_filters(self):
-        self.resource.request.GET = {'field': 'a'}
+        self.resource.request.validated['querystring'] = {'field': 'a'}
         self.resource.collection_delete()
-        self.resource.request.GET = {}
+        self.resource.request.validated['querystring'] = {}
         result = self.resource.collection_get()
         records = result['data']
         self.assertEqual(len(records), 1)

tests/core/resource/test_object_permissions.py

@@ -169,7 +169,7 @@ def test_permissions_can_be_removed_with_patch(self):
                          ['basicauth:bob', 'jean-louis'])
 
     def test_412_errors_do_not_put_permission_in_record(self):
-        self.resource.request.headers['If-Match'] = '"1234567"'  # invalid
+        self.resource.request.validated['header'] = {'If-Match': 1234567}  # invalid
         try:
             self.resource.put()
         except httpexceptions.HTTPPreconditionFailed as e:
@@ -227,7 +227,7 @@ def test_collection_is_filtered_for_current_guest(self):
         self.assertEqual(len(result['data']), 2)
 
     def test_guest_collection_can_be_filtered(self):
-        self.resource.request.GET = {'letter': 'a'}
+        self.resource.request.validated['querystring'] = {'letter': 'a'}
         with mock.patch.object(self.resource, 'is_known_field'):
             result = self.resource.collection_get()
         self.assertEqual(len(result['data']), 1)
@@ -280,7 +280,7 @@ def test_collection_is_filtered_for_current_guest(self):
         self.assertEqual(len(result['data']), 2)
 
     def test_guest_collection_can_be_filtered(self):
-        self.resource.request.GET = {'letter': 'b'}
+        self.resource.request.validated['querystring'] = {'letter': 'b'}
         with mock.patch.object(self.resource, 'is_known_field'):
             result = self.resource.collection_delete()
         self.assertEqual(len(result['data']), 1)