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"