def test_get_fk_name_with_name_different_of_column_name(self):
def add_in_registry():
@register(Model)
class Test:
name = String(primary_key=True, db_column_name='other')
registry = self.init_registry(add_in_registry)
ma = ModelAttribute('Model.Test', 'name')
assert ma.get_fk_name(registry) == 'test.other'
def test_get_fk_name_with_name_different_of_column_name(self):
def add_in_registry():
@register(Model)
class Test:
name = String(primary_key=True, db_column_name='other')
registry = self.init_registry(add_in_registry)
ma = ModelAttribute('Model.Test', 'name')
self.assertEqual(ma.get_fk_name(registry), 'test.other')
def after_model_construction(self, base, namespace,
transformation_properties):
for eventtype in ('before_insert', 'after_insert', 'before_update',
'after_update', 'before_delete', 'after_delete'):
attr = eventtype + '_orm_event'
if hasattr(base, attr):
if not hasattr(getattr(base, attr), '__self__'):
raise ORMEventException("On %s %s is not a classmethod" %
(base, attr))
self.registry._sqlalchemy_known_events.append(
(ModelMapper(base, eventtype), namespace,
ModelAttribute(namespace, attr)))
def transform_base_attribute(self, attr, method, namespace, base,
transformation_properties,
new_type_properties):
"""declare in the registry the sqlalchemy event
:param attr: attribute name
:param method: method pointer of the attribute
:param namespace: the namespace of the model
:param base: One of the base of the model
:param transformation_properties: the properties of the model
:param new_type_properties: param to add in a new base if need
"""
if not hasattr(method, 'is_an_sqlalchemy_event_listener'):
return
elif method.is_an_sqlalchemy_event_listener is True:
self.registry._sqlalchemy_known_events.append(
(method.sqlalchemy_listener, namespace,
ModelAttribute(namespace, attr)))
def register(self, parent, name, cls_, **kwargs):
""" add new sub registry in the registry
:param parent: Existing global registry
:param name: Name of the new registry to add it
:param cls_: Class Interface to add in registry
"""
_registryname = parent.__registry_name__ + '.' + name
if 'tablename' in kwargs:
tablename = kwargs.pop('tablename')
if not isinstance(tablename, str):
tablename = tablename.__tablename__
elif hasattr(parent, name):
tablename = getattr(parent, name).__tablename__
else:
if parent is Declarations or parent is Declarations.Model:
tablename = name.lower()
elif hasattr(parent, '__tablename__'):
tablename = parent.__tablename__
tablename += '_' + name.lower()
if not hasattr(parent, name):
p = {
'__tablename__': tablename,
'__registry_name__': _registryname,
'use': lambda x: ModelAttribute(_registryname, x),
}
ns = type(name, tuple(), p)
setattr(parent, name, ns)
if parent is Declarations:
return
kwargs['__registry_name__'] = _registryname
kwargs['__tablename__'] = tablename
update_factory(kwargs)
RegistryManager.add_entry_in_register('Model', _registryname, cls_,
**kwargs)
setattr(cls_, '__anyblok_kwargs__', kwargs)
def test_get_column_name(self, registry_blok):
registry = registry_blok
ma = ModelAttribute('Model.System.Field', 'name')
assert ma.get_column_name(registry) == 'name'
def test_check_model_in_first_step_no_sql_model(self, registry_blok):
registry = registry_blok
ma = ModelAttribute('Model.System', 'name')
with pytest.raises(ModelAttributeException):
ma.check_model_in_first_step(registry)
def test_without_attribute(self):
with self.assertRaises(ModelAttributeException):
ModelAttribute('Model.System.Model', None)
def test_existing_FakeRelationShip(self, registry_blok):
registry = registry_blok
ma = ModelAttribute('Model.System.Field', 'name')
assert ma.add_fake_relationship(registry, 'Model.System',
'test') is None
def test_get_fk_name_with_unexisting_model(self):
registry = self.init_registry(None)
ma = ModelAttribute('Model.Unexisting.Model', 'name')
with self.assertRaises(ModelAttributeException):
ma.get_fk_name(registry)
def test_get_fk(self, registry_blok):
registry = registry_blok
ma = ModelAttribute('Model.System.Model', 'name')
assert isinstance(ma.get_fk(registry), ForeignKey)
def test_without_model(self, registry_blok):
with pytest.raises(ModelAttributeException):
ModelAttribute(None, 'name')
def test_get_attribute(self, registry_blok):
registry = registry_blok
ma = ModelAttribute('Model.System.Model', 'name')
assert ma.get_attribute(registry) == registry.get(
'Model.System.Model').name
def test_get_fk(self):
registry = self.init_registry(None)
ma = ModelAttribute('Model.System.Model', 'name')
self.assertTrue(isinstance(ma.get_fk(registry), ForeignKey))
def test_get_fk_with_options(self):
registry = self.init_registry(None)
ma = ModelAttribute('Model.System.Model', 'name').options(
ondelete='cascade')
mafk = ma.get_fk(registry)
self.assertTrue(isinstance(mafk, ForeignKey))
def test_without_model(self):
with self.assertRaises(ModelAttributeException):
ModelAttribute(None, 'name')
def test_get_fk_name(self):
registry = self.init_registry(None)
ma = ModelAttribute('Model.System.Model', 'name')
self.assertEqual(ma.get_fk_name(registry), 'system_model.name')
def test_get_fk_name_unexisting_attribute(self):
registry = self.init_registry(None)
ma = ModelAttribute('Model.System.Model', 'id')
with self.assertRaises(ModelAttributeException):
ma.get_fk_name(registry)
def test_from_declaration(self):
ma = ModelAttribute('Model.System.Model', 'name')
maa = ModelAttributeAdapter(ma)
assert maa is ma
def test_get_fk_name_with_wrong_model(self, registry_blok):
registry = registry_blok
ma = ModelAttribute('Model.System', 'name')
with pytest.raises(ModelAttributeException):
ma.get_fk_name(registry)
def test_get_attribute(self):
registry = self.init_registry(None)
ma = ModelAttribute('Model.System.Model', 'name')
self.assertEqual(ma.get_attribute(registry),
registry.get('Model.System.Model').name)
def test_get_fk_name_unexisting_attribute(self, registry_blok):
registry = registry_blok
ma = ModelAttribute('Model.System.Model', 'id')
with pytest.raises(ModelAttributeException):
ma.get_fk_name(registry)
def test_without_attribute(self, registry_blok):
with pytest.raises(ModelAttributeException):
ModelAttribute('Model.System.Model', None)
def test_without_model_and_attribute(self):
with self.assertRaises(ModelAttributeException):
ModelAttribute(None, None)
def test_without_model_and_attribute(self, registry_blok):
with pytest.raises(ModelAttributeException):
ModelAttribute(None, None)
def test_str(self, registry_blok):
ma = ModelAttribute('Model.System.Model', 'name')
assert str(ma) == 'Model.System.Model => name'
def test_get_fk_name_with_unexisting_model(self, registry_blok):
registry = registry_blok
ma = ModelAttribute('Model.Unexisting.Model', 'name')
with pytest.raises(ModelAttributeException):
ma.get_fk_name(registry)
def test_get_fk_remote(self, registry_blok):
registry = registry_blok
ma = ModelAttribute('Model.System.Column', 'name')
assert ma.get_fk_remote(registry) is None
def test_get_fk_name(self, registry_blok):
registry = registry_blok
ma = ModelAttribute('Model.System.Model', 'name')
assert ma.get_fk_name(registry) == 'system_model.name'
def test_get_complete_remote(self, registry_blok):
registry = registry_blok
ma = ModelAttribute('Model.System.Field', 'name')
assert ma.get_complete_remote(registry) is None
def test_get_fk_with_options(self, registry_blok):
registry = registry_blok
ma = ModelAttribute('Model.System.Model',
'name').options(ondelete='cascade')
mafk = ma.get_fk(registry)
assert isinstance(mafk, ForeignKey)
def test_existing_FakeColumn(self, registry_blok):
registry = registry_blok
ma = ModelAttribute('Model.System.Field', 'name')
assert ma.add_fake_column(registry) is None
