def _fixture(self, m1, m2, include_schemas=False):
self.metadata, model_metadata = m1, m2
self.metadata.create_all(self.bind)
with self.bind.connect() as conn:
self.context = context = MigrationContext.configure(
connection=conn,
opts={
'compare_type': True,
'compare_server_default': True,
'target_metadata': model_metadata,
'upgrade_token': "upgrades",
'downgrade_token': "downgrades",
'alembic_module_prefix': 'op.',
'sqlalchemy_module_prefix': 'sa.',
}
)
connection = context.bind
autogen_context = {
'imports': set(),
'connection': connection,
'dialect': connection.dialect,
'context': context
}
diffs = []
autogenerate._produce_net_changes(connection, model_metadata, diffs,
autogen_context,
object_filters=_default_object_filters,
include_schemas=include_schemas
)
return diffs
def _fixture(
self, m1, m2, include_schemas=False,
opts=None, object_filters=_default_object_filters):
self.metadata, model_metadata = m1, m2
self.metadata.create_all(self.bind)
with self.bind.connect() as conn:
ctx_opts = {
'compare_type': True,
'compare_server_default': True,
'target_metadata': model_metadata,
'upgrade_token': "upgrades",
'downgrade_token': "downgrades",
'alembic_module_prefix': 'op.',
'sqlalchemy_module_prefix': 'sa.',
'include_object': object_filters,
'include_schemas': include_schemas
}
if opts:
ctx_opts.update(opts)
self.context = context = MigrationContext.configure(
connection=conn,
opts=ctx_opts
)
autogen_context = api.AutogenContext(context, model_metadata)
uo = ops.UpgradeOps(ops=[])
autogenerate._produce_net_changes(
autogen_context, uo
)
return uo.as_diffs()
def test_uses_custom_compare_type_function(self):
my_compare_type = mock.Mock()
self.context._user_compare_type = my_compare_type
uo = ops.UpgradeOps(ops=[])
ctx = self.autogen_context
autogenerate._produce_net_changes(ctx, uo)
first_table = self.m2.tables["sometable"]
first_column = first_table.columns["id"]
eq_(len(my_compare_type.mock_calls), 2)
# We'll just test the first call
_, args, _ = my_compare_type.mock_calls[0]
(
context,
inspected_column,
metadata_column,
inspected_type,
metadata_type,
) = args
eq_(context, self.context)
eq_(metadata_column, first_column)
eq_(metadata_type, first_column.type)
eq_(inspected_column.name, first_column.name)
eq_(type(inspected_type), INTEGER)
def test_uses_custom_compare_type_function(self):
my_compare_type = Mock()
self.context._user_compare_type = my_compare_type
uo = ops.UpgradeOps(ops=[])
ctx = self.autogen_context
autogenerate._produce_net_changes(ctx, uo)
first_table = self.m2.tables["sometable"]
first_column = first_table.columns["id"]
eq_(len(my_compare_type.mock_calls), 2)
# We'll just test the first call
_, args, _ = my_compare_type.mock_calls[0]
(
context,
inspected_column,
metadata_column,
inspected_type,
metadata_type,
) = args
eq_(context, self.context)
eq_(metadata_column, first_column)
eq_(metadata_type, first_column.type)
eq_(inspected_column.name, first_column.name)
eq_(type(inspected_type), INTEGER)
def _fixture(self,
m1,
m2,
include_schemas=False,
opts=None,
object_filters=_default_object_filters):
self.metadata, model_metadata = m1, m2
self.metadata.create_all(self.bind)
with self.bind.connect() as conn:
ctx_opts = {
'compare_type': True,
'compare_server_default': True,
'target_metadata': model_metadata,
'upgrade_token': "upgrades",
'downgrade_token': "downgrades",
'alembic_module_prefix': 'op.',
'sqlalchemy_module_prefix': 'sa.',
'include_object': object_filters,
'include_schemas': include_schemas
}
if opts:
ctx_opts.update(opts)
self.context = context = MigrationContext.configure(
connection=conn, opts=ctx_opts)
autogen_context = api.AutogenContext(context, model_metadata)
uo = ops.UpgradeOps(ops=[])
autogenerate._produce_net_changes(autogen_context, uo)
return uo.as_diffs()
def test_diffs(self):
"""test generation of diff rules"""
metadata = self.m2
connection = self.context.bind
diffs = []
autogenerate._produce_net_changes(
connection,
metadata,
diffs,
self.autogen_context,
object_filters=_default_object_filters,
include_schemas=True)
eq_(diffs[0], ('add_table', metadata.tables['%s.item' % self.schema]))
eq_(diffs[1][0], 'remove_table')
eq_(diffs[1][1].name, "extra")
eq_(diffs[2][0], "add_column")
eq_(diffs[2][1], self.schema)
eq_(diffs[2][2], "address")
eq_(diffs[2][3], metadata.tables['%s.address' % self.schema].c.street)
eq_(diffs[3][0], "add_constraint")
eq_(diffs[3][1].name, "uq_email")
eq_(diffs[4][0], "add_column")
eq_(diffs[4][1], self.schema)
eq_(diffs[4][2], "order")
eq_(diffs[4][3], metadata.tables['%s.order' % self.schema].c.user_id)
eq_(diffs[5][0][0], "modify_type")
eq_(diffs[5][0][1], self.schema)
eq_(diffs[5][0][2], "order")
eq_(diffs[5][0][3], "amount")
eq_(repr(diffs[5][0][5]), "NUMERIC(precision=8, scale=2)")
eq_(repr(diffs[5][0][6]), "Numeric(precision=10, scale=2)")
self._assert_fk_diff(diffs[6],
"add_fk",
"order", ["user_id"],
"user", ["id"],
source_schema=config.test_schema)
eq_(diffs[7][0][0], "modify_default")
eq_(diffs[7][0][1], self.schema)
eq_(diffs[7][0][2], "user")
eq_(diffs[7][0][3], "a1")
eq_(diffs[7][0][6].arg, "x")
eq_(diffs[8][0][0], 'modify_nullable')
eq_(diffs[8][0][5], True)
eq_(diffs[8][0][6], False)
eq_(diffs[9][0], 'remove_index')
eq_(diffs[9][1].name, 'pw_idx')
eq_(diffs[10][0], 'remove_column')
eq_(diffs[10][3].name, 'pw')
def test_no_version_table(self):
diffs = []
ctx = self.autogen_context.copy()
ctx['metadata'] = self.m2
autogenerate._produce_net_changes(ctx, diffs)
eq_(diffs, [])
def _fixture(self, m1, m2):
self.metadata, model_metadata = m1, m2
self.metadata.create_all(self.bind)
with self.bind.connect() as conn:
self.context = context = MigrationContext.configure(
connection=conn,
opts={
'compare_type': True,
'compare_server_default': True,
'target_metadata': model_metadata,
'upgrade_token': "upgrades",
'downgrade_token': "downgrades",
'alembic_module_prefix': 'op.',
'sqlalchemy_module_prefix': 'sa.',
})
connection = context.bind
autogen_context = {
'imports': set(),
'connection': connection,
'dialect': connection.dialect,
'context': context
}
diffs = []
autogenerate._produce_net_changes(
connection,
model_metadata,
diffs,
autogen_context,
object_filters=_default_object_filters,
)
return diffs
def test_version_table_in_target(self):
Table(
self.version_table_name,
self.m2, Column('x', Integer), schema=self.version_table_schema)
ctx = self.autogen_context
uo = ops.UpgradeOps(ops=[])
autogenerate._produce_net_changes(ctx, uo)
eq_(uo.as_diffs(), [])
def test_version_table_in_target(self):
Table(
self.version_table_name,
self.m2, Column('x', Integer), schema=self.version_table_schema)
ctx = self.autogen_context
uo = ops.UpgradeOps(ops=[])
autogenerate._produce_net_changes(ctx, uo)
eq_(uo.as_diffs(), [])
def test_no_change(self):
metadata = self.m2
connection = self.context.bind
diffs = []
autogenerate._produce_net_changes(connection, metadata, diffs,
self.autogen_context)
eq_(diffs, [])
def test_version_table_in_target(self):
diffs = []
Table(
self.version_table_name,
self.m2, Column('x', Integer), schema=self.version_table_schema)
autogenerate._produce_net_changes(self.context.bind, self.m2,
diffs, self.autogen_context)
eq_(diffs, [])
def test_diffs(self):
"""test generation of diff rules"""
metadata = self.m2
connection = self.context.bind
diffs = []
autogenerate._produce_net_changes(
connection, metadata, diffs,
self.autogen_context,
object_filters=_default_object_filters,
include_schemas=True
)
eq_(
diffs[0],
('add_table', metadata.tables['%s.item' % self.schema])
)
eq_(diffs[1][0], 'remove_table')
eq_(diffs[1][1].name, "extra")
eq_(diffs[2][0], "add_column")
eq_(diffs[2][1], self.schema)
eq_(diffs[2][2], "address")
eq_(diffs[2][3], metadata.tables['%s.address' % self.schema].c.street)
eq_(diffs[3][0], "add_constraint")
eq_(diffs[3][1].name, "uq_email")
eq_(diffs[4][0], "add_column")
eq_(diffs[4][1], self.schema)
eq_(diffs[4][2], "order")
eq_(diffs[4][3], metadata.tables['%s.order' % self.schema].c.user_id)
eq_(diffs[5][0][0], "modify_type")
eq_(diffs[5][0][1], self.schema)
eq_(diffs[5][0][2], "order")
eq_(diffs[5][0][3], "amount")
eq_(repr(diffs[5][0][5]), "NUMERIC(precision=8, scale=2)")
eq_(repr(diffs[5][0][6]), "Numeric(precision=10, scale=2)")
eq_(diffs[6][0][0], "modify_default")
eq_(diffs[6][0][1], self.schema)
eq_(diffs[6][0][2], "user")
eq_(diffs[6][0][3], "a1")
eq_(diffs[6][0][6].arg, "x")
eq_(diffs[7][0][0], 'modify_nullable')
eq_(diffs[7][0][5], True)
eq_(diffs[7][0][6], False)
eq_(diffs[8][0], 'remove_index')
eq_(diffs[8][1].name, 'pw_idx')
eq_(diffs[9][0], 'remove_column')
eq_(diffs[9][3].name, 'pw')
def test_diffs(self):
"""test generation of diff rules"""
metadata = self.m2
uo = ops.UpgradeOps(ops=[])
ctx = self.autogen_context
autogenerate._produce_net_changes(ctx, uo)
diffs = uo.as_diffs()
eq_(diffs[0], ("add_table", metadata.tables["item"]))
eq_(diffs[1][0], "remove_table")
eq_(diffs[1][1].name, "extra")
eq_(diffs[2][0], "add_column")
eq_(diffs[2][1], None)
eq_(diffs[2][2], "address")
eq_(diffs[2][3], metadata.tables["address"].c.street)
eq_(diffs[3][0], "add_constraint")
eq_(diffs[3][1].name, "uq_email")
eq_(diffs[4][0], "add_column")
eq_(diffs[4][1], None)
eq_(diffs[4][2], "order")
eq_(diffs[4][3], metadata.tables["order"].c.user_id)
eq_(diffs[5][0][0], "modify_type")
eq_(diffs[5][0][1], None)
eq_(diffs[5][0][2], "order")
eq_(diffs[5][0][3], "amount")
eq_(repr(diffs[5][0][5]), "NUMERIC(precision=8, scale=2)")
eq_(repr(diffs[5][0][6]), "Numeric(precision=10, scale=2)")
self._assert_fk_diff(
diffs[6], "add_fk", "order", ["user_id"], "user", ["id"]
)
eq_(diffs[7][0][0], "modify_default")
eq_(diffs[7][0][1], None)
eq_(diffs[7][0][2], "user")
eq_(diffs[7][0][3], "a1")
eq_(diffs[7][0][6].arg, "x")
eq_(diffs[8][0][0], "modify_nullable")
eq_(diffs[8][0][5], True)
eq_(diffs[8][0][6], False)
eq_(diffs[9][0], "remove_index")
eq_(diffs[9][1].name, "pw_idx")
eq_(diffs[10][0], "remove_column")
eq_(diffs[10][3].name, "pw")
eq_(diffs[10][3].table.name, "user")
assert isinstance(diffs[10][3].type, String)
def test_column_type_not_modified_when_custom_compare_type_returns_False(self):
my_compare_type = Mock()
my_compare_type.return_value = False
self.context._user_compare_type = my_compare_type
diffs = []
autogenerate._produce_net_changes(self.context.bind, self.m2,
diffs, self.autogen_context)
eq_(diffs, [])
def test_version_table_in_target(self):
diffs = []
Table(
self.version_table_name,
self.m2, Column('x', Integer), schema=self.version_table_schema)
ctx = self.autogen_context.copy()
ctx['metadata'] = self.m2
autogenerate._produce_net_changes(ctx, diffs)
eq_(diffs, [])
def test_version_table_in_target(self):
diffs = []
Table(self.version_table_name,
self.m2,
Column('x', Integer),
schema=self.version_table_schema)
ctx = self.autogen_context
autogenerate._produce_net_changes(ctx, diffs)
eq_(diffs, [])
def test_column_type_not_modified_custom_compare_type_returns_False(self):
my_compare_type = Mock()
my_compare_type.return_value = False
self.context._user_compare_type = my_compare_type
diffs = []
autogenerate._produce_net_changes(self.context.bind, self.m2,
diffs, self.autogen_context)
eq_(diffs, [])
def test_no_change(self):
metadata = self.m2
connection = self.context.bind
diffs = []
autogenerate._produce_net_changes(connection, metadata, diffs,
self.autogen_context
)
eq_(diffs, [])
def _fixture(
self,
m1,
m2,
include_schemas=False,
opts=None,
object_filters=_default_object_filters,
name_filters=_default_name_filters,
return_ops=False,
max_identifier_length=None,
):
if max_identifier_length:
dialect = self.bind.dialect
existing_length = dialect.max_identifier_length
dialect.max_identifier_length = (
dialect._user_defined_max_identifier_length
) = max_identifier_length
try:
self._alembic_metadata, model_metadata = m1, m2
for m in util.to_list(self._alembic_metadata):
m.create_all(self.bind)
with self.bind.connect() as conn:
ctx_opts = {
"compare_type": True,
"compare_server_default": True,
"target_metadata": model_metadata,
"upgrade_token": "upgrades",
"downgrade_token": "downgrades",
"alembic_module_prefix": "op.",
"sqlalchemy_module_prefix": "sa.",
"include_object": object_filters,
"include_name": name_filters,
"include_schemas": include_schemas,
}
if opts:
ctx_opts.update(opts)
self.context = context = MigrationContext.configure(
connection=conn, opts=ctx_opts)
autogen_context = api.AutogenContext(context, model_metadata)
uo = ops.UpgradeOps(ops=[])
autogenerate._produce_net_changes(autogen_context, uo)
if return_ops:
return uo
else:
return uo.as_diffs()
finally:
if max_identifier_length:
dialect = self.bind.dialect
dialect.max_identifier_length = (
dialect._user_defined_max_identifier_length
) = existing_length
def test_alt_schema_included_downgrade(self):
metadata = self.m2
connection = self.context.bind
diffs = []
autogenerate._produce_net_changes(connection, metadata, diffs,
self.autogen_context,
include_symbol=lambda n, s: n == 't2',
include_schemas=True
)
eq_(diffs[0][0], "remove_table")
eq_(diffs[0][1].schema, self.test_schema_name)
def test_autogen(self):
diffs = []
ctx = self.autogen_context.copy()
ctx['metadata'] = self.m2
autogenerate._produce_net_changes(ctx, diffs)
eq_(diffs[0][0], "add_table")
eq_(diffs[0][1].name, "sometable")
eq_(diffs[1][0], "add_column")
eq_(diffs[1][3].key, "otherkey")
def test_default_schema_omitted_upgrade(self):
metadata = self.m2
connection = self.context.bind
diffs = []
autogenerate._produce_net_changes(connection, metadata, diffs,
self.autogen_context,
include_symbol=lambda n, s: n == 't3',
include_schemas=True
)
eq_(diffs[0][0], "add_table")
eq_(diffs[0][1].schema, None)
def test_autogen(self):
uo = ops.UpgradeOps(ops=[])
ctx = self.autogen_context
autogenerate._produce_net_changes(ctx, uo)
diffs = uo.as_diffs()
eq_(diffs[0][0], "add_table")
eq_(diffs[0][1].name, "sometable")
eq_(diffs[1][0], "add_column")
eq_(diffs[1][3].key, "otherkey")
def test_column_type_not_modified_custom_compare_type_returns_False(self):
my_compare_type = mock.Mock()
my_compare_type.return_value = False
self.context._user_compare_type = my_compare_type
diffs = []
ctx = self.autogen_context
diffs = []
autogenerate._produce_net_changes(ctx, diffs)
eq_(diffs, [])
def test_autogen(self):
uo = ops.UpgradeOps(ops=[])
ctx = self.autogen_context
autogenerate._produce_net_changes(ctx, uo)
diffs = uo.as_diffs()
eq_(diffs[0][0], "add_table")
eq_(diffs[0][1].name, "sometable")
eq_(diffs[1][0], "add_column")
eq_(diffs[1][3].key, "otherkey")
def test_column_type_modified_custom_compare_type_returns_True(self):
my_compare_type = Mock()
my_compare_type.return_value = True
self.context._user_compare_type = my_compare_type
diffs = []
autogenerate._produce_net_changes(self.context.bind, self.m2,
diffs, self.autogen_context)
eq_(diffs[0][0][0], 'modify_type')
eq_(diffs[1][0][0], 'modify_type')
def test_column_type_modified_when_custom_compare_type_returns_True(self):
my_compare_type = Mock()
my_compare_type.return_value = True
self.context._user_compare_type = my_compare_type
diffs = []
autogenerate._produce_net_changes(self.context.bind, self.m2, diffs,
self.autogen_context)
eq_(diffs[0][0][0], 'modify_type')
eq_(diffs[1][0][0], 'modify_type')
def test_column_type_modified_custom_compare_type_returns_True(self):
my_compare_type = Mock()
my_compare_type.return_value = True
self.context._user_compare_type = my_compare_type
ctx = self.autogen_context
uo = ops.UpgradeOps(ops=[])
autogenerate._produce_net_changes(ctx, uo)
diffs = uo.as_diffs()
eq_(diffs[0][0][0], 'modify_type')
eq_(diffs[1][0][0], 'modify_type')
def test_column_type_modified_custom_compare_type_returns_True(self):
my_compare_type = Mock()
my_compare_type.return_value = True
self.context._user_compare_type = my_compare_type
ctx = self.autogen_context
uo = ops.UpgradeOps(ops=[])
autogenerate._produce_net_changes(ctx, uo)
diffs = uo.as_diffs()
eq_(diffs[0][0][0], 'modify_type')
eq_(diffs[1][0][0], 'modify_type')
def test_column_type_not_modified_custom_compare_type_returns_False(self):
my_compare_type = Mock()
my_compare_type.return_value = False
self.context._user_compare_type = my_compare_type
diffs = []
ctx = self.autogen_context.copy()
ctx['metadata'] = self.m2
diffs = []
autogenerate._produce_net_changes(ctx, diffs)
eq_(diffs, [])
def test_column_type_modified_custom_compare_type_returns_True(self):
my_compare_type = Mock()
my_compare_type.return_value = True
self.context._user_compare_type = my_compare_type
ctx = self.autogen_context.copy()
ctx['metadata'] = self.m2
diffs = []
autogenerate._produce_net_changes(ctx, diffs)
eq_(diffs[0][0][0], 'modify_type')
eq_(diffs[1][0][0], 'modify_type')
def test_default_schema_omitted_upgrade(self):
metadata = self.m2
connection = self.context.bind
diffs = []
autogenerate._produce_net_changes(
connection,
metadata,
diffs,
self.autogen_context,
include_symbol=lambda n, s: n == 't3',
include_schemas=True)
eq_(diffs[0][0], "add_table")
eq_(diffs[0][1].schema, None)
def test_alt_schema_included_downgrade(self):
metadata = self.m2
connection = self.context.bind
diffs = []
autogenerate._produce_net_changes(
connection,
metadata,
diffs,
self.autogen_context,
include_symbol=lambda n, s: n == 't2',
include_schemas=True)
eq_(diffs[0][0], "remove_table")
eq_(diffs[0][1].schema, self.test_schema_name)
def test_diffs(self):
"""test generation of diff rules"""
metadata = self.m2
connection = self.context.bind
diffs = []
autogenerate._produce_net_changes(
connection,
metadata,
diffs,
self.autogen_context,
include_symbol=_default_include_symbol,
include_schemas=True)
eq_(diffs[0],
('add_table', metadata.tables['%s.item' % self.test_schema_name]))
eq_(diffs[1][0], 'remove_table')
eq_(diffs[1][1].name, "extra")
eq_(diffs[2][0], "add_column")
eq_(diffs[2][1], self.test_schema_name)
eq_(diffs[2][2], "address")
eq_(diffs[2][3],
metadata.tables['%s.address' % self.test_schema_name].c.street)
eq_(diffs[3][0], "add_column")
eq_(diffs[3][1], self.test_schema_name)
eq_(diffs[3][2], "order")
eq_(diffs[3][3],
metadata.tables['%s.order' % self.test_schema_name].c.user_id)
eq_(diffs[4][0][0], "modify_type")
eq_(diffs[4][0][1], self.test_schema_name)
eq_(diffs[4][0][2], "order")
eq_(diffs[4][0][3], "amount")
eq_(repr(diffs[4][0][5]), "NUMERIC(precision=8, scale=2)")
eq_(repr(diffs[4][0][6]), "Numeric(precision=10, scale=2)")
eq_(diffs[5][0], 'remove_column')
eq_(diffs[5][3].name, 'pw')
eq_(diffs[6][0][0], "modify_default")
eq_(diffs[6][0][1], self.test_schema_name)
eq_(diffs[6][0][2], "user")
eq_(diffs[6][0][3], "a1")
eq_(diffs[6][0][6].arg, "x")
eq_(diffs[7][0][0], 'modify_nullable')
eq_(diffs[7][0][5], True)
eq_(diffs[7][0][6], False)
def test_autogen(self):
metadata = self.m2
connection = self.context.bind
diffs = []
autogenerate._produce_net_changes(connection, metadata, diffs,
self.autogen_context,
include_schemas=False
)
eq_(diffs[0][0], "add_table")
eq_(diffs[0][1].name, "sometable")
eq_(diffs[1][0], "add_column")
eq_(diffs[1][3].key, "otherkey")
def test_alt_schema_included_downgrade(self):
def include_object(obj, name, type_, reflected, compare_to):
if type_ == "table":
return name == "t2"
else:
return True
self._update_context(object_filters=include_object,
include_schemas=True)
uo = ops.UpgradeOps(ops=[])
autogenerate._produce_net_changes(self.autogen_context, uo)
diffs = uo.as_diffs()
eq_(diffs[0][0], "remove_table")
eq_(diffs[0][1].schema, config.test_schema)
def test_autogen(self):
metadata = self.m2
connection = self.context.bind
diffs = []
autogenerate._produce_net_changes(connection, metadata, diffs,
self.autogen_context,
include_schemas=False
)
eq_(diffs[0][0], "add_table")
eq_(diffs[0][1].name, "sometable")
eq_(diffs[1][0], "add_column")
eq_(diffs[1][3].key, "otherkey")
def test_diffs(self):
"""test generation of diff rules"""
metadata = self.m2
connection = self.context.bind
diffs = []
autogenerate._produce_net_changes(connection, metadata, diffs,
self.autogen_context,
include_symbol= _default_include_symbol
)
eq_(
diffs[0],
('add_table', metadata.tables['item'])
)
eq_(diffs[1][0], 'remove_table')
eq_(diffs[1][1].name, "extra")
eq_(diffs[2][0], "add_column")
eq_(diffs[2][1], None)
eq_(diffs[2][2], "address")
eq_(diffs[2][3], metadata.tables['address'].c.street)
eq_(diffs[3][0], "add_column")
eq_(diffs[3][1], None)
eq_(diffs[3][2], "order")
eq_(diffs[3][3], metadata.tables['order'].c.user_id)
eq_(diffs[4][0][0], "modify_type")
eq_(diffs[4][0][1], None)
eq_(diffs[4][0][2], "order")
eq_(diffs[4][0][3], "amount")
eq_(repr(diffs[4][0][5]), "NUMERIC(precision=8, scale=2)")
eq_(repr(diffs[4][0][6]), "Numeric(precision=10, scale=2)")
eq_(diffs[5][0], 'remove_column')
eq_(diffs[5][3].name, 'pw')
eq_(diffs[6][0][0], "modify_default")
eq_(diffs[6][0][1], None)
eq_(diffs[6][0][2], "user")
eq_(diffs[6][0][3], "a1")
eq_(diffs[6][0][6].arg, "x")
eq_(diffs[7][0][0], 'modify_nullable')
eq_(diffs[7][0][5], True)
eq_(diffs[7][0][6], False)
def test_diffs_order(self):
"""
Added in order to test that child tables(tables with FKs) are generated
before their parent tables
"""
ctx = self.autogen_context
uo = ops.UpgradeOps(ops=[])
autogenerate._produce_net_changes(ctx, uo)
diffs = uo.as_diffs()
eq_(diffs[0][0], 'add_table')
eq_(diffs[0][1].name, "parent")
eq_(diffs[1][0], 'add_table')
eq_(diffs[1][1].name, "child")
def test_diffs_order(self):
"""
Added in order to test that child tables(tables with FKs) are generated
before their parent tables
"""
ctx = self.autogen_context
uo = ops.UpgradeOps(ops=[])
autogenerate._produce_net_changes(ctx, uo)
diffs = uo.as_diffs()
eq_(diffs[0][0], 'add_table')
eq_(diffs[0][1].name, "parent")
eq_(diffs[1][0], 'add_table')
eq_(diffs[1][1].name, "child")
def test_alt_schema_included_downgrade(self):
def include_object(obj, name, type_, reflected, compare_to):
if type_ == "table":
return name == "t2"
else:
return True
self._update_context(
object_filters=include_object, include_schemas=True
)
uo = ops.UpgradeOps(ops=[])
autogenerate._produce_net_changes(self.autogen_context, uo)
diffs = uo.as_diffs()
eq_(diffs[0][0], "remove_table")
eq_(diffs[0][1].schema, config.test_schema)
def test_diffs_order(self):
"""
Added in order to test that child tables(tables with FKs) are generated
before their parent tables
"""
ctx = self.autogen_context.copy()
ctx['metadata'] = self.m2
diffs = []
autogenerate._produce_net_changes(ctx, diffs)
eq_(diffs[0][0], 'add_table')
eq_(diffs[0][1].name, "parent")
eq_(diffs[1][0], 'add_table')
eq_(diffs[1][1].name, "child")
def test_alt_schema_included_downgrade(self):
diffs = []
def include_object(obj, name, type_, reflected, compare_to):
if type_ == "table":
return name == "t2"
else:
return True
self.autogen_context.update({
'object_filters': [include_object],
'include_schemas': True,
'metadata': self.m2
})
autogenerate._produce_net_changes(self.autogen_context, diffs)
eq_(diffs[0][0], "remove_table")
eq_(diffs[0][1].schema, config.test_schema)
def test_alt_schema_included_downgrade(self):
metadata = self.m2
connection = self.context.bind
diffs = []
def include_object(obj, name, type_, reflected, compare_to):
if type_ == "table":
return name == "t2"
else:
return True
autogenerate._produce_net_changes(connection, metadata, diffs,
self.autogen_context,
object_filters=[include_object],
include_schemas=True
)
eq_(diffs[0][0], "remove_table")
eq_(diffs[0][1].schema, self.test_schema_name)
def test_diffs_order(self):
"""
Added in order to test that child tables(tables with FKs) are generated
before their parent tables
"""
metadata = self.m4
connection = self.empty_context.bind
diffs = []
autogenerate._produce_net_changes(connection, metadata, diffs,
self.autogen_empty_context)
eq_(diffs[0][0], 'add_table')
eq_(diffs[0][1].name, "parent")
eq_(diffs[1][0], 'add_table')
eq_(diffs[1][1].name, "child")
def test_diffs_order(self):
"""
Added in order to test that child tables(tables with FKs) are generated
before their parent tables
"""
metadata = self.m4
connection = self.empty_context.bind
diffs = []
autogenerate._produce_net_changes(connection, metadata, diffs,
self.autogen_empty_context)
eq_(diffs[0][0], 'add_table')
eq_(diffs[0][1].name, "parent")
eq_(diffs[1][0], 'add_table')
eq_(diffs[1][1].name, "child")
def test_uses_custom_compare_type_function(self):
my_compare_type = Mock()
self.context._user_compare_type = my_compare_type
diffs = []
autogenerate._produce_net_changes(self.context.bind, self.m2,
diffs, self.autogen_context)
first_table = self.m2.tables['sometable']
first_column = first_table.columns['id']
eq_(len(my_compare_type.mock_calls), 2)
# We'll just test the first call
_, args, _ = my_compare_type.mock_calls[0]
context, inspected_column, metadata_column, inspected_type, metadata_type = args
eq_(context, self.context)
eq_(metadata_column, first_column)
eq_(metadata_type, first_column.type)
eq_(inspected_column.name, first_column.name)
eq_(type(inspected_type), INTEGER)
def test_uses_custom_compare_type_function(self):
my_compare_type = Mock()
self.context._user_compare_type = my_compare_type
diffs = []
autogenerate._produce_net_changes(self.context.bind, self.m2, diffs,
self.autogen_context)
first_table = self.m2.tables['sometable']
first_column = first_table.columns['id']
eq_(len(my_compare_type.mock_calls), 2)
# We'll just test the first call
_, args, _ = my_compare_type.mock_calls[0]
context, inspected_column, metadata_column, inspected_type, metadata_type = args
eq_(context, self.context)
eq_(metadata_column, first_column)
eq_(metadata_type, first_column.type)
eq_(inspected_column.name, first_column.name)
eq_(type(inspected_type), INTEGER)
def test_no_version_table(self):
diffs = []
autogenerate._produce_net_changes(self.context.bind, self.m2, diffs,
self.autogen_context)
eq_(diffs, [])
def test_variant_no_issue(self):
uo = ops.UpgradeOps(ops=[])
autogenerate._produce_net_changes(self.autogen_context, uo)
diffs = uo.as_diffs()
eq_(diffs, [])
def test_dont_add_system(self):
uo = ops.UpgradeOps(ops=[])
autogenerate._produce_net_changes(self.autogen_context, uo)
diffs = uo.as_diffs()
eq_(diffs, [])
def test_diffs(self):
"""test generation of diff rules"""
metadata = self.m2
self._update_context(include_schemas=True)
uo = ops.UpgradeOps(ops=[])
autogenerate._produce_net_changes(self.autogen_context, uo)
diffs = uo.as_diffs()
eq_(diffs[0], ("add_table", metadata.tables["%s.item" % self.schema]))
eq_(diffs[1][0], "remove_table")
eq_(diffs[1][1].name, "extra")
eq_(diffs[2][0], "add_column")
eq_(diffs[2][1], self.schema)
eq_(diffs[2][2], "address")
eq_(diffs[2][3], metadata.tables["%s.address" % self.schema].c.street)
eq_(diffs[3][0], "add_constraint")
eq_(diffs[3][1].name, "uq_email")
eq_(diffs[4][0], "add_column")
eq_(diffs[4][1], self.schema)
eq_(diffs[4][2], "order")
eq_(diffs[4][3], metadata.tables["%s.order" % self.schema].c.user_id)
eq_(diffs[5][0][0], "modify_type")
eq_(diffs[5][0][1], self.schema)
eq_(diffs[5][0][2], "order")
eq_(diffs[5][0][3], "amount")
eq_(repr(diffs[5][0][5]), "NUMERIC(precision=8, scale=2)")
eq_(repr(diffs[5][0][6]), "Numeric(precision=10, scale=2)")
self._assert_fk_diff(
diffs[6],
"add_fk",
"order",
["user_id"],
"user",
["id"],
source_schema=config.test_schema,
)
eq_(diffs[7][0][0], "modify_default")
eq_(diffs[7][0][1], self.schema)
eq_(diffs[7][0][2], "user")
eq_(diffs[7][0][3], "a1")
eq_(diffs[7][0][6].arg, "x")
eq_(diffs[8][0][0], "modify_nullable")
eq_(diffs[8][0][5], True)
eq_(diffs[8][0][6], False)
eq_(diffs[9][0], "remove_index")
eq_(diffs[9][1].name, "pw_idx")
eq_(diffs[10][0], "remove_column")
eq_(diffs[10][3].name, "pw")
def test_diffs(self):
"""test generation of diff rules"""
metadata = self.m2
diffs = []
self.autogen_context.update({
'object_filters': _default_object_filters,
'include_schemas': True,
'metadata': self.m2
})
autogenerate._produce_net_changes(self.autogen_context, diffs)
eq_(
diffs[0],
('add_table', metadata.tables['%s.item' % self.schema])
)
eq_(diffs[1][0], 'remove_table')
eq_(diffs[1][1].name, "extra")
eq_(diffs[2][0], "add_column")
eq_(diffs[2][1], self.schema)
eq_(diffs[2][2], "address")
eq_(diffs[2][3], metadata.tables['%s.address' % self.schema].c.street)
eq_(diffs[3][0], "add_constraint")
eq_(diffs[3][1].name, "uq_email")
eq_(diffs[4][0], "add_column")
eq_(diffs[4][1], self.schema)
eq_(diffs[4][2], "order")
eq_(diffs[4][3], metadata.tables['%s.order' % self.schema].c.user_id)
eq_(diffs[5][0][0], "modify_type")
eq_(diffs[5][0][1], self.schema)
eq_(diffs[5][0][2], "order")
eq_(diffs[5][0][3], "amount")
eq_(repr(diffs[5][0][5]), "NUMERIC(precision=8, scale=2)")
eq_(repr(diffs[5][0][6]), "Numeric(precision=10, scale=2)")
self._assert_fk_diff(
diffs[6], "add_fk",
"order", ["user_id"],
"user", ["id"],
source_schema=config.test_schema
)
eq_(diffs[7][0][0], "modify_default")
eq_(diffs[7][0][1], self.schema)
eq_(diffs[7][0][2], "user")
eq_(diffs[7][0][3], "a1")
eq_(diffs[7][0][6].arg, "x")
eq_(diffs[8][0][0], 'modify_nullable')
eq_(diffs[8][0][5], True)
eq_(diffs[8][0][6], False)
eq_(diffs[9][0], 'remove_index')
eq_(diffs[9][1].name, 'pw_idx')
eq_(diffs[10][0], 'remove_column')
eq_(diffs[10][3].name, 'pw')
def test_diffs(self):
"""test generation of diff rules"""
metadata = self.m2
diffs = []
ctx = self.autogen_context.copy()
ctx['metadata'] = self.m2
ctx['object_filters'] = _default_object_filters
autogenerate._produce_net_changes(
ctx, diffs
)
eq_(
diffs[0],
('add_table', metadata.tables['item'])
)
eq_(diffs[1][0], 'remove_table')
eq_(diffs[1][1].name, "extra")
eq_(diffs[2][0], "add_column")
eq_(diffs[2][1], None)
eq_(diffs[2][2], "address")
eq_(diffs[2][3], metadata.tables['address'].c.street)
eq_(diffs[3][0], "add_constraint")
eq_(diffs[3][1].name, "uq_email")
eq_(diffs[4][0], "add_column")
eq_(diffs[4][1], None)
eq_(diffs[4][2], "order")
eq_(diffs[4][3], metadata.tables['order'].c.user_id)
eq_(diffs[5][0][0], "modify_type")
eq_(diffs[5][0][1], None)
eq_(diffs[5][0][2], "order")
eq_(diffs[5][0][3], "amount")
eq_(repr(diffs[5][0][5]), "NUMERIC(precision=8, scale=2)")
eq_(repr(diffs[5][0][6]), "Numeric(precision=10, scale=2)")
self._assert_fk_diff(
diffs[6], "add_fk",
"order", ["user_id"],
"user", ["id"]
)
eq_(diffs[7][0][0], "modify_default")
eq_(diffs[7][0][1], None)
eq_(diffs[7][0][2], "user")
eq_(diffs[7][0][3], "a1")
eq_(diffs[7][0][6].arg, "x")
eq_(diffs[8][0][0], 'modify_nullable')
eq_(diffs[8][0][5], True)
eq_(diffs[8][0][6], False)
eq_(diffs[9][0], 'remove_index')
eq_(diffs[9][1].name, 'pw_idx')
eq_(diffs[10][0], 'remove_column')
eq_(diffs[10][3].name, 'pw')
def test_no_version_table(self):
diffs = []
ctx = self.autogen_context
autogenerate._produce_net_changes(ctx, diffs)
eq_(diffs, [])
def test_no_version_table(self):
ctx = self.autogen_context
uo = ops.UpgradeOps(ops=[])
autogenerate._produce_net_changes(ctx, uo)
eq_(uo.as_diffs(), [])
def test_no_change(self):
uo = ops.UpgradeOps(ops=[])
ctx = self.autogen_context
autogenerate._produce_net_changes(ctx, uo)
diffs = uo.as_diffs()
eq_(diffs, [])
