def test_resolver(self): from jsonschema import RefResolver dirname = os.path.dirname(__file__) schemas_path = 'file://' + os.path.join(dirname, 'schemas/') resolver = RefResolver(schemas_path, None) country_schema_file = \ open(os.path.join(dirname, 'schemas/') + 'country.json') person_schema_file = \ open(os.path.join(dirname, 'schemas/') + 'person.json') country_schema = json.load(country_schema_file) person_schema = json.load(person_schema_file) Country = warlock.model_factory(country_schema, resolver) Person = warlock.model_factory(person_schema, resolver) england = Country(name="England", population=53865800, overlord=Person(title="Queen", firstname="Elizabeth", lastname="Windsor")) expected = { 'name': 'England', 'population': 53865800, 'overlord': { 'title': 'Queen', 'lastname': 'Windsor', 'firstname': 'Elizabeth' } } self.assertEqual(england, expected)
def test_resolver(self): from jsonschema import RefResolver dirname = os.path.dirname(__file__) schemas_path = 'file://' + os.path.join(dirname, 'schemas/') resolver = RefResolver(schemas_path, None) country_schema_file = \ open(os.path.join(dirname, 'schemas/') + 'country.json') person_schema_file = \ open(os.path.join(dirname, 'schemas/') + 'person.json') country_schema = json.load(country_schema_file) person_schema = json.load(person_schema_file) Country = warlock.model_factory(country_schema, resolver) Person = warlock.model_factory(person_schema, resolver) england = Country( name="England", population=53865800, overlord=Person( title="Queen", firstname="Elizabeth", lastname="Windsor" ) ) expected = { 'name': 'England', 'population': 53865800, 'overlord': { 'title': 'Queen', 'lastname': 'Windsor', 'firstname': 'Elizabeth' } } self.assertEqual(england, expected)
def test_resolver(self): from jsonschema import RefResolver dirname = os.path.dirname(__file__) schemas_path = "file://" + os.path.join(dirname, "schemas/") resolver = RefResolver(schemas_path, None) country_schema_file = open( os.path.join(dirname, "schemas/") + "country.json") person_schema_file = open( os.path.join(dirname, "schemas/") + "person.json") country_schema = json.load(country_schema_file) person_schema = json.load(person_schema_file) Country = warlock.model_factory(country_schema, resolver) Person = warlock.model_factory(person_schema, resolver) england = Country( name="England", population=53865800, overlord=Person(title="Queen", firstname="Elizabeth", lastname="Windsor"), ) expected = { "name": "England", "population": 53865800, "overlord": { "title": "Queen", "lastname": "Windsor", "firstname": "Elizabeth", }, } self.assertEqual(england, expected)
def test_naming(self): Country = warlock.model_factory(fixture) self.assertEqual('Country', Country.__name__) Country2 = warlock.model_factory(fixture, name='Country2') self.assertEqual('Country2', Country2.__name__) nameless = warlock.model_factory(nameless_fixture) self.assertEqual('Model', nameless.__name__) nameless2 = warlock.model_factory(nameless_fixture, name='Country3') self.assertEqual('Country3', nameless2.__name__)
def test_naming(self): Country = warlock.model_factory(fixture) self.assertEqual("Country", Country.__name__) Country2 = warlock.model_factory(fixture, name="Country2") self.assertEqual("Country2", Country2.__name__) nameless = warlock.model_factory(nameless_fixture) self.assertEqual("Model", nameless.__name__) nameless2 = warlock.model_factory(nameless_fixture, name="Country3") self.assertEqual("Country3", nameless2.__name__)
def test_naming(self): Country = warlock.model_factory(fixture) self.assertEqual(Country.__name__, 'Country') Country2 = warlock.model_factory(fixture, name='Country2') self.assertEqual(Country2.__name__, 'Country2') nameless = warlock.model_factory(nameless_fixture) self.assertEqual(nameless.__name__, 'Model') nameless2 = warlock.model_factory(nameless_fixture, name='Country3') self.assertEqual(nameless2.__name__, 'Country3')
def test_recursive_models(self): Parent = warlock.model_factory(parent_fixture) Child = warlock.model_factory(child_fixture) mom = Parent(name='Abby', children=[]) teenager = Child(age=15, mother=mom) toddler = Child(age=3, mother=mom) mom.children = [teenager, toddler] self.assertEqual(mom.children[0].age, 15) self.assertEqual(mom.children[1].age, 3)
def test_deepcopy(self): """Make sure we aren't leaking references.""" Mixmaster = warlock.model_factory(complex_fixture) mike = Mixmaster(sub={"foo": "mike"}) self.assertEquals("mike", mike.sub["foo"]) mike_1 = mike.copy() mike_1["sub"]["foo"] = "james" self.assertEquals("mike", mike.sub["foo"]) mike_2 = dict(six.iteritems(mike)) mike_2["sub"]["foo"] = "james" self.assertEquals("mike", mike.sub["foo"]) mike_2 = dict(mike.items()) mike_2["sub"]["foo"] = "james" self.assertEquals("mike", mike.sub["foo"]) mike_3_sub = list(six.itervalues(mike))[0] mike_3_sub["foo"] = "james" self.assertEquals("mike", mike.sub["foo"]) mike_3_sub = list(mike.values())[0] mike_3_sub["foo"] = "james" self.assertEquals("mike", mike.sub["foo"])
def test_patch_drop_attribute(self): Country = warlock.model_factory(fixture) sweden = Country(name='Sweden', population=9379116) del sweden['name'] self.assertEqual( json.loads(sweden.patch), json.loads('[{"path": "/name", "op": "remove"}]'))
def unvalidated_model(self): """A model which does not validate the image against the v2 schema.""" schema = self.schema_client.get('image') warlock_model = warlock.model_factory(schema.raw(), schemas.SchemaBasedModel) warlock_model.validate = lambda *args, **kwargs: None return warlock_model
def test_deepcopy(self): """Make sure we aren't leaking references.""" Mixmaster = warlock.model_factory(complex_fixture) mike = Mixmaster(sub={'foo': 'mike'}) self.assertEquals('mike', mike.sub['foo']) mike_1 = mike.copy() mike_1['sub']['foo'] = 'james' self.assertEquals('mike', mike.sub['foo']) mike_2 = dict(six.iteritems(mike)) mike_2['sub']['foo'] = 'james' self.assertEquals('mike', mike.sub['foo']) mike_2 = dict(mike.items()) mike_2['sub']['foo'] = 'james' self.assertEquals('mike', mike.sub['foo']) mike_3_sub = list(six.itervalues(mike))[0] mike_3_sub['foo'] = 'james' self.assertEquals('mike', mike.sub['foo']) mike_3_sub = list(mike.values())[0] mike_3_sub['foo'] = 'james' self.assertEquals('mike', mike.sub['foo'])
def test_deepcopy(self): """Make sure we aren't leaking references.""" Mixmaster = warlock.model_factory(complex_fixture) mike = Mixmaster(sub={'foo': 'mike'}) self.assertEquals(mike.sub['foo'], 'mike') mike_1 = mike.copy() mike_1['sub']['foo'] = 'james' self.assertEquals(mike.sub['foo'], 'mike') mike_2 = dict(mike.iteritems()) mike_2['sub']['foo'] = 'james' self.assertEquals(mike.sub['foo'], 'mike') mike_2 = dict(mike.items()) mike_2['sub']['foo'] = 'james' self.assertEquals(mike.sub['foo'], 'mike') mike_3_sub = list(mike.itervalues())[0] mike_3_sub['foo'] = 'james' self.assertEquals(mike.sub['foo'], 'mike') mike_3_sub = list(mike.values())[0] mike_3_sub['foo'] = 'james' self.assertEquals(mike.sub['foo'], 'mike')
def unvalidated_model(self): """A model which does not validate the image against the v2 schema.""" schema = self.schema_client.get('image') warlock_model = warlock.model_factory( schema.raw(), base_class=schemas.SchemaBasedModel) warlock_model.validate = lambda *args, **kwargs: None return warlock_model
def test_items(self): Country = warlock.model_factory(fixture) sweden = Country(name='Sweden', population=9379116) self.assertEqual(set(list(six.iteritems(sweden))), set([('name', 'Sweden'), ('population', 9379116)])) self.assertEqual(set(sweden.items()), set([('name', 'Sweden'), ('population', 9379116)]))
def test_forbidden_methods(self): Country = warlock.model_factory(fixture) sweden = Country(name='Sweden', population=9379116) exc = warlock.InvalidOperation self.assertRaises(exc, sweden.clear) self.assertRaises(exc, sweden.pop, 0) self.assertRaises(exc, sweden.popitem)
def test_BaseModel_setattr(self): model_class = model_factory(self._test_schema, BaseModel) model = model_class(**self._test_values) self.assertRaises(AttributeError, getattr, model, 'test') model.test = 'FOO' self.assertEqual('FOO', model.test) self.assertRaises(AttributeError, getattr, model.json_object, 'test')
def test_items(self): Country = warlock.model_factory(fixture) sweden = Country(name='Sweden', population=9379116) self.assertEqual(set(list(sweden.iteritems())), set([('name', 'Sweden'), ('population', 9379116)])) self.assertEqual(set(sweden.items()), set([('name', 'Sweden'), ('population', 9379116)]))
def create_one_image(attrs=None): """Create a fake image. :param Dictionary attrs: A dictionary with all attrbutes of image :return: A FakeResource object with id, name, owner, protected, visibility and tags attrs """ attrs = attrs or {} # Set default attribute image_info = { 'id': str(uuid.uuid4()), 'name': 'image-name' + uuid.uuid4().hex, 'owner': 'image-owner' + uuid.uuid4().hex, 'protected': bool(random.choice([0, 1])), 'visibility': random.choice(['public', 'private']), 'tags': [uuid.uuid4().hex for r in range(2)], } # Overwrite default attributes if there are some attributes set image_info.update(attrs) # Set up the schema model = warlock.model_factory( IMAGE_schema, schemas.SchemaBasedModel, ) return model(**image_info)
def test_patch_alter_value(self): Country = warlock.model_factory(fixture) sweden = Country(name='Sweden', population=9379116) sweden['name'] = 'Finland' self.assertEqual( sweden.patch, '[{"path": "/name", "value": "Finland", "op": "replace"}]')
def test_BaseModel(self): model_class = model_factory(self._test_schema, BaseModel) model = model_class(**self._test_values) model.test = 'foo' self.assertEqual('FOO', model.type) self.assertEqual('0001', model.id)
def model(**item): schema = self.schemas.get('scene') wrapped_model = warlock.model_factory( schema.raw(), schemas.SceneSchemaModel) model = wrapped_model(**item) model.controller = self.scenes return model
def test_changes(self): Country = warlock.model_factory(fixture) sweden = Country(name="Sweden", population=9379116) self.assertEqual(sweden.changes, {}) sweden["name"] = "Finland" self.assertEqual(sweden.changes, {"name": "Finland"}) sweden["name"] = "Norway" self.assertEqual(sweden.changes, {"name": "Norway"})
def test_changes(self): Country = warlock.model_factory(fixture) sweden = Country(name='Sweden', population=9379116) self.assertEqual(sweden.changes, {}) sweden['name'] = 'Finland' self.assertEqual(sweden.changes, {'name': 'Finland'}) sweden['name'] = 'Norway' self.assertEqual(sweden.changes, {'name': 'Norway'})
def test_patch_alter_value(self): Country = warlock.model_factory(fixture) sweden = Country(name="Sweden", population=9379116) sweden["name"] = "Finland" self.assertEqual( json.loads(sweden.patch), json.loads( '[{"path": "/name", "value": "Finland", "op": "replace"}]'), )
def get_project_by_id(self, project_id): PROJECT_SCHEMA = {'name': {'type': ['null', 'string'], 'description': 'name of the project/tenant', 'maxLength': 255}} MockProject = warlock.model_factory(PROJECT_SCHEMA) if not project_id: return None elif 'admin' in project_id.lower(): return MockProject(name='admin') else: return MockProject(name='UnknownUser')
def test_attr_syntax(self): Country = warlock.model_factory(fixture) sweden = Country(name='Sweden', population=9379116) sweden.name = 'Finland' self.assertEqual(sweden.name, 'Finland') delattr(sweden, 'name') self.assertRaises(AttributeError, getattr, sweden, 'name')
def test_dict_syntax(self): Country = warlock.model_factory(fixture) sweden = Country(name='Sweden', population=9379116) sweden['name'] = 'Finland' self.assertEqual('Finland', sweden['name']) del sweden['name'] self.assertRaises(AttributeError, getattr, sweden, 'name')
def test_attr_syntax(self): Country = warlock.model_factory(fixture) sweden = Country(name="Sweden", population=9379116) sweden.name = "Finland" self.assertEqual("Finland", sweden.name) delattr(sweden, "name") self.assertRaises(AttributeError, getattr, sweden, "name")
def test_items(self): Country = warlock.model_factory(fixture) sweden = Country(name="Sweden", population=9379116) self.assertEqual( set(list(six.iteritems(sweden))), set([("name", "Sweden"), ("population", 9379116)]), ) self.assertEqual(set(sweden.items()), set([("name", "Sweden"), ("population", 9379116)]))
def test_dict_syntax(self): Country = warlock.model_factory(fixture) sweden = Country(name='Sweden', population=9379116) sweden['name'] = 'Finland' self.assertEqual(sweden['name'], 'Finland') del sweden['name'] self.assertRaises(AttributeError, getattr, sweden, 'name')
def test_attr_syntax(self): Country = warlock.model_factory(fixture) sweden = Country(name='Sweden', population=9379116) sweden.name = 'Finland' self.assertEqual('Finland', sweden.name) delattr(sweden, 'name') self.assertRaises(AttributeError, getattr, sweden, 'name')
def setUp(self): super(TestImageShow, self).setUp() # Set up the schema self.model = warlock.model_factory(image_fakes.IMAGE_schema, schemas.SchemaBasedModel) self.images_mock.get.return_value = self.model(**image_fakes.IMAGE) # Get the command object to test self.cmd = image.ShowImage(self.app, None)
def test_patch_multiple_operations(self): Country = warlock.model_factory(fixture) sweden = Country(name='Sweden', population=9379116) sweden['name'] = 'Finland' sweden['population'] = 5387000 self.assertEqual( sweden.patch, '[{"path": "/name", "value": "Finland", "op": "replace"}, ' '{"path": "/population", "value": 5387000, "op": "replace"}]')
def __init__(self, value: Dict) -> None: """Initialize object based on it's json schema Args: datatype (str): datatype that can be found in the json schema _json (Dict): json data to be validated against the schema """ schema: Dict = get_schema_datatypes(self._data_type) self._model = warlock.model_factory(schema) self._json = {} self._json = self._model(value)
def test_warlock_to_dict(self): schema = { "name": "Test", "properties": {"id": {"type": "string"}, "name": {"type": "string"}, "_unused": {"type": "string"}}, } test_model = warlock.model_factory(schema) test_obj = test_model(id="471c2475-da2f-47ac-aba5-cb4aa3d546f5", name="test-image") test_dict = meta.warlock_to_dict(test_obj) self.assertNotIn("_unused", test_dict) self.assertEqual("test-image", test_dict["name"]) self.assertTrue(hasattr(test_dict, "name")) self.assertEquals(test_dict.name, test_dict["name"])
def test_with_value_spec(self): o = self.calculation_info.create_object(id="/cat/name/1", category="ENDPOINT", version='1') res = schema.get("result_endpoint").schema res['properties']['result'] = { "enum": ["positive", "negative", "unknown"]} o['return_type_spec'] = res vts = copy.deepcopy(o['return_type_spec']) vt = warlock.model_factory(vts) t = vt() t.cmp_id = "" t.result = "positive"
def setUp(self): super(TestImageSet, self).setUp() # Set up the schema self.model = warlock.model_factory( image_fakes.IMAGE_schema, schemas.SchemaBasedModel, ) self.images_mock.get.return_value = self.model(**image_fakes.IMAGE) self.images_mock.update.return_value = self.model(**image_fakes.IMAGE) # Get the command object to test self.cmd = image.SetImage(self.app, None)
def test_patch_multiple_operations(self): Country = warlock.model_factory(fixture) sweden = Country(name='Sweden', population=9379116) sweden['name'] = 'Finland' sweden['population'] = 5387000 patch_obj = json.loads(sweden.patch) test_obj = [{"path": "/population", "value": 5387000, "op": "replace"}, {"path": "/name", "value": "Finland", "op": "replace"}] self.assertEqual(patch_obj.count(test_obj[0]), 1) self.assertEqual(patch_obj.count(test_obj[1]), 1)
def test_no_mask_arbitrary_properties(self): fixture_copy = copy.deepcopy(fixture) fixture_copy['additionalProperties'] = {'type': 'string'} Country = warlock.model_factory(fixture_copy) # We should still depend on the schema for validation self.assertRaises(ValueError, Country, GDP=56956) # But arbitrary properties should be allowed if they check out sweden = Country(overlord='Waldon') sweden.abbreviation = 'SE' exc = warlock.InvalidOperation self.assertRaises(exc, setattr, sweden, 'abbreviation', 0)
def test_patch_reduce_operations(self): Country = warlock.model_factory(fixture) sweden = Country(name='Sweden', population=9379116) sweden['name'] = 'Finland' self.assertEqual( json.loads(sweden.patch), [{"path": "/name", "value": "Finland", "op": "replace"}]) sweden['name'] = 'Norway' self.assertEqual( json.loads(sweden.patch), [{"path": "/name", "value": "Norway", "op": "replace"}])
def replacement(request): version = request.matchdict.get('version') input_schema, output_schema = get_schemas(schema_name, version) if input_schema is None or output_schema is None: msg = u"The schema '%s %s' doesn't exist" % (schema_name, version) return failure(msg, error_code='INTERNAL_ERROR') input_json = request.json_body error = validate_json_schema(input_json, input_schema) if error is not None: return failure(error, error_code='SCHEMA_VALIDATION_ERROR') input_model = model_factory(input_schema, base_class=model) input = input_model(**input_json) error = validate_object(request, input) if error is not None: return failure(str(error), error_code=getattr(error, 'code', None)) output_model = model_factory(output_schema) response = output_model(success=True, message="") return func(request, input, response)
def test_invalid_operations(self): Country = warlock.model_factory(fixture) sweden = Country(name='Sweden', population=9379116) # Ensure a valid object was created self.assertEqual(sweden.name, 'Sweden') self.assertEqual(sweden.population, 9379116) # Specific exceptions should be raised for invalid operations self.assertRaises(AttributeError, getattr, sweden, 'overlord') exc = warlock.InvalidOperation self.assertRaises(exc, setattr, sweden, 'overlord', 'Bears') self.assertRaises(exc, setattr, sweden, 'name', 5) self.assertRaises(exc, setattr, sweden, 'population', 'N/A')
def setUp(self): super(TestImageUnset, self).setUp() # Set up the schema self.model = warlock.model_factory( image_fakes.IMAGE_schema, schemas.SchemaBasedModel, ) self.images_mock.get.return_value = self.image self.image_tags_mock.delete.return_value = self.image # Get the command object to test self.cmd = image.UnsetImage(self.app, None)
def test_invalid_operations(self): Country = warlock.model_factory(fixture) sweden = Country(name="Sweden", population=9379116) # Ensure a valid object was created self.assertEqual(sweden.name, "Sweden") self.assertEqual(sweden.population, 9379116) # Specific exceptions should be raised for invalid operations self.assertRaises(AttributeError, getattr, sweden, "overlord") exc = warlock.InvalidOperation self.assertRaises(exc, setattr, sweden, "overlord", "Bears") self.assertRaises(exc, setattr, sweden, "name", 5) self.assertRaises(exc, setattr, sweden, "population", "N/A")
def setUp(self): super(TestImageSet, self).setUp() # Set up the schema self.model = warlock.model_factory(image_fakes.IMAGE_schema, schemas.SchemaBasedModel) self.project_mock.get.return_value = fakes.FakeResource( None, copy.deepcopy(identity_fakes.PROJECT), loaded=True ) self.domain_mock.get.return_value = fakes.FakeResource(None, copy.deepcopy(identity_fakes.DOMAIN), loaded=True) self.images_mock.get.return_value = self.model(**image_fakes.IMAGE) self.images_mock.update.return_value = self.model(**image_fakes.IMAGE) # Get the command object to test self.cmd = image.SetImage(self.app, None)
def __init__(self, schema_version: str, value: Dict = {}): """Initialization Args: schema_version (str): schema version of the object to look up under that object ttype value (Dict, optional): the initial entry for the json which will be validated. Defaults to {}. """ self.schema_version = schema_version schema: Dict = get_schema_object(self._object_type, self.schema_version) self._model = warlock.model_factory(schema) self._json = self._model(value) if "metadata" not in self._json: self._json["metadata"] = Metadata().json if "version" not in self._json: self._json["version"] = Version(schema_version=self.schema_version).json
def test_patch_multiple_operations(self): Country = warlock.model_factory(fixture) sweden = Country(name='Sweden', population=9379116) sweden['name'] = 'Finland' sweden['population'] = 5387000 self.assertEqual(len(json.loads(sweden.patch)), 2) patches = json.loads( '[{"path": "/name", "value": "Finland", "op": "replace"}, ' '{"path": "/population", "value": 5387000, "op": "replace"}]') for patch in json.loads(sweden.patch): self.assertTrue(patch in patches)
def test_patch_reduce_operations(self): Country = warlock.model_factory(fixture) sweden = Country(name='Sweden', population=9379116) sweden['name'] = 'Finland' self.assertEqual( json.loads(sweden.patch), json.loads( '[{"path": "/name", "value": "Finland", "op": "replace"}]')) sweden['name'] = 'Norway' self.assertEqual( json.loads(sweden.patch), json.loads( '[{"path": "/name", "value": "Norway", "op": "replace"}]'))
def get_project_by_id(self, project_id): PROJECT_SCHEMA = { 'name': { 'type': ['null', 'string'], 'description': 'name of the project/tenant', 'maxLength': 255 } } MockProject = warlock.model_factory(PROJECT_SCHEMA) if not project_id: return None elif 'admin' in project_id.lower(): return MockProject(name='admin') else: return MockProject(name='UnknownUser')
def model(**item): item_type = item['type'] _logger.debug("Item type: {}".format(item_type)) if item_type in self._schema_ignore: return None schema = self.schemas.get(item_type) if schema: wrapped_model = warlock.model_factory( schema.raw(), schemas.ActionSchemaModel) actions = item['actions'] model = wrapped_model(**item) self.devices._add_actions(model, actions) return model else: return None