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.__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_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 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_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 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_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 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(),
                                           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(sweden.iteritems())),
                      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_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 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_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(sweden.name, 'Finland')

        delattr(sweden, 'name')
        self.assertRaises(AttributeError, getattr, sweden, 'name')

 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 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 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"