Esempi in Python per staging_env

Esempio n. 1

File: test_postgresql.py Progetto: chishaku/alembic

 def setup_class(cls):
     cls.bind = config.db
     cls.conn = cls.bind.connect()
     staging_env()
     cls.migration_context = MigrationContext.configure(
         connection=cls.conn, opts={"compare_type": True, "compare_server_default": True}
     )

Esempio n. 2

File: test_autogen_indexes.py Progetto: assembl/alembic

    def setUp(self):
        staging_env()
        self.bind = eng = engines.testing_engine()

        def unimpl(*arg, **kw):
            raise NotImplementedError()
        eng.dialect.get_unique_constraints = unimpl

Esempio n. 3

File: test_postgresql.py Progetto: chishaku/alembic

    def setUp(self):
        staging_env()
        self.cfg = cfg = _no_sql_testing_config()

        self.rid = rid = util.rev_id()

        self.script = script = ScriptDirectory.from_config(cfg)
        script.generate_revision(rid, None, refresh=True)

Esempio n. 4

File: test_mssql.py Progetto: zzzeek/alembic

    def setup_class(cls):
        staging_env()
        if util.sqla_105:
            directives = "sqlalchemy.legacy_schema_aliasing=false"
        else:
            directives = ""
        cls.cfg = cfg = _no_sql_testing_config("mssql", directives)

        cls.a, cls.b, cls.c = three_rev_fixture(cfg)

Esempio n. 5

File: test_postgresql.py Progetto: RazerM/alembic

 def setup_class(cls):
     cls.bind = config.db
     staging_env()
     cls.migration_context = MigrationContext.configure(
         connection=cls.bind.connect(),
         opts={
             'compare_type': True,
             'compare_server_default': True
         }
     )

Esempio n. 6

File: test_mysql.py Progetto: zzzeek/alembic

 def setup_class(cls):
     cls.bind = config.db
     staging_env()
     context = MigrationContext.configure(
         connection=cls.bind.connect(),
         opts={"compare_type": True, "compare_server_default": True},
     )
     connection = context.bind
     cls.autogen_context = {
         "imports": set(),
         "connection": connection,
         "dialect": connection.dialect,
         "context": context,
     }

Esempio n. 7

File: test_script_consumption.py Progetto: RazerM/alembic

    def setUp(self):
        self.env = staging_env()
        self.cfg = cfg = _no_sql_testing_config()
        cfg.set_main_option('dialect_name', 'sqlite')
        cfg.remove_main_option('url')

        self.a, self.b, self.c = three_rev_fixture(cfg)

Esempio n. 8

File: test_version_traversal.py Progetto: zzzeek/alembic

    def setup_class(cls):
        cls.env = env = staging_env()
        cls.a = env.generate_revision(util.rev_id(), "->a")
        cls.b = env.generate_revision(util.rev_id(), "a->b")

        cls.c1 = env.generate_revision(util.rev_id(), "b->c1")
        cls.d1 = env.generate_revision(util.rev_id(), "c1->d1")

        cls.c2 = env.generate_revision(
            util.rev_id(),
            "b->c2",
            branch_labels="c2branch",
            head=cls.b.revision,
            splice=True,
        )
        cls.d2 = env.generate_revision(
            util.rev_id(), "c2->d2", head=cls.c2.revision
        )

        cls.e = env.generate_revision(
            util.rev_id(),
            "merge d1 and d2",
            head=(cls.d1.revision, cls.d2.revision),
        )

        cls.f = env.generate_revision(util.rev_id(), "e->f")

Esempio n. 9

