def init_registry_with_bloks(self, bloks, function, **kwargs):
""" call a function to filled the blok manager with new model and
bloks to install
:param bloks: list of blok's names
:param function: function to call
:param kwargs: kwargs for the function
:rtype: registry instance
"""
if bloks is None:
bloks = []
if isinstance(bloks, tuple):
bloks = list(bloks)
if 'anyblok-test' not in bloks:
bloks.append('anyblok-test')
from copy import deepcopy
loaded_bloks = deepcopy(RegistryManager.loaded_bloks)
if function is not None:
EnvironmentManager.set('current_blok', 'anyblok-test')
try:
function(**kwargs)
finally:
EnvironmentManager.set('current_blok', None)
try:
self.registry = registry = self.__class__.getRegistry()
if bloks:
registry.upgrade(install=bloks)
finally:
RegistryManager.loaded_bloks = loaded_bloks
return registry
def test_without_environment_for_set(self):
# don't use define_environment_cls, because she must be verify
EnvironmentManager.environment = None
try:
EnvironmentManager.set('db_name', 'test')
self.fail('No watchdog for None environment')
except EnvironmentException:
pass
def _finish(self, final_state):
assert self.transaction is not None
del _SESSION_STATE[self.registry.session]
registry = self.registry
self.transaction = self.registry = None
self.state = final_state
if not self.keep_session:
registry.session.close()
else:
registry.session.expire_all()
EnvironmentManager.set('_precommit_hook', [])
def setUpClass(cls):
super(TestMigration, cls).setUpClass()
cls.init_configuration_manager()
cls.createdb()
BlokManager.load()
register = Declarations.register
Model = Declarations.Model
cls.loaded_bloks = deepcopy(RegistryManager.loaded_bloks)
EnvironmentManager.set('current_blok', 'anyblok-core')
@register(Model)
class Test:
integer = Int(primary_key=True)
other = Str()
@register(Model)
class TestUnique:
integer = Int(primary_key=True)
other = Str(unique=True)
@register(Model)
class TestFKTarget:
integer = Int(primary_key=True)
@register(Model)
class TestFK:
integer = Int(primary_key=True)
other = Int(foreign_key=Model.TestFKTarget.use('integer'))
@register(Model)
class TestM2M1:
idmodel1 = Int(primary_key=True)
@register(Model)
class TestM2M2:
idmodel2 = Int(primary_key=True)
rel_m2m = Many2Many(label="Rel", model=Model.TestM2M1,
join_table='reltable',
remote_columns='idmodel1',
m2m_remote_columns='idmodel1',
local_columns='idmodel2',
m2m_local_columns='idmodel2',
many2many='rel_m2m_inv')
EnvironmentManager.set('current_blok', None)
def load(cls, entry_points=('bloks',)):
""" Load all the bloks and import them
:param entry_points: Use by ``iter_entry_points`` to get the blok
:exception: BlokManagerException
"""
if not entry_points:
raise BlokManagerException("The entry_points mustn't be empty")
cls.entry_points = entry_points
if EnvironmentManager.get('current_blok'):
while EnvironmentManager.get('current_blok'):
sleep(0.1)
EnvironmentManager.set('current_blok', 'start')
bloks = []
for entry_point in entry_points:
count = 0
for i in iter_entry_points(entry_point):
count += 1
blok = i.load()
blok.required_by = []
blok.optional_by = []
blok.conditional_by = []
blok.conflicting_by = []
cls.set(i.name, blok)
blok.name = i.name
bloks.append((blok.priority, i.name))
if not count:
raise BlokManagerException(
"Invalid bloks group %r" % entry_point)
# Empty the ordered blok to reload it depending on the priority
cls.ordered_bloks = []
bloks.sort()
try:
while bloks:
blok = bloks.pop(0)[1]
cls.get_need_blok(blok)
finally:
EnvironmentManager.set('current_blok', None)
def test_global_property(self):
RegistryManager.declare_entry('Other')
blok = 'newblok'
RegistryManager.init_blok(blok)
try:
oldblok = EnvironmentManager.get('current_blok')
EnvironmentManager.set('current_blok', blok)
assert not RegistryManager.has_blok_property('myproperty')
RegistryManager.add_or_replace_blok_property('myproperty', 2)
assert RegistryManager.has_blok_property('myproperty')
assert RegistryManager.get_blok_property('myproperty') == 2
RegistryManager.add_or_replace_blok_property('myproperty', 3)
assert RegistryManager.get_blok_property('myproperty') == 3
RegistryManager.remove_blok_property('myproperty')
assert not RegistryManager.has_blok_property('myproperty')
finally:
EnvironmentManager.set('current_blok', oldblok)
def load(cls, entry_points=('bloks', )):
""" Load all the bloks and import them
:param entry_points: Use by ``iter_entry_points`` to get the blok
:exception: BlokManagerException
"""
if not entry_points:
raise BlokManagerException("The entry_points mustn't be empty")
cls.entry_points = entry_points
if EnvironmentManager.get('current_blok'):
while EnvironmentManager.get('current_blok'):
sleep(0.1)
EnvironmentManager.set('current_blok', 'start')
bloks = []
for entry_point in entry_points:
count = 0
for i in iter_entry_points(entry_point):
count += 1
blok = i.load()
blok.required_by = []
blok.optional_by = []
blok.conditional_by = []
blok.conflicting_by = []
cls.set(i.name, blok)
blok.name = i.name
bloks.append((blok.priority, i.name))
if not count:
raise BlokManagerException("Invalid bloks group %r" %
entry_point)
# Empty the ordered blok to reload it depending on the priority
cls.ordered_bloks = []
bloks.sort()
try:
while bloks:
blok = bloks.pop(0)[1]
cls.get_need_blok(blok)
finally:
EnvironmentManager.set('current_blok', None)
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 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 test_global_property(self):
RegistryManager.declare_entry('Other')
blok = 'newblok'
RegistryManager.init_blok(blok)
try:
oldblok = EnvironmentManager.get('current_blok')
EnvironmentManager.set('current_blok', blok)
self.assertEqual(RegistryManager.has_blok_property('myproperty'),
False)
RegistryManager.add_or_replace_blok_property('myproperty', 2)
self.assertEqual(
RegistryManager.has_blok_property('myproperty'), True)
self.assertEqual(
RegistryManager.get_blok_property('myproperty'), 2)
RegistryManager.add_or_replace_blok_property('myproperty', 3)
self.assertEqual(
RegistryManager.get_blok_property('myproperty'), 3)
RegistryManager.remove_blok_property('myproperty')
self.assertEqual(RegistryManager.has_blok_property('myproperty'),
False)
finally:
EnvironmentManager.set('current_blok', oldblok)
def test_global_property(self):
RegistryManager.declare_entry('Other')
blok = 'newblok'
RegistryManager.init_blok(blok)
try:
oldblok = EnvironmentManager.get('current_blok')
EnvironmentManager.set('current_blok', blok)
self.assertEqual(RegistryManager.has_blok_property('myproperty'),
False)
RegistryManager.add_or_replace_blok_property('myproperty', 2)
self.assertEqual(RegistryManager.has_blok_property('myproperty'),
True)
self.assertEqual(RegistryManager.get_blok_property('myproperty'),
2)
RegistryManager.add_or_replace_blok_property('myproperty', 3)
self.assertEqual(RegistryManager.get_blok_property('myproperty'),
3)
RegistryManager.remove_blok_property('myproperty')
self.assertEqual(RegistryManager.has_blok_property('myproperty'),
False)
finally:
EnvironmentManager.set('current_blok', oldblok)
def init_registry(self, function, **kwargs):
""" call a function to filled the blok manager with new model
:param function: function to call
:param kwargs: kwargs for the function
:rtype: registry instance
"""
from copy import deepcopy
loaded_bloks = deepcopy(RegistryManager.loaded_bloks)
if function is not None:
EnvironmentManager.set('current_blok', 'anyblok-core')
try:
function(**kwargs)
finally:
EnvironmentManager.set('current_blok', None)
try:
self.registry = registry = self.__class__.getRegistry()
finally:
RegistryManager.loaded_bloks = loaded_bloks
return registry
def get_need_blok(cls, blok):
if cls.has(blok):
return True
if blok not in cls.bloks:
return False
cls.get_need_blok_linked_bloks(blok)
cls.ordered_bloks.append(blok)
EnvironmentManager.set('current_blok', blok)
if not ImportManager.has(blok):
# Import only if not exist don't reload here
mod = ImportManager.add(blok)
mod.imports()
else:
mod = ImportManager.get(blok)
mod.reload()
if cls.bloks[blok].autoinstall:
cls.auto_install.append(blok)
return True
def get_need_blok(cls, blok):
if cls.has(blok):
return True
if blok not in cls.bloks:
return False
cls.get_need_blok_linked_bloks(blok)
cls.ordered_bloks.append(blok)
EnvironmentManager.set('current_blok', blok)
if not ImportManager.has(blok):
# Import only if not exist don't reload here
mod = ImportManager.add(blok)
mod.imports()
else:
mod = ImportManager.get(blok)
mod.reload()
if cls.bloks[blok].autoinstall:
cls.auto_install.append(blok)
return True
def reload_registry(self, registry, function, **kwargs):
""" call a function to filled the blok manager with new model and
before reload the registry
:param bloks: list of blok's names
:param function: function to call
:param kwargs: kwargs for the function
:rtype: registry instance
"""
from copy import deepcopy
loaded_bloks = deepcopy(RegistryManager.loaded_bloks)
if function is not None:
EnvironmentManager.set('current_blok', 'anyblok-test')
try:
function(**kwargs)
finally:
EnvironmentManager.set('current_blok', None)
try:
registry.reload()
finally:
RegistryManager.loaded_bloks = loaded_bloks
return registry
def reload_registry(self, registry, function, **kwargs):
""" call a function to filled the blok manager with new model and
before reload the registry
:param bloks: list of blok's names
:param function: function to call
:param kwargs: kwargs for the function
:rtype: registry instance
"""
from copy import deepcopy
loaded_bloks = deepcopy(RegistryManager.loaded_bloks)
if function is not None:
EnvironmentManager.set('current_blok', 'anyblok-test')
try:
function(**kwargs)
finally:
EnvironmentManager.set('current_blok', None)
try:
registry.reload()
finally:
RegistryManager.loaded_bloks = loaded_bloks
return registry
def setUpClass(cls):
super(TestCoreInterfaceCoreBase, cls).setUpClass()
RegistryManager.init_blok('testCore' + cls._corename)
EnvironmentManager.set('current_blok', 'testCore' + cls._corename)
def revert():
EnvironmentManager.set('current_blok', None)
del RegistryManager.loaded_bloks['testModel']
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(TestRegistryCore, cls).setUpClass()
RegistryManager.declare_core('test')
RegistryManager.init_blok('testCore')
EnvironmentManager.set('current_blok', 'testCore')
def tearDownClass(cls):
super(TestRegistryCore, cls).tearDownClass()
EnvironmentManager.set('current_blok', None)
del RegistryManager.loaded_bloks['testCore']
RegistryManager.undeclare_core('test')
def tearDownClass(cls):
super(TestCoreInterfaceMixin, cls).tearDownClass()
EnvironmentManager.set('current_blok', None)
del RegistryManager.loaded_bloks['testMixin']
def setUpClass(cls):
super(TestCoreInterfaceCoreBase, cls).setUpClass()
RegistryManager.init_blok('testCore' + cls._corename)
EnvironmentManager.set('current_blok', 'testCore' + cls._corename)
def test_set_and_get_variable(self):
db_name = 'test db name'
EnvironmentManager.set('db_name', db_name)
self.assertEqual(EnvironmentManager.get('db_name'), db_name)
def setUpClass(cls):
super(TestModel, cls).setUpClass()
RegistryManager.init_blok('testModel')
EnvironmentManager.set('current_blok', 'testModel')
def setUpClass(cls):
super(TestModel, cls).setUpClass()
RegistryManager.init_blok('testModel')
EnvironmentManager.set('current_blok', 'testModel')
def tearDownClass(cls):
super(TestRegistryCore, cls).tearDownClass()
EnvironmentManager.set('current_blok', None)
del RegistryManager.loaded_bloks['testCore']
RegistryManager.undeclare_core('test')
def setUpClass(cls):
super(TestRegistryCore, cls).setUpClass()
RegistryManager.declare_core('test')
RegistryManager.init_blok('testCore')
EnvironmentManager.set('current_blok', 'testCore')
def tearDownClass(cls):
super(TestModel, cls).tearDownClass()
EnvironmentManager.set('current_blok', None)
del RegistryManager.loaded_bloks['testModel']
def setUp(self):
super(TestTask, self).setUp()
self.registry = registry = self.init_registry(None)
registry.upgrade(install=('test_dramatiq_2', ))
EnvironmentManager.set('job_autocommit', False)
def __exit__(self, type, value, traceback):
EnvironmentManager.set('context', self.previous_context)
def reset():
EnvironmentManager.set('current_blok', None)
del RegistryManager.loaded_bloks['testCore' + self._corename]
def revert():
EnvironmentManager.set('current_blok', None)
del RegistryManager.loaded_bloks['testCore']
RegistryManager.undeclare_core('test')
def tearDownClass(cls):
super(TestCoreInterfaceCoreBase, cls).tearDownClass()
EnvironmentManager.set('current_blok', None)
del RegistryManager.loaded_bloks['testCore' + cls._corename]
def setUpClass(cls):
super(TestCoreInterfaceMixin, cls).setUpClass()
RegistryManager.init_blok('testMixin')
EnvironmentManager.set('current_blok', 'testMixin')
def setUpClass(cls):
super(TestMigration, cls).setUpClass()
cls.init_configuration_manager()
cls.createdb()
BlokManager.load()
register = Declarations.register
Model = Declarations.Model
cls.loaded_bloks = deepcopy(RegistryManager.loaded_bloks)
EnvironmentManager.set('current_blok', 'anyblok-core')
@register(Model)
class Test:
integer = Int(primary_key=True)
other = Str()
@register(Model)
class TestUnique:
integer = Int(primary_key=True)
other = Str(unique=True)
@register(Model)
class TestIndex:
integer = Int(primary_key=True)
other = Str(index=True)
@register(Model)
class TestCheck:
integer = Int(primary_key=True)
@classmethod
def define_table_args(cls):
table_args = super(TestCheck, cls).define_table_args()
return table_args + (
CheckConstraint('integer > 0', name='test'),)
@register(Model)
class TestCheckLongConstraintName:
integer = Int(primary_key=True)
@classmethod
def define_table_args(cls):
table_args = super(TestCheckLongConstraintName,
cls).define_table_args()
return table_args + (
CheckConstraint('integer > 0', name=(
'long_long_long_long_long_long_long_long_long_long_'
'long_long_long_long_long_long_long_long_test')),)
@register(Model)
class TestFKTarget:
integer = Int(primary_key=True)
@register(Model)
class TestFK:
integer = Int(primary_key=True)
other = Int(
foreign_key=Model.TestFKTarget.use('integer'))
@register(Model)
class TestFK2:
integer = Int(primary_key=True)
other = Int(
foreign_key=Model.TestFKTarget.use('integer').options(
ondelete='cascade'))
@register(Model)
class TestM2M1:
idmodel1 = Int(primary_key=True)
@register(Model)
class TestM2M2:
idmodel2 = Int(primary_key=True)
rel_m2m = Many2Many(label="Rel", model=Model.TestM2M1,
join_table='reltable',
remote_columns='idmodel1',
m2m_remote_columns='idmodel1',
local_columns='idmodel2',
m2m_local_columns='idmodel2',
many2many='rel_m2m_inv')
EnvironmentManager.set('current_blok', None)
def test_set_and_get_variable(self):
db_name = 'test db name'
EnvironmentManager.set('db_name', db_name)
self.assertEqual(EnvironmentManager.get('db_name'), db_name)
def setUpClass(cls):
super(TestMigration, cls).setUpClass()
cls.init_configuration_manager()
cls.createdb()
BlokManager.load()
register = Declarations.register
Model = Declarations.Model
cls.loaded_bloks = deepcopy(RegistryManager.loaded_bloks)
EnvironmentManager.set('current_blok', 'anyblok-core')
@register(Model)
class Test:
integer = Int(primary_key=True)
other = Str()
@register(Model)
class TestUnique:
integer = Int(primary_key=True)
other = Str(unique=True)
@register(Model)
class TestIndex:
integer = Int(primary_key=True)
other = Str(index=True)
@register(Model)
class TestCheck:
integer = Int(primary_key=True)
@classmethod
def define_table_args(cls):
table_args = super(TestCheck, cls).define_table_args()
return table_args + (CheckConstraint('integer > 0',
name='test'), )
@register(Model)
class TestCheckLongConstraintName:
integer = Int(primary_key=True)
@classmethod
def define_table_args(cls):
table_args = super(TestCheckLongConstraintName,
cls).define_table_args()
return table_args + (CheckConstraint(
'integer > 0',
name=('long_long_long_long_long_long_long_long_long_long_'
'long_long_long_long_long_long_long_long_test')), )
@register(Model)
class TestFKTarget:
integer = Int(primary_key=True)
@register(Model)
class TestFK:
integer = Int(primary_key=True)
other = Int(foreign_key=Model.TestFKTarget.use('integer'))
@register(Model)
class TestFK2:
integer = Int(primary_key=True)
other = Int(foreign_key=Model.TestFKTarget.use('integer').options(
ondelete='cascade'))
@register(Model)
class TestM2M1:
idmodel1 = Int(primary_key=True)
@register(Model)
class TestM2M2:
idmodel2 = Int(primary_key=True)
rel_m2m = Many2Many(label="Rel",
model=Model.TestM2M1,
join_table='reltable',
remote_columns='idmodel1',
m2m_remote_columns='idmodel1',
local_columns='idmodel2',
m2m_local_columns='idmodel2',
many2many='rel_m2m_inv')
EnvironmentManager.set('current_blok', None)
def __init__(self, *args, **kwargs):
EnvironmentManager.set('current_blok', None)
super(BlokManagerException, self).__init__(*args, **kwargs)
def setUpClass(cls):
super(TestCoreInterfaceMixin, cls).setUpClass()
RegistryManager.init_blok('testMixin')
EnvironmentManager.set('current_blok', 'testMixin')
def setUpClass(cls):
super(TestRegistryEntry, cls).setUpClass()
RegistryManager.declare_entry('Other')
RegistryManager.init_blok('testEntry')
EnvironmentManager.set('current_blok', 'testEntry')
def tearDownClass(cls):
super(TestCoreInterfaceMixin, cls).tearDownClass()
EnvironmentManager.set('current_blok', None)
del RegistryManager.loaded_bloks['testMixin']
def tearDownClass(cls):
super(TestModel, cls).tearDownClass()
EnvironmentManager.set('current_blok', None)
del RegistryManager.loaded_bloks['testModel']
def tearDownClass(cls):
super(TestCoreInterfaceCoreBase, cls).tearDownClass()
EnvironmentManager.set('current_blok', None)
del RegistryManager.loaded_bloks['testCore' + cls._corename]
def __init__(self, *args, **kwargs):
EnvironmentManager.set('current_blok', None)
super(BlokManagerException, self).__init__(*args, **kwargs)
def revert():
EnvironmentManager.set('current_blok', None)
del RegistryManager.loaded_bloks['testEntry']
RegistryManager.undeclare_entry('Other')
