def test_validate_schema_exception_handling(self):
"""Ensure validate_schema covers basic exception reporting."""
property_schema = PropertySchema()
property_schema.required = 'UNDEFINED'
schema_instance = SchemaType()
schema_instance.some_attr = property_schema
self.assertRaisesRegexp(
ValidationException,
r"""The value for "required" is not """
r"""of type "<type 'bool'>": UNDEFINED""",
schema_type.validate_schema, schema_instance)
expected_errors_list = [
"""The value for "required" is not of type "<type 'bool'>": UNDEFINED"""]
try:
schema_type.validate_schema(schema_instance)
self.fail('A ValidationException should have been thrown.')
except ValidationException as ve:
self.assertListEqual(expected_errors_list, ve.validation_errors)
errors = schema_type.validate_schema(
schema_instance,
raise_validation_exception=False)
self.assertListEqual(expected_errors_list, errors)
def test_validate_schema_exception_handling(self):
"""Ensure validate_schema covers basic exception reporting."""
property_schema = PropertySchema()
property_schema.required = 'UNDEFINED'
schema_instance = SchemaType()
schema_instance.some_attr = property_schema
self.assertRaisesRegexp(
ValidationException, r"""The value for "required" is not """
r"""of type "<type 'bool'>": UNDEFINED""",
schema_type.validate_schema, schema_instance)
expected_errors_list = [
"""The value for "required" is not of type "<type 'bool'>": UNDEFINED"""
]
try:
schema_type.validate_schema(schema_instance)
self.fail('A ValidationException should have been thrown.')
except ValidationException as ve:
self.assertListEqual(expected_errors_list, ve.validation_errors)
errors = schema_type.validate_schema(schema_instance,
raise_validation_exception=False)
self.assertListEqual(expected_errors_list, errors)
def test_schema_definition(self):
"""SchemaType instantiation testing to confirm dict behaviour."""
schema_object = SchemaType()
self.assertIsNotNone(schema_object)
schema_object = SchemaType({
'property1': {}
})
self.assertIsNotNone(schema_object)
self.assertTrue(hasattr(schema_object, 'property1'))
self.assertTrue('property1' in schema_object)
def test_validate_schema(self):
"""Valid schema testing of validate_schema."""
schema = SchemaType({'some_property': {'type': 'int'}})
# Dict test
schema_type.validate_schema(schema)
# OnticType test
base_type_schema = SchemaType(schema)
schema_type.validate_schema(base_type_schema)
# SchemaType test
schema_type_schema = SchemaType(schema)
schema_type.validate_schema(schema_type_schema)
class Requester(OnticType):
ONTIC_SCHEMA = SchemaType({
'id': {
'type': long,
'required': True,
},
'type': {
'type': basestring,
'required': True,
'default': 'request',
'enum': {'request'},
},
'protocol': {
'type': basestring,
'required': True,
'default': 'tcp',
'enum': {'tcp'},
},
'address': {
'type': basestring,
'required': True,
'default': 'localhost'
},
'port': {
'type': int,
'required': True,
'default': 60053,
'min': 0,
}
})
class CommandMessage(OnticType):
CMD_RUN = 1
CMD_MSG = 0
CMD_KILL = -1
_data_type_by_method = {
'add_listener': Listener,
}
_methods = set(_data_type_by_method.keys())
@classmethod
def type_data_for_method(cls, method, data):
data_type = cls._data_type_by_method.get(method)
if data_type:
return data_type(data)
else:
raise ValueError('Unknown method: %s', method)
ONTIC_SCHEMA = SchemaType({
'cmd': {
'type': 'int',
'required': True,
'enum': {CMD_RUN, CMD_MSG, CMD_KILL}
},
'method': {
'type': 'str',
'enum': _methods,
},
'data': {
'type': 'dict',
'default': {},
},
})
def test_validate_value_exception_handling(self):
"""Ensure validation exception handling by validation_object method."""
schema_instance = SchemaType(some_attr={'type': 'int'})
my_type = ontic_type.create_ontic_type('ValidateCheck',
schema_instance)
ontic_object = my_type()
ontic_object.some_attr = 'WRONG'
self.assertRaisesRegexp(
ValidationException,
r"""The value for "some_attr" is not of type "<type 'int'>":"""
r""" WRONG""", ontic_type.validate_value, 'some_attr',
ontic_object)
expected_errors = [
'''The value for "some_attr" is not of type "<type 'int'>": WRONG'''
]
try:
ontic_type.validate_value('some_attr', ontic_object)
self.fail('A ValidateException should have been thrown.')
except ValidationException as ve:
self.assertListEqual(expected_errors, ve.validation_errors)
errors = ontic_type.validate_value('some_attr',
ontic_object,
raise_validation_exception=False)
self.assertListEqual(expected_errors, errors)
def test_valid_perfect_usage(self):
"""Ensure that the perfect behavior is correct."""
schema_def = SchemaType({
'prop_1': {
'type': 'int'
},
'prop_2': {
'type': 'int',
'default': 20
},
'prop_3': {
'type': 'int',
'default': 30
},
'prop_4': {
'type': 'int',
'default': 40
},
})
my_type = ontic_type.create_ontic_type('PerfectOntic', schema_def)
ontic_object = my_type()
ontic_object.prop_1 = 1
ontic_object.prop_3 = None
ontic_object.prop_4 = 400
ontic_object.extra_prop = 'Extra'
expected_dict = {
'prop_1': 1,
'prop_2': 20,
'prop_3': 30,
'prop_4': 400
}
ontic_type.perfect_object(ontic_object)
self.assertDictEqual(expected_dict, ontic_object)
def test_create_ontic_type(self):
"""The most simple and basic dynamic Ontic."""
# Test creation from raw dictionary.
my_type = ontic_type.create_ontic_type('Simple', dict())
self.assertIsNotNone(my_type)
ontic_object = my_type()
self.assert_dynamic_accessing(ontic_object)
self.assertIsInstance(ontic_object, my_type)
# Test creation using a SchemaType object.
my_type = ontic_type.create_ontic_type('AnotherSimple', SchemaType())
self.assertIsNotNone(my_type)
ontic_object = my_type()
self.assert_dynamic_accessing(ontic_object)
self.assertIsInstance(ontic_object, my_type)
def create_ontic_type(name, schema):
"""Create an **Ontic** type to generate objects with a given schema.
*create_ontic_type* function creates an :class:`OnticType` with a given
name and schema definition. The schema definition can be a dict instance
that is a valid schema definition or a
:class:`ontic.schema_type.SchemaType`. This makes the following forms
valid::
MyType = create_ontic_type('MyType', {'prop':{'type':'int'}})
schema_instance = SchemaType(prop={'type':'int'})
MyType = create_ontic_type('MyType', schema_instance)
:param name: The name to apply to the created class, with
:class:`OnticType` as parent.
:type name: str
:param schema: A representation of the schema in dictionary format.
:type schema: dict, :class:`ontic.schema_type.SchemaType`
:return: A class whose base is :class:`OnticType`.
:rtype: ClassType
:raises ValueError: String name required. Dict or
:class:`ontic.schema_type.SchemaType` schema required.
"""
if name is None or name is '':
raise ValueError('The string "name" argument is required.')
if schema is None:
raise ValueError('The schema dictionary is required.')
if not isinstance(schema, dict):
raise ValueError('The schema must be a dict or SchemaType.')
ontic_type = type(name, (OnticType, ), dict())
if not isinstance(schema, SchemaType):
schema = SchemaType(schema)
ontic_type.ONTIC_SCHEMA = schema
return ontic_type
def test_perfect_collection_types(self):
"""Ensure that collection defaults are handled correctly."""
schema_def = SchemaType({
'dict_prop': {
'type': 'dict',
'default': {
'a': 1,
'b': 2,
'c': 3
}
},
'list_prop': {
'type': 'list',
'default': [1, 2, 3]
},
'set_prop': {
'type': 'set',
'default': {1, 2, 3}
}
})
my_type = ontic_type.create_ontic_type('PerfectCollection', schema_def)
ontic_object = my_type()
ontic_type.perfect_object(ontic_object)
# Test that the collection values are equal
self.assertDictEqual(schema_def.dict_prop.default,
ontic_object.dict_prop)
self.assertListEqual(schema_def.list_prop.default,
ontic_object.list_prop)
self.assertSetEqual(schema_def.set_prop.default, ontic_object.set_prop)
# Ensure that the collections are not the same objects
self.assertIsNot(schema_def.dict_prop.default, ontic_object.dict_prop)
self.assertIsNot(schema_def.list_prop.default, ontic_object.list_prop)
self.assertIsNot(schema_def.set_prop.default, ontic_object.set_prop)
def test_perfect_schema_type(self):
"""Validate 'perfect_schema' method usage."""
candidate_schema = SchemaType({
'prop1':
meta_type.PropertySchema(),
'prop2':
meta_type.PropertySchema({
'type': 'str',
'min': 5
})
})
self.assertEqual(2, len(candidate_schema))
self.assertEqual(10, len(candidate_schema.prop1))
self.assertEqual(10, len(candidate_schema.prop2))
self.maxDiff = None
self.assertDictEqual(
{
'prop1': {
'regex': None,
'member_max': None,
'enum': None,
'min': None,
'default': None,
'max': None,
'required': False,
'member_min': None,
'member_type': None,
'type': None
},
'prop2': {
'regex': None,
'member_max': None,
'enum': None,
'min': 5.0,
'default': None,
'max': None,
'required': False,
'member_min': None,
'member_type': None,
'type': str
}
}, candidate_schema)
schema_type.perfect_schema(candidate_schema)
self.assertEqual(2, len(candidate_schema))
self.assertEqual(10, len(candidate_schema.prop1))
self.assertEqual(10, len(candidate_schema.prop2))
self.assertDictEqual(
{
'prop1': {
'default': None,
'enum': None,
'member_max': None,
'member_min': None,
'member_type': None,
'max': None,
'min': None,
'regex': None,
'required': False,
'type': None
},
'prop2': {
'default': None,
'enum': None,
'member_max': None,
'member_min': None,
'member_type': None,
'max': None,
'min': 5.0,
'regex': None,
'required': False,
'type': str
}
}, candidate_schema)
self.assertIsInstance(candidate_schema.prop1, meta_type.PropertySchema)
self.assertIsInstance(candidate_schema.prop2, meta_type.PropertySchema)
def test_perfect_collection_default_copy(self):
"""Ensure that collection default settings are handled correctly."""
# Configure default collection.
default_dict = {'key': 'value'}
default_list = ['item']
inner_tuple = (1, 2)
outer_tuple = (inner_tuple, 3, 4)
default_set = {'entity', outer_tuple}
# Configure default collections to test deep copy behavior.
ontic_object = ontic_type.OnticType()
ontic_object.dict = default_dict
default_deep_dict = {'name': default_dict}
default_deep_list = [default_dict]
default_deep_set = {(inner_tuple, outer_tuple)}
schema_def = SchemaType({
'dict_no_default': {
'type': 'dict',
},
'list_no_default': {
'type': 'list',
},
'set_no_default': {
'type': 'set',
},
'dict_with_default': {
'type': 'dict',
'default': default_dict,
},
'list_with_default': {
'type': 'list',
'default': default_list,
},
'set_with_default': {
'type': 'set',
'default': default_set,
},
'dict_deep_default': {
'type': 'dict',
'default': default_deep_dict,
},
'list_deep_default': {
'type': 'list',
'default': default_deep_list,
},
'set_deep_default': {
'type': 'set',
'default': default_deep_set,
},
})
# Execute test subject.
my_type = ontic_type.create_ontic_type('CollectionDefaults',
schema_def)
my_object = my_type()
ontic_type.perfect_object(my_object)
ontic_type.validate_object(my_object)
# Assert the no default state.
self.assertIsNone(my_object.dict_no_default)
self.assertIsNone(my_object.list_no_default)
self.assertIsNone(my_object.set_no_default)
# Assert equality and copy of defaults.
self.assertDictEqual(default_dict, my_object.dict_with_default)
self.assertIsNot(default_dict, my_object.dict_with_default)
self.assertListEqual(default_list, my_object.list_with_default)
self.assertIsNot(default_list, my_object.list_with_default)
self.assertSetEqual(default_set, my_object.set_with_default)
self.assertIsNot(default_set, my_object.set_with_default)
# Assert equality and copy of deep defaults.
self.assertDictEqual(default_dict, my_object.dict_deep_default['name'])
self.assertIsNot(default_deep_dict['name'],
my_object.dict_deep_default['name'])
self.assertDictEqual(default_dict, my_object.list_deep_default[0])
self.assertIsNot(default_deep_list[0], my_object.list_deep_default[0])
self.assertSetEqual(default_deep_set, my_object.set_deep_default)
self.assertIsNot(default_deep_set, my_object.set_deep_default)