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 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)