def test_starting_rev_context_runs_abbreviated(self):
env_file_fixture("""
context.configure(dialect_name='sqlite')
context.run_migrations()
""")
command.upgrade(self.cfg, "%s:%s" % (b[0:4], c), sql=True)
command.downgrade(self.cfg, "%s:%s" % (b[0:4], a), sql=True)
def test_starting_rev_pre_context_abbreviated(self):
env_file_fixture("""
assert context.get_starting_revision_argument() == '%s'
""" % b[0:4])
command.upgrade(self.cfg, "%s:%s" % (b[0:4], c), sql=True)
command.stamp(self.cfg, "%s:%s" % (b[0:4], c), sql=True)
command.downgrade(self.cfg, "%s:%s" % (b[0:4], a), sql=True)
def test_offline_inline_enum_drop(self):
self._inline_enum_script()
with capture_context_buffer() as buf:
command.downgrade(self.cfg, "%s:base" % self.rid, sql=True)
assert "DROP TABLE sometable" in buf.getvalue()
# no drop since we didn't emit events
assert "DROP TYPE pgenum" not in buf.getvalue()
def downgrade(self, revisions=None):
revisions = revisions or ['head']
if len(revisions) != 1:
msg = ('Only supply a single revision for downgrade')
raise AlembicCommandError(msg)
command.downgrade(self.config, revisions[0], sql=self.offline)
def setupPackage():
os.environ['MONGO_URI'] = 'mongodb://localhost'
os.environ['MONGO_DB_NAME'] = 'royal_example'
os.environ['MONGO_DB_PREFIX'] = ''
# sqla extentsion setup.
global engine
alembic_config = Config()
alembic_config.set_main_option('script_location',
'example/ext/sqla/db')
alembic_config.set_main_option('sqlalchemy.url', mysql_uri)
engine = create_engine(mysql_uri)
try:
command.downgrade(alembic_config, 'base')
except:
log.exception("Migration downgrade failed, clearing all tables")
metadata = MetaData(engine)
metadata.reflect()
for table in metadata.tables.values():
for fk in table.foreign_keys:
engine.execute(DropConstraint(fk.constraint))
metadata.drop_all()
command.upgrade(alembic_config, 'head')
def downgrade(directory=None, revision='-1', sql=False, tag=None, x_arg=None):
"""Revert to a previous version"""
config = current_app.extensions['migrate'].migrate.get_config(directory,
x_arg=x_arg)
if sql and revision == '-1':
revision = 'head:-1'
command.downgrade(config, revision, sql=sql, tag=tag)
def test_tag_cfg_arg(self):
env_file_fixture("""
context.configure(dialect_name='sqlite', tag='there')
assert context.get_tag_argument() == 'there'
""")
command.upgrade(self.cfg, b, sql=True, tag='hi')
command.downgrade(self.cfg, "%s:%s" % (b, a), sql=True, tag='hi')
def test_destination_rev_pre_context(self):
env_file_fixture("""
assert context.get_revision_argument() == '%s'
""" % b)
command.upgrade(self.cfg, b, sql=True)
command.stamp(self.cfg, b, sql=True)
command.downgrade(self.cfg, "%s:%s" % (c, b), sql=True)
def downgrade(self, rev):
try:
command.downgrade(self._config, rev)
except sqlalchemy.exc.OperationalError, err:
_log('DBUpdater: failed to downgrade release: {0}'.format(err), logLevel=logging.ERROR)
raise err
def downgrade(self, rev):
try:
command.downgrade(self._config, rev)
except sqlalchemy.exc.OperationalError, err:
current_app.logger.error('DBUpdater: failed to downgrade release: {0}'.format(err))
raise err
def downgrade(self, directory=None, revision='-1', sql=False, tag=None,
**kwargs): # pragma: no cover
"""Revert to a previous version"""
config = _get_config(directory)
if sql and revision == '-1':
revision = 'head:-1'
command.downgrade(config, revision, sql=sql, tag=tag)
def test_tag_None(self):
env_file_fixture("""
context.configure(dialect_name='sqlite')
assert context.get_tag_argument() is None
""")
command.upgrade(self.cfg, b, sql=True)
command.downgrade(self.cfg, "%s:%s" % (b, a), sql=True)
def test_upgrade_with_output_encoding(self):
env_file_fixture("""
url = config.get_main_option('sqlalchemy.url')
context.configure(url=url, output_encoding='utf-8')
assert not context.requires_connection()
""")
command.upgrade(self.cfg, a, sql=True)
command.downgrade(self.cfg, "%s:%s" % (b, a), sql=True)
def test_destination_rev_post_context(self):
env_file_fixture("""
context.configure(dialect_name='sqlite')
assert context.get_revision_argument() == '%s'
""" % b)
command.upgrade(self.cfg, b, sql=True)
command.downgrade(self.cfg, "%s:%s" % (c, b), sql=True)
command.stamp(self.cfg, b, sql=True)
def test_head_rev_pre_context(self):
env_file_fixture("""
assert context.get_head_revision() == '%s'
""" % c)
command.upgrade(self.cfg, b, sql=True)
command.downgrade(self.cfg, "%s:%s" % (b, a), sql=True)
command.stamp(self.cfg, b, sql=True)
command.current(self.cfg)
def downgrade(context, directory='migrations', revision='-1', sql=False, tag=None, x_arg=None):
"""Revert to a previous version"""
from app import create_app
with create_app().app_context():
config = _get_config(directory, x_arg=x_arg)
if sql and revision == '-1':
revision = 'head:-1'
command.downgrade(config, revision, sql=sql, tag=tag)
def test_tag_pre_context(self):
env_file_fixture(
"""
assert context.get_tag_argument() == 'hi'
"""
)
command.upgrade(self.cfg, b, sql=True, tag="hi")
command.downgrade(self.cfg, "%s:%s" % (b, a), sql=True, tag="hi")
def test_destination_rev_context_runs_abbreviated(self):
env_file_fixture("""
context.configure(dialect_name='sqlite')
context.run_migrations()
""")
command.upgrade(self.cfg, "%s:%s" % (a, b[0:4]), sql=True)
command.stamp(self.cfg, b[0:4], sql=True)
command.downgrade(self.cfg, "%s:%s" % (c, b[0:4]), sql=True)
def test_tag_pre_context_None(self):
env_file_fixture(
"""
assert context.get_tag_argument() is None
"""
)
command.upgrade(self.cfg, b, sql=True)
command.downgrade(self.cfg, "%s:%s" % (b, a), sql=True)
def test_not_requires_connection(self):
env_file_fixture(
"""
assert not context.requires_connection()
"""
)
command.upgrade(self.cfg, a, sql=True)
command.downgrade(self.cfg, "%s:%s" % (b, a), sql=True)
def test_requires_connection(self):
env_file_fixture(
"""
assert context.requires_connection()
"""
)
command.upgrade(self.cfg, a)
command.downgrade(self.cfg, a)
def test_starting_rev_pre_context(self):
env_file_fixture(
"""
assert context.get_starting_revision_argument() == 'x'
"""
)
command.upgrade(self.cfg, "x:y", sql=True)
command.downgrade(self.cfg, "x:y", sql=True)
def test_use_integer_column_for_amount(self):
from sqlalchemy import Column
from sqlalchemy import Integer
from sqlalchemy import Numeric
class Plan(self.declarative_base):
__tablename__ = 'plan'
guid = Column(Integer, primary_key=True)
amount = Column(Numeric(10, 2))
class Subscription(self.declarative_base):
__tablename__ = 'subscription'
guid = Column(Integer, primary_key=True)
amount = Column(Numeric(10, 2))
class Transaction(self.declarative_base):
__tablename__ = 'transaction'
guid = Column(Integer, primary_key=True)
amount = Column(Numeric(10, 2))
self.declarative_base.metadata.create_all()
with db_transaction.manager:
for amount in ['12.34', '55.66', '10']:
amount = decimal.Decimal(amount)
plan = Plan(amount=amount)
subscription = Subscription(amount=amount)
transaction = Transaction(amount=amount)
self.session.add(plan)
self.session.add(subscription)
self.session.add(transaction)
from alembic import command
command.stamp(self.alembic_cfg, 'base')
command.upgrade(self.alembic_cfg, 'b3d4192b123')
# Notice: this with statement here makes sure the database transaction
# will be closed after querying, otherwise, we have two connections
# to postgresql (one by testing code, one by Alembic), when we are
# doing following downgrade, there is table alter, it appears
# there will be a deadlock when there is a overlap of two transaction
# scope
with db_transaction.manager:
for table in [Plan, Subscription, Transaction]:
amounts = self.session.query(table.amount).all()
amounts = map(lambda item: float(item[0]), amounts)
# make sure all float dollars are converted into integer cents
self.assertEqual(set(amounts), set([1234, 5566, 1000]))
command.downgrade(self.alembic_cfg, 'base')
with db_transaction.manager:
for table in [Plan, Subscription, Transaction]:
amounts = self.session.query(table.amount).all()
amounts = map(lambda item: item[0], amounts)
self.assertEqual(
set(amounts),
set(map(decimal.Decimal, ['12.34', '55.66', '10']))
)
def test_version_to_none():
with capture_context_buffer() as buf:
command.downgrade(cfg, "%s:base" % c, sql=True)
assert "CREATE TABLE alembic_version" not in buf.getvalue()
assert "INSERT INTO alembic_version" not in buf.getvalue()
assert "DROP TABLE alembic_version" in buf.getvalue()
assert "DROP STEP 3" in buf.getvalue()
assert "DROP STEP 2" in buf.getvalue()
assert "DROP STEP 1" in buf.getvalue()
def test_starting_rev_post_context(self):
env_file_fixture("""
context.configure(dialect_name='sqlite', starting_rev='x')
assert context.get_starting_revision_argument() == 'x'
""")
command.upgrade(self.cfg, a, sql=True)
command.downgrade(self.cfg, "%s:%s" % (b, a), sql=True)
command.current(self.cfg)
command.stamp(self.cfg, a)
def test_head_rev_post_context(self):
env_file_fixture("""
context.configure(dialect_name='sqlite')
assert context.get_head_revision() == '%s'
""" % c)
command.upgrade(self.cfg, b, sql=True)
command.downgrade(self.cfg, "%s:%s" % (b, a), sql=True)
command.stamp(self.cfg, b, sql=True)
command.current(self.cfg)
def test_version_to_middle(self):
with capture_context_buffer() as buf:
command.downgrade(self.cfg, "%s:%s" % (self.c, self.a), sql=True)
assert "CREATE TABLE alembic_version" not in buf.getvalue()
assert "INSERT INTO alembic_version" not in buf.getvalue()
assert "DROP TABLE alembic_version" not in buf.getvalue()
assert "DROP STEP 3" in buf.getvalue()
assert "DROP STEP 2" in buf.getvalue()
assert "DROP STEP 1" not in buf.getvalue()
def migration_downgrade(commit):
"""Migrate database structure"""
from alembic.config import Config
from alembic.command import downgrade
config = Config(os.path.normpath(os.path.abspath(__file__) + "/../alembic.ini"))
config.set_main_option("script_location", "alembic")
downgrade(config, commit)
def actionDowngradeDB(self, version=None):
from alembic.config import Config
from alembic import command
if not version:
self.parser.error("Downgrade DB requires version for migration")
alembic_cfg = Config()
alembic_cfg.set_main_option("script_location", "alembic")
alembic_cfg.set_main_option("url", config.DB_URL)
command.downgrade(alembic_cfg, version)
def command_database(action=None):
config_path = os.path.join(root_path, "alembic.ini")
if not os.path.exists(config_path):
config_path = "/usr/share/opmuse/alembic.ini"
alembic_config = Config(config_path)
database_type = get_database_type()
if action == "create":
if database_type == "mysql":
try:
engine = get_engine(no_database=True)
engine.execute("CREATE DATABASE IF NOT EXISTS %s" % get_database_name())
except ProgrammingError as e:
parser.error('Error occured while creating database: %s' % e)
engine = get_engine()
Base.metadata.create_all(engine)
command.stamp(alembic_config, "head")
# TODO rename to upgrade
elif action == "update":
try:
command.upgrade(alembic_config, "head")
except ProgrammingError as e:
parser.error('Error occured while updating database: %s' % e)
elif action == "downgrade":
try:
command.downgrade(alembic_config, "-1")
except ProgrammingError as e:
parser.error('Error occured while downgrading database: %s' % e)
elif action == "drop":
if database_type == "sqlite":
parser.error('Dropping is unsupported for sqlite.')
engine = get_engine(no_database=True)
engine.execute("DROP DATABASE IF EXISTS %s" % get_database_name())
command_whoosh("drop")
elif action == "fixtures":
from opmuse.test.fixtures import run_fixtures
run_fixtures()
elif action == "reset":
engine = get_engine()
engine.execute(Queue.__table__.delete())
engine.execute(TrackPath.__table__.delete())
engine.execute(Track.__table__.delete())
engine.execute(ListenedTrack.__table__.delete())
engine.execute(UserAndAlbum.__table__.delete())
engine.execute(Album.__table__.delete())
engine.execute(Artist.__table__.delete())
engine.execute(CacheObject.__table__.delete())
command_whoosh("drop")
else:
parser.error('Needs to provide a valid action (create, update, downgrade, drop, fixtures, reset).')
def test_offline_distinct_enum_drop(self):
self._distinct_enum_script()
with capture_context_buffer() as buf:
command.downgrade(self.cfg, "%s:base" % self.rid, sql=True)
assert "DROP TABLE sometable" in buf.getvalue()
assert "DROP TYPE pgenum" in buf.getvalue()
def test_downgrade(self):
alembic_command.upgrade(self.config, '45a07fac3d38')
with self.assertRaises(NotImplementedError):
alembic_command.downgrade(self.config, '2748e48cee3a')
def test_downgrade(self):
alembic_command.upgrade(self.config, '552b213c2b8c')
with self.assertRaises(NotImplementedError):
alembic_command.downgrade(self.config, '45a07fac3d38')
def test_downgrade():
downgrade(config, 'base')
def downgrade_database(engine: Engine, revision: str):
config = get_alembic_config(engine)
downgrade(config, revision)
def test_004_downgrade(self):
command.downgrade(self.cfg, 'base')
db = sqlite_db()
assert not db.dialect.has_table(db.connect(), 'foo')
assert not db.dialect.has_table(db.connect(), 'bar')
assert not db.dialect.has_table(db.connect(), 'bat')
def _test_004_downgrade(self):
command.downgrade(self.cfg, "base")
db = self.bind
assert not db.dialect.has_table(db.connect(), "foo")
assert not db.dialect.has_table(db.connect(), "bar")
assert not db.dialect.has_table(db.connect(), "bat")
def run_alembic_downgrade(alembic_config, conn, rev, run_id=None):
alembic_config.attributes["connection"] = conn
alembic_config.attributes["run_id"] = run_id
downgrade(alembic_config, rev)
def db_downgrade(self, revision):
with self.app_context():
command.downgrade(self._alembic_config, revision)
def downgrade(directory=None, revision='-1', sql=False, tag=None, x_arg=None):
"""Revert to a previous version"""
config = _get_config(directory, x_arg=x_arg)
if sql and revision == '-1':
revision = 'head:-1'
command.downgrade(config, revision, sql=sql, tag=tag)
def teardown():
alc.downgrade(AlembicConfig('alembic.ini'), 'base')
def cli(ctx):
"""
Run setup after a fresh Vagrant installation.
"""
log = logging.getLogger('ipsv.setup')
assert isinstance(ctx, Context)
lock_path = os.path.join(ctx.config.get('Paths', 'Data'), 'setup.lck')
if os.path.exists(lock_path):
raise Exception('Setup is locked, please remove the setup lock file to continue')
# Create our package directories
p = Echo('Creating IPS Vagrant system directories...')
dirs = ['/etc/ipsv', ctx.config.get('Paths', 'Data'), ctx.config.get('Paths', 'Log'),
ctx.config.get('Paths', 'NginxSitesAvailable'), ctx.config.get('Paths', 'NginxSitesEnabled'),
ctx.config.get('Paths', 'NginxSSL')]
for d in dirs:
if not os.path.exists(d):
os.makedirs(d, 0o755)
p.done()
p = Echo('Copying IPS Vagrant configuration files...')
with open('/etc/ipsv/ipsv.conf', 'w+') as f:
ctx.config.write(f)
p.done()
# Set up alembic
alembic_cfg = Config(os.path.join(ctx.basedir, 'alembic.ini'))
alembic_cfg.set_main_option("script_location", os.path.join(ctx.basedir, 'migrations'))
alembic_cfg.set_main_option("sqlalchemy.url", "sqlite:////{path}"
.format(path=os.path.join(ctx.config.get('Paths', 'Data'), 'sites.db')))
command.current(alembic_cfg)
command.downgrade(alembic_cfg, 'base')
command.upgrade(alembic_cfg, 'head')
# Update the system
p = Echo('Updating package cache...')
cache = apt.Cache()
cache.update()
cache.open(None)
p.done()
p = Echo('Upgrading system packages...')
cache.upgrade()
cache.commit()
p.done()
# Install our required packages
requirements = ['nginx', 'php5-fpm', 'php5-curl', 'php5-gd', 'php5-imagick', 'php5-json', 'php5-mysql',
'php5-readline', 'php5-apcu', 'php5-xdebug']
for requirement in requirements:
# Make sure the package is available
p = Echo('Marking package {pkg} for installation'.format(pkg=requirement))
if requirement not in cache:
log.warn('Required package {pkg} not available'.format(pkg=requirement))
p.done(p.FAIL)
continue
# Mark the package for installation
cache[requirement].mark_install()
p.done()
log.info('Committing package cache')
p = Echo('Downloading and installing packages...')
cache.commit()
p.done()
# Disable the default server block
p = Echo('Configuring Nginx...')
default_available = os.path.join(ctx.config.get('Paths', 'NginxSitesAvailable'), 'default')
default_enabled = os.path.join(ctx.config.get('Paths', 'NginxSitesEnabled'), 'default')
if os.path.isfile(default_available):
os.remove(default_available)
if os.path.islink(default_enabled):
os.unlink(default_enabled)
p.done()
# Restart Nginx
FNULL = open(os.devnull, 'w')
p = Echo('Restarting Nginx...')
subprocess.check_call(['service', 'nginx', 'restart'], stdout=FNULL, stderr=subprocess.STDOUT)
p.done()
# php.ini configuration
p = Echo('Configuring php...')
with open('/etc/php5/fpm/php.ini', 'a') as f:
f.write('\n[XDebug]')
f.write('\nxdebug.cli_color=1')
temp_fh, temp_path = mkstemp()
with open(temp_path, 'w') as nf:
with open('/etc/php5/fpm/php.ini') as of:
# Configuration options we are replacing
upload_max_filesize = re.compile( '^upload_max_filesize\s+=\s+(\d+[a-zA-Z])\s*$' )
post_max_size = re.compile( '^post_max_size\s+=\s+(\d+[a-zA-Z])\s*$' )
for line in of:
match = upload_max_filesize.match( line ) if upload_max_filesize is not True else False
if match:
nf.write( 'upload_max_filesize = 1000M\n' )
upload_max_filesize = True
continue
match = post_max_size.match( line ) if post_max_size is not True else False
if match:
nf.write( 'post_max_size = 1000M\n' )
post_max_size = True
continue
nf.write(line)
os.close(temp_fh)
os.remove('/etc/php5/fpm/php.ini')
shutil.move(temp_path, '/etc/php5/fpm/php.ini')
os.chmod('/etc/php5/fpm/php.ini', 0o644)
p.done()
# php5-fpm configuration
p = Echo('Configuring php5-fpm...')
if os.path.isfile('/etc/php5/fpm/pool.d/www.conf'):
os.remove('/etc/php5/fpm/pool.d/www.conf')
fpm_config = FpmPoolConfig().template
with open('/etc/php5/fpm/pool.d/ips.conf', 'w') as f:
f.write(fpm_config)
p.done()
# Restart php5-fpm
p = Echo('Restarting php5-fpm...')
subprocess.check_call(['service', 'php5-fpm', 'restart'], stdout=FNULL, stderr=subprocess.STDOUT)
p.done()
# Copy the man pages and rebuild the manual database
p = Echo('Writing manual pages...')
man_path = os.path.join(ctx.basedir, 'man', 'ipsv.1')
sys_man_path = '/usr/local/share/man/man1'
if not os.path.exists(sys_man_path):
os.makedirs(sys_man_path)
shutil.copyfile(man_path, os.path.join(sys_man_path, 'ipsv.1'))
subprocess.check_call(['mandb'], stdout=FNULL, stderr=subprocess.STDOUT)
# Enable the welcome message
log.debug('Writing welcome message')
wm_header = '## DO NOT REMOVE :: AUTOMATICALLY GENERATED BY IPSV ##'
wm_remove = False
# Remove old profile data
for line in fileinput.input('/etc/profile', inplace=True):
# Header / footer match?
if line == wm_header:
# Footer match (Stop removing)
if wm_remove:
wm_remove = False
continue
# Header match (Start removing)
wm_remove = True
continue
# Removing lines?
if wm_remove:
continue
# Print line and continue as normal
sys.stdout.write(line)
# Write new profile data
with open('/etc/profile', 'a') as f:
f.write("\n" + wm_header + "\n")
fl_lock_path = os.path.join(ctx.config.get('Paths', 'Data'), 'first_login.lck')
f.write('if [ ! -f "{lp}" ]; then'.format(lp=fl_lock_path) + "\n")
f.write(' less "{wp}"'.format(wp=os.path.join(ctx.basedir, 'WELCOME.rst')) + "\n")
f.write(' sudo touch "{lp}"'.format(lp=fl_lock_path) + "\n")
f.write('fi' + "\n")
f.write(wm_header + "\n")
p.done()
log.debug('Writing setup lock file')
with open(os.path.join(ctx.config.get('Paths', 'Data'), 'setup.lck'), 'w') as f:
f.write('1')
def del_table_users_and_return_after_test():
command.downgrade(alembic_cfg, 'base')
yield None
command.upgrade(alembic_cfg, 'head')
def down_version(target='head', sql_mode=False):
CABIN.info('Downgrade migration!')
return downgrade(ini_configuration(os.getcwd()), target, sql=sql_mode)
def test_migrations_forward_backward(self):
"""
This is a very broad test that checks that the migration mechanism
works. More specifically, it checks that::
- Alembic database migrations to specific versions work (upgrade &
downgrade)
- The methods that are checking the database schema version and perform
the migration procedure to the last version work correctly.
"""
from aiida.backends.sqlalchemy.tests.migration_test import versions
from aiida.backends.sqlalchemy.utils import check_schema_version
try:
# Constructing the versions directory
versions_dpath = os.path.join(
os.path.dirname(versions.__file__))
# Setting dynamically the the path to the alembic configuration
# (this is where the env.py file can be found)
alembic_cfg = Config()
alembic_cfg.set_main_option('script_location', self.alembic_dpath)
# Setting dynamically the versions directory. These are the
# migration scripts to pass from one version to the other. The
# default ones are overridden with test-specific migrations.
alembic_cfg.set_main_option('version_locations', versions_dpath)
# Using the connection initialized by the tests
with sa.engine.begin() as connection:
alembic_cfg.attributes['connection'] = connection
self.assertIsNone(get_db_schema_version(alembic_cfg),
"The initial database version should be "
"None (no version) since the test setUp "
"method should undo all migrations")
# Migrate the database to the latest version
check_schema_version(force_migration=True, alembic_cfg=alembic_cfg)
with sa.engine.begin() as connection:
alembic_cfg.attributes['connection'] = connection
self.assertEquals(get_db_schema_version(alembic_cfg),
get_migration_head(alembic_cfg),
"The latest database version is not the "
"expected one.")
with sa.engine.begin() as connection:
alembic_cfg.attributes['connection'] = connection
# Migrating the database to the base version
command.downgrade(alembic_cfg, "base")
self.assertIsNone(get_db_schema_version(alembic_cfg),
"The database version is not the expected "
"one. It should be None (initial).")
except Exception as test_ex:
# If there is an exception, clean the alembic related tables
from sqlalchemy.engine import reflection
# Getting the current database table names
inspector = reflection.Inspector.from_engine(
sa.get_scoped_session().bind)
db_table_names = set(inspector.get_table_names())
# The alembic related database names
alemb_table_names = set(['account', 'alembic_version'])
# Get the intersection of the above tables
tables_to_drop = set.intersection(db_table_names,
alemb_table_names)
# Delete only the tables that exist
for table in tables_to_drop:
from psycopg2 import ProgrammingError
from sqlalchemy.orm import sessionmaker, scoped_session
try:
with sa.engine.begin() as connection:
connection.execute('DROP TABLE {};'.format(table))
except Exception as db_ex:
print("The following error occured during the cleaning of"
"the database: {}".format(db_ex.message))
# Since the database cleaning is over, raise the test
# exception that was caught
raise test_ex
def handle_db_downgrade_command(args):
cfg = get_alembic_config(args)
command.downgrade(cfg, "-1")
handle_db_fixsequence_command(args)
def test_tag_pre_context(self):
env_file_fixture("""
assert context.get_tag_argument() == 'hi'
""")
command.upgrade(self.cfg, b, sql=True, tag='hi')
command.downgrade(self.cfg, "%s:%s" % (b, a), sql=True, tag='hi')
def _reverse_migration(self, rev, alembic_conf):
"""Reverse the migration specified by rev"""
downgrade(alembic_conf, rev)
def downgrade(directory=None, revision='-1', sql=False, tag=None):
"""Revert to a previous version"""
config = _get_config(directory)
command.downgrade(config, revision, sql=sql, tag=tag)
def test_migrations_stairway(alembic_config: Config, revision: Script):
upgrade(alembic_config, revision.revision)
downgrade(alembic_config, revision.down_revision or "-1")
upgrade(alembic_config, revision.revision)
def test_tag_pre_context_None(self):
env_file_fixture("""
assert context.get_tag_argument() is None
""")
command.upgrade(self.cfg, b, sql=True)
command.downgrade(self.cfg, "%s:%s" % (b, a), sql=True)
def db_downgrade(context, revision):
command.downgrade(context.obj['alembic'], revision)
def _test_003_downgrade(self):
command.downgrade(self.cfg, self.a)
db = self.bind
assert db.dialect.has_table(db.connect(), 'foo')
assert not db.dialect.has_table(db.connect(), 'bar')
assert not db.dialect.has_table(db.connect(), 'bat')
def test_not_requires_connection(self):
env_file_fixture("""
assert not context.requires_connection()
""")
command.upgrade(self.cfg, a, sql=True)
command.downgrade(self.cfg, "%s:%s" % (b, a), sql=True)
def test_requires_connection(self):
env_file_fixture("""
assert context.requires_connection()
""")
command.upgrade(self.cfg, a)
command.downgrade(self.cfg, a)
def test_starting_rev_pre_context(self):
env_file_fixture("""
assert context.get_starting_revision_argument() == 'x'
""")
command.upgrade(self.cfg, "x:y", sql=True)
command.downgrade(self.cfg, "x:y", sql=True)
def teardown():
print('Downgrading alembic migrations...\n')
command.downgrade(alembic_config, 'base')
def test_downgrade(self):
alembic_command.upgrade(self.config, '2748e48cee3a')
with self.assertRaises(NotImplementedError):
alembic_command.downgrade(self.config, '1284c81cf727')
def tearDown(self):
command.downgrade(get_alembic_config(), 'base')
return super().tearDown()
def migrate(direction):
"""Migrate db revision"""
if direction == "up":
command.upgrade(alembic_config, "head")
elif direction == "down":
command.downgrade(alembic_config, "-1")
