def _initialize(self):
# Manages a RDB engine and a metadata instance for this repository.
# Both are global objects that should only be created once per process
# (for each RDB repository), hence we use a global object manager.
if not is_engine_initialized(self.name):
engine = self.__make_engine()
set_engine(self.name, engine)
# Bind the engine to the session factory and the metadata.
self.session_factory.configure(bind=engine)
else:
engine = get_engine(self.name)
if not is_metadata_initialized(self.name):
md_fac = self._config["metadata_factory"]
if self._config.get("messaging_enable", False):
# Wrap the metadata callback to also call the mapping
# function for system entities.
reset_on_start = self._config.get("messaging_reset_on_start", False)
def wrapper(engine, reset_on_start=reset_on_start):
metadata = md_fac(engine)
map_system_entities(engine, metadata, reset_on_start)
return metadata
metadata = wrapper(engine)
else:
metadata = md_fac(engine)
set_metadata(self.name, metadata)
else:
metadata = get_metadata(self.name)
metadata.bind = engine
def _initialize(self):
# Manages a RDB engine and a metadata instance for this repository.
# Both are global objects that should only be created once per process
# (for each RDB repository), hence we use a global object manager.
if not is_engine_initialized(self.name):
engine = self.__make_engine()
set_engine(self.name, engine)
# Bind the engine to the session factory and the metadata.
self.session_factory.configure(bind=engine)
else:
engine = get_engine(self.name)
if not is_metadata_initialized(self.name):
md_fac = self._config['metadata_factory']
if self._config.get('messaging_enable', False):
# Wrap the metadata callback to also call the mapping
# function for system entities.
reset_on_start = \
self._config.get('messaging_reset_on_start', False)
def wrapper(engine, reset_on_start=reset_on_start):
metadata = md_fac(engine)
map_system_entities(engine, metadata, reset_on_start)
return metadata
metadata = wrapper(engine)
else:
metadata = md_fac(engine)
set_metadata(self.name, metadata)
else:
metadata = get_metadata(self.name)
metadata.bind = engine
def test_rdb_engine_manager(self):
key = 'test'
self.assert_false(is_engine_initialized(key))
eng = create_engine('sqlite://')
set_engine(key, eng)
self.assert_raises(ValueError, set_engine, key, eng)
self.assert_true(is_engine_initialized(key))
self.assert_true(get_engine(key) is eng)
reset_engines()
self.assert_false(is_engine_initialized(key))
def test_rdb_engine_manager(self):
key = 'test'
self.assert_false(is_engine_initialized(key))
eng = create_engine('sqlite://')
set_engine(key, eng)
self.assert_raises(ValueError, set_engine, key, eng)
self.assert_true(is_engine_initialized(key))
self.assert_true(get_engine(key) is eng)
reset_engines()
self.assert_false(is_engine_initialized(key))
def __exit__(self, ext_type, value, tb):
# Roll back the outer transaction and close the connection.
self.__session.close()
self.__transaction.rollback()
self.__connection.close()
# Remove the session we created.
Session.remove()
# Restore flags.
Session.configure(autoflush=self.__old_autoflush_flag,
bind=get_engine(self.__engine_name))
self.__repo.join_transaction = self.__old_join_transaction_flag
def __exit__(self, ext_type, value, tb):
# Roll back the outer transaction and close the connection.
self.__session.close()
self.__transaction.rollback()
self.__connection.close()
# Remove the session we created.
Session.remove()
# Restore flags.
Session.configure(autoflush=self.__old_autoflush_flag,
bind=get_engine(self.__engine_name))
self.__repo.join_transaction = self.__old_join_transaction_flag
def __enter__(self):
# We set up an outer transaction that allows us to roll back all
# changes (including commits) the unittest may want to make.
engine = get_engine(self.__engine_name)
self.__connection = engine.connect()
self.__transaction = self.__connection.begin()
# Configure the autoflush behavior of the session.
self.__old_autoflush_flag = Session.autoflush # pylint:disable=E1101
Session.remove()
Session.configure(autoflush=self.__autoflush)
# Throw out the Zope transaction manager for testing.
Session.configure(extension=None)
# Create a new session for the tests.
self.__session = Session(bind=self.__connection)
return self.__session
def __enter__(self):
# We set up an outer transaction that allows us to roll back all
# changes (including commits) the unittest may want to make.
engine = get_engine(self.__engine_name)
self.__connection = engine.connect()
self.__transaction = self.__connection.begin()
# Configure the autoflush behavior of the session.
self.__old_autoflush_flag = Session.autoflush # pylint:disable=E1101
Session.remove()
Session.configure(autoflush=self.__autoflush)
# Throw out the Zope transaction manager for testing.
Session.configure(extension=None)
# Create a new session for the tests.
self.__session = Session(bind=self.__connection)
return self.__session
def _initialize(self):
if not is_engine_initialized(self.name):
engine = self.__make_engine()
set_engine(self.name, engine)
else:
engine = get_engine(self.name)
db_name = self._config['db_name']
self.__db = operator.getitem(engine, db_name)
if db_name == 'test':
# Reset the test database.
for coll_name in \
self.__db.collection_names(include_system_collections=False):
self.__db.drop_collection(coll_name)
# Set up the class registry.
for rc in self.registered_resources:
ent_cls = get_entity_class(rc)
if not MongoClassRegistry.is_registered(ent_cls):
MongoClassRegistry.register(ent_cls, self.__db)
def setup_thelma(thelma_settings):
# Create source DB session.
src_db_string = "postgresql+psycopg2://%s:%s@%s:%s/%s" \
% (DB_USER, DB_PWD, SOURCE_DB_HOST,
SOURCE_DB_PORT, SOURCE_DB_NAME)
src_engine = create_engine(src_db_string)
src_session_maker = sessionmaker(bind=src_engine)
src_sess = src_session_maker()
# Initialize TheLMA and create target DB session.
reg = Registry('thelma')
config = create_config(thelma_settings, registry=reg)
config.setup_registry(settings=thelma_settings)
config.begin()
config.load_zcml('configure.zcml')
repo_mgr = config.get_registered_utility(IRepositoryManager)
repo_mgr.initialize_all()
tgt_engine = get_engine(REPOSITORY_TYPES.RDB)
tgt_session_maker = sessionmaker(bind=tgt_engine)
tgt_sess = tgt_session_maker()
return src_sess, tgt_sess
def __enter__(self):
# We set up an outer transaction that allows us to roll back all
# changes (including commits) the unittest may want to make.
engine = get_engine(self.__engine_name)
self.__connection = engine.connect()
self.__transaction = self.__connection.begin()
reg = get_current_registry()
repo_mgr = reg.getUtility(IRepositoryManager)
self.__repo = repo_mgr.get(self.__engine_name)
# Configure the autoflush behavior of the session.
if Session.registry.has():
self.__old_autoflush_flag = Session.autoflush # pylint:disable=E1101
else:
self.__old_autoflush_flag = self.__autoflush
Session.remove()
Session.configure(autoflush=self.__autoflush)
# Create a new session for the tests.
Session.configure(bind=self.__connection)
self.__old_join_transaction_flag = self.__repo.join_transaction
self.__repo.join_transaction = False
self.__session = self.__repo.session_factory()
return self.__session
def __enter__(self):
# We set up an outer transaction that allows us to roll back all
# changes (including commits) the unittest may want to make.
engine = get_engine(self.__engine_name)
self.__connection = engine.connect()
self.__transaction = self.__connection.begin()
reg = get_current_registry()
repo_mgr = reg.getUtility(IRepositoryManager)
self.__repo = repo_mgr.get(self.__engine_name)
# Configure the autoflush behavior of the session.
if Session.registry.has():
self.__old_autoflush_flag = Session.autoflush # pylint:disable=E1101
else:
self.__old_autoflush_flag = self.__autoflush
Session.remove()
Session.configure(autoflush=self.__autoflush)
# Create a new session for the tests.
Session.configure(bind=self.__connection)
self.__old_join_transaction_flag = self.__repo.join_transaction
self.__repo.join_transaction = False
self.__session = self.__repo.session_factory()
return self.__session
def _make_session_factory(self):
engine = get_engine(self.name)
query_class = self.__check_query_class(engine)
return RdbSessionFactory(self, query_class)
def _make_session_factory(self):
engine = get_engine(self.name)
query_class = self.__check_query_class(engine)
return RdbSessionFactory(self, query_class)
