def wrapper(self):
from anyblok.registry import RegistryManager
name = self.__name__
if name in cls.declaration_types:
raise DeclarationsException(
"The declaration type %r is already defined" % name)
cls.declaration_types[name] = self
setattr(self, '__registry_name__', name)
setattr(self, '__declaration_type__', name)
setattr(cls, name, self)
if isAnEntry:
assemble_callback = initialize_callback = None
if assemble and hasattr(self, assemble):
assemble_callback = getattr(self, assemble)
if initialize and hasattr(self, initialize):
initialize_callback = getattr(self, initialize)
RegistryManager.declare_entry(
name, assemble_callback=assemble_callback,
initialize_callback=initialize_callback)
# All declaration type can need to be unload declarated values
if unload and hasattr(self, unload):
RegistryManager.declare_unload_callback(
name, getattr(self, unload))
return self
def test_add_core(self):
class test:
pass
RegistryManager.add_core_in_register('test', test)
self.assertInCore(test)
assert RegistryManager.has_core_in_register('testCore', 'test')
def reload_blokmanager(cls, **kwargs):
"""Reload all the bloks with their code sources"""
RegistryManager.clear() # close all the registry
BlokManager.reload() # reload all the blok code
# FIXME BlokManager.reload should close all the registry and
# forbidden load registry during the reload
return [{'type': 'RELOAD'}]
def imports(self):
""" Imports modules and / or packages listed in the blok path"""
from anyblok.blok import BlokManager
from anyblok.registry import RegistryManager
RegistryManager.init_blok(self.blok)
b = BlokManager.get(self.blok)
b.import_declaration_module()
def add_testCore(self, request, bloks_loaded):
def reset():
EnvironmentManager.set('current_blok', None)
del RegistryManager.loaded_bloks['testCore' + self._corename]
request.addfinalizer(reset)
RegistryManager.init_blok('testCore' + self._corename)
EnvironmentManager.set('current_blok', 'testCore' + self._corename)
def imports(self):
""" Imports modules and / or packages listed in the blok path"""
from anyblok.blok import BlokManager
from anyblok.registry import RegistryManager
RegistryManager.init_blok(self.blok)
b = BlokManager.get(self.blok)
b.import_declaration_module()
def test_add_entry(self):
class test:
pass
RegistryManager.add_entry_in_register('Other', 'test', test)
self.assertInEntry('test', test)
assert RegistryManager.has_entry_in_register('testEntry', 'Other',
'test')
def unregister(self, entry, cls_):
""" Remove the Interface from the registry
:param entry: entry declaration of the model where the ``cls_``
must be removed
:param cls_: Class Interface to remove in the declaration
"""
RegistryManager.remove_in_register(cls_)
def unregister(self, entry, cls_):
""" Remove the Interface from the registry
:param entry: entry declaration of the model where the ``cls_``
must be removed
:param cls_: Class Interface to remove in registry
"""
RegistryManager.remove_in_register(cls_)
def tearDown(self):
""" Clear the registry, unload the blok manager and drop the database
"""
if self.registry:
self.registry.close()
RegistryManager.clear()
BlokManager.unload()
super(DBTestCase, self).tearDown()
def test_add_core(self):
class test:
pass
RegistryManager.add_core_in_register('test', test)
self.assertInCore(test)
self.assertEqual(
RegistryManager.has_core_in_register('testCore', 'test'),
True)
def init_env(self, request):
def revert():
EnvironmentManager.set('current_blok', None)
del RegistryManager.loaded_bloks['testModel']
request.addfinalizer(revert)
RegistryManager.init_blok('testModel')
EnvironmentManager.set('current_blok', 'testModel')
def init_env(self, request):
def revert():
EnvironmentManager.set('current_blok', None)
del RegistryManager.loaded_bloks['testCore']
RegistryManager.undeclare_core('test')
request.addfinalizer(revert)
RegistryManager.declare_core('test')
RegistryManager.init_blok('testCore')
EnvironmentManager.set('current_blok', 'testCore')
def test_update_query(self):
registry = RegistryManager.get(Configuration.get('db_name'))
registry.upgrade(install=('test-me-blok2',))
registry.commit()
self.assertTrue(registry.System.Blok.query().all_name())
self.assertTrue(registry.System.Blok.query().all())
registry.close()
registry = RegistryManager.get(Configuration.get('db_name'))
self.assertTrue(registry.System.Blok.query().all_name())
self.assertTrue(registry.System.Blok.query().all())
def tearDown(self):
""" Clear the registry, unload the blok manager and drop the database
"""
registry = RegistryManager.get(Configuration.get('db_name'))
registry.close()
RegistryManager.clear()
BlokManager.unload()
clear_mappers()
self.__class__.dropdb()
super(TestBlok, self).tearDown()
def tearDown(self):
""" Clear the registry, unload the blok manager and drop the database
"""
if self.registry:
self.registry.close()
RegistryManager.clear()
BlokManager.unload()
clear_mappers()
super(DBTestCase, self).tearDown()
def test_add_entry(self):
class test:
pass
RegistryManager.add_entry_in_register('Other', 'test', test)
self.assertInEntry('test', test)
self.assertEqual(
RegistryManager.has_entry_in_register('testEntry', 'Other',
'test'),
True)
def test_get_entry_properties_in_register(self):
class test:
pass
RegistryManager.add_entry_in_register('Other', 'test', test,
property1='test')
properties = RegistryManager.get_entry_properties_in_register(
'Other', 'test')
hasproperty1 = 'property1' in properties
self.assertTrue(hasproperty1)
self.assertEqual(properties['property1'], 'test')
def test_get_entry_properties_in_register(self):
class test:
pass
RegistryManager.add_entry_in_register('Other',
'test',
test,
property1='test')
properties = RegistryManager.get_entry_properties_in_register(
'Other', 'test')
hasproperty1 = 'property1' in properties
assert hasproperty1
assert properties['property1'] == 'test'
def test_init_blok(self):
RegistryManager.init_blok('newblok')
is_exist = 'newblok' in RegistryManager.loaded_bloks
self.assertEqual(is_exist, True)
for core in ('Base', 'SqlBase', 'SqlViewBase', 'Session', 'Query',
'InstrumentedList'):
self.assertIn(
core, RegistryManager.loaded_bloks['newblok']['Core'].keys())
self.assertEqual(
RegistryManager.loaded_bloks['newblok']['Core'][core], [])
self.assertEqual(RegistryManager.loaded_bloks['newblok']['Model'],
{'registry_names': []})
self.assertEqual(RegistryManager.loaded_bloks['newblok']['Mixin'],
{'registry_names': []})
def test_init_blok(self):
RegistryManager.init_blok('newblok')
is_exist = 'newblok' in RegistryManager.loaded_bloks
self.assertEqual(is_exist, True)
for core in ('Base', 'SqlBase', 'SqlViewBase', 'Session', 'Query',
'InstrumentedList'):
self.assertIn(
core, RegistryManager.loaded_bloks['newblok']['Core'].keys())
self.assertEqual(
RegistryManager.loaded_bloks['newblok']['Core'][core], [])
self.assertEqual(RegistryManager.loaded_bloks['newblok']['Model'],
{'registry_names': []})
self.assertEqual(RegistryManager.loaded_bloks['newblok']['Mixin'],
{'registry_names': []})
def register(self, parent, name, cls_, **kwargs):
""" Add new sub registry in the registry
:param parent: Existing declaration
:param name: Name of the new declaration to add it
:param cls_: Class Interface to add in the declaration
"""
if not hasattr(parent, name):
core = type(name, tuple(), {})
setattr(parent, name, core)
if parent == Declarations:
return
RegistryManager.add_core_in_register(name, cls_)
def register(self, parent, name, cls_, **kwargs):
""" Add new sub registry in the registry
:param parent: Existing declaration
:param name: Name of the new declaration to add it
:param cls_: Class Interface to add in the declaration
"""
if not hasattr(parent, name):
core = type(name, tuple(), {})
setattr(parent, name, core)
if parent == Declarations:
return
RegistryManager.add_core_in_register(name, cls_)
def test_add_entry(self):
RegistryManager.declare_entry('Other')
RegistryManager.init_blok('newblok')
is_exist = 'newblok' in RegistryManager.loaded_bloks
self.assertEqual(is_exist, True)
for entry in ('Base', 'SqlBase', 'SqlViewBase', 'Session', 'Query',
'InstrumentedList'):
self.assertEqual(
RegistryManager.loaded_bloks['newblok']['Core'][entry], [])
self.assertEqual(RegistryManager.loaded_bloks['newblok']['Model'],
{'registry_names': []})
self.assertEqual(RegistryManager.loaded_bloks['newblok']['Mixin'],
{'registry_names': []})
self.assertEqual(RegistryManager.loaded_bloks['newblok']['Other'],
{'registry_names': []})
def test_init_blok(self):
RegistryManager.init_blok('newblok')
is_exist = 'newblok' in RegistryManager.loaded_bloks
assert is_exist
for core in ('Base', 'SqlBase', 'SqlViewBase', 'Session', 'Query',
'InstrumentedList'):
assert core in RegistryManager.loaded_bloks['newblok'][
'Core'].keys()
assert RegistryManager.loaded_bloks['newblok']['Core'][core] == []
assert RegistryManager.loaded_bloks['newblok']['Model'] == {
'registry_names': []
}
assert RegistryManager.loaded_bloks['newblok']['Mixin'] == {
'registry_names': []
}
def createdb(application, configuration_groups, **kwargs):
""" Create a database and install blok from config
:param application: name of the application
:param configuration_groups: list configuration groupe to load
:param \**kwargs: ArgumentParser named arguments
"""
format_configuration(configuration_groups,
'create_db', 'install-bloks',
'install-or-update-bloks')
load_init_function_from_entry_points()
Configuration.load(application, configuration_groups=configuration_groups,
**kwargs)
BlokManager.load()
db_name = Configuration.get('db_name')
db_template_name = Configuration.get('db_template_name', None)
url = Configuration.get('get_url')(db_name=db_name)
create_database(url, template=db_template_name)
registry = RegistryManager.get(db_name)
if registry is None:
return
if Configuration.get('install_all_bloks'):
bloks = registry.System.Blok.list_by_state('uninstalled')
else:
install_bloks = Configuration.get('install_bloks') or []
iou_bloks = Configuration.get('install_or_update_bloks') or []
bloks = list(set(install_bloks + iou_bloks))
registry.upgrade(install=bloks)
registry.commit()
registry.close()
def init_registry_with_bloks(bloks, function, **kwargs):
if bloks is None:
bloks = []
if isinstance(bloks, tuple):
bloks = list(bloks)
if isinstance(bloks, str):
bloks = [bloks]
anyblok_test_name = 'anyblok-test'
if anyblok_test_name not in bloks:
bloks.append(anyblok_test_name)
loaded_bloks = deepcopy(RegistryManager.loaded_bloks)
if function is not None:
EnvironmentManager.set('current_blok', anyblok_test_name)
try:
function(**kwargs)
finally:
EnvironmentManager.set('current_blok', None)
try:
registry = RegistryManager.get(Configuration.get('db_name'),
unittest=True)
# update required blok
registry_bloks = registry.get_bloks_by_states('installed', 'toinstall')
toinstall = [x for x in bloks if x not in registry_bloks]
toupdate = [x for x in bloks if x in registry_bloks]
registry.upgrade(install=toinstall, update=toupdate)
finally:
RegistryManager.loaded_bloks = loaded_bloks
return registry
def load_registry(self):
if self.enabled and self.registryLoaded is False:
# Load the registry here not in configuration,
# because the configuration are not load in order of score
self.registryLoaded = True
BlokManager.load()
load_init_function_from_entry_points(unittest=True)
Configuration.load_config_for_test()
Configuration.parse_options(self.AnyBlokOptions, ('bloks',))
db_name = Configuration.get('db_name')
if not db_name:
raise Exception("No database defined to run Test")
registry = RegistryManager.get(db_name)
if registry:
installed_bloks = registry.System.Blok.list_by_state(
"installed")
selected_bloks = Configuration.get('selected_bloks')
if not selected_bloks:
selected_bloks = installed_bloks
unwanted_bloks = Configuration.get('unwanted_bloks')
if unwanted_bloks is None:
unwanted_bloks = []
self.bloks_path = [BlokManager.getPath(x)
for x in BlokManager.ordered_bloks]
self.authoried_bloks_test_files = [
path for blok in installed_bloks
if blok in selected_bloks and blok not in unwanted_bloks
for path in [join(BlokManager.getPath(blok), 'tests')]
if exists(path)]
registry.close() # free the registry to force create it again
def get_registry_for(dbname, loadwithoutmigration=True, log_repeat=False):
settings = {
'anyblok.session.event': [register],
}
return RegistryManager.get(
dbname, loadwithoutmigration=loadwithoutmigration,
log_repeat=log_repeat, **settings)
def test_remove_entry(self):
class test:
pass
def has_test_in_removed():
core = RegistryManager.loaded_bloks['testEntry']['removed']
if test in core:
return True
return False
RegistryManager.add_entry_in_register('Other', 'test', test)
self.assertInEntry('test', test)
self.assertFalse(has_test_in_removed())
RegistryManager.remove_in_register(test)
self.assertTrue(has_test_in_removed())
def createdb(cls, keep_existing=False, with_demo=False):
"""Create the database specified in configuration.
::
cls.init_configuration_manager()
cls.createdb()
:param keep_existing: If false drop the previous db before create it
"""
url = Configuration.get('get_url')()
db_template_name = Configuration.get('db_template_name', None)
if database_exists(url):
if keep_existing:
return False
drop_database(url)
create_database(url, template=db_template_name)
registry = RegistryManager.get(Configuration.get('db_name', None))
if registry is None:
return
registry.System.Parameter.set(
"with-demo", Configuration.get('with_demo', with_demo))
return True
def test_remove_core(self):
class test:
pass
def has_test_in_removed():
core = RegistryManager.loaded_bloks['testCore']['removed']
if test in core:
return True
return False
RegistryManager.add_core_in_register('test', test)
self.assertInCore(test)
self.assertEqual(has_test_in_removed(), False)
RegistryManager.remove_in_register(test)
self.assertEqual(has_test_in_removed(), True)
def anyblok_createdb():
"""Create a database and install blok from config"""
load_init_function_from_entry_points()
Configuration.load('createdb')
configuration_post_load()
BlokManager.load()
db_name = get_db_name()
db_template_name = Configuration.get('db_template_name', None)
url = Configuration.get('get_url')(db_name=db_name)
create_database(url, template=db_template_name)
anyblok_registry = RegistryManager.get(db_name)
if anyblok_registry is None:
return
anyblok_registry.System.Parameter.set(
"with-demo", Configuration.get('with_demo', False))
if Configuration.get('install_all_bloks'):
bloks = anyblok_registry.System.Blok.list_by_state('uninstalled')
else:
install_bloks = Configuration.get('install_bloks') or []
iou_bloks = Configuration.get('install_or_update_bloks') or []
bloks = list(set(install_bloks + iou_bloks))
anyblok_registry.upgrade(install=bloks)
anyblok_registry.commit()
anyblok_registry.close()
def test_remove_core(self):
class test:
pass
def has_test_in_removed():
core = RegistryManager.loaded_bloks['testCore']['removed']
if test in core:
return True
return False
RegistryManager.add_core_in_register('test', test)
self.assertInCore(test)
assert not has_test_in_removed()
RegistryManager.remove_in_register(test)
assert has_test_in_removed()
def test_add_entry(self):
RegistryManager.declare_entry('Other')
RegistryManager.init_blok('newblok')
is_exist = 'newblok' in RegistryManager.loaded_bloks
self.assertEqual(is_exist, True)
for entry in ('Base', 'SqlBase', 'SqlViewBase', 'Session', 'Query',
'InstrumentedList'):
self.assertEqual(
RegistryManager.loaded_bloks['newblok']['Core'][entry], [])
self.assertEqual(RegistryManager.loaded_bloks['newblok']['Model'],
{'registry_names': []})
self.assertEqual(RegistryManager.loaded_bloks['newblok']['Mixin'],
{'registry_names': []})
self.assertEqual(RegistryManager.loaded_bloks['newblok']['Other'],
{'registry_names': []})
def before_process_message(self, broker, message):
"""Called before process message
Invalid the cache, this is mean that if a cache have to be invalidated
then it will be invalidated else nothing is done
If the message is in the ``Model.Dramatiq.Message`` then
the status will be change to **running**
:param broker: the broker used
:param message: the message send in the broker
"""
registry = RegistryManager.get(Configuration.get('db_name'))
logger.debug("[before_process_message] %s: update message(%s) status ",
id(registry.session), message.message_id)
# cache may have change, then we do the invalidation in the dramatiq
# side
registry.System.Cache.clear_invalidate_cache()
M = registry.Dramatiq.Message
m = M.get_instance_of(message)
if m:
m.update_status(M.STATUS_RUNNING)
registry.commit()
EnvironmentManager.set('is_called_by_dramatiq_actor', True)
def load_client(request):
""" Return the client main page """
database = request.session.get('database')
login = request.session.get('login')
password = request.session.get('password')
state = request.session.get('state')
if not(database and login and password and state == "connected"):
logout(request)
return HTTPFound(location=request.route_url('homepage'))
try:
registry = RegistryManager.get(database)
assert registry.Web.Login.check_authentification(login, password)
except:
logout(request)
return HTTPFound(location=request.route_url('homepage'))
css = registry.Web.get_css()
js = registry.Web.get_js()
js_babel = registry.Web.get_js_babel()
# TODO see in system.parmeter if they are no data for title
title = Configuration.get('app_name', 'ERPBlok')
templates = registry.Web.get_templates()
return render_to_response('erpblok:client.mak',
{'title': title,
'css': css,
'js': js,
'js_babel': js_babel,
'templates': templates,
}, request=request)
def anyblok_createdb():
"""Create a database and install blok from config"""
load_init_function_from_entry_points()
Configuration.load('createdb')
configuration_post_load()
BlokManager.load()
db_name = get_db_name()
db_template_name = Configuration.get('db_template_name', None)
url = Configuration.get('get_url')(db_name=db_name)
create_database(url, template=db_template_name)
registry = RegistryManager.get(db_name)
if registry is None:
return
if Configuration.get('install_all_bloks'):
bloks = registry.System.Blok.list_by_state('uninstalled')
else:
install_bloks = Configuration.get('install_bloks') or []
iou_bloks = Configuration.get('install_or_update_bloks') or []
bloks = list(set(install_bloks + iou_bloks))
registry.upgrade(install=bloks)
registry.commit()
registry.close()
def get_registry_for(dbname, loadwithoutmigration=True, log_repeat=False):
settings = {
'anyblok.session.event': [register],
}
return RegistryManager.get(dbname,
loadwithoutmigration=loadwithoutmigration,
log_repeat=log_repeat,
**settings)
def setUp(self):
super(TestBlok, self).setUp()
self.__class__.init_configuration_manager()
self.__class__.createdb(keep_existing=False)
BlokManager.load(entry_points=('bloks', 'test_bloks'))
registry = RegistryManager.get(Configuration.get('db_name'))
registry.commit()
registry.close()
def webserver(request, configuration_loaded, init_session):
with TestClient(
create_app(
RegistryManager.get(
Configuration.get("db_name"),
loadwithoutmigration=True,
))) as client:
yield client
def test_add_entry(self):
RegistryManager.declare_entry('Other')
RegistryManager.init_blok('newblok')
is_exist = 'newblok' in RegistryManager.loaded_bloks
assert is_exist
for entry in ('Base', 'SqlBase', 'SqlViewBase', 'Session', 'Query',
'InstrumentedList'):
assert RegistryManager.loaded_bloks['newblok']['Core'][entry] == []
assert RegistryManager.loaded_bloks['newblok']['Model'] == {
'registry_names': []
}
assert RegistryManager.loaded_bloks['newblok']['Mixin'] == {
'registry_names': []
}
assert RegistryManager.loaded_bloks['newblok']['Other'] == {
'registry_names': []
}
def before_worker_thread_shutdown(self, *args, **kwargs):
"""Called before worker thread shutdown
remove the session instance to clean the Session pool
"""
registry = RegistryManager.get(Configuration.get('db_name'))
logger.debug("[before_worker_thread_shutdown] %s: %r %r",
id(registry.session), args, kwargs)
registry.Session.remove()
def register(cls, 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 not hasattr(parent, name):
kwargs['__registry_name__'] = _registryname
ns = type(name, tuple(), kwargs)
setattr(parent, name, ns)
if parent is Declarations:
return
RegistryManager.add_entry_in_register(cls.__name__, _registryname,
cls_, **kwargs)
def setUpClass(cls):
""" Initialize the registry.
"""
super(BlokTestCase, cls).setUpClass()
additional_setting = cls.additional_setting()
if cls.registry is None:
cls.registry = RegistryManager.get(Configuration.get('db_name'),
**additional_setting)
cls.registry.commit()
def after_worker_shutdown(self, *args, **kwargs):
"""Called before worker shutdown
Close the AnyBlok registry
"""
registry = RegistryManager.get(Configuration.get('db_name'))
logger.debug("[after_worker_shutdown] %s: %r %r", id(registry.session),
args, kwargs)
registry.close()
def reload(self):
""" Reload all the imports for this module
:exception: ImportManagerException
"""
from anyblok.blok import BlokManager
from anyblok.registry import RegistryManager
from anyblok.environment import EnvironmentManager
b = BlokManager.get(self.blok)
if not hasattr(b, 'reload_declaration_module'):
return
try:
EnvironmentManager.set('reload', True)
RegistryManager.init_blok(self.blok)
b.reload_declaration_module(reload_wraper)
finally:
EnvironmentManager.set('reload', False)
def register(cls, 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 not hasattr(parent, name):
kwargs['__registry_name__'] = _registryname
ns = type(name, tuple(), kwargs)
setattr(parent, name, ns)
if parent is Declarations:
return
RegistryManager.add_entry_in_register(
cls.__name__, _registryname, cls_, **kwargs)
def reload(self):
""" Reload all the imports for this module
:exception: ImportManagerException
"""
from anyblok.blok import BlokManager
from anyblok.registry import RegistryManager
from anyblok.environment import EnvironmentManager
b = BlokManager.get(self.blok)
if not hasattr(b, 'reload_declaration_module'):
return
try:
EnvironmentManager.set('reload', True)
RegistryManager.init_blok(self.blok)
b.reload_declaration_module(reload_module)
finally:
EnvironmentManager.set('reload', False)
def get_registry_for(
dbname: str, loadwithoutmigration: bool = True, log_repeat: bool = False
):
# Methode copied from anyblok_pyramid.common"""
settings: Dict[str, Any] = {}
return RegistryManager.get(
dbname,
loadwithoutmigration=loadwithoutmigration,
log_repeat=log_repeat,
**settings,
)
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 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 drop_database(database):
""" Close the registry instance of the database and drop the database
:param: database's name
"""
url = Configuration.get('get_url')(db_name=database)
if not database_exists(url):
raise Exception("Database %r does not already exist")
registry = RegistryManager.get(database)
registry.close()
SU_drop_database(url)
def test_add_callback(self):
def callback():
pass
RegistryManager.declare_entry('Other', assemble_callback=callback,
initialize_callback=callback)
hasModel = 'Model' in RegistryManager.declared_entries
hasMixin = 'Mixin' in RegistryManager.declared_entries
hasOther = 'Other' in RegistryManager.declared_entries
self.assertEqual(hasModel, True)
self.assertEqual(hasMixin, True)
self.assertEqual(hasOther, True)
cb = Model.assemble_callback
hasModelCb = cb == RegistryManager.callback_assemble_entries['Model']
cb = callback
hasOtherCb = cb == RegistryManager.callback_assemble_entries['Other']
self.assertEqual(hasModelCb, True)
self.assertEqual(hasOtherCb, True)
cb = Model.initialize_callback
hasModelCb = cb == RegistryManager.callback_initialize_entries['Model']
cb = callback
hasOtherCb = cb == RegistryManager.callback_initialize_entries['Other']
self.assertEqual(hasModelCb, True)
self.assertEqual(hasOtherCb, True)
RegistryManager.init_blok('newblok')
is_exist = 'newblok' in RegistryManager.loaded_bloks
self.assertEqual(is_exist, True)
hasCore = 'Core' in RegistryManager.loaded_bloks['newblok']
hasModel = 'Model' in RegistryManager.loaded_bloks['newblok']
hasMixin = 'Mixin' in RegistryManager.loaded_bloks['newblok']
hasOther = 'Other' in RegistryManager.loaded_bloks['newblok']
self.assertEqual(hasCore, True)
self.assertEqual(hasModel, True)
self.assertEqual(hasMixin, True)
self.assertEqual(hasOther, True)
def getRegistry(cls):
"""Return the registry for the test database.
This assumes the database is created, and the registry has already
been initialized::
registry = self.getRegistry()
:rtype: registry instance
"""
additional_setting = cls.additional_setting()
return RegistryManager.get(Configuration.get('db_name'),
**additional_setting)
def create_database(database):
""" Create a new database, initialize it and return an AnyBlok registry
:param: database's name
:rtype: AnyBlok registry instance
"""
url = Configuration.get('get_url')(db_name=database)
if database_exists(url):
raise Exception("Database %r already exist")
db_template_name = Configuration.get('db_template_name', None)
SU_create_database(url, template=db_template_name)
registry = RegistryManager.get(database)
return registry
def tearDownClass(cls):
super(TestRegistryEntry, cls).tearDownClass()
EnvironmentManager.set('current_blok', None)
del RegistryManager.loaded_bloks['testEntry']
RegistryManager.undeclare_entry('Other')
def setUpClass(cls):
super(TestRegistryEntry, cls).setUpClass()
RegistryManager.declare_entry('Other')
RegistryManager.init_blok('testEntry')
EnvironmentManager.set('current_blok', 'testEntry')