File: test_version_traversal.py Progetto: zzzeek/alembic

    def setup_class(cls):
        cls.env = env = staging_env()
        cls.a1 = env.generate_revision(
            util.rev_id(), "->a1", branch_labels=["lib1"]
        )
        cls.b1 = env.generate_revision(util.rev_id(), "a1->b1")
        cls.c1 = env.generate_revision(
            util.rev_id(), "b1->c1", branch_labels=["c1lib"]
        )

        cls.a2 = env.generate_revision(util.rev_id(), "->a2", head=())
        cls.b2 = env.generate_revision(
            util.rev_id(), "a2->b2", head=cls.a2.revision
        )
        cls.c2 = env.generate_revision(
            util.rev_id(), "b2->c2", head=cls.b2.revision, depends_on=["c1lib"]
        )

        cls.d1 = env.generate_revision(
            util.rev_id(), "c1->d1", head=cls.c1.revision
        )
        cls.e1 = env.generate_revision(
            util.rev_id(), "d1->e1", head=cls.d1.revision
        )
        cls.f1 = env.generate_revision(
            util.rev_id(), "e1->f1", head=cls.e1.revision
        )

Esempio n. 10

File: test_version_traversal.py Progetto: zzzeek/alembic

    def setup_class(cls):
        """
        issue #377

        Structure::

            <base> -> a1 --+--> a2 -------> a3
                           |     ^          |
                           |     |   +------+
                           |     |   |
                           |     +---|------+
                           |         |      |
                           |         v      |
                           +-------> b1 --> b2 --> b3

        """
        cls.env = env = staging_env()
        cls.a1 = env.generate_revision("a1", "->a1", head="base")
        cls.a2 = env.generate_revision("a2", "->a2")

        cls.b1 = env.generate_revision("b1", "->b1", head="base")
        cls.b2 = env.generate_revision(
            "b2", "->b2", depends_on="a2", head="b1"
        )
        cls.b3 = env.generate_revision("b3", "->b3", head="b2")

        cls.a3 = env.generate_revision(
            "a3", "->a3", head="a2", depends_on="b1"
        )

Esempio n. 11

File: test_version_traversal.py Progetto: zzzeek/alembic

    def setup_class(cls):
        """
        A -> B2 (branchpoint),

        B1, B2 -> C1 (mergepoint)
        B2, B3 -> C2 (mergepoint)

        C1 -> D1 (head),

        C2 -> D2 (head),


        """
        cls.env = env = staging_env()

        cls.a = env.generate_revision("a", "a")
        cls.b1 = env.generate_revision("b1", "b1", head=cls.a.revision)
        cls.b2 = env.generate_revision(
            "b2", "b2", splice=True, head=cls.a.revision
        )
        cls.b3 = env.generate_revision(
            "b3", "b3", splice=True, head=cls.a.revision
        )

        cls.c1 = env.generate_revision(
            "c1", "c1", head=(cls.b1.revision, cls.b2.revision)
        )

        cls.c2 = env.generate_revision(
            "c2", "c2", splice=True, head=(cls.b2.revision, cls.b3.revision)
        )

        cls.d1 = env.generate_revision("d1", "d1", head=cls.c1.revision)

        cls.d2 = env.generate_revision("d2", "d2", head=cls.c2.revision)

Esempio n. 12

File: test_version_traversal.py Progetto: zzzeek/alembic

 def setup_class(cls):
     cls.env = env = staging_env()
     cls.a = env.generate_revision(util.rev_id(), "->a")
     cls.b = env.generate_revision(util.rev_id(), "a->b")
     cls.c = env.generate_revision(util.rev_id(), "b->c")
     cls.d = env.generate_revision(util.rev_id(), "c->d")
     cls.e = env.generate_revision(util.rev_id(), "d->e")

Esempio n. 13

