def test_warn_if_is_conflicting_with_global_name_with_module_and_target(
self, ):
with pytest.warns(None) as recorded_warnings:
Import(module="a.b",
target="c").warn_if_is_conflicting_with_global_name()
if len(recorded_warnings) != 0:
pytest.fail("Unexpected warning!")
with pytest.warns(
UniqueGlobalNameConflictWarning) as recorded_warnings:
Import(module="a.b",
target="Varchar").warn_if_is_conflicting_with_global_name()
if len(recorded_warnings) != 1:
pytest.fail("Expected 1 warning!")
with pytest.warns(None) as recorded_warnings:
Import(
module="a.b",
target="Varchar",
expect_conflict_with_global_name="Varchar",
).warn_if_is_conflicting_with_global_name()
if len(recorded_warnings) != 0:
pytest.fail("Unexpected warning!")
def alter_columns(self) -> AlterStatements:
response: t.List[str] = []
extra_imports: t.List[Import] = []
extra_definitions: t.List[Definition] = []
for table in self.schema:
snapshot_table = self._get_snapshot_table(table.class_name)
if snapshot_table:
delta: TableDelta = table - snapshot_table
else:
continue
for alter_column in delta.alter_columns:
new_params = serialise_params(alter_column.params)
extra_imports.extend(new_params.extra_imports)
extra_definitions.extend(new_params.extra_definitions)
old_params = serialise_params(alter_column.old_params)
extra_imports.extend(old_params.extra_imports)
extra_definitions.extend(old_params.extra_definitions)
column_class = (alter_column.column_class.__name__
if alter_column.column_class else "None")
old_column_class = (alter_column.old_column_class.__name__ if
alter_column.old_column_class else "None")
if alter_column.column_class is not None:
extra_imports.append(
Import(
module=alter_column.column_class.__module__,
target=alter_column.column_class.__name__,
expect_conflict_with_global_name=getattr(
UniqueGlobalNames,
f"COLUMN_{alter_column.column_class.__name__.upper()}", # noqa: E501
),
))
if alter_column.old_column_class is not None:
extra_imports.append(
Import(
module=alter_column.old_column_class.__module__,
target=alter_column.old_column_class.__name__,
expect_conflict_with_global_name=getattr(
UniqueGlobalNames,
f"COLUMN_{alter_column.old_column_class.__name__.upper()}", # noqa: E501
),
))
response.append(
f"manager.alter_column(table_class_name='{table.class_name}', tablename='{table.tablename}', column_name='{alter_column.column_name}', params={new_params.params}, old_params={old_params.params}, column_class={column_class}, old_column_class={old_column_class})" # noqa: E501
)
return AlterStatements(
statements=response,
extra_imports=extra_imports,
extra_definitions=extra_definitions,
)
def new_table_columns(self) -> AlterStatements:
new_tables: t.List[DiffableTable] = list(
set(self.schema) - set(self.schema_snapshot))
response: t.List[str] = []
extra_imports: t.List[Import] = []
extra_definitions: t.List[str] = []
for table in new_tables:
if (table.class_name
in self.rename_tables_collection.new_class_names):
continue
for column in table.columns:
# In case we cause subtle bugs:
params = deepcopy(column._meta.params)
_params = serialise_params(params)
cleaned_params = _params.params
extra_imports.extend(_params.extra_imports)
extra_definitions.extend(_params.extra_definitions)
extra_imports.append(
Import(
module=column.__class__.__module__,
target=column.__class__.__name__,
))
response.append(
f"manager.add_column(table_class_name='{table.class_name}', tablename='{table.tablename}', column_name='{column._meta.name}', column_class_name='{column.__class__.__name__}', column_class={column.__class__.__name__}, params={str(cleaned_params)})" # noqa: E501
)
return AlterStatements(
statements=response,
extra_imports=extra_imports,
extra_definitions=extra_definitions,
)
def add_columns(self) -> AlterStatements:
response: t.List[str] = []
extra_imports: t.List[Import] = []
extra_definitions: t.List[Definition] = []
for table in self.schema:
snapshot_table = self._get_snapshot_table(table.class_name)
if snapshot_table:
delta: TableDelta = table - snapshot_table
else:
continue
for add_column in delta.add_columns:
if (add_column.column_name
in self.rename_columns_collection.new_column_names):
continue
params = serialise_params(add_column.params)
cleaned_params = params.params
extra_imports.extend(params.extra_imports)
extra_definitions.extend(params.extra_definitions)
column_class = add_column.column_class
extra_imports.append(
Import(
module=column_class.__module__,
target=column_class.__name__,
expect_conflict_with_global_name=getattr(
UniqueGlobalNames,
f"COLUMN_{column_class.__name__.upper()}",
),
))
response.append(
f"manager.add_column(table_class_name='{table.class_name}', tablename='{table.tablename}', column_name='{add_column.column_name}', db_column_name='{add_column.db_column_name}', column_class_name='{add_column.column_class_name}', column_class={column_class.__name__}, params={str(cleaned_params)})" # noqa: E501
)
return AlterStatements(
statements=response,
extra_imports=extra_imports,
extra_definitions=extra_definitions,
)
def test_with_module_and_target(self):
assert repr(Import(module="a.b", target="c")) == "from a.b import c"
def test_with_module_only(self):
assert repr(Import(module="a.b.c")) == "import a.b.c"