def test_empty(self): schema = self._make_schema() request = self._make_request('{}') validate_colander_schema(schema, request) self.assertEqual(request.errors, []) self.assertEqual(request.validated, {'cell': (), 'wifi': (), 'radio': ''})
def test_colander_schema_using_defaults(self): """ Schema could contains default values """ schema = CorniceSchema.from_colander(DefaultSchema) dummy_request = MockRequest('', {'bar': 'test'}) setattr(dummy_request, 'errors', Errors(dummy_request)) validate_colander_schema(schema, dummy_request) qs_fields = schema.get_attributes(location="querystring") errors = dummy_request.errors self.assertEqual(len(errors), 0) self.assertEqual(len(qs_fields), 2) expected = {'foo': 'foo', 'bar': 'test'} self.assertEqual(expected, dummy_request.validated) dummy_request = MockRequest('', {'bar': 'test', 'foo': 'test'}) setattr(dummy_request, 'errors', Errors(dummy_request)) validate_colander_schema(schema, dummy_request) qs_fields = schema.get_attributes(location="querystring") errors = dummy_request.errors self.assertEqual(len(errors), 0) self.assertEqual(len(qs_fields), 2)
def test_colander_schema_using_defaults(self): """ Schema could contains default values """ schema = CorniceSchema.from_colander(DefaultSchema) dummy_request = get_mock_request("", {"bar": "test"}) validate_colander_schema(schema, dummy_request) qs_fields = schema.get_attributes(location="querystring") errors = dummy_request.errors self.assertEqual(len(errors), 0) self.assertEqual(len(qs_fields), 2) expected = {"foo": "foo", "bar": "test"} self.assertEqual(expected, dummy_request.validated) dummy_request = get_mock_request("", {"bar": "test", "foo": "test"}) validate_colander_schema(schema, dummy_request) qs_fields = schema.get_attributes(location="querystring") errors = dummy_request.errors self.assertEqual(len(errors), 0) self.assertEqual(len(qs_fields), 2) expected = {"foo": "test", "bar": "test"} self.assertEqual(expected, dummy_request.validated)
def test_colander_schema_using_drop(self): """ remove fields from validated data if they deserialize to colander's `drop` object. """ schema = CorniceSchema.from_colander(DropSchema) class MockRequest(object): def __init__(self, body): self.headers = {} self.matchdict = {} self.body = body self.GET = {} self.POST = {} self.validated = {} self.registry = { 'cornice_deserializers': { 'application/json': extract_json_data } } dummy_request = MockRequest('{"bar": "required_data"}') setattr(dummy_request, 'errors', Errors(dummy_request)) validate_colander_schema(schema, dummy_request) self.assertNotIn('foo', dummy_request.validated)
def collection_post(self): set_config(self.request.user) if self.model.is_readonly: raise HTTPBadRequest() validate_colander_schema(self._schema, self.request) obj = self.model(**self.request.json_body) Session.add(obj) return obj
def test_sequence_with_null(self): # null can be passed to a sequence field schema = CorniceSchema.from_colander(TestNoneSchema) dummy_request = get_mock_request('{"foo": "abc", "bar": null}') validate_colander_schema(schema, dummy_request) self.assertEqual(len(dummy_request.errors), 0) self.assertIsNone(dummy_request.validated['bar'])
def test_minimal(self): schema = self._make_schema() request = self._make_request( '{"items": [{"lat": 12.3456781, "lon": 23.4567892}]}') validate_colander_schema(schema, request) self.assertFalse(request.errors) self.assertTrue('items' in request.validated) self.assertEqual(len(request.validated['items']), 1)
def test_validate_colander_schema_can_preserve_unknown_fields(self): schema = CorniceSchema.from_colander(PreserveUnkownSchema) data = json.dumps({"bar": "required_data", "optional": "true"}) dummy_request = get_mock_request(data) validate_colander_schema(schema, dummy_request) self.assertDictEqual(dummy_request.validated, {"bar": "required_data", "optional": "true"}) self.assertEqual(len(dummy_request.errors), 0)
def wrapper(request): # if the args contain a klass argument then use it to resolve the view # location (if the view argument isn't a callable) ob = None view_ = view if 'klass' in args and not callable(view): params = dict(request=request) if 'factory' in args and 'acl' not in args: params['context'] = request.context ob = args['klass'](**params) if is_string(view): view_ = getattr(ob, view.lower()) elif isinstance(view, _UnboundView): view_ = view.make_bound_view(ob) # set data deserializer if 'deserializer' in args: request.deserializer = args['deserializer'] # do schema validation if 'schema' in args: validate_colander_schema(args['schema'], request) elif hasattr(ob, 'schema'): validate_colander_schema(ob.schema, request) # the validators can either be a list of callables or contain some # non-callable values. In which case we want to resolve them using the # object if any validators = args.get('validators', ()) for validator in validators: if is_string(validator) and ob is not None: validator = getattr(ob, validator) validator(request) # only call the view if we don't have validation errors if len(request.errors) == 0: # if we have an object, the request had already been passed to it if ob: response = view_() else: response = view_(request) # check for errors and return them if any if len(request.errors) > 0: # We already checked for CORS, but since the response is created # again, we want to do that again before returning the response. request.info['cors_checked'] = False return args['error_handler'](request.errors) # We can't apply filters at this level, since "response" may not have # been rendered into a proper Response object yet. Instead, give the # request a reference to its api_kwargs so that a tween can apply them. # We also pass the object we created (if any) so we can use it to find # the filters that are in fact methods. request.cornice_args = (args, ob) return response
def test_extra_params_qs(self): schema = CorniceSchema.from_colander(QsSchema) dummy_request = get_mock_request("", {"foo": "test", "bar": "test"}) validate_colander_schema(schema, dummy_request) errors = dummy_request.errors self.assertEqual(len(errors), 0) expected = {"foo": "test"} self.assertEqual(expected, dummy_request.validated)
def test_extra_params_qs(self): schema = CorniceSchema.from_colander(QsSchema) dummy_request = get_mock_request('', {'foo': 'test', 'bar': 'test'}) validate_colander_schema(schema, dummy_request) errors = dummy_request.errors self.assertEqual(len(errors), 0) expected = {'foo': 'test'} self.assertEqual(expected, dummy_request.validated)
def test_colander_schema_with_root_validator(self): """ Test the preparer run on the root node """ schema = CorniceSchema.from_colander(WithValidatorSchema) dummy_request = MockRequest('{"bar": "heloo"}') with self.assertRaises(Invalid) as e: validate_colander_schema(schema, dummy_request) self.assertEqual({'': 'Bubblicious'}, e.exception.asdict())
def test_colander_schema_with_root_preparer(self): """ Test the preparer run on the root node """ schema = CorniceSchema.from_colander(WithPreparerSchema) dummy_request = MockRequest('{"bar": "not_mama"}') validate_colander_schema(schema, dummy_request) self.assertEqual('mama', dummy_request.validated['bar'])
def test_colander_schema_using_dotted_names(self): """ Schema could be passed as string in view """ schema = CorniceSchema.from_colander("cornice.tests.schema.AccountSchema") dummy_request = get_mock_request('{"nickname": "john"}') validate_colander_schema(schema, dummy_request) self.assertIn("nickname", dummy_request.validated) self.assertNotIn("city", dummy_request.validated)
def put(self): set_config(self.request.user) if self.model.is_readonly: raise HTTPBadRequest() validate_colander_schema(self._schema, self.request) result = Session.query(self.model).get(int(self.request.matchdict['id'])) if result: for k, v in self.request.json_body.items(): setattr(result, k, v) return result raise HTTPNotFound()
def test_imperative_colander_schema(self): # not specifying body should act the same way as specifying it schema = CorniceSchema.from_colander(imperative_schema) body_fields = schema.get_attributes(location="body") qs_fields = schema.get_attributes(location="querystring") self.assertEqual(len(body_fields), 2) self.assertEqual(len(qs_fields), 1) dummy_request = get_mock_request('{"bar": "some data"}') validate_colander_schema(schema, dummy_request)
def test_extra_params_qs_strict(self): schema = CorniceSchema.from_colander(StrictQsSchema) dummy_request = get_mock_request("", {"foo": "test", "bar": "test"}) validate_colander_schema(schema, dummy_request) errors = dummy_request.errors self.assertEqual(len(errors), 1) self.assertEqual(errors[0], {"description": "bar is not allowed", "location": "querystring", "name": "bar"}) expected = {"foo": "test"} self.assertEqual(expected, dummy_request.validated)
def test_colander_schema_default_value(self): # apply default value to field if the input for them is # missing schema = CorniceSchema.from_colander(DefaultValueSchema) dummy_request = get_mock_request('{"foo": 5}') validate_colander_schema(schema, dummy_request) self.assertIn('bar', dummy_request.validated) self.assertEqual(len(dummy_request.errors), 0) self.assertEqual(dummy_request.validated['foo'], 5) # default value should be available self.assertEqual(dummy_request.validated['bar'], 10)
def test_validate_colander_schema_can_preserve_unknown_fields(self): schema = CorniceSchema.from_colander(PreserveUnkownSchema) data = json.dumps({"bar": "required_data", "optional": "true"}) dummy_request = get_mock_request(data) validate_colander_schema(schema, dummy_request) self.assertDictEqual(dummy_request.validated, { "bar": "required_data", "optional": "true" }) self.assertEqual(len(dummy_request.errors), 0)
def test_colander_schema_using_dotted_names(self): """ Schema could be passed as string in view """ schema = CorniceSchema.from_colander( 'cornice.tests.schema.AccountSchema') dummy_request = get_mock_request('{"nickname": "john"}') validate_colander_schema(schema, dummy_request) self.assertIn('nickname', dummy_request.validated) self.assertNotIn('city', dummy_request.validated)
def test_colander_schema_using_drop(self): """ remove fields from validated data if they deserialize to colander's `drop` object. """ schema = CorniceSchema.from_colander(DropSchema) dummy_request = MockRequest('{"bar": "required_data"}') setattr(dummy_request, 'errors', Errors(dummy_request)) validate_colander_schema(schema, dummy_request) self.assertNotIn('foo', dummy_request.validated) self.assertIn('bar', dummy_request.validated)
def test_extra_params_qs_strict(self): schema = CorniceSchema.from_colander(StrictQsSchema) dummy_request = get_mock_request('', {'foo': 'test', 'bar': 'test'}) validate_colander_schema(schema, dummy_request) errors = dummy_request.errors self.assertEqual(len(errors), 1) self.assertEqual(errors[0], {'description': 'bar is not allowed', 'location': 'querystring', 'name': 'bar'}) expected = {'foo': 'test'} self.assertEqual(expected, dummy_request.validated)
def test_colander_schema_using_drop(self): """ remove fields from validated data if they deserialize to colander's `drop` object. """ schema = CorniceSchema.from_colander(DropSchema) dummy_request = get_mock_request('{"bar": "required_data"}') validate_colander_schema(schema, dummy_request) self.assertNotIn('foo', dummy_request.validated) self.assertIn('bar', dummy_request.validated) self.assertEqual(len(dummy_request.errors), 0)
def test_colander_schema_using_dotted_names(self): """ Schema could be passed as string in view """ schema = CorniceSchema.from_colander( 'cornice.tests.schema.AccountSchema') dummy_request = MockRequest('{"nickname": "john"}') setattr(dummy_request, 'errors', Errors(dummy_request)) validate_colander_schema(schema, dummy_request) self.assertIn('nickname', dummy_request.validated) self.assertNotIn('city', dummy_request.validated)
def test_extra_params_qs(self): schema = CorniceSchema.from_colander(QsSchema) dummy_request = get_mock_request('', { 'foo': 'test', 'bar': 'test' }) validate_colander_schema(schema, dummy_request) errors = dummy_request.errors self.assertEqual(len(errors), 0) expected = {'foo': 'test'} self.assertEqual(expected, dummy_request.validated)
def wrapper(request): # if the args contain a klass argument then use it to resolve the view # location (if the view argument isn't a callable) ob = None view_ = view if 'klass' in args: params = dict(request=request) if 'factory' in args and 'acl' not in args: params['context'] = args['factory'](request) ob = args['klass'](**params) if is_string(view): view_ = getattr(ob, view.lower()) # do schema validation if 'schema' in args: validate_colander_schema(args['schema'], request) elif hasattr(ob, 'schema'): validate_colander_schema(ob.schema, request) # the validators can either be a list of callables or contain some # non-callable values. In which case we want to resolve them using the # object if any validators = args.get('validators', ()) for validator in validators: if is_string(validator) and ob is not None: validator = getattr(ob, validator) validator(request) # only call the view if we don't have validation errors if len(request.errors) == 0: # if we have an object, the request had already been passed to it if ob: response = view_() else: response = view_(request) # check for errors and return them if any if len(request.errors) > 0: # We already checked for CORS, but since the response is created # again, we want to do that again before returning the response. request.info['cors_checked'] = False return args['error_handler'](request.errors) # We can't apply filters at this level, since "response" may not have # been rendered into a proper Response object yet. Instead, give the # request a reference to its api_kwargs so that a tween can apply them. # We also pass the object we created (if any) so we can use it to find # the filters that are in fact methods. request.cornice_args = (args, ob) return response
def test_extra_params_qs_strict(self): schema = CorniceSchema.from_colander(StrictQsSchema) dummy_request = MockRequest('', {'foo': 'test', 'bar': 'test'}) setattr(dummy_request, 'errors', Errors(dummy_request)) validate_colander_schema(schema, dummy_request) errors = dummy_request.errors self.assertEqual(len(errors), 1) self.assertEqual(errors[0], {'description': 'bar is not allowed', 'location': 'querystring', 'name': 'bar'}) expected = {'foo': 'test'} self.assertEqual(expected, dummy_request.validated)
def test_colander_nested_schema(self): schema = CorniceSchema.from_colander(NestedSchema) dummy_request = get_mock_request('{"ham": {"bar": "POST"}}', {"egg.bar": "GET"}) validate_colander_schema(schema, dummy_request) qs_fields = schema.get_attributes(location="querystring") errors = dummy_request.errors self.assertEqual(len(errors), 0, errors) self.assertEqual(len(qs_fields), 1) expected = {"egg": {"bar": "GET"}, "ham": {"bar": "POST"}} self.assertEqual(expected, dummy_request.validated)
def test_colander_strict_schema(self): schema = CorniceSchema.from_colander(StrictSchema) dummy_request = get_mock_request( """ {"bar": "required_data", "foo": "optional_data", "other": "not_wanted_data"} """ ) validate_colander_schema(schema, dummy_request) errors = dummy_request.errors self.assertEqual(len(errors), 1) self.assertEqual(errors[0], {"description": "other is not allowed", "location": "body", "name": "other"}) self.assertIn("foo", dummy_request.validated) self.assertIn("bar", dummy_request.validated)
def test_colander_strict_schema(self): schema = CorniceSchema.from_colander(StrictSchema) dummy_request = MockRequest('''{"bar": "required_data", "foo": "optional_data", "other": "not_wanted_data"}''') setattr(dummy_request, 'errors', Errors(dummy_request)) validate_colander_schema(schema, dummy_request) errors = dummy_request.errors self.assertEqual(len(errors), 1) self.assertEqual(errors[0], {'description': 'other is not allowed', 'location': 'body', 'name': 'other'}) self.assertIn('foo', dummy_request.validated) self.assertIn('bar', dummy_request.validated)
def test_colander_nested_schema(self): schema = CorniceSchema.from_colander(NestedSchema) dummy_request = MockRequest('{"ham": {"bar": "POST"}}', {'egg.bar': 'GET'}) setattr(dummy_request, 'errors', Errors(dummy_request)) validate_colander_schema(schema, dummy_request) qs_fields = schema.get_attributes(location="querystring") errors = dummy_request.errors self.assertEqual(len(errors), 0, errors) self.assertEqual(len(qs_fields), 1) expected = {'egg': {'bar': 'GET'}, 'ham': {'bar': 'POST'}, } self.assertEqual(expected, dummy_request.validated)
def test_post_data_fails_validation_on_error(self): schema = CorniceSchema.from_colander(PostDataSchema) class MockRequest(object): def __init__(self, body): self.headers = {} self.matchdict = {} self.body = body self.GET = {} self.POST = {'foo' : ''} self.validated = {} dummy_request = MockRequest('{"bar": "irrelevant data"}') setattr(dummy_request, 'errors', Errors(dummy_request)) validate_colander_schema(schema, dummy_request) missing_foo = filter(lambda x: x['name'] == 'foo', dummy_request.errors) assert missing_foo self.assertNotIn('foo', dummy_request.validated)
def wrapper(request): # if the args contain a klass argument then use it to resolve the view # location (if the view argument isn't a callable) ob = None view_ = view if 'klass' in args: ob = args['klass'](request) if isinstance(view, str): view_ = getattr(ob, view.lower()) # do schema validation if 'schema' in args: validate_colander_schema(args['schema'], request) # the validators can either be a list of callables or contain some # non-callable values. In which case we want to resolve them using the # object if any validators = args.get('validators', ()) for validator in validators: if isinstance(validator, str) and ob is not None: validator = getattr(ob, validator) validator(request) # only call the view if we don't have validation errors if len(request.errors) == 0: # if we have an object, the request had already been passed to it if ob: response = view_() else: response = view_(request) # check for errors and return them if any if len(request.errors) > 0: return args['error_handler'](request.errors) # We can't apply filters at this level, since "response" may not have # been rendered into a proper Response object yet. Instead, give the # request a reference to its api_kwargs so that a tween can apply them. # We also pass the object we created (if any) so we can use it to find # the filters that are in fact methods. request.cornice_args = (args, ob) return response
def test_colander_schema_using_drop(self): """ remove fields from validated data if they deserialize to colander's `drop` object. """ schema = CorniceSchema.from_colander(DropSchema) class MockRequest(object): def __init__(self, body): self.headers = {} self.matchdict = {} self.body = body self.GET = {} self.POST = {} self.validated = {} dummy_request = MockRequest('{"bar": "required_data"}') setattr(dummy_request, 'errors', Errors(dummy_request)) validate_colander_schema(schema, dummy_request) self.assertNotIn('foo', dummy_request.validated)
def test_colander_schema_using_drop(self): """ remove fields from validated data if they deserialize to colander's `drop` object. """ schema = CorniceSchema.from_colander(DropSchema) class MockRequest(object): def __init__(self, body): self.headers = {} self.matchdict = {} self.body = body self.GET = {} self.POST = {} self.validated = {} dummy_request = MockRequest('') setattr(dummy_request, 'errors', Errors(dummy_request)) validate_colander_schema(schema, dummy_request) self.assertNotIn('foo', dummy_request.validated)
def wrapper(request): # if the args contain a klass argument then use it to resolve the view # location (if the view argument isn't a callable) ob = None view_ = view if 'klass' in args: ob = args['klass'](request) if isinstance(view, basestring): view_ = getattr(ob, view.lower()) # do schema validation if 'schema' in args: validate_colander_schema(args['schema'], request) # the validators can either be a list of callables or contain some # non-callable values. In which case we want to resolve them using the # object if any validators = args.get('validators', ()) for validator in validators: if isinstance(validator, basestring) and ob is not None: validator = getattr(ob, validator) validator(request) if len(request.errors) > 0: return args['error_handler'](request.errors) # if we have an object, the request had already been passed to it if ob: response = view_() else: response = view_(request) # We can't apply filters at this level, since "response" may not have # been rendered into a proper Response object yet. Instead, give the # request a reference to its api_kwargs so that a tween can apply them. # We also pass the object we created (if any) so we can use it to find # the filters that are in fact methods. request.cornice_args = (args, ob) return response
def test_wrong_cell_data(self): schema = self._make_schema() request = self._make_request( '{"cell": [{"mcc": "a", "mnc": 2, "lac": 3, "cid": 4}]}') validate_colander_schema(schema, request) self.assertTrue(request.errors)
def validate_req(self, request): validate_colander_schema(validator_from_model(self.cls), request)
def test_empty(self): schema = self._make_schema() request = self._make_request('{}') validate_colander_schema(schema, request) self.assertTrue(request.errors)
def test_empty_wifi_entry(self): schema = self._make_schema() request = self._make_request( '{"lat": 12.3456781, "lon": 23.4567892, "wifi": [{}]}') validate_colander_schema(schema, request) self.assertTrue(request.errors)
def test_empty_cell_entry(self): schema = self._make_schema() request = self._make_request('{"cell": [{}]}') validate_colander_schema(schema, request) self.assertTrue('cell' in request.validated)