File: test_version_traversal.py Progetto: zzzeek/alembic

    def setup_class(cls):
        cls.env = env = staging_env()
        cls.a1 = env.generate_revision(util.rev_id(), "->a1")
        cls.b1 = env.generate_revision(util.rev_id(), "a1->b1")
        cls.c1 = env.generate_revision(util.rev_id(), "b1->c1")

        cls.a2 = env.generate_revision(
            util.rev_id(), "->a2", head=(), refresh=True
        )
        cls.b2 = env.generate_revision(
            util.rev_id(), "a2->b2", head=cls.a2.revision
        )
        cls.c2 = env.generate_revision(
            util.rev_id(), "b2->c2", head=cls.b2.revision
        )

        # mergepoint between c1, c2
        # d1 dependent on c2
        cls.d1 = env.generate_revision(
            util.rev_id(),
            "d1",
            head=(cls.c1.revision, cls.c2.revision),
            refresh=True,
        )

        # but then c2 keeps going into d2
        cls.d2 = env.generate_revision(
            util.rev_id(),
            "d2",
            head=cls.c2.revision,
            refresh=True,
            splice=True,
        )

Esempio n. 14

File: test_command.py Progetto: zzzeek/alembic

    def setUp(self):
        self.bind = _sqlite_file_db()
        self.env = staging_env()
        self.cfg = _sqlite_testing_config()
        self.a = a = util.rev_id()
        self.b = b = util.rev_id()
        script = ScriptDirectory.from_config(self.cfg)
        script.generate_revision(a, None, refresh=True)
        write_script(
            script,
            a,
            """
revision = '%s'
down_revision = None
"""
            % a,
        )
        script.generate_revision(b, None, refresh=True)
        write_script(
            script,
            b,
            """
revision = '%s'
down_revision = '%s'
"""
            % (b, a),
        )

Esempio n. 15

File: test_version_traversal.py Progetto: chishaku/alembic

    def setup_class(cls):
        cls.env = env = staging_env()
        cls.a1 = env.generate_revision(
            util.rev_id(), '->a1',
            branch_labels=['lib1'])
        cls.b1 = env.generate_revision(util.rev_id(), 'a1->b1')
        cls.c1 = env.generate_revision(
            util.rev_id(), 'b1->c1',
            branch_labels=['c1lib'])

        cls.a2 = env.generate_revision(util.rev_id(), '->a2', head=())
        cls.b2 = env.generate_revision(
            util.rev_id(), 'a2->b2', head=cls.a2.revision)
        cls.c2 = env.generate_revision(
            util.rev_id(), 'b2->c2', head=cls.b2.revision,
            depends_on=['c1lib'])

        cls.d1 = env.generate_revision(
            util.rev_id(), 'c1->d1',
            head=cls.c1.revision)
        cls.e1 = env.generate_revision(
            util.rev_id(), 'd1->e1',
            head=cls.d1.revision)
        cls.f1 = env.generate_revision(
            util.rev_id(), 'e1->f1',
            head=cls.e1.revision)

Esempio n. 16

File: test_script_production.py Progetto: graingert/alembic

    def setUp(self):
        self.env = staging_env()
        self.cfg = _multi_dir_testing_config()
        self.cfg.set_main_option("revision_environment", "true")

        script = ScriptDirectory.from_config(self.cfg)
        # MARKMARK
        self.model1 = util.rev_id()
        self.model2 = util.rev_id()
        self.model3 = util.rev_id()
        for model, name in [
            (self.model1, "model1"),
            (self.model2, "model2"),
            (self.model3, "model3"),
        ]:
            script.generate_revision(
                model, name, refresh=True,
                version_path=os.path.join(_get_staging_directory(), name),
                head="base")

            write_script(script, model, """\
"%s"
revision = '%s'
down_revision = None
branch_labels = ['%s']

from alembic import op

def upgrade():
    pass

def downgrade():
    pass

""" % (name, model, name))

Esempio n. 17

