def db(request):
host_url = f'postgres+psycopg2://{POSTGRES_USER}:{POSTGRES_PASS}@{POSTGRES_HOST}:{POSTGRES_PORT}'
pg_database_url = '{}/postgres'.format(host_url)
engine = create_engine(pg_database_url, echo=True)
conn = engine.connect()
conn.execute('commit')
try:
conn.execute('create database test')
except:
pass
conn.close()
alembic_config = AlembicConfig('alembic.ini')
alembic_config.set_main_option('sqlalchemy.url',
'{}/test'.format(host_url))
alembic_upgrade(alembic_config, 'head')
yield
conn = engine.connect()
conn.execute(
"SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = 'test';"
)
conn.execute('commit')
conn.execute('DROP DATABASE test')
conn.close()
engine.dispose()
def db() -> Dict[Engine, sessionmaker]:
engine = create_engine(TestConfig.SQLALCHEMY_DATABASE_URI, echo=True)
session = sessionmaker(bind=engine)
_db = {'engine': engine, 'session': session}
try:
alembic_config = AlembicConfig(os.path.abspath("../../alembic.ini"))
alembic_config.set_main_option('script_location',
os.path.abspath("../../meant_alembic"))
alembic_config.set_main_option('sqlalchemy.url',
TestConfig.SQLALCHEMY_DATABASE_URI)
alembic_upgrade(alembic_config, 'head')
except CommandError:
log(message="testing only specified TCs", keyword="INFO")
alembic_config = AlembicConfig(os.path.abspath("../../../alembic.ini"))
alembic_config.set_main_option(
'script_location', os.path.abspath("../../../meant_alembic"))
alembic_config.set_main_option('sqlalchemy.url',
TestConfig.SQLALCHEMY_DATABASE_URI)
alembic_upgrade(alembic_config, 'head')
log(message="database created", keyword="INFO")
yield _db
log(message="database disposed", keyword="INFO")
engine.dispose()
def upgrade(app):
alembic_ini = get_alembic_ini()
config = Config(file_=alembic_ini.as_posix())
if not app:
alembic_upgrade(config, "heads")
else:
alembic_upgrade(config, f"{app}@head")
def upgrade_db(self, version: str='head') -> None:
'''Upgrade db using sqlalchemy migrations.
@param version: version to upgrade to (if None upgrade to latest)
'''
assert meta.engine
_assert_engine_msg: str = (
u'Database migration - only Postgresql engine supported (not %s).'
) % meta.engine.name
assert meta.engine.name in (
u'postgres', u'postgresql'
), _assert_engine_msg
self.setup_migration_version_control()
version_before = self.current_version()
alembic_upgrade(self.alembic_config, version)
version_after = self.current_version()
if version_after != version_before:
log.info(
u'CKAN database version upgraded: %s -> %s',
version_before,
version_after
)
else:
log.info(u'CKAN database version remains as: %s', version_after)
def pg_server(unused_port, container_starter):
tag = "13.1"
image = 'postgres:{}'.format(tag)
internal_port = 5432
host_port = unused_port()
environment = {'POSTGRES_USER': '******',
'POSTGRES_PASSWORD': '******',
'POSTGRES_DB': 'postgres'}
#
# volume = (str(TEMP_FOLDER / 'docker' / 'pg'),
# '/var/lib/postgresql/data')
container = container_starter(image, 'db', internal_port, host_port,
environment, None)
params = dict(database='postgres',
user='******',
password='******',
host='localhost',
port=host_port)
def connect():
conn = psycopg2.connect(**params)
cur = conn.cursor()
cur.close()
conn.close()
wait_for_container(connect, image, psycopg2.Error)
container['params'] = params
alembic_config = AlembicConfig('alembic.ini')
alembic_config.set_main_option('sqlalchemy.url', f'postgresql://*****:*****@localhost:{container["port"]}/postgres')
alembic_upgrade(alembic_config, 'head')
return container
def _db(app):
db = SQLAlchemy(app)
with app.app_context():
Migrate(app, db)
alembic_config = AlembicConfig('migrations/alembic.ini')
alembic_config.set_main_option('sqlalchemy.url',
app.config['SQLALCHEMY_DATABASE_URI'])
alembic_upgrade(alembic_config, 'head')
return db
def db():
engine = create_engine(config['TEST_DB_URL'], echo=True)
Session = sessionmaker(bind=engine)
_db = {'engine': engine, 'session': Session}
alembic_config = AlembicConfig(config['ALEMBIC_INI'])
alembic_config.set_main_option('sqlalchemy.url', config['TEST_DB_URL'])
alembic_upgrade(alembic_config, 'head')
yield _db
engine.dispose()
def db():
"""
Fixture to create test database, apply migrations
and finally delete it once the test cases are executed.
"""
if not database_exists(uri):
create_database(uri)
alembic_config = AlembicConfig('alembic.ini')
alembic_config.set_main_option('sqlalchemy.url', uri)
alembic_upgrade(alembic_config, 'head')
yield "success"
drop_database(uri)
def template_db(worker_id):
if worker_id != "master":
return
connection = create_engine(DATABASE_URL).connect()
connection.connection.connection.set_isolation_level(0)
create_db(connection, TEMPLATE_DB_NAME)
connection.close()
alembic_config = AlembicConfig("alembic.ini")
alembic_config.set_main_option("sqlalchemy.url",
get_url_for_db(TEMPLATE_DB_NAME))
alembic_upgrade(alembic_config, "head")
def setup_test_database():
url = str(settings.DATABASE_URL)
assert not database_exists(
url), "Test database already exists. Aborting tests."
create_database(url)
alembic_cfg = AlembicConfig("alembic.ini")
alembic_upgrade(alembic_cfg, "head")
yield
drop_database(url)
def db():
engine = create_engine(config["TEST_DB_URL"], echo=True)
session = sessionmaker(bind=engine)
_db = {"engine": engine, "session": session}
alembic_config = alembic_Config(config["ALEMBIC_INI"])
alembic_config.set_main_option("sqlalchemy.url", config["TEST_DB_URL"])
alembic_upgrade(alembic_config, "head")
yield _db
engine.dispose()
async def pg_engine(loop): # pylint: disable=unused-argument
"""fixture for migrations"""
engine = await init_pg_pool()
config = AlembicConfig('alembic.ini')
alembic_upgrade(config, 'head')
yield engine
alembic_downgrade(config, 'base')
engine.close()
await engine.wait_closed()
def app():
test_app = create_app()
ctx = test_app.test_request_context()
ctx.push()
alembic_config = AlembicConfig('migrations/alembic.ini')
alembic_config
alembic_upgrade(alembic_config, 'head')
def teardown():
ctx.pop()
return test_app
def db():
from shortener.utils.pg import DEFAULT_PG_URL
tmp_name = '.'.join([uuid.uuid4().hex, 'pytest'])
tmp_url = str(URL(DEFAULT_PG_URL).with_path(tmp_name))
create_database(tmp_url)
alembic_config = AlembicConfig(ALEMBIC_INI)
alembic_config.set_main_option('sqlalchemy.url', tmp_url)
alembic_config.set_main_option(
'script_location', str(ALEMBIC_SCRIPT_LOCATION))
alembic_upgrade(alembic_config, 'head')
try:
yield tmp_name
finally:
drop_database(tmp_url)
def create_database(self, use_migrations=True):
self.db.session = self.db.create_scoped_session({
'scopefunc': get_scopefunc(),
})
self.db.session.execute('SET storage_engine=InnoDB;')
if use_migrations:
try:
self.db.session.execute('TRUNCATE alembic_version;')
except sqlalchemy.exc.ProgrammingError:
self.db.session.rollback()
config = Config('migrations/alembic.ini', 'alembic')
alembic_upgrade(config, 'head')
else:
self.db.create_all()
def connection():
connection = engine.connect()
# run alembic migrations
alembic_ini_path = Path(
__file__).parent.parent.parent.absolute().as_posix() + '/alembic.ini'
alembic_config = AlembicConfig(alembic_ini_path)
alembic_config.set_main_option('sqlalchemy.url',
os.getenv('TEST_DATABASE_URL'))
alembic_config.set_main_option('script_location',
os.getenv('ALEMBIC_SCRIPT_LOCATION'))
alembic_upgrade(alembic_config, 'head')
exit(200)
yield connection
connection.close()
print("connection closed")
def db(app):
with app.app_context():
engine = create_engine(app.config['SQLALCHEMY_DATABASE_URI'],
echo=True)
session_factory = sessionmaker(bind=engine)
_db = {
'engine': engine,
'session_factory': session_factory,
}
alembic_config = AlembicConfig(app.config['ALEMBIC_INI'])
alembic_config.set_main_option('sqlalchemy.url',
app.config['SQLALCHEMY_DATABASE_URI'])
alembic_upgrade(alembic_config, 'head')
yield _db
engine.dispose()
def db():
pkg_root = os.path.dirname(os.path.realpath(__file__))
db_path = os.path.join(pkg_root, "test.db")
if os.path.exists(db_path):
os.remove(db_path)
engine = create_engine(f"sqlite:///{db_path}", echo=True)
session_factory = sessionmaker(bind=engine)
alembic_config = AlembicConfig(os.path.join(pkg_root, "alembic.ini"))
alembic_config.set_main_option("sqlalchemy.url", f"sqlite:///{db_path}")
alembic_config.set_main_option("script_location", os.path.join(pkg_root, "migrations"))
alembic_upgrade(alembic_config, "head")
yield {
"engine": engine,
"session_factory": session_factory,
}
engine.dispose()
def db(request):
engine = create_engine(TEST_DATABASE_URI, echo=True)
session_factory = sessionmaker(bind=engine)
print('\n----- CREATE TEST DB CONNECTION POOL\n')
_db = {
'engine': engine,
'session_factory': session_factory,
}
alembic_config = AlembicConfig(ALEMBIC_CONFIG)
alembic_config.set_main_option('sqlalchemy.url', TEST_DATABASE_URI)
alembic_upgrade(alembic_config, 'head')
print('\n----- RUN ALEMBIC MIGRATION\n')
yield _db
print('\n----- CREATE TEST DB INSTANCE POOL\n')
engine.dispose()
print('\n----- RELEASE TEST DB CONNECTION POOL\n')
def migrate():
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from alembic.command import upgrade as alembic_upgrade
engine = create_engine(app.config['SQLALCHEMY_DATABASE_URI'],
echo=True)
session_factory = sessionmaker(bind=engine)
_db = {
'engine': engine,
'session_factory': session_factory,
}
alembic_upgrade(get_db_config(), 'head')
session = _db['session_factory']()
session.rollback()
session.close()
engine.dispose()
def db(create_app):
app = create_app
test_db_url = app.config['SQLALCHEMY_DATABASE_URI']
alembic_ini = app.config['ALEMBIC_INI']
engine = create_engine(test_db_url, echo=True)
session = sessionmaker(bind=engine)
_db = {'engine': engine,
'session': session}
with app.app_context():
alembic_cfg = alembicConfig(alembic_ini)
alembic_cfg.set_main_option("script_location", "migrations")
alembic_cfg.set_main_option('sqlalchemy.url', test_db_url)
alembic_upgrade(alembic_cfg, 'head')
yield _db
engine.dispose()
def db(request):
db_fd, src.app.config['DATABASE'] = tempfile.mkstemp()
src.app.config['TESTING'] = True
os.close(db_fd)
os.unlink(app.config['DATABASE'])
engine = create_engine(config['TEST_DB_URL'], echo=True)
session_factory = sessionmaker(bind=engine)
print('\n----- CREATE TEST DB CONNECTION POOL\n')
_db = {
'engine': engine,
'session_factory': session_factory,
}
alembic_config = AlembicConfig(config['ALEMBIC_INI'])
alembic_config.set_main_option('sqlalchemy.url', config['TEST_DB_URL'])
alembic_upgrade(alembic_config, 'head')
print('\n----- RUN ALEMBIC MIGRATION\n')
yield _db
print('\n----- CREATE TEST DB INSTANCE POOL\n')
engine.dispose()
print('\n----- RELEASE TEST DB CONNECTION POOL\n')
def upgrade_db(self, version='head'):
'''Upgrade db using sqlalchemy migrations.
@param version: version to upgrade to (if None upgrade to latest)
'''
_assert_engine_msg = (
u'Database migration - only Postgresql engine supported (not %s).'
) % meta.engine.name
assert meta.engine.name in (
u'postgres', u'postgresql'
), _assert_engine_msg
self.setup_migration_version_control()
version_before = self.current_version()
alembic_upgrade(self.alembic_config, version)
version_after = self.current_version()
if version_after != version_before:
log.info(
u'CKAN database version upgraded: %s -> %s',
version_before,
version_after
)
else:
log.info(u'CKAN database version remains as: %s', version_after)
def checkout(_config, relative_revision, revision):
alembic_config = _config.alembic_config
script = ScriptDirectory.from_config(alembic_config)
all_revisions = [rev.revision for rev in script.walk_revisions()]
if revision == 'head':
alembic_upgrade(alembic_config, revision)
elif revision is not None:
if revision not in all_revisions:
raise click.UsageError('No such a revision: {}, '
'check `history` to find appropriate '
'revision.'.format(revision))
try:
alembic_upgrade(alembic_config, revision)
except Exception:
alembic_downgrade(alembic_config, revision)
elif relative_revision and relative_revision.upgrade:
alembic_upgrade(alembic_config, relative_revision.n)
elif relative_revision:
alembic_downgrade(alembic_config, relative_revision.n)
else:
raise click.BadParameter(
'onf of `relatie_revision`, `revision` MUST be required.')
def checkout(_config, relative_revision, revision):
alembic_config = _config.alembic_config
script = ScriptDirectory.from_config(alembic_config)
all_revisions = [rev.revision for rev in script.walk_revisions()]
if revision == 'head':
alembic_upgrade(alembic_config, revision)
elif revision is not None:
if revision not in all_revisions:
raise click.UsageError('No such a revision: {}, '
'check `history` to find appropriate '
'revision.'.format(revision))
try:
alembic_upgrade(alembic_config, revision)
except Exception:
alembic_downgrade(alembic_config, revision)
elif relative_revision and relative_revision.upgrade:
alembic_upgrade(alembic_config, relative_revision.n)
elif relative_revision:
alembic_downgrade(alembic_config, relative_revision.n)
else:
raise click.BadParameter(
'onf of `relatie_revision`, `revision` MUST be required.')
def upgrade(revision):
"""Upgrade a revision to --revision or newest revision"""
engine = get_engine()
config, _ = get_alembic_config(engine)
alembic_upgrade(config, revision)
def migrate_db():
alembic_config = AlembicConfig('alembic.ini')
alembic_config.set_main_option('sqlalchemy.url', settings.DATABASE_URL)
alembic_upgrade(alembic_config, 'head')
def make_migrations():
alembic_config = AlembicConfig('alembic.ini')
alembic_config.set_main_option('script_location', 'alembic')
alembic_upgrade(alembic_config, 'head')
def upgrade(revision):
"""리버전의 버전을 올립니다. 특정 리비전이 정해지지않는다면
가장 최신 리비전으로 버전을 올립니다.
"""
alembic_upgrade(alembic_config(), revision)
def apply_migration():
config = AlembicConfig('../migrations/alembic.ini')
config.set_main_option('script_location', '../migrations')
alembic_upgrade(config, 'head')
def migrate_db(database_url: str):
alembic_config = AlembicConfig("alembic.ini")
alembic_config.set_main_option("sqlalchemy.url", database_url)
alembic_upgrade(alembic_config, "head")
def upgrade_db(postgres_server: Dict[str, str], revision: str) -> None:
print("UPGRADING DB --------------")
alembic_upgrade(config=postgres_server["alembic_cfg"], revision=revision)
def create_tables(alembic_config, engine, use_migrations):
if use_migrations:
alembic_upgrade(alembic_config, 'heads', sql=False)
else:
Base.metadata.create_all(engine)
def upgrade(revision):
"""리버전의 버전을 올립니다. 특정 리비전이 정해지지않는다면
가장 최신 리비전으로 버전을 올립니다.
"""
alembic_upgrade(alembic_config(), revision)
