def test_ignores_extension_functions(engine) -> None: # Extensions contain functions and don't have local representations # Unless they are excluded, every autogenerate migration will produce # drop statements for those functions try: engine.execute("create extension if not exists unaccent;") register_entities([], schemas=["public"]) run_alembic_command( engine=engine, command="revision", command_kwargs={ "autogenerate": True, "rev_id": "1", "message": "no_drops" }, ) migration_create_path = TEST_VERSIONS_ROOT / "1_no_drops.py" with migration_create_path.open() as migration_file: migration_contents = migration_file.read() assert "op.drop_entity" not in migration_contents finally: engine.execute("drop extension if exists unaccent;")
def test_update_revision(engine) -> None: # Create the view outside of a revision engine.execute(TEST_VIEW.to_sql_statement_create()) # Update definition of TO_UPPER UPDATED_TEST_VIEW = PGView( TEST_VIEW.schema, TEST_VIEW.signature, """select *, TRUE as is_updated from pg_views""" ) register_entities([UPDATED_TEST_VIEW]) # Autogenerate a new migration # It should detect the change we made and produce a "replace_function" statement output = run_alembic_command( engine=engine, command="revision", command_kwargs={"autogenerate": True, "rev_id": "2", "message": "replace"}, ) migration_replace_path = TEST_VERSIONS_ROOT / "2_replace.py" with migration_replace_path.open() as migration_file: migration_contents = migration_file.read() assert "op.replace_entity" in migration_contents assert "op.create_entity" not in migration_contents assert "op.drop_entity" not in migration_contents assert "from alembic_utils.pg_view import PGView" in migration_contents # Execute upgrade run_alembic_command(engine=engine, command="upgrade", command_kwargs={"revision": "head"}) # Execute Downgrade run_alembic_command(engine=engine, command="downgrade", command_kwargs={"revision": "base"})
def test_drop_revision(engine) -> None: # Register no functions locally register_entities([], schemas=["DEV"]) # Manually create a SQL function engine.execute(TEST_VIEW.to_sql_statement_create()) output = run_alembic_command( engine=engine, command="revision", command_kwargs={"autogenerate": True, "rev_id": "1", "message": "drop"}, ) migration_create_path = TEST_VERSIONS_ROOT / "1_drop.py" with migration_create_path.open() as migration_file: migration_contents = migration_file.read() # import pdb; pdb.set_trace() assert "op.drop_entity" in migration_contents assert "op.create_entity" in migration_contents assert "from alembic_utils" in migration_contents assert migration_contents.index("op.drop_entity") < migration_contents.index("op.create_entity") # Execute upgrade run_alembic_command(engine=engine, command="upgrade", command_kwargs={"revision": "head"}) # Execute Downgrade run_alembic_command(engine=engine, command="downgrade", command_kwargs={"revision": "base"})
def test_drop_fails_without_cascade(engine) -> None: engine.execute(A.to_sql_statement_create()) engine.execute(B_A.to_sql_statement_create()) register_entities([B_A], schemas=["DEV"], entity_types=[PGView]) output = run_alembic_command( engine=engine, command="revision", command_kwargs={ "autogenerate": True, "rev_id": "1", "message": "drop" }, ) migration_create_path = TEST_VERSIONS_ROOT / "1_drop.py" with migration_create_path.open() as migration_file: migration_contents = migration_file.read() assert "op.drop_entity" in migration_contents assert "op.create_entity" in migration_contents assert "from alembic_utils" in migration_contents assert migration_contents.index( "op.drop_entity") < migration_contents.index("op.create_entity") with pytest.raises(InternalError): # sqlalchemy.exc.InternalError: (psycopg2.errors.DependentObjectsStillExist) cannot drop view "A_view" because other objects depend on it run_alembic_command(engine=engine, command="upgrade", command_kwargs={"revision": "head"})
def test_noop_revision(sql_setup, engine) -> None: engine.execute(FUNC.to_sql_statement_create()) engine.execute(TRIG.to_sql_statement_create()) register_entities([FUNC, TRIG], entity_types=[PGTrigger]) output = run_alembic_command( engine=engine, command="revision", command_kwargs={ "autogenerate": True, "rev_id": "3", "message": "do_nothing" }, ) migration_do_nothing_path = TEST_VERSIONS_ROOT / "3_do_nothing.py" with migration_do_nothing_path.open() as migration_file: migration_contents = migration_file.read() assert "op.create_entity" not in migration_contents assert "op.drop_entity" not in migration_contents assert "op.replace_entity" not in migration_contents assert "from alembic_utils" not in migration_contents # Execute upgrade run_alembic_command(engine=engine, command="upgrade", command_kwargs={"revision": "head"}) # Execute Downgrade run_alembic_command(engine=engine, command="downgrade", command_kwargs={"revision": "base"})
def test_drop(sql_setup, engine) -> None: # Manually create a SQL function engine.execute(FUNC.to_sql_statement_create()) engine.execute(TRIG.to_sql_statement_create()) # Register no functions locally register_entities([], schemas=["public"], entity_types=[PGTrigger]) run_alembic_command( engine=engine, command="revision", command_kwargs={ "autogenerate": True, "rev_id": "1", "message": "drop" }, ) migration_create_path = TEST_VERSIONS_ROOT / "1_drop.py" with migration_create_path.open() as migration_file: migration_contents = migration_file.read() assert "op.drop_entity" in migration_contents assert "op.create_entity" in migration_contents assert "from alembic_utils" in migration_contents assert migration_contents.index( "op.drop_entity") < migration_contents.index("op.create_entity")
def test_create_revision(engine) -> None: register_entities([TEST_VIEW], entity_types=[PGView]) output = run_alembic_command( engine=engine, command="revision", command_kwargs={ "autogenerate": True, "rev_id": "1", "message": "create" }, ) migration_create_path = TEST_VERSIONS_ROOT / "1_create.py" with migration_create_path.open() as migration_file: migration_contents = migration_file.read() assert "op.create_entity" in migration_contents assert "op.drop_entity" in migration_contents assert "op.replace_entity" not in migration_contents assert "from alembic_utils.pg_view import PGView" in migration_contents # Execute upgrade run_alembic_command(engine=engine, command="upgrade", command_kwargs={"revision": "head"}) # Execute Downgrade run_alembic_command(engine=engine, command="downgrade", command_kwargs={"revision": "base"})
def test_migration_create_function(engine) -> None: register_entities([TO_UPPER, TO_UPPER], entity_types=[PGFunction]) with pytest.raises(DuplicateRegistration): run_alembic_command( engine=engine, command="revision", command_kwargs={"autogenerate": True, "rev_id": "1", "message": "raise"}, )
def test_update_revision(engine, schema_setup) -> None: # Create the view outside of a revision engine.execute(TEST_POLICY.to_sql_statement_create()) # Update definition of TO_UPPER UPDATED_TEST_POLICY = PGPolicy( schema=TEST_POLICY.schema, signature=TEST_POLICY.signature, on_entity=TEST_POLICY.on_entity, definition=""" for update to anon_user using (true); """, ) register_entities([UPDATED_TEST_POLICY], entity_types=[PGPolicy]) # Autogenerate a new migration # It should detect the change we made and produce a "replace_function" statement output = run_alembic_command( engine=engine, command="revision", command_kwargs={ "autogenerate": True, "rev_id": "2", "message": "replace" }, ) migration_replace_path = TEST_VERSIONS_ROOT / "2_replace.py" with migration_replace_path.open() as migration_file: migration_contents = migration_file.read() assert "op.replace_entity" in migration_contents assert "op.create_entity" not in migration_contents assert "op.drop_entity" not in migration_contents assert "from alembic_utils.pg_policy import PGPolicy" in migration_contents # Execute upgrade run_alembic_command(engine=engine, command="upgrade", command_kwargs={"revision": "head"}) # Execute Downgrade run_alembic_command(engine=engine, command="downgrade", command_kwargs={"revision": "base"})
def test_update_is_unreachable(engine) -> None: # Updates are not possible. The only parameter that may change is # schema, and that will result in a drop and create due to schema # scoping assumptions made for all other entities # Create the view outside of a revision engine.execute(TEST_EXT.to_sql_statement_create()) UPDATED_TEST_EXT = PGExtension("DEV", TEST_EXT.signature) register_entities([UPDATED_TEST_EXT], schemas=["public", "DEV"], entity_types=[PGExtension]) # Autogenerate a new migration # It should detect the change we made and produce a "replace_function" statement output = run_alembic_command( engine=engine, command="revision", command_kwargs={"autogenerate": True, "rev_id": "2", "message": "replace"}, ) migration_replace_path = TEST_VERSIONS_ROOT / "2_replace.py" with migration_replace_path.open() as migration_file: migration_contents = migration_file.read() assert "op.replace_entity" not in migration_contents assert "from alembic_utils.pg_extension import PGExtension" in migration_contents
def test_update_create_or_replace_failover_to_drop_add(engine) -> None: # Create the view outside of a revision engine.execute(TEST_VIEW.to_sql_statement_create()) # Update definition of TO_UPPER # deleted columns from the beginning of the view. # this will fail a create or replace statemnt # psycopg2.errors.InvalidTableDefinition) cannot drop columns from view # and should fail over to drop and then replace (in plpgsql of `create_or_replace_entity` method # on pgview UPDATED_TEST_VIEW = PGView(TEST_VIEW.schema, TEST_VIEW.signature, """select TRUE as is_updated from pg_views""") register_entities([UPDATED_TEST_VIEW], entity_types=[PGView]) # Autogenerate a new migration # It should detect the change we made and produce a "replace_function" statement output = run_alembic_command( engine=engine, command="revision", command_kwargs={ "autogenerate": True, "rev_id": "2", "message": "replace" }, ) migration_replace_path = TEST_VERSIONS_ROOT / "2_replace.py" with migration_replace_path.open() as migration_file: migration_contents = migration_file.read() assert "op.replace_entity" in migration_contents assert "op.create_entity" not in migration_contents assert "op.drop_entity" not in migration_contents assert "from alembic_utils.pg_view import PGView" in migration_contents # Execute upgrade run_alembic_command(engine=engine, command="upgrade", command_kwargs={"revision": "head"}) # Execute Downgrade run_alembic_command(engine=engine, command="downgrade", command_kwargs={"revision": "base"})
def test_attempt_revision_on_unparsable(engine) -> None: BROKEN_VIEW = PGView(schema="public", signature="broken_view", definition="NOPE;") register_entities([BROKEN_VIEW], entity_types=[PGView]) # Reraise of psycopg2.errors.SyntaxError with pytest.raises(ProgrammingError): run_alembic_command( engine=engine, command="revision", command_kwargs={ "autogenerate": True, "rev_id": "1", "message": "create" }, )
def test_noop_revision(engine) -> None: # Create the view outside of a revision engine.execute(TEST_VIEW.to_sql_statement_create()) register_entities([TEST_VIEW]) # Create a third migration without making changes. # This should result in no create, drop or replace statements run_alembic_command(engine=engine, command="upgrade", command_kwargs={"revision": "head"}) output = run_alembic_command( engine=engine, command="revision", command_kwargs={"autogenerate": True, "rev_id": "3", "message": "do_nothing"}, ) migration_do_nothing_path = TEST_VERSIONS_ROOT / "3_do_nothing.py" with migration_do_nothing_path.open() as migration_file: migration_contents = migration_file.read() assert "op.create_entity" not in migration_contents assert "op.drop_entity" not in migration_contents assert "op.replace_entity" not in migration_contents assert "from alembic_utils" not in migration_contents # Execute upgrade run_alembic_command(engine=engine, command="upgrade", command_kwargs={"revision": "head"}) # Execute Downgrade run_alembic_command(engine=engine, command="downgrade", command_kwargs={"revision": "base"})
def test_drop_fails_with_cascade(engine, sess) -> None: engine.execute(A.to_sql_statement_create()) engine.execute(B_A.to_sql_statement_create()) register_entities([B_A], schemas=["DEV"], entity_types=[PGView]) output = run_alembic_command( engine=engine, command="revision", command_kwargs={ "autogenerate": True, "rev_id": "1", "message": "drop" }, ) migration_create_path = TEST_VERSIONS_ROOT / "1_drop.py" with migration_create_path.open() as migration_file: migration_contents = migration_file.read() assert "op.drop_entity" in migration_contents assert "op.drop_entity(public_a_view)" in migration_contents migration_contents = migration_contents.replace( "op.drop_entity(public_a_view)", "op.drop_entity(public_a_view, cascade=True)") with migration_create_path.open("w") as migration_file: migration_file.write(migration_contents) assert "op.create_entity" in migration_contents assert "from alembic_utils" in migration_contents assert migration_contents.index( "op.drop_entity") < migration_contents.index("op.create_entity") # Cascade drops *B_A* and succeeds run_alembic_command(engine=engine, command="upgrade", command_kwargs={"revision": "head"}) # Make sure the drop ocurred all_views = PGView.from_database(sess, "public") assert len(all_views) == 0
def test_migration_create_function(engine) -> None: to_upper1 = to_upper() to_upper2 = to_upper() register_entities([to_upper1, to_upper2], entity_types=[PGFunction]) entities = registry.entities() assert len(entities) == 1 assert entities[0] == to_upper2 run_alembic_command( engine=engine, command="revision", command_kwargs={ "autogenerate": True, "rev_id": "1", "message": "raise" }, )
def test_create_revision(sql_setup, engine) -> None: engine.execute(FUNC.to_sql_statement_create()) register_entities([FUNC, TRIG], entity_types=[PGTrigger]) run_alembic_command( engine=engine, command="revision", command_kwargs={ "autogenerate": True, "rev_id": "1", "message": "create" }, ) migration_create_path = TEST_VERSIONS_ROOT / "1_create.py" with migration_create_path.open() as migration_file: migration_contents = migration_file.read() assert "op.create_entity" in migration_contents # Make sure #is_constraint flag was populated assert "is_constraint" in migration_contents assert "op.drop_entity" in migration_contents assert "op.replace_entity" not in migration_contents assert "from alembic_utils.pg_trigger import PGTrigger" in migration_contents # Execute upgrade run_alembic_command(engine=engine, command="upgrade", command_kwargs={"revision": "head"}) # Execute Downgrade run_alembic_command(engine=engine, command="downgrade", command_kwargs={"revision": "base"})
def test_replace_revision(sql_setup, engine) -> None: engine.execute(TEST_GRANT.to_sql_statement_create()) UPDATED_GRANT = PGGrantTable( schema="public", table="account", columns=["id"], role="anon_user", grant=Grant.SELECT, with_grant_option=True, ) register_entities([UPDATED_GRANT], entity_types=[PGGrantTable]) run_alembic_command( engine=engine, command="revision", command_kwargs={"autogenerate": True, "rev_id": "2", "message": "update"}, ) migration_create_path = TEST_VERSIONS_ROOT / "2_update.py" with migration_create_path.open() as migration_file: migration_contents = migration_file.read() # Granting can not be done in place. assert "op.replace_entity" in migration_contents assert "op.create_entity" not in migration_contents assert "op.drop_entity" not in migration_contents assert "from alembic_utils.pg_grant_table import PGGrantTable" in migration_contents # Execute upgrade run_alembic_command(engine=engine, command="upgrade", command_kwargs={"revision": "head"}) # Execute Downgrade run_alembic_command(engine=engine, command="downgrade", command_kwargs={"revision": "base"})
def test_view_contains_colon(engine) -> None: TEST_SEMI_VIEW = PGView( schema="public", signature="sample", definition="select ':' as myfield, '1'::int as othi", ) # NOTE: if a definition contains something that looks like a bind parameter e.g. :a # an exception is raised. This test confirms that non-bind-parameter usage of colon # is a non-issue register_entities([TEST_SEMI_VIEW], entity_types=[PGView]) output = run_alembic_command( engine=engine, command="revision", command_kwargs={ "autogenerate": True, "rev_id": "1", "message": "create" }, ) migration_create_path = TEST_VERSIONS_ROOT / "1_create.py" with migration_create_path.open() as migration_file: migration_contents = migration_file.read() assert "op.create_entity" in migration_contents assert "op.drop_entity" in migration_contents assert "op.replace_entity" not in migration_contents assert "from alembic_utils.pg_view import PGView" in migration_contents # Execute upgrade run_alembic_command(engine=engine, command="upgrade", command_kwargs={"revision": "head"}) # Execute Downgrade run_alembic_command(engine=engine, command="downgrade", command_kwargs={"revision": "base"})
def test_create_revision(engine) -> None: register_entities([TO_FLOAT_FROM_INT, TO_FLOAT_FROM_TEXT], entity_types=[PGFunction]) run_alembic_command( engine=engine, command="revision", command_kwargs={ "autogenerate": True, "rev_id": "1", "message": "create" }, ) migration_create_path = TEST_VERSIONS_ROOT / "1_create.py" with migration_create_path.open() as migration_file: migration_contents = migration_file.read() assert migration_contents.count("op.create_entity") == 2 assert "op.drop_entity" in migration_contents assert "op.replace_entity" not in migration_contents assert "from alembic_utils.pg_function import PGFunction" in migration_contents # Execute upgrade run_alembic_command(engine=engine, command="upgrade", command_kwargs={"revision": "head"}) # Execute Downgrade run_alembic_command(engine=engine, command="downgrade", command_kwargs={"revision": "base"})
def test_create_revision_with_url_w_colon(engine) -> None: """Ensure no regression where views escape colons More info at: https://github.com/olirice/alembic_utils/issues/58 """ url = "https://something/" query = f"SELECT concat('{url}', v::text) FROM generate_series(1,2) x(v)" some_view = PGView(schema="public", signature="exa", definition=query) register_entities([some_view], entity_types=[PGView]) output = run_alembic_command( engine=engine, command="revision", command_kwargs={ "autogenerate": True, "rev_id": "1", "message": "create" }, ) migration_create_path = TEST_VERSIONS_ROOT / "1_create.py" with migration_create_path.open() as migration_file: migration_contents = migration_file.read() assert url in migration_contents assert "op.create_entity" in migration_contents assert "op.drop_entity" in migration_contents assert "op.replace_entity" not in migration_contents assert "from alembic_utils.pg_view import PGView" in migration_contents # Execute upgrade run_alembic_command(engine=engine, command="upgrade", command_kwargs={"revision": "head"}) # Execute Downgrade run_alembic_command(engine=engine, command="downgrade", command_kwargs={"revision": "base"})
def test_view_contains_semicolon(engine) -> None: TEST_SEMI_VIEW = PGView( schema="public", signature="sample", definition="select ':a' as myfield, '1'::int as othi") register_entities([TEST_SEMI_VIEW], entity_types=[PGView]) output = run_alembic_command( engine=engine, command="revision", command_kwargs={ "autogenerate": True, "rev_id": "1", "message": "create" }, ) migration_create_path = TEST_VERSIONS_ROOT / "1_create.py" with migration_create_path.open() as migration_file: migration_contents = migration_file.read() assert "op.create_entity" in migration_contents assert "op.drop_entity" in migration_contents assert "op.replace_entity" not in migration_contents assert "from alembic_utils.pg_view import PGView" in migration_contents # Execute upgrade run_alembic_command(engine=engine, command="upgrade", command_kwargs={"revision": "head"}) # Execute Downgrade run_alembic_command(engine=engine, command="downgrade", command_kwargs={"revision": "base"})
def test_migration_create_function(engine, reset: None) -> None: register_entities([TO_UPPER]) output = run_alembic_command( engine=engine, command="revision", command_kwargs={"autogenerate": True, "rev_id": "1", "message": "create"}, ) migration_create_path = TEST_VERSIONS_ROOT / "1_create.py" with migration_create_path.open() as migration_file: migration_contents = migration_file.read() assert migration_contents.count("op.create_entity") == 1 assert migration_contents.count("op.drop_entity") == 1 assert migration_contents.count("from alembic_utils") == 1
def test_plpgsql_colon_esacpe(engine) -> None: # PGFunction.__init__ overrides colon escapes for plpgsql # because := should not be escaped for sqlalchemy.text # if := is escaped, an exception would be raised PLPGSQL_FUNC = PGFunction( schema="public", signature="some_func(some_text text)", definition=""" returns text as $$ declare copy_o_text text; begin copy_o_text := some_text; return copy_o_text; end; $$ language plpgsql """, ) register_entities([PLPGSQL_FUNC], entity_types=[PGFunction]) run_alembic_command( engine=engine, command="revision", command_kwargs={ "autogenerate": True, "rev_id": "1", "message": "create" }, ) migration_create_path = TEST_VERSIONS_ROOT / "1_create.py" with migration_create_path.open() as migration_file: migration_contents = migration_file.read() assert "op.create_entity" in migration_contents assert "op.drop_entity" in migration_contents assert "op.replace_entity" not in migration_contents assert "from alembic_utils.pg_function import PGFunction" in migration_contents # Execute upgrade run_alembic_command(engine=engine, command="upgrade", command_kwargs={"revision": "head"}) # Execute Downgrade run_alembic_command(engine=engine, command="downgrade", command_kwargs={"revision": "base"})
def test_update_revision(engine) -> None: engine.execute(TO_FLOAT_FROM_INT.to_sql_statement_create()) engine.execute(TO_FLOAT_FROM_TEXT.to_sql_statement_create()) UPDATE = PGFunction( schema="public", signature="to_float(x integer)", definition=""" returns float as $$ select x::text::float $$ language SQL; """, ) register_entities([UPDATE, TO_FLOAT_FROM_TEXT], entity_types=[PGFunction]) # Autogenerate a new migration # It should detect the change we made and produce a "replace_function" statement run_alembic_command( engine=engine, command="revision", command_kwargs={ "autogenerate": True, "rev_id": "2", "message": "replace" }, ) migration_replace_path = TEST_VERSIONS_ROOT / "2_replace.py" with migration_replace_path.open() as migration_file: migration_contents = migration_file.read() # One up and one down assert migration_contents.count("op.replace_entity") == 2 assert "op.create_entity" not in migration_contents assert "op.drop_entity" not in migration_contents assert "from alembic_utils.pg_function import PGFunction" in migration_contents # Execute upgrade run_alembic_command(engine=engine, command="upgrade", command_kwargs={"revision": "head"}) # Execute Downgrade run_alembic_command(engine=engine, command="downgrade", command_kwargs={"revision": "base"})
def test_trig_update_revision(sql_setup, engine) -> None: engine.execute(FUNC.to_sql_statement_create()) engine.execute(TRIG.to_sql_statement_create()) UPDATED_TRIG = PGTrigger( schema="public", signature="lower_account_email", on_entity="public.account", is_constraint=True, definition=""" AFTER INSERT OR UPDATE ON public.account FOR EACH ROW EXECUTE PROCEDURE public.downcase_email() """, ) register_entities([FUNC, UPDATED_TRIG], entity_types=[PGTrigger]) # Autogenerate a new migration # It should detect the change we made and produce a "replace_function" statement run_alembic_command( engine=engine, command="revision", command_kwargs={ "autogenerate": True, "rev_id": "2", "message": "replace" }, ) migration_replace_path = TEST_VERSIONS_ROOT / "2_replace.py" with migration_replace_path.open() as migration_file: migration_contents = migration_file.read() assert "op.replace_entity" in migration_contents assert "op.create_entity" not in migration_contents assert "op.drop_entity" not in migration_contents assert "from alembic_utils.pg_trigger import PGTrigger" in migration_contents # Execute upgrade run_alembic_command(engine=engine, command="upgrade", command_kwargs={"revision": "head"}) # Execute Downgrade run_alembic_command(engine=engine, command="downgrade", command_kwargs={"revision": "base"})
def test_update_revision(engine) -> None: engine.execute(TO_UPPER.to_sql_statement_create()) # Update definition of TO_UPPER UPDATED_TO_UPPER = PGFunction( TO_UPPER.schema, TO_UPPER.signature, r'''returns text as $$ select upper(some_text) || 'def' -- """ \n \\ $$ language SQL immutable strict;''', ) register_entities([UPDATED_TO_UPPER]) # Autogenerate a new migration # It should detect the change we made and produce a "replace_function" statement run_alembic_command( engine=engine, command="revision", command_kwargs={ "autogenerate": True, "rev_id": "2", "message": "replace" }, ) migration_replace_path = TEST_VERSIONS_ROOT / "2_replace.py" with migration_replace_path.open() as migration_file: migration_contents = migration_file.read() assert "op.replace_entity" in migration_contents assert "op.create_entity" not in migration_contents assert "op.drop_entity" not in migration_contents assert "from alembic_utils.pg_function import PGFunction" in migration_contents # Execute upgrade run_alembic_command(engine=engine, command="upgrade", command_kwargs={"revision": "head"}) # Execute Downgrade run_alembic_command(engine=engine, command="downgrade", command_kwargs={"revision": "base"})
def test_has_no_parameters(engine) -> None: # Error was occuring in drop statement when function had no parameters # related to parameter parsing to drop default statements SIDE_EFFECT = PGFunction( schema="public", signature="side_effect()", definition=""" returns integer as $$ select 1; $$ language SQL; """, ) # Register no functions locally register_entities([SIDE_EFFECT], schemas=["public"], entity_types=[PGFunction]) run_alembic_command( engine=engine, command="revision", command_kwargs={ "autogenerate": True, "rev_id": "1", "message": "no_arguments" }, ) migration_create_path = TEST_VERSIONS_ROOT / "1_no_arguments.py" with migration_create_path.open() as migration_file: migration_contents = migration_file.read() assert "op.drop_entity" in migration_contents # Execute upgrade run_alembic_command(engine=engine, command="upgrade", command_kwargs={"revision": "head"}) # Execute Downgrade run_alembic_command(engine=engine, command="downgrade", command_kwargs={"revision": "base"})
def test_create_revision_with_filters(engine) -> None: for entity in reflected_entities: engine.execute(entity.to_sql_statement_create()) register_entities(registered_entities) run_alembic_command( engine=engine, command="revision", command_kwargs={ "autogenerate": True, "rev_id": "1", "message": "filtered_upgrade" }, ) migration_create_path = TEST_VERSIONS_ROOT / "1_filtered_upgrade.py" with migration_create_path.open() as migration_file: migration_contents = migration_file.read() assert "op.create_entity(public_a_view)" in migration_contents assert "op.create_entity(public_toupper)" in migration_contents assert "op.drop_entity(public_reflected_view)" in migration_contents assert "op.drop_entity(public_reflected_toupper)" in migration_contents assert not "op.create_entity(public_exclude_obj_view)" in migration_contents assert not "op.create_entity(public_exclude_obj_toupper)" in migration_contents assert not "op.drop_entity(public_exclude_name_reflected_view)" in migration_contents assert not "op.drop_entity(public_exclude_obj_reflected_toupper)" in migration_contents # Execute upgrade run_alembic_command(engine=engine, command="upgrade", command_kwargs={"revision": "head"}) # Execute Downgrade run_alembic_command(engine=engine, command="downgrade", command_kwargs={"revision": "base"})
def test_current(engine) -> None: """Test that the alembic current command does not erorr""" # Runs with no error output = run_alembic_command(engine, "current", {}) assert output == ""