File: test_version_traversal.py Progetto: SvenDowideit/clearlinux

    def setup_class(cls):
        cls.env = env = staging_env()
        cls.a1 = env.generate_revision(util.rev_id(), '->a1', head='base')
        cls.a2 = env.generate_revision(util.rev_id(), '->a2', head='base')
        cls.a3 = env.generate_revision(util.rev_id(), '->a3', head='base')
        cls.amerge = env.generate_revision(util.rev_id(), 'amerge', head=[
            cls.a1.revision, cls.a2.revision, cls.a3.revision
        ])

        cls.b1 = env.generate_revision(util.rev_id(), '->b1', head='base')
        cls.b2 = env.generate_revision(util.rev_id(), '->b2', head='base')
        cls.bmerge = env.generate_revision(util.rev_id(), 'bmerge', head=[
            cls.b1.revision, cls.b2.revision
        ])

        cls.c1 = env.generate_revision(util.rev_id(), '->c1', head='base')
        cls.c2 = env.generate_revision(util.rev_id(), '->c2', head='base')
        cls.c3 = env.generate_revision(util.rev_id(), '->c3', head='base')
        cls.cmerge = env.generate_revision(util.rev_id(), 'cmerge', head=[
            cls.c1.revision, cls.c2.revision, cls.c3.revision
        ])

        cls.d1 = env.generate_revision(
            util.rev_id(), 'overmerge',
            head="base",
            depends_on=[
                cls.a3.revision, cls.b2.revision, cls.c1.revision
            ])

Esempio n. 18

File: test_version_traversal.py Progetto: SvenDowideit/clearlinux

 def setup_class(cls):
     cls.env = env = staging_env()
     cls.a = env.generate_revision(util.rev_id(), '->a')
     cls.b = env.generate_revision(util.rev_id(), 'a->b')
     cls.c = env.generate_revision(util.rev_id(), 'b->c')
     cls.d = env.generate_revision(util.rev_id(), 'c->d')
     cls.e = env.generate_revision(util.rev_id(), 'd->e')

Esempio n. 19

File: test_script_consumption.py Progetto: zzzeek/alembic

    def setUp(self):
        self.env = staging_env()
        self.cfg = cfg = _no_sql_testing_config()
        cfg.set_main_option("dialect_name", "sqlite")
        cfg.remove_main_option("url")
        self.a = util.rev_id()
        script = ScriptDirectory.from_config(cfg)
        script.generate_revision(self.a, "revision a", refresh=True)
        write_script(
            script,
            self.a,
            (
                compat.u(
                    """# coding: utf-8
from __future__ import unicode_literals
revision = '%s'
down_revision = None

from alembic import op

def upgrade():
    op.execute("« S’il vous plaît…")

def downgrade():
    op.execute("drôle de petite voix m’a réveillé")

"""
                )
                % self.a
            ),
            encoding="utf-8",
        )

Esempio n. 20

File: test_mysql.py Progetto: SvenDowideit/clearlinux

 def setup_class(cls):
     cls.bind = config.db
     staging_env()
     context = MigrationContext.configure(
         connection=cls.bind.connect(),
         opts={
             'compare_type': True,
             'compare_server_default': True
         }
     )
     connection = context.bind
     cls.autogen_context = {
         'imports': set(),
         'connection': connection,
         'dialect': connection.dialect,
         'context': context
     }

Esempio n. 21

File: test_script_consumption.py Progetto: RazerM/alembic

    def _opened_transaction_fixture(self):
        self.env = staging_env()
        self.cfg = _sqlite_testing_config()

        script = ScriptDirectory.from_config(self.cfg)
        a = util.rev_id()
        b = util.rev_id()
        c = util.rev_id()
        script.generate_revision(a, "revision a", refresh=True)
        write_script(script, a, """
"rev a"

revision = '%s'
down_revision = None

def upgrade():
    pass

def downgrade():
    pass

""" % (a, ))
        script.generate_revision(b, "revision b", refresh=True)
        write_script(script, b, """
"rev b"
revision = '%s'
down_revision = '%s'

from alembic import op


def upgrade():
    conn = op.get_bind()
    trans = conn.begin()


def downgrade():
    pass

""" % (b, a))
        script.generate_revision(c, "revision c", refresh=True)
        write_script(script, c, """
"rev c"
revision = '%s'
down_revision = '%s'

from alembic import op


def upgrade():
    pass


def downgrade():
    pass

""" % (c, b))
        return a, b, c

