Example #1
0
    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)
Example #2
0
    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)
Example #3
0
    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)
Example #4
0
    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__)
Example #5
0
    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__)
Example #6
0
 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')
Example #7
0
    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)
Example #8
0
    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)
Example #9
0
    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"])
Example #10
0
 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"}]'))
Example #11
0
 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
Example #12
0
    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'])
Example #13
0
    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')
Example #14
0
 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(), base_class=schemas.SchemaBasedModel)
     warlock_model.validate = lambda *args, **kwargs: None
     return warlock_model
Example #16
0
 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)]))
Example #17
0
 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)
Example #18
0
 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')
Example #19
0
 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)]))
Example #20
0
    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)
Example #21
0
 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"}]')
Example #22
0
 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)
Example #23
0
    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 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)
Example #25
0
 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
Example #26
0
 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"})
Example #27
0
 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'})
Example #28
0
 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'})
Example #29
0
 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"}]'),
     )
Example #30
0
 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')
Example #31
0
    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')
Example #32
0
    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')
Example #33
0
    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")
Example #34
0
 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)]))
Example #35
0
    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')
Example #36
0
    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)
Example #38
0
    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"}]')
Example #39
0
    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)
Example #40
0
 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"])
Example #41
0
    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)
Example #43
0
    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)
Example #44
0
    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)
Example #45
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"}])
Example #46
0
    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)
Example #47
0
        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)
Example #48
0
    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')
Example #49
0
    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')
Example #50
0
    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)
Example #51
0
    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)
Example #53
0
    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
Example #54
0
    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)
Example #55
0
    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)
Example #56
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),
            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"}]'))
Example #57
0
 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')
Example #58
0
 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