def setUp(self):
try:
SchemaReader._instances[SchemaReader] = None # @UndefinedVariable
del SchemaReader._instances[SchemaReader] # @UndefinedVariable
except Exception as e:
print str(e)
self.schemaReader = SchemaReader()
def test_get_several_fields_from_object_should_return_different_SchemaField(
self):
schemaReader = SchemaReader()
schema_fields = schemaReader.get_schema_fields('SeveralFieldsModel')
self.assertEquals(4, len(schema_fields),
"Not all fields were recovered")
for expected_field in [
SchemaField(name='mytext',
field_type='string',
required=True,
min_length=1,
max_length=10),
SchemaField(name='mynum',
field_type='integer',
required=True,
min_value=0,
max_value=100),
SchemaField(name='mybool', field_type='boolean',
required=True),
SchemaField(name='mydefault',
field_type='string',
required=True,
default='default_value')
]:
for returned_field in schema_fields:
if expected_field.name == returned_field.name:
self.assertEquals(
expected_field.required, returned_field.required,
"Invalid required recovered for {0}".format(
returned_field.name))
def test_bad_json_schema_should_load_file_and_launch_GenericServiceError(
self):
# only right schema loaded
schemaReader = SchemaReader()
self.assertEquals(3, len(self.schemaReader._schemas))
json_doc = '{"user":"******", "other_property":"asdasd"}'
self.assertRaises(
GenericServiceError, lambda: schemaReader.validate_json_document(
json_doc, 'BadUserModel'))
json_mock.loads.assert_called_once_with(ANY)
def test_serializer_with_max_integer_values_should_work(self):
# mock schema instance
schema_reader = SchemaReader()
with nested(
patch.object(schema_reader,
'validate_object'), # @UndefinedVariable
patch.object(
schema_reader,
'get_schema_fields',
)) as (validate_mock,
mock_schema_instance): # @UndefinedVariable
mock_schema_instance.return_value = [
SchemaField(name='key1',
field_type='integer',
required=True,
min_value=1,
max_value=500),
SchemaField(name='keycustom',
field_type='custom_obj',
required=True)
]
class IntegersSerializers(SchemaSerializer):
class Meta():
schema = 'schemaMock'
serializer = IntegersSerializers(data={
'key1': 12,
'keycustom': 'test'
})
self.assertTrue(serializer.is_valid())
def test_get_fields_from_object_should_return_valid_list_SchemaField(self):
schemaReader = SchemaReader()
schema_fields = schemaReader.get_schema_fields('OptionalProperties')
self.assertEquals(4, len(schema_fields),
"Not all fields were recovered")
for expected_field in [
SchemaField(name='obi', field_type='string', required=False),
SchemaField(name='oba', field_type='string', required=False),
SchemaField(name='user', field_type='string', required=True),
SchemaField(name='password',
field_type='string',
required=True)
]:
for returned_field in schema_fields:
if expected_field.name == returned_field.name:
self.assertEquals(
expected_field.required, returned_field.required,
"Invalid required recovered for {0}".format(
returned_field))
def json_schema_validation(self, instance):
"""
Performs json schema validation for the given object
according to schema defined in serializer.
:param instance the object to run schema validation
:return instance validated or None if Schema validation fails
"""
try:
SchemaReader().validate_object(instance, self.opts.schema)
except ValidationErrorSchema as e:
logger.info(
'Object not compliant with schema validation for Model %s',
e.message)
self._errors = self.fulfill_error_validation(e)
return None
return instance
def setUp(self):
super(InstancesSerializerTests, self).setUp()
mock_schema_instance = MagicMock(name='mock_schema_instance')
mock_schema_instance.return_value = [
SchemaField(name='uri', field_type='string', required=True, min_length=1, max_length=2048),
SchemaField(name='version', field_type='string', required=True, min_length=1, max_length=256),
SchemaField(name='environment', field_type='string', required=False, min_length=1, max_length=512,
default='production'),
SchemaField(name='class_name', field_type='string', required=True, min_length=1, max_length=512)
]
# mock schema instance
schema_reader = SchemaReader()
self.patcher_validate = patch.object(schema_reader, 'validate_object') # @UndefinedVariable
self.patcher_schema = patch.object(schema_reader, # @UndefinedVariable
'get_schema_fields', mock_schema_instance)
self.patcher_schema.start()
self.patcher_validate.start()
def setUp(self):
super(ClassesSerializerTests, self).setUp()
mock_schema_instance = MagicMock(name='mock_schema_instance')
mock_schema_instance.return_value = [
SchemaField(name='_id', field_type='string', required=True, min_length=1, max_length=512),
SchemaField(name='description', field_type='string', required=False),
SchemaField(name='default_version', field_type='string', required=True, min_length=1, max_length=256)
]
mock_get_schema_fields = MagicMock(name='mock_get_schema')
mock_get_schema_fields.return_value = mock_schema_instance
# mock schema instance
schema_reader = SchemaReader()
self.patcher_validate = patch.object(schema_reader, 'validate_object') # @UndefinedVariable
self.patcher_schema = patch.object(schema_reader, # @UndefinedVariable
'get_schema_fields', mock_schema_instance)
self.patcher_schema.start()
self.patcher_validate.start()
def get_default_fields(self):
"""
Return all the fields that should be serialized for the model.
"""
schema = self.opts.schema
schema_fields = SchemaReader().get_schema_fields(schema)
ret = SortedDict()
for schema_field in schema_fields:
if schema_field.field_type == 'array':
# TODO : Add support for arrays in schemas, nested serializers
pass
elif isinstance(schema_field.field_type, list):
pass
else:
ret[schema_field.name] = self.get_field(schema_field)
return ret
def setUp(self):
mock_schema_instance = MagicMock(name='mock_schema_instance')
mock_schema_instance.return_value = [
SchemaField(name='origin',
field_type='string',
required=True,
min_length=1),
SchemaField(name='class_name',
field_type='string',
required=True,
min_length=1)
]
# mock singleton schema
schema_reader = SchemaReader()
self.patcher_validate = patch.object(
schema_reader, 'validate_object') # @UndefinedVariable
self.patcher_schema = patch.object(
schema_reader, # @UndefinedVariable
'get_schema_fields',
mock_schema_instance)
self.patcher_schema.start()
self.patcher_validate.start()
def setUp(self):
super(UserSerializerTests, self).setUp()
mock_schema_instance = MagicMock(name='mock_schema_instance')
mock_schema_instance.return_value = [
SchemaField(name='username', field_type='string', required=True),
SchemaField(name='password', field_type='string', required=True),
SchemaField(name='is_admin',
field_type='boolean',
required=True,
default=False)
]
mock_get_schema_fields = MagicMock(name='mock_get_schema')
mock_get_schema_fields.return_value = mock_schema_instance
# mock schema instance
schema_reader = SchemaReader()
self.patcher_validate = patch.object(
schema_reader, 'validate_object') # @UndefinedVariable
self.patcher_schema = patch.object(
schema_reader, # @UndefinedVariable
'get_schema_fields',
mock_schema_instance)
self.patcher_schema.start()
self.patcher_validate.start()
def test_right_json_string_should_return_void(self):
schemaReader = SchemaReader()
json_doc = '{"user":"******", "password":"******"}'
schemaReader.validate_json_document(json_doc, self.right_model)
class SchemaReaderTest(unittest.TestCase):
right_model = "UserModel"
@override_settings(JSON_SCHEMAS_FOLDER=path_properties)
def setUp(self):
try:
SchemaReader._instances[SchemaReader] = None # @UndefinedVariable
del SchemaReader._instances[SchemaReader] # @UndefinedVariable
except Exception as e:
print str(e)
self.schemaReader = SchemaReader()
def test_schema_reader_should_be_a_singleton(self):
schemaReader2 = SchemaReader()
self.assertEquals(id(self.schemaReader), id(schemaReader2))
def test_right_json_schema_should_load_file(self):
self.schemaReader = SchemaReader()
schema = self.schemaReader.get_schema('UserModel')
self.assertEquals('UserModel', schema['title'])
self.assertEquals('object', schema['type'])
def test_init_schema_not_json_schemas_config_should_exit(self):
Singleton._instances.pop(SchemaReader, None)
class SettingsMock(object):
pass
mock_settings = SettingsMock()
with patch('commons.json_schema_validator.schema_reader.settings',
new=mock_settings) as mock_settings:
self.assertRaises(GenericServiceError, SchemaReader)
def test_get_unexisting_json_schema_should_launch_GenericServiceError(
self):
# only right schema loaded
self.assertEquals(3, len(self.schemaReader._schemas))
self.assertRaises(GenericServiceError,
lambda: self.schemaReader.get_schema('BadUserModel'))
@patch('commons.json_schema_validator.schema_reader.json', json_mock)
def test_bad_json_schema_should_load_file_and_launch_GenericServiceError(
self):
# only right schema loaded
schemaReader = SchemaReader()
self.assertEquals(3, len(self.schemaReader._schemas))
json_doc = '{"user":"******", "other_property":"asdasd"}'
self.assertRaises(
GenericServiceError, lambda: schemaReader.validate_json_document(
json_doc, 'BadUserModel'))
json_mock.loads.assert_called_once_with(ANY)
def test_right_json_string_should_return_void(self):
schemaReader = SchemaReader()
json_doc = '{"user":"******", "password":"******"}'
schemaReader.validate_json_document(json_doc, self.right_model)
def test_bad_field_json_string_should_raise_validationerror(self):
schemaReader = SchemaReader()
json_doc = '{"user":"******", "other_property":"asdasd"}'
self.assertRaises(
ValidationError, lambda: schemaReader.validate_json_document(
json_doc, self.right_model))
def test_bad_type_json_string_should_raise_validationerror(self):
schemaReader = SchemaReader()
json_doc = '{"user":"******", "password":12}'
self.assertRaises(
ValidationError, lambda: schemaReader.validate_json_document(
json_doc, self.right_model))
def test_right_object_should_return_void(self):
schemaReader = SchemaReader()
json_obj = {"user": "******", "password": "******"}
schemaReader.validate_object(json_obj, self.right_model)
def test_bad_object_should_return_raise_validationerror(self):
schemaReader = SchemaReader()
json_obj = {"user": "******", "other_property": "asdasd"}
self.assertRaises(
ValidationError,
lambda: schemaReader.validate_object(json_obj, self.right_model))
def test_get_fields_from_object_should_return_valid_list_SchemaField(self):
schemaReader = SchemaReader()
schema_fields = schemaReader.get_schema_fields('OptionalProperties')
self.assertEquals(4, len(schema_fields),
"Not all fields were recovered")
for expected_field in [
SchemaField(name='obi', field_type='string', required=False),
SchemaField(name='oba', field_type='string', required=False),
SchemaField(name='user', field_type='string', required=True),
SchemaField(name='password',
field_type='string',
required=True)
]:
for returned_field in schema_fields:
if expected_field.name == returned_field.name:
self.assertEquals(
expected_field.required, returned_field.required,
"Invalid required recovered for {0}".format(
returned_field))
def test_get_several_fields_from_object_should_return_different_SchemaField(
self):
schemaReader = SchemaReader()
schema_fields = schemaReader.get_schema_fields('SeveralFieldsModel')
self.assertEquals(4, len(schema_fields),
"Not all fields were recovered")
for expected_field in [
SchemaField(name='mytext',
field_type='string',
required=True,
min_length=1,
max_length=10),
SchemaField(name='mynum',
field_type='integer',
required=True,
min_value=0,
max_value=100),
SchemaField(name='mybool', field_type='boolean',
required=True),
SchemaField(name='mydefault',
field_type='string',
required=True,
default='default_value')
]:
for returned_field in schema_fields:
if expected_field.name == returned_field.name:
self.assertEquals(
expected_field.required, returned_field.required,
"Invalid required recovered for {0}".format(
returned_field.name))
def test_schema_reader_should_be_a_singleton(self):
schemaReader2 = SchemaReader()
self.assertEquals(id(self.schemaReader), id(schemaReader2))
def test_right_json_schema_should_load_file(self):
self.schemaReader = SchemaReader()
schema = self.schemaReader.get_schema('UserModel')
self.assertEquals('UserModel', schema['title'])
self.assertEquals('object', schema['type'])
def test_right_object_should_return_void(self):
schemaReader = SchemaReader()
json_obj = {"user": "******", "password": "******"}
schemaReader.validate_object(json_obj, self.right_model)
def test_bad_type_json_string_should_raise_validationerror(self):
schemaReader = SchemaReader()
json_doc = '{"user":"******", "password":12}'
self.assertRaises(
ValidationError, lambda: schemaReader.validate_json_document(
json_doc, self.right_model))
def test_bad_field_json_string_should_raise_validationerror(self):
schemaReader = SchemaReader()
json_doc = '{"user":"******", "other_property":"asdasd"}'
self.assertRaises(
ValidationError, lambda: schemaReader.validate_json_document(
json_doc, self.right_model))
def test_bad_object_should_return_raise_validationerror(self):
schemaReader = SchemaReader()
json_obj = {"user": "******", "other_property": "asdasd"}
self.assertRaises(
ValidationError,
lambda: schemaReader.validate_object(json_obj, self.right_model))