Esempio n. 22

File: test_command.py Progetto: zzzeek/alembic

 def setup_class(cls):
     cls.env = env = staging_env()
     cls.cfg = _sqlite_testing_config()
     cls.a1 = env.generate_revision("a1", "a1")
     cls.a2 = env.generate_revision("a2", "a2")
     cls.a3 = env.generate_revision("a3", "a3")
     cls.b1 = env.generate_revision("b1", "b1", head="base")
     cls.b2 = env.generate_revision("b2", "b2", head="b1", depends_on="a2")
     cls.b3 = env.generate_revision("b3", "b3", head="b2")

Esempio n. 23

File: test_version_traversal.py Progetto: SvenDowideit/clearlinux

    def setup_class(cls):
        cls.env = env = staging_env()
        cls.a1 = env.generate_revision(util.rev_id(), '->a1')
        cls.b1 = env.generate_revision(util.rev_id(), 'a1->b1')

        cls.a2 = env.generate_revision(
            util.rev_id(), '->a2', head=(),
            refresh=True)
        cls.b2 = env.generate_revision(
            util.rev_id(), 'a2->b2', head=cls.a2.revision)

Esempio n. 24

File: test_version_traversal.py Progetto: RazerM/alembic

    def setup_class(cls):
        """
        a1 ---+
              |
        a2 ---+--> amerge
              |
        a3 ---+
         ^
         |
         +---------------------------+
                                     |
        b1 ---+                      |
              +--> bmerge        overmerge / d1
        b2 ---+                     |  |
         ^                          |  |
         |                          |  |
         +--------------------------+  |
                                       |
         +-----------------------------+
         |
         v
        c1 ---+
              |
        c2 ---+--> cmerge
              |
        c3 ---+

        """
        cls.env = env = staging_env()
        cls.a1 = env.generate_revision("a1", '->a1', head='base')
        cls.a2 = env.generate_revision("a2", '->a2', head='base')
        cls.a3 = env.generate_revision("a3", '->a3', head='base')
        cls.amerge = env.generate_revision("amerge", 'amerge', head=[
            cls.a1.revision, cls.a2.revision, cls.a3.revision
        ])

        cls.b1 = env.generate_revision("b1", '->b1', head='base')
        cls.b2 = env.generate_revision("b2", '->b2', head='base')
        cls.bmerge = env.generate_revision("bmerge", 'bmerge', head=[
            cls.b1.revision, cls.b2.revision
        ])

        cls.c1 = env.generate_revision("c1", '->c1', head='base')
        cls.c2 = env.generate_revision("c2", '->c2', head='base')
        cls.c3 = env.generate_revision("c3", '->c3', head='base')
        cls.cmerge = env.generate_revision("cmerge", 'cmerge', head=[
            cls.c1.revision, cls.c2.revision, cls.c3.revision
        ])

        cls.d1 = env.generate_revision(
            "d1", 'o',
            head="base",
            depends_on=[
                cls.a3.revision, cls.b2.revision, cls.c1.revision
            ])

Esempio n. 25

File: test_script_production.py Progetto: tc1989tc/alembic

    def setUp(self):
        self.engine1 = _sqlite_file_db(tempname='eng1.db')
        self.engine2 = _sqlite_file_db(tempname='eng2.db')
        self.engine3 = _sqlite_file_db(tempname='eng3.db')

        self.env = staging_env(template="multidb")
        self.cfg = _multidb_testing_config({
            "engine1": self.engine1,
            "engine2": self.engine2,
            "engine3": self.engine3
        })

Esempio n. 26

File: test_script_production.py Progetto: graingert/alembic

    def _test_006_from_clean_env(self):
        # test the environment so far with a
        # new ScriptDirectory instance.

        env = staging_env(create=False)
        abc_rev = env.get_revision(abc)
        def_rev = env.get_revision(def_)
        eq_(abc_rev.nextrev, set([def_]))
        eq_(abc_rev.revision, abc)
        eq_(def_rev.down_revision, abc)
        eq_(env.get_heads(), [def_])
        eq_(env.get_base(), abc)

Esempio n. 27

File: test_version_traversal.py Progetto: SvenDowideit/clearlinux

    def setup_class(cls):
        """

        33e21c000cfe -> 178d4e761bbd (head),
        2bef33cb3a58, 3904558db1c6, 968330f320d -> 33e21c000cfe (mergepoint)
        46c99f866004 -> 18f46b42410d (head),
        2bef33cb3a58, 3904558db1c6, 968330f320d -> 46c99f866004 (mergepoint)
        f0fa4315825 -> 3904558db1c6 (branchpoint),

        --------------------------

        A -> B2 (branchpoint),

        B1, B2, B3 -> C1 (mergepoint)
        B1, B2, B3 -> C2 (mergepoint)

        C1 -> D1 (head),

        C2 -> D2 (head),


        """
        cls.env = env = staging_env()

        cls.a = env.generate_revision(
            'a', 'a'
        )
        cls.b1 = env.generate_revision('b1', 'b1',
                                       head=cls.a.revision)
        cls.b2 = env.generate_revision('b2', 'b2',
                                       splice=True,
                                       head=cls.a.revision)
        cls.b3 = env.generate_revision('b3', 'b3',
                                       splice=True,
                                       head=cls.a.revision)

        cls.c1 = env.generate_revision(
            'c1', 'c1',
            head=(cls.b1.revision, cls.b2.revision, cls.b3.revision))

        cls.c2 = env.generate_revision(
            'c2', 'c2',
            splice=True,
            head=(cls.b1.revision, cls.b2.revision, cls.b3.revision))

        cls.d1 = env.generate_revision(
            'd1', 'd1', head=cls.c1.revision)

        cls.d2 = env.generate_revision(
            'd2', 'd2', head=cls.c2.revision)

Esempio n. 28

File: test_postgresql.py Progetto: SvenDowideit/clearlinux

 def setup_class(cls):
     cls.bind = config.db
     staging_env()
     context = MigrationContext.configure(
         connection=cls.bind.connect(),
         opts={
             'compare_type': True,
             'compare_server_default': True
         }
     )
     connection = context.bind
     cls.autogen_context = {
         'imports': set(),
         'connection': connection,
         'dialect': connection.dialect,
         'context': context,
         'opts': {
             'compare_type': True,
             'compare_server_default': True,
             'alembic_module_prefix': 'op.',
             'sqlalchemy_module_prefix': 'sa.',
         }
     }

Esempio n. 29

File: test_version_traversal.py Progetto: SvenDowideit/clearlinux

    def setup_class(cls):
        cls.env = env = staging_env()
        cls.a = env.generate_revision(util.rev_id(), '->a')
        cls.b = env.generate_revision(util.rev_id(), 'a->b')

        cls.c1 = env.generate_revision(
            util.rev_id(), 'b->c1',
            branch_labels='c1branch',
            refresh=True)
        cls.d1 = env.generate_revision(util.rev_id(), 'c1->d1')

        cls.c2 = env.generate_revision(
            util.rev_id(), 'b->c2',
            branch_labels='c2branch',
            head=cls.b.revision, splice=True)
        cls.d2 = env.generate_revision(
            util.rev_id(), 'c2->d2',
            head=cls.c2.revision)

Esempio n. 30

File: test_version_traversal.py Progetto: zzzeek/alembic

    def setup_class(cls):
        cls.env = env = staging_env()
        cls.a = env.generate_revision(util.rev_id(), "->a")
        cls.b = env.generate_revision(util.rev_id(), "a->b")

        cls.c1 = env.generate_revision(
            util.rev_id(), "b->c1", branch_labels="c1branch", refresh=True
        )
        cls.d1 = env.generate_revision(util.rev_id(), "c1->d1")

        cls.c2 = env.generate_revision(
            util.rev_id(),
            "b->c2",
            branch_labels="c2branch",
            head=cls.b.revision,
            splice=True,
        )
        cls.d2 = env.generate_revision(
            util.rev_id(), "c2->d2", head=cls.c2.revision
        )

Esempio n. 31

    def setup_class(cls):
        staging_env()
        directives = "sqlalchemy.legacy_schema_aliasing=false"
        cls.cfg = cfg = _no_sql_testing_config("mssql", directives)

        cls.a, cls.b, cls.c = three_rev_fixture(cfg)

Esempio n. 32

File: test_script_consumption.py Progetto: s132048/docs-korean-alembic

 def setUp(self):
     self.env = staging_env(sourceless=False)
     self.cfg = _sqlite_testing_config()

Esempio n. 33

 def setUp(self):
     staging_env()
     self.cfg = _no_sql_testing_config()

Esempio n. 34

File: test_script_consumption.py Progetto: zzzeek/alembic

    def _opened_transaction_fixture(self, future=False):
        self.env = staging_env()

        if future:
            self.cfg = _sqlite_testing_config(future=future)
        else:
            self.cfg = _sqlite_testing_config()

        if self.branched_connection:
            self._branched_connection_env()

        script = ScriptDirectory.from_config(self.cfg)
        a = util.rev_id()
        b = util.rev_id()
        c = util.rev_id()

        script.generate_revision(a, "revision a", refresh=True)
        write_script(
            script,
            a,
            """
"rev a"

revision = '%s'
down_revision = None

def upgrade():
    pass

def downgrade():
    pass

"""
            % (a,),
        )
        script.generate_revision(b, "revision b", refresh=True)
        write_script(
            script,
            b,
            """
"rev b"
revision = '%s'
down_revision = '%s'

from alembic import op


def upgrade():
    conn = op.get_bind()
    # this should fail for a SQLAlchemy 2.0 connection b.c. there is
    # already a transaction.
    trans = conn.begin()


def downgrade():
    pass

"""
            % (b, a),
        )
        script.generate_revision(c, "revision c", refresh=True)
        write_script(
            script,
            c,
            """
"rev c"
revision = '%s'
down_revision = '%s'

from alembic import op


def upgrade():
    pass


def downgrade():
    pass

"""
            % (c, b),
        )
        return a, b, c

Esempio n. 35

 def setup_class(cls):
     cls.env = staging_env()
     cls.cfg = _sqlite_testing_config()
     cls.a, cls.b, cls.c = three_rev_fixture(cls.cfg)

Esempio n. 36

File: _autogen_fixtures.py Progetto: yuriolive/alembic

 def setup_class(cls):
     staging_env()
     cls.bind = cls._get_bind()
     cls.m1 = cls._get_db_schema()
     cls.m1.create_all(cls.bind)
     cls.m2 = cls._get_model_schema()

Esempio n. 37

File: test_postgresql.py Progetto: rnedy/alembic

 def setup_class(cls):
     cls.bind = config.db
     staging_env()

Esempio n. 38

File: test_version_traversal.py Progetto: BlackEarth/alembic-migrations

    def setup_class(cls):
        """
        Structure::

            a1 ---+
                  |
            a2 ---+--> amerge
                  |
            a3 ---+
             ^
             |
             +---------------------------+
                                         |
            b1 ---+                      |
                  +--> bmerge        overmerge / d1
            b2 ---+                     |  |
             ^                          |  |
             |                          |  |
             +--------------------------+  |
                                           |
             +-----------------------------+
             |
             v
            c1 ---+
                  |
            c2 ---+--> cmerge
                  |
            c3 ---+

        """
        cls.env = env = staging_env()
        cls.a1 = env.generate_revision("a1", "->a1", head="base")
        cls.a2 = env.generate_revision("a2", "->a2", head="base")
        cls.a3 = env.generate_revision("a3", "->a3", head="base")
        cls.amerge = env.generate_revision(
            "amerge",
            "amerge",
            head=[cls.a1.revision, cls.a2.revision, cls.a3.revision],
        )

        cls.b1 = env.generate_revision("b1", "->b1", head="base")
        cls.b2 = env.generate_revision("b2", "->b2", head="base")
        cls.bmerge = env.generate_revision(
            "bmerge", "bmerge", head=[cls.b1.revision, cls.b2.revision]
        )

        cls.c1 = env.generate_revision("c1", "->c1", head="base")
        cls.c2 = env.generate_revision("c2", "->c2", head="base")
        cls.c3 = env.generate_revision("c3", "->c3", head="base")
        cls.cmerge = env.generate_revision(
            "cmerge",
            "cmerge",
            head=[cls.c1.revision, cls.c2.revision, cls.c3.revision],
        )

        cls.d1 = env.generate_revision(
            "d1",
            "o",
            head="base",
            depends_on=[cls.a3.revision, cls.b2.revision, cls.c1.revision],
        )

Esempio n. 39

File: test_script_production.py Progetto: tailhook/alembic

 def setUp(self):
     self.env = staging_env()
     self.cfg = _sqlite_testing_config()
     self.a, self.b, self.c = three_rev_fixture(self.cfg)

Esempio n. 40

File: test_script_consumption.py Progetto: s132048/docs-korean-alembic

 def setUp(self):
     self.bind = _sqlite_file_db()
     self.env = staging_env(sourceless=self.sourceless)
     self.cfg = _sqlite_testing_config(sourceless=self.sourceless)

Esempio n. 41

File: test_script_production.py Progetto: tailhook/alembic

 def setUp(self):
     global env
     env = staging_env()

Esempio n. 42

 def setUp(self):
     self.env = staging_env()
     self.cfg = _sqlite_testing_config()

Esempio n. 43

File: test_script_production.py Progetto: tailhook/alembic

 def setUp(self):
     self.env = staging_env()
     self.cfg = _multi_dir_testing_config()

Esempio n. 44

    def setUp(self):
        staging_env()
        self.cfg = _no_sql_testing_config()

        global a, b, c
        a, b, c = three_rev_fixture(self.cfg)

Esempio n. 45

 def setUp(self):
     self.env = staging_env()

Esempio n. 46

    def setup_class(cls):
        staging_env()
        cls.cfg = cfg = _no_sql_testing_config("mssql")

        cls.a, cls.b, cls.c = \
            three_rev_fixture(cfg)

Esempio n. 47

File: _autogen_fixtures.py Progetto: yuriolive/alembic

 def setUp(self):
     staging_env()
     self.bind = config.db

Esempio n. 48

File: test_script_consumption.py Progetto: s132048/docs-korean-alembic

    def _opened_transaction_fixture(self):
        self.env = staging_env()
        self.cfg = _sqlite_testing_config()

        script = ScriptDirectory.from_config(self.cfg)
        a = util.rev_id()
        b = util.rev_id()
        c = util.rev_id()
        script.generate_revision(a, "revision a", refresh=True)
        write_script(
            script, a, """
"rev a"

revision = '%s'
down_revision = None

def upgrade():
    pass

def downgrade():
    pass

""" % (a, ))
        script.generate_revision(b, "revision b", refresh=True)
        write_script(
            script, b, """
"rev b"
revision = '%s'
down_revision = '%s'

from alembic import op


def upgrade():
    conn = op.get_bind()
    trans = conn.begin()


def downgrade():
    pass

""" % (b, a))
        script.generate_revision(c, "revision c", refresh=True)
        write_script(
            script, c, """
"rev c"
revision = '%s'
down_revision = '%s'

from alembic import op


def upgrade():
    pass


def downgrade():
    pass

""" % (c, b))
        return a, b, c

Esempio n. 49

File: test_script_production.py Progetto: tailhook/alembic

 def setUp(self):
     staging_env()
     self.cfg = _no_sql_testing_config(
         directives="\nrevision_environment=true\n")