| OLD | NEW |
|---|
| (Empty) | |
| 1 import unittest |
| 2 |
| 3 from rope.refactor.importutils import ImportTools, importinfo, add_import |
| 4 from ropetest import testutils |
| 5 |
| 6 |
| 7 class ImportUtilsTest(unittest.TestCase): |
| 8 |
| 9 def setUp(self): |
| 10 super(ImportUtilsTest, self).setUp() |
| 11 self.project = testutils.sample_project() |
| 12 self.import_tools = ImportTools(self.project) |
| 13 |
| 14 self.mod = testutils.create_module(self.project, 'mod') |
| 15 self.pkg1 = testutils.create_package(self.project, 'pkg1') |
| 16 self.mod1 = testutils.create_module(self.project, 'mod1', self.pkg1) |
| 17 self.pkg2 = testutils.create_package(self.project, 'pkg2') |
| 18 self.mod2 = testutils.create_module(self.project, 'mod2', self.pkg2) |
| 19 self.mod3 = testutils.create_module(self.project, 'mod3', self.pkg2) |
| 20 p1 = testutils.create_package(self.project, 'p1') |
| 21 p2 = testutils.create_package(self.project, 'p2', p1) |
| 22 p3 = testutils.create_package(self.project, 'p3', p2) |
| 23 m1 = testutils.create_module(self.project, 'm1', p3) # noqa |
| 24 l = testutils.create_module(self.project, 'l', p3) # noqa |
| 25 |
| 26 def tearDown(self): |
| 27 testutils.remove_project(self.project) |
| 28 super(ImportUtilsTest, self).tearDown() |
| 29 |
| 30 def test_get_import_for_module(self): |
| 31 mod = self.project.find_module('mod') |
| 32 import_statement = self.import_tools.get_import(mod) |
| 33 self.assertEquals('import mod', |
| 34 import_statement.get_import_statement()) |
| 35 |
| 36 def test_get_import_for_module_in_nested_modules(self): |
| 37 mod = self.project.find_module('pkg1.mod1') |
| 38 import_statement = self.import_tools.get_import(mod) |
| 39 self.assertEquals('import pkg1.mod1', |
| 40 import_statement.get_import_statement()) |
| 41 |
| 42 def test_get_import_for_module_in_init_dot_py(self): |
| 43 init_dot_py = self.pkg1.get_child('__init__.py') |
| 44 import_statement = self.import_tools.get_import(init_dot_py) |
| 45 self.assertEquals('import pkg1', |
| 46 import_statement.get_import_statement()) |
| 47 |
| 48 def test_get_from_import_for_module(self): |
| 49 mod = self.project.find_module('mod') |
| 50 import_statement = self.import_tools.get_from_import(mod, 'a_func') |
| 51 self.assertEquals('from mod import a_func', |
| 52 import_statement.get_import_statement()) |
| 53 |
| 54 def test_get_from_import_for_module_in_nested_modules(self): |
| 55 mod = self.project.find_module('pkg1.mod1') |
| 56 import_statement = self.import_tools.get_from_import(mod, 'a_func') |
| 57 self.assertEquals('from pkg1.mod1 import a_func', |
| 58 import_statement.get_import_statement()) |
| 59 |
| 60 def test_get_from_import_for_module_in_init_dot_py(self): |
| 61 init_dot_py = self.pkg1.get_child('__init__.py') |
| 62 import_statement = self.import_tools.\ |
| 63 get_from_import(init_dot_py, 'a_func') |
| 64 self.assertEquals('from pkg1 import a_func', |
| 65 import_statement.get_import_statement()) |
| 66 |
| 67 def test_get_import_statements(self): |
| 68 self.mod.write('import pkg1\n') |
| 69 pymod = self.project.get_module('mod') |
| 70 module_with_imports = self.import_tools.module_imports(pymod) |
| 71 imports = module_with_imports.imports |
| 72 self.assertEquals('import pkg1', |
| 73 imports[0].import_info.get_import_statement()) |
| 74 |
| 75 def test_get_import_statements_with_alias(self): |
| 76 self.mod.write('import pkg1.mod1 as mod1\n') |
| 77 pymod = self.project.get_module('mod') |
| 78 module_with_imports = self.import_tools.module_imports(pymod) |
| 79 imports = module_with_imports.imports |
| 80 self.assertEquals('import pkg1.mod1 as mod1', |
| 81 imports[0].import_info.get_import_statement()) |
| 82 |
| 83 def test_get_import_statements_for_froms(self): |
| 84 self.mod.write('from pkg1 import mod1\n') |
| 85 pymod = self.project.get_module('mod') |
| 86 module_with_imports = self.import_tools.module_imports(pymod) |
| 87 imports = module_with_imports.imports |
| 88 self.assertEquals('from pkg1 import mod1', |
| 89 imports[0].import_info.get_import_statement()) |
| 90 |
| 91 def test_get_multi_line_import_statements_for_froms(self): |
| 92 self.mod.write('from pkg1 \\\n import mod1\n') |
| 93 pymod = self.project.get_module('mod') |
| 94 module_with_imports = self.import_tools.module_imports(pymod) |
| 95 imports = module_with_imports.imports |
| 96 self.assertEquals('from pkg1 import mod1', |
| 97 imports[0].import_info.get_import_statement()) |
| 98 |
| 99 def test_get_import_statements_for_from_star(self): |
| 100 self.mod.write('from pkg1 import *\n') |
| 101 pymod = self.project.get_module('mod') |
| 102 module_with_imports = self.import_tools.module_imports(pymod) |
| 103 imports = module_with_imports.imports |
| 104 self.assertEquals('from pkg1 import *', |
| 105 imports[0].import_info.get_import_statement()) |
| 106 |
| 107 @testutils.run_only_for_25 |
| 108 def test_get_import_statements_for_new_relatives(self): |
| 109 self.mod2.write('from .mod3 import x\n') |
| 110 pymod = self.project.get_module('pkg2.mod2') |
| 111 module_with_imports = self.import_tools.module_imports(pymod) |
| 112 imports = module_with_imports.imports |
| 113 self.assertEquals('from .mod3 import x', |
| 114 imports[0].import_info.get_import_statement()) |
| 115 |
| 116 def test_ignoring_indented_imports(self): |
| 117 self.mod.write('if True:\n import pkg1\n') |
| 118 pymod = self.project.get_module('mod') |
| 119 module_with_imports = self.import_tools.module_imports(pymod) |
| 120 imports = module_with_imports.imports |
| 121 self.assertEquals(0, len(imports)) |
| 122 |
| 123 def test_import_get_names(self): |
| 124 self.mod.write('import pkg1 as pkg\n') |
| 125 pymod = self.project.get_module('mod') |
| 126 module_with_imports = self.import_tools.module_imports(pymod) |
| 127 imports = module_with_imports.imports |
| 128 context = importinfo.ImportContext(self.project, self.project.root) |
| 129 self.assertEquals(['pkg'], |
| 130 imports[0].import_info.get_imported_names(context)) |
| 131 |
| 132 def test_import_get_names_with_alias(self): |
| 133 self.mod.write('import pkg1.mod1\n') |
| 134 pymod = self.project.get_module('mod') |
| 135 module_with_imports = self.import_tools.module_imports(pymod) |
| 136 imports = module_with_imports.imports |
| 137 context = importinfo.ImportContext(self.project, self.project.root) |
| 138 self.assertEquals(['pkg1'], |
| 139 imports[0].import_info.get_imported_names(context)) |
| 140 |
| 141 def test_import_get_names_with_alias2(self): |
| 142 self.mod1.write('def a_func():\n pass\n') |
| 143 self.mod.write('from pkg1.mod1 import *\n') |
| 144 pymod = self.project.get_module('mod') |
| 145 module_with_imports = self.import_tools.module_imports(pymod) |
| 146 imports = module_with_imports.imports |
| 147 context = importinfo.ImportContext(self.project, self.project.root) |
| 148 self.assertEquals(['a_func'], |
| 149 imports[0].import_info.get_imported_names(context)) |
| 150 |
| 151 def test_empty_getting_used_imports(self): |
| 152 self.mod.write('') |
| 153 pymod = self.project.get_module('mod') |
| 154 module_with_imports = self.import_tools.module_imports(pymod) |
| 155 imports = module_with_imports.get_used_imports(pymod) |
| 156 self.assertEquals(0, len(imports)) |
| 157 |
| 158 def test_empty_getting_used_imports2(self): |
| 159 self.mod.write('import pkg\n') |
| 160 pymod = self.project.get_module('mod') |
| 161 module_with_imports = self.import_tools.module_imports(pymod) |
| 162 imports = module_with_imports.get_used_imports(pymod) |
| 163 self.assertEquals(0, len(imports)) |
| 164 |
| 165 def test_simple_getting_used_imports(self): |
| 166 self.mod.write('import pkg\nprint(pkg)\n') |
| 167 pymod = self.project.get_module('mod') |
| 168 module_with_imports = self.import_tools.module_imports(pymod) |
| 169 imports = module_with_imports.get_used_imports(pymod) |
| 170 self.assertEquals(1, len(imports)) |
| 171 self.assertEquals('import pkg', imports[0].get_import_statement()) |
| 172 |
| 173 def test_simple_getting_used_imports2(self): |
| 174 self.mod.write('import pkg\ndef a_func():\n print(pkg)\n') |
| 175 pymod = self.project.get_module('mod') |
| 176 module_with_imports = self.import_tools.module_imports(pymod) |
| 177 imports = module_with_imports.get_used_imports(pymod) |
| 178 self.assertEquals(1, len(imports)) |
| 179 self.assertEquals('import pkg', imports[0].get_import_statement()) |
| 180 |
| 181 def test_getting_used_imports_for_nested_scopes(self): |
| 182 self.mod.write('import pkg1\nprint(pkg1)\n' |
| 183 'def a_func():\n pass\nprint(pkg1)\n') |
| 184 pymod = self.project.get_module('mod') |
| 185 module_with_imports = self.import_tools.module_imports(pymod) |
| 186 imports = module_with_imports.get_used_imports( |
| 187 pymod['a_func'].get_object()) |
| 188 self.assertEquals(0, len(imports)) |
| 189 |
| 190 def test_getting_used_imports_for_nested_scopes2(self): |
| 191 self.mod.write('from pkg1 import mod1\ndef a_func():' |
| 192 '\n print(mod1)\n') |
| 193 pymod = self.project.get_module('mod') |
| 194 module_with_imports = self.import_tools.module_imports(pymod) |
| 195 imports = module_with_imports.get_used_imports( |
| 196 pymod['a_func'].get_object()) |
| 197 self.assertEquals(1, len(imports)) |
| 198 self.assertEquals('from pkg1 import mod1', |
| 199 imports[0].get_import_statement()) |
| 200 |
| 201 def test_empty_removing_unused_imports(self): |
| 202 self.mod.write('import pkg1\nprint(pkg1)\n') |
| 203 pymod = self.project.get_module('mod') |
| 204 module_with_imports = self.import_tools.module_imports(pymod) |
| 205 module_with_imports.remove_unused_imports() |
| 206 self.assertEquals('import pkg1\nprint(pkg1)\n', |
| 207 module_with_imports.get_changed_source()) |
| 208 |
| 209 def test_simple_removing_unused_imports(self): |
| 210 self.mod.write('import pkg1\n\n') |
| 211 pymod = self.project.get_module('mod') |
| 212 module_with_imports = self.import_tools.module_imports(pymod) |
| 213 module_with_imports.remove_unused_imports() |
| 214 self.assertEquals('', module_with_imports.get_changed_source()) |
| 215 |
| 216 def test_simple_removing_unused_imports_for_froms(self): |
| 217 self.mod1.write('def a_func():\n pass' |
| 218 '\ndef another_func():\n pass\n') |
| 219 self.mod.write('from pkg1.mod1 import a_func, ' |
| 220 'another_func\n\na_func()\n') |
| 221 pymod = self.project.get_module('mod') |
| 222 module_with_imports = self.import_tools.module_imports(pymod) |
| 223 module_with_imports.remove_unused_imports() |
| 224 self.assertEquals('from pkg1.mod1 import a_func\n\na_func()\n', |
| 225 module_with_imports.get_changed_source()) |
| 226 |
| 227 def test_simple_removing_unused_imports_for_from_stars(self): |
| 228 self.mod.write('from pkg1.mod1 import *\n\n') |
| 229 pymod = self.project.get_module('mod') |
| 230 module_with_imports = self.import_tools.module_imports(pymod) |
| 231 module_with_imports.remove_unused_imports() |
| 232 self.assertEquals('', module_with_imports.get_changed_source()) |
| 233 |
| 234 def test_simple_removing_unused_imports_for_nested_modules(self): |
| 235 self.mod1.write('def a_func():\n pass\n') |
| 236 self.mod.write('import pkg1.mod1\npkg1.mod1.a_func()') |
| 237 pymod = self.project.get_module('mod') |
| 238 module_with_imports = self.import_tools.module_imports(pymod) |
| 239 module_with_imports.remove_unused_imports() |
| 240 self.assertEquals('import pkg1.mod1\npkg1.mod1.a_func()', |
| 241 module_with_imports.get_changed_source()) |
| 242 |
| 243 def test_removing_unused_imports_and_functions_of_the_same_name(self): |
| 244 self.mod.write('def a_func():\n pass\ndef a_func():\n pass\n') |
| 245 pymod = self.project.get_module('mod') |
| 246 module_with_imports = self.import_tools.module_imports(pymod) |
| 247 module_with_imports.remove_unused_imports() |
| 248 self.assertEquals('def a_func():\n pass\ndef a_func():\n pass\n', |
| 249 module_with_imports.get_changed_source()) |
| 250 |
| 251 def test_removing_unused_imports_for_from_import_with_as(self): |
| 252 self.mod.write('a_var = 1\n') |
| 253 self.mod1.write('from mod import a_var as myvar\na_var = myvar\n') |
| 254 pymod = self.project.get_pymodule(self.mod1) |
| 255 module_with_imports = self.import_tools.module_imports(pymod) |
| 256 module_with_imports.remove_unused_imports() |
| 257 self.assertEquals('from mod import a_var as myvar\na_var = myvar\n', |
| 258 module_with_imports.get_changed_source()) |
| 259 |
| 260 def test_not_removing_imports_that_conflict_with_class_names(self): |
| 261 code = 'import pkg1\nclass A(object):\n pkg1 = 0\n' \ |
| 262 ' def f(self):\n a_var = pkg1\n' |
| 263 self.mod.write(code) |
| 264 pymod = self.project.get_module('mod') |
| 265 module_with_imports = self.import_tools.module_imports(pymod) |
| 266 module_with_imports.remove_unused_imports() |
| 267 self.assertEquals(code, module_with_imports.get_changed_source()) |
| 268 |
| 269 def test_adding_imports(self): |
| 270 self.mod.write('\n') |
| 271 pymod = self.project.get_module('mod') |
| 272 module_with_imports = self.import_tools.module_imports(pymod) |
| 273 new_import = self.import_tools.get_import(self.mod1) |
| 274 module_with_imports.add_import(new_import) |
| 275 self.assertEquals('import pkg1.mod1\n', |
| 276 module_with_imports.get_changed_source()) |
| 277 |
| 278 def test_adding_from_imports(self): |
| 279 self.mod1.write('def a_func():\n pass\n' |
| 280 'def another_func():\n pass\n') |
| 281 self.mod.write('from pkg1.mod1 import a_func\n') |
| 282 pymod = self.project.get_module('mod') |
| 283 module_with_imports = self.import_tools.module_imports(pymod) |
| 284 new_import = self.import_tools.get_from_import( |
| 285 self.mod1, 'another_func') |
| 286 module_with_imports.add_import(new_import) |
| 287 self.assertEquals('from pkg1.mod1 import a_func, another_func\n', |
| 288 module_with_imports.get_changed_source()) |
| 289 |
| 290 def test_adding_to_star_imports(self): |
| 291 self.mod1.write('def a_func():\n pass' |
| 292 '\ndef another_func():\n pass\n') |
| 293 self.mod.write('from pkg1.mod1 import *\n') |
| 294 pymod = self.project.get_module('mod') |
| 295 module_with_imports = self.import_tools.module_imports(pymod) |
| 296 new_import = self.import_tools.get_from_import( |
| 297 self.mod1, 'another_func') |
| 298 module_with_imports.add_import(new_import) |
| 299 self.assertEquals('from pkg1.mod1 import *\n', |
| 300 module_with_imports.get_changed_source()) |
| 301 |
| 302 def test_adding_star_imports(self): |
| 303 self.mod1.write('def a_func():\n pass\n' |
| 304 'def another_func():\n pass\n') |
| 305 self.mod.write('from pkg1.mod1 import a_func\n') |
| 306 pymod = self.project.get_module('mod') |
| 307 module_with_imports = self.import_tools.module_imports(pymod) |
| 308 new_import = self.import_tools.get_from_import(self.mod1, '*') |
| 309 module_with_imports.add_import(new_import) |
| 310 self.assertEquals('from pkg1.mod1 import *\n', |
| 311 module_with_imports.get_changed_source()) |
| 312 |
| 313 def test_adding_imports_and_preserving_spaces_after_imports(self): |
| 314 self.mod.write('import pkg1\n\n\nprint(pkg1)\n') |
| 315 pymod = self.project.get_module('mod') |
| 316 module_with_imports = self.import_tools.module_imports(pymod) |
| 317 new_import = self.import_tools.get_import(self.pkg2) |
| 318 module_with_imports.add_import(new_import) |
| 319 self.assertEquals('import pkg1\nimport pkg2\n\n\nprint(pkg1)\n', |
| 320 module_with_imports.get_changed_source()) |
| 321 |
| 322 def test_not_changing_the_format_of_unchanged_imports(self): |
| 323 self.mod1.write('def a_func():\n pass\n' |
| 324 'def another_func():\n pass\n') |
| 325 self.mod.write('from pkg1.mod1 import (a_func,\n another_func)\n') |
| 326 pymod = self.project.get_module('mod') |
| 327 module_with_imports = self.import_tools.module_imports(pymod) |
| 328 self.assertEquals( |
| 329 'from pkg1.mod1 import (a_func,\n another_func)\n', |
| 330 module_with_imports.get_changed_source()) |
| 331 |
| 332 def test_not_changing_the_format_of_unchanged_imports2(self): |
| 333 self.mod1.write('def a_func():\n pass\n' |
| 334 'def another_func():\n pass\n') |
| 335 self.mod.write('from pkg1.mod1 import (a_func)\na_func()\n') |
| 336 pymod = self.project.get_module('mod') |
| 337 module_with_imports = self.import_tools.module_imports(pymod) |
| 338 module_with_imports.remove_unused_imports() |
| 339 self.assertEquals('from pkg1.mod1 import (a_func)\na_func()\n', |
| 340 module_with_imports.get_changed_source()) |
| 341 |
| 342 def test_removing_unused_imports_and_reoccuring_names(self): |
| 343 self.mod1.write('def a_func():\n pass\n' |
| 344 'def another_func():\n pass\n') |
| 345 self.mod.write('from pkg1.mod1 import *\n' |
| 346 'from pkg1.mod1 import a_func\na_func()\n') |
| 347 pymod = self.project.get_module('mod') |
| 348 module_with_imports = self.import_tools.module_imports(pymod) |
| 349 module_with_imports.remove_unused_imports() |
| 350 self.assertEquals('from pkg1.mod1 import *\na_func()\n', |
| 351 module_with_imports.get_changed_source()) |
| 352 |
| 353 def test_removing_unused_imports_and_reoccuring_names2(self): |
| 354 self.mod.write('import pkg2.mod2\nimport pkg2.mod3\n' |
| 355 'print(pkg2.mod2, pkg2.mod3)') |
| 356 pymod = self.project.get_module('mod') |
| 357 module_with_imports = self.import_tools.module_imports(pymod) |
| 358 module_with_imports.remove_unused_imports() |
| 359 self.assertEquals( |
| 360 'import pkg2.mod2\nimport pkg2.mod3\nprint(pkg2.mod2, pkg2.mod3)', |
| 361 module_with_imports.get_changed_source()) |
| 362 |
| 363 def test_removing_unused_imports_and_common_packages(self): |
| 364 self.mod.write('import pkg1.mod1\nimport pkg1' |
| 365 '\nprint(pkg1, pkg1.mod1)\n') |
| 366 pymod = self.project.get_module('mod') |
| 367 module_with_imports = self.import_tools.module_imports(pymod) |
| 368 module_with_imports.remove_unused_imports() |
| 369 self.assertEquals('import pkg1.mod1\nprint(pkg1, pkg1.mod1)\n', |
| 370 module_with_imports.get_changed_source()) |
| 371 |
| 372 def test_removing_unused_imports_and_common_packages_reversed(self): |
| 373 self.mod.write('import pkg1\nimport pkg1.mod1' |
| 374 '\nprint(pkg1, pkg1.mod1)\n') |
| 375 pymod = self.project.get_module('mod') |
| 376 module_with_imports = self.import_tools.module_imports(pymod) |
| 377 module_with_imports.remove_duplicates() |
| 378 self.assertEquals('import pkg1.mod1\nprint(pkg1, pkg1.mod1)\n', |
| 379 module_with_imports.get_changed_source()) |
| 380 |
| 381 def test_removing_unused_imports_and_common_packages2(self): |
| 382 self.mod.write('import pkg1.mod1\nimport pkg1.mod2\nprint(pkg1)\n') |
| 383 pymod = self.project.get_module('mod') |
| 384 module_with_imports = self.import_tools.module_imports(pymod) |
| 385 module_with_imports.remove_unused_imports() |
| 386 self.assertEquals('import pkg1.mod1\nprint(pkg1)\n', |
| 387 module_with_imports.get_changed_source()) |
| 388 |
| 389 def test_removing_unused_imports_and_froms(self): |
| 390 self.mod1.write('def func1():\n pass\n') |
| 391 self.mod.write('from pkg1.mod1 import func1\n') |
| 392 pymod = self.project.get_module('mod') |
| 393 module_with_imports = self.import_tools.module_imports(pymod) |
| 394 module_with_imports.remove_unused_imports() |
| 395 self.assertEquals('', module_with_imports.get_changed_source()) |
| 396 |
| 397 def test_removing_unused_imports_and_froms2(self): |
| 398 self.mod1.write('def func1():\n pass\n') |
| 399 self.mod.write('from pkg1.mod1 import func1\nfunc1()') |
| 400 pymod = self.project.get_module('mod') |
| 401 module_with_imports = self.import_tools.module_imports(pymod) |
| 402 module_with_imports.remove_unused_imports() |
| 403 self.assertEquals('from pkg1.mod1 import func1\nfunc1()', |
| 404 module_with_imports.get_changed_source()) |
| 405 |
| 406 def test_removing_unused_imports_and_froms3(self): |
| 407 self.mod1.write('def func1():\n pass\n') |
| 408 self.mod.write('from pkg1.mod1 import func1\n' |
| 409 'def a_func():\n func1()\n') |
| 410 pymod = self.project.get_module('mod') |
| 411 module_with_imports = self.import_tools.module_imports(pymod) |
| 412 module_with_imports.remove_unused_imports() |
| 413 self.assertEquals( |
| 414 'from pkg1.mod1 import func1\ndef a_func():\n func1()\n', |
| 415 module_with_imports.get_changed_source()) |
| 416 |
| 417 def test_removing_unused_imports_and_froms4(self): |
| 418 self.mod1.write('def func1():\n pass\n') |
| 419 self.mod.write('from pkg1.mod1 import func1\nclass A(object):\n' |
| 420 ' def a_func(self):\n func1()\n') |
| 421 pymod = self.project.get_module('mod') |
| 422 module_with_imports = self.import_tools.module_imports(pymod) |
| 423 module_with_imports.remove_unused_imports() |
| 424 self.assertEquals('from pkg1.mod1 import func1\nclass A(object):\n' |
| 425 ' def a_func(self):\n func1()\n', |
| 426 module_with_imports.get_changed_source()) |
| 427 |
| 428 def test_removing_unused_imports_and_getting_attributes(self): |
| 429 self.mod1.write('class A(object):\n def f(self):\n pass\n') |
| 430 self.mod.write('from pkg1.mod1 import A\nvar = A().f()') |
| 431 pymod = self.project.get_module('mod') |
| 432 module_with_imports = self.import_tools.module_imports(pymod) |
| 433 module_with_imports.remove_unused_imports() |
| 434 self.assertEquals('from pkg1.mod1 import A\nvar = A().f()', |
| 435 module_with_imports.get_changed_source()) |
| 436 |
| 437 def test_removing_unused_imports_function_parameters(self): |
| 438 self.mod1.write('def func1():\n pass\n') |
| 439 self.mod.write('import pkg1\ndef a_func(pkg1):\n my_var = pkg1\n') |
| 440 pymod = self.project.get_module('mod') |
| 441 module_with_imports = self.import_tools.module_imports(pymod) |
| 442 module_with_imports.remove_unused_imports() |
| 443 self.assertEquals('def a_func(pkg1):\n my_var = pkg1\n', |
| 444 module_with_imports.get_changed_source()) |
| 445 |
| 446 def test_trivial_expanding_star_imports(self): |
| 447 self.mod1.write('def a_func():\n pass\n' |
| 448 'def another_func():\n pass\n') |
| 449 self.mod.write('from pkg1.mod1 import *\n') |
| 450 pymod = self.project.get_module('mod') |
| 451 module_with_imports = self.import_tools.module_imports(pymod) |
| 452 module_with_imports.expand_stars() |
| 453 self.assertEquals('', module_with_imports.get_changed_source()) |
| 454 |
| 455 def test_expanding_star_imports(self): |
| 456 self.mod1.write('def a_func():\n pass\n' |
| 457 'def another_func():\n pass\n') |
| 458 self.mod.write('from pkg1.mod1 import *\na_func()\n') |
| 459 pymod = self.project.get_module('mod') |
| 460 module_with_imports = self.import_tools.module_imports(pymod) |
| 461 module_with_imports.expand_stars() |
| 462 self.assertEquals('from pkg1.mod1 import a_func\na_func()\n', |
| 463 module_with_imports.get_changed_source()) |
| 464 |
| 465 def test_removing_duplicate_imports(self): |
| 466 self.mod.write('import pkg1\nimport pkg1\n') |
| 467 pymod = self.project.get_module('mod') |
| 468 module_with_imports = self.import_tools.module_imports(pymod) |
| 469 module_with_imports.remove_duplicates() |
| 470 self.assertEquals('import pkg1\n', |
| 471 module_with_imports.get_changed_source()) |
| 472 |
| 473 def test_removing_duplicates_and_reoccuring_names(self): |
| 474 self.mod.write('import pkg2.mod2\nimport pkg2.mod3\n') |
| 475 pymod = self.project.get_module('mod') |
| 476 module_with_imports = self.import_tools.module_imports(pymod) |
| 477 module_with_imports.remove_duplicates() |
| 478 self.assertEquals('import pkg2.mod2\nimport pkg2.mod3\n', |
| 479 module_with_imports.get_changed_source()) |
| 480 |
| 481 def test_removing_duplicate_imports_for_froms(self): |
| 482 self.mod1.write( |
| 483 'def a_func():\n pass\ndef another_func():\n pass\n') |
| 484 self.mod.write('from pkg1 import a_func\n' |
| 485 'from pkg1 import a_func, another_func\n') |
| 486 pymod = self.project.get_module('mod') |
| 487 module_with_imports = self.import_tools.module_imports(pymod) |
| 488 module_with_imports.remove_duplicates() |
| 489 self.assertEquals('from pkg1 import a_func, another_func\n', |
| 490 module_with_imports.get_changed_source()) |
| 491 |
| 492 def test_transforming_froms_to_normal_changing_imports(self): |
| 493 self.mod1.write('def a_func():\n pass\n') |
| 494 self.mod.write('from pkg1.mod1 import a_func\nprint(a_func)\n') |
| 495 pymod = self.project.get_module('mod') |
| 496 changed_module = self.import_tools.froms_to_imports(pymod) |
| 497 self.assertEquals('import pkg1.mod1\nprint(pkg1.mod1.a_func)\n', |
| 498 changed_module) |
| 499 |
| 500 def test_transforming_froms_to_normal_changing_occurances(self): |
| 501 self.mod1.write('def a_func():\n pass\n') |
| 502 self.mod.write('from pkg1.mod1 import a_func\na_func()') |
| 503 pymod = self.project.get_module('mod') |
| 504 changed_module = self.import_tools.froms_to_imports(pymod) |
| 505 self.assertEquals('import pkg1.mod1\npkg1.mod1.a_func()', |
| 506 changed_module) |
| 507 |
| 508 def test_transforming_froms_to_normal_for_multi_imports(self): |
| 509 self.mod1.write('def a_func():\n pass\n' |
| 510 'def another_func():\n pass\n') |
| 511 self.mod.write('from pkg1.mod1 import *\na_func()\nanother_func()\n') |
| 512 pymod = self.project.get_module('mod') |
| 513 changed_module = self.import_tools.froms_to_imports(pymod) |
| 514 self.assertEquals( |
| 515 'import pkg1.mod1\npkg1.mod1.a_func()\npkg1.mod1.another_func()\n', |
| 516 changed_module) |
| 517 |
| 518 def test_transform_froms_to_norm_for_multi_imports_inside_parens(self): |
| 519 self.mod1.write('def a_func():\n pass\n' |
| 520 'def another_func():\n pass\n') |
| 521 self.mod.write('from pkg1.mod1 import (a_func, \n another_func)' |
| 522 '\na_func()\nanother_func()\n') |
| 523 pymod = self.project.get_module('mod') |
| 524 changed_module = self.import_tools.froms_to_imports(pymod) |
| 525 self.assertEquals( |
| 526 'import pkg1.mod1\npkg1.mod1.a_func()\npkg1.mod1.another_func()\n', |
| 527 changed_module) |
| 528 |
| 529 def test_transforming_froms_to_normal_from_stars(self): |
| 530 self.mod1.write('def a_func():\n pass\n') |
| 531 self.mod.write('from pkg1.mod1 import *\na_func()\n') |
| 532 pymod = self.project.get_module('mod') |
| 533 changed_module = self.import_tools.froms_to_imports(pymod) |
| 534 self.assertEquals('import pkg1.mod1\npkg1.mod1.a_func()\n', |
| 535 changed_module) |
| 536 |
| 537 def test_transforming_froms_to_normal_from_stars2(self): |
| 538 self.mod1.write('a_var = 10') |
| 539 self.mod.write('import pkg1.mod1\nfrom pkg1.mod1 import a_var\n' |
| 540 'def a_func():\n print(pkg1.mod1, a_var)\n') |
| 541 pymod = self.project.get_module('mod') |
| 542 changed_module = self.import_tools.froms_to_imports(pymod) |
| 543 self.assertEquals('import pkg1.mod1\n' |
| 544 'def a_func():\n ' |
| 545 'print(pkg1.mod1, pkg1.mod1.a_var)\n', |
| 546 changed_module) |
| 547 |
| 548 def test_transforming_froms_to_normal_from_with_alias(self): |
| 549 self.mod1.write('def a_func():\n pass\n') |
| 550 self.mod.write( |
| 551 'from pkg1.mod1 import a_func as another_func\nanother_func()\n') |
| 552 pymod = self.project.get_module('mod') |
| 553 changed_module = self.import_tools.froms_to_imports(pymod) |
| 554 self.assertEquals('import pkg1.mod1\npkg1.mod1.a_func()\n', |
| 555 changed_module) |
| 556 |
| 557 def test_transforming_froms_to_normal_for_relatives(self): |
| 558 self.mod2.write('def a_func():\n pass\n') |
| 559 self.mod3.write('from mod2 import *\na_func()\n') |
| 560 pymod = self.project.get_pymodule(self.mod3) |
| 561 changed_module = self.import_tools.froms_to_imports(pymod) |
| 562 self.assertEquals('import pkg2.mod2\npkg2.mod2.a_func()\n', |
| 563 changed_module) |
| 564 |
| 565 def test_transforming_froms_to_normal_for_os_path(self): |
| 566 self.mod.write('from os import path\npath.exists(\'.\')\n') |
| 567 pymod = self.project.get_pymodule(self.mod) |
| 568 changed_module = self.import_tools.froms_to_imports(pymod) |
| 569 self.assertEquals('import os\nos.path.exists(\'.\')\n', changed_module) |
| 570 |
| 571 def test_transform_relatives_imports_to_abs_imports_doing_nothing(self): |
| 572 self.mod2.write('from pkg1 import mod1\nimport mod1\n') |
| 573 pymod = self.project.get_pymodule(self.mod2) |
| 574 self.assertEquals('from pkg1 import mod1\nimport mod1\n', |
| 575 self.import_tools.relatives_to_absolutes(pymod)) |
| 576 |
| 577 def test_transform_relatives_to_absolute_imports_for_normal_imports(self): |
| 578 self.mod2.write('import mod3\n') |
| 579 pymod = self.project.get_pymodule(self.mod2) |
| 580 self.assertEquals('import pkg2.mod3\n', |
| 581 self.import_tools.relatives_to_absolutes(pymod)) |
| 582 |
| 583 def test_transform_relatives_imports_to_absolute_imports_for_froms(self): |
| 584 self.mod3.write('def a_func():\n pass\n') |
| 585 self.mod2.write('from mod3 import a_func\n') |
| 586 pymod = self.project.get_pymodule(self.mod2) |
| 587 self.assertEquals('from pkg2.mod3 import a_func\n', |
| 588 self.import_tools.relatives_to_absolutes(pymod)) |
| 589 |
| 590 @testutils.run_only_for_25 |
| 591 def test_transform_rel_imports_to_abs_imports_for_new_relatives(self): |
| 592 self.mod3.write('def a_func():\n pass\n') |
| 593 self.mod2.write('from .mod3 import a_func\n') |
| 594 pymod = self.project.get_pymodule(self.mod2) |
| 595 self.assertEquals('from pkg2.mod3 import a_func\n', |
| 596 self.import_tools.relatives_to_absolutes(pymod)) |
| 597 |
| 598 def test_transform_relatives_to_absolute_imports_for_normal_imports2(self): |
| 599 self.mod2.write('import mod3\nprint(mod3)') |
| 600 pymod = self.project.get_pymodule(self.mod2) |
| 601 self.assertEquals('import pkg2.mod3\nprint(pkg2.mod3)', |
| 602 self.import_tools.relatives_to_absolutes(pymod)) |
| 603 |
| 604 def test_transform_relatives_to_absolute_imports_for_aliases(self): |
| 605 self.mod2.write('import mod3 as mod3\nprint(mod3)') |
| 606 pymod = self.project.get_pymodule(self.mod2) |
| 607 self.assertEquals('import pkg2.mod3 as mod3\nprint(mod3)', |
| 608 self.import_tools.relatives_to_absolutes(pymod)) |
| 609 |
| 610 def test_organizing_imports(self): |
| 611 self.mod1.write('import mod1\n') |
| 612 pymod = self.project.get_pymodule(self.mod1) |
| 613 self.assertEquals('', self.import_tools.organize_imports(pymod)) |
| 614 |
| 615 def test_organizing_imports_without_deduplication(self): |
| 616 contents = 'from pkg2 import mod2\nfrom pkg2 import mod3\n' |
| 617 self.mod.write(contents) |
| 618 pymod = self.project.get_pymodule(self.mod) |
| 619 self.project.prefs['split_imports'] = True |
| 620 self.assertEquals(contents, |
| 621 self.import_tools.organize_imports(pymod, |
| 622 unused=False)) |
| 623 |
| 624 def test_splitting_imports(self): |
| 625 self.mod.write('from pkg1 import mod1\nfrom pkg2 import mod2, mod3\n') |
| 626 pymod = self.project.get_pymodule(self.mod) |
| 627 self.project.prefs['split_imports'] = True |
| 628 self.assertEquals('from pkg1 import mod1\nfrom pkg2 import mod2\n' |
| 629 'from pkg2 import mod3\n', |
| 630 self.import_tools.organize_imports(pymod, |
| 631 unused=False)) |
| 632 |
| 633 def test_splitting_duplicate_imports(self): |
| 634 self.mod.write('from pkg2 import mod1\nfrom pkg2 import mod1, mod2\n') |
| 635 pymod = self.project.get_pymodule(self.mod) |
| 636 self.project.prefs['split_imports'] = True |
| 637 self.assertEquals('from pkg2 import mod1\nfrom pkg2 import mod2\n', |
| 638 self.import_tools.organize_imports(pymod, |
| 639 unused=False)) |
| 640 |
| 641 def test_splitting_duplicate_imports2(self): |
| 642 self.mod.write('from pkg2 import mod1, mod3\n' |
| 643 'from pkg2 import mod1, mod2\n' |
| 644 'from pkg2 import mod2, mod3\n') |
| 645 pymod = self.project.get_pymodule(self.mod) |
| 646 self.project.prefs['split_imports'] = True |
| 647 self.assertEquals('from pkg2 import mod1\nfrom pkg2 import mod2\n' |
| 648 'from pkg2 import mod3\n', |
| 649 self.import_tools.organize_imports(pymod, |
| 650 unused=False)) |
| 651 |
| 652 def test_removing_self_imports(self): |
| 653 self.mod.write('import mod\nmod.a_var = 1\nprint(mod.a_var)\n') |
| 654 pymod = self.project.get_pymodule(self.mod) |
| 655 self.assertEquals('a_var = 1\nprint(a_var)\n', |
| 656 self.import_tools.organize_imports(pymod)) |
| 657 |
| 658 def test_removing_self_imports2(self): |
| 659 self.mod1.write('import pkg1.mod1\npkg1.mod1.a_var = 1\n' |
| 660 'print(pkg1.mod1.a_var)\n') |
| 661 pymod = self.project.get_pymodule(self.mod1) |
| 662 self.assertEquals('a_var = 1\nprint(a_var)\n', |
| 663 self.import_tools.organize_imports(pymod)) |
| 664 |
| 665 def test_removing_self_imports_with_as(self): |
| 666 self.mod.write('import mod as mymod\n' |
| 667 'mymod.a_var = 1\nprint(mymod.a_var)\n') |
| 668 pymod = self.project.get_pymodule(self.mod) |
| 669 self.assertEquals('a_var = 1\nprint(a_var)\n', |
| 670 self.import_tools.organize_imports(pymod)) |
| 671 |
| 672 def test_removing_self_imports_for_froms(self): |
| 673 self.mod1.write('from pkg1 import mod1\n' |
| 674 'mod1.a_var = 1\nprint(mod1.a_var)\n') |
| 675 pymod = self.project.get_pymodule(self.mod1) |
| 676 self.assertEquals('a_var = 1\nprint(a_var)\n', |
| 677 self.import_tools.organize_imports(pymod)) |
| 678 |
| 679 def test_removing_self_imports_for_froms_with_as(self): |
| 680 self.mod1.write('from pkg1 import mod1 as mymod\n' |
| 681 'mymod.a_var = 1\nprint(mymod.a_var)\n') |
| 682 pymod = self.project.get_pymodule(self.mod1) |
| 683 self.assertEquals('a_var = 1\nprint(a_var)\n', |
| 684 self.import_tools.organize_imports(pymod)) |
| 685 |
| 686 def test_removing_self_imports_for_froms2(self): |
| 687 self.mod.write('from mod import a_var\na_var = 1\nprint(a_var)\n') |
| 688 pymod = self.project.get_pymodule(self.mod) |
| 689 self.assertEquals('a_var = 1\nprint(a_var)\n', |
| 690 self.import_tools.organize_imports(pymod)) |
| 691 |
| 692 def test_removing_self_imports_for_froms3(self): |
| 693 self.mod.write('from mod import a_var\na_var = 1\nprint(a_var)\n') |
| 694 pymod = self.project.get_pymodule(self.mod) |
| 695 self.assertEquals('a_var = 1\nprint(a_var)\n', |
| 696 self.import_tools.organize_imports(pymod)) |
| 697 |
| 698 def test_removing_self_imports_for_froms4(self): |
| 699 self.mod.write('from mod import a_var as myvar\n' |
| 700 'a_var = 1\nprint(myvar)\n') |
| 701 pymod = self.project.get_pymodule(self.mod) |
| 702 self.assertEquals('a_var = 1\nprint(a_var)\n', |
| 703 self.import_tools.organize_imports(pymod)) |
| 704 |
| 705 def test_removing_self_imports_with_no_dot_after_mod(self): |
| 706 self.mod.write('import mod\nprint(mod)\n') |
| 707 pymod = self.project.get_pymodule(self.mod) |
| 708 self.assertEquals('import mod\n\n\nprint(mod)\n', |
| 709 self.import_tools.organize_imports(pymod)) |
| 710 |
| 711 def test_removing_self_imports_with_no_dot_after_mod2(self): |
| 712 self.mod.write('import mod\na_var = 1\n' |
| 713 'print(mod\\\n \\\n .var)\n\n') |
| 714 pymod = self.project.get_pymodule(self.mod) |
| 715 self.assertEquals('a_var = 1\nprint(var)\n\n', |
| 716 self.import_tools.organize_imports(pymod)) |
| 717 |
| 718 def test_removing_self_imports_for_from_import_star(self): |
| 719 self.mod.write('from mod import *\na_var = 1\nprint(myvar)\n') |
| 720 pymod = self.project.get_pymodule(self.mod) |
| 721 self.assertEquals('a_var = 1\nprint(myvar)\n', |
| 722 self.import_tools.organize_imports(pymod)) |
| 723 |
| 724 def test_not_removing_future_imports(self): |
| 725 self.mod.write('from __future__ import division\n') |
| 726 pymod = self.project.get_pymodule(self.mod) |
| 727 self.assertEquals('from __future__ import division\n', |
| 728 self.import_tools.organize_imports(pymod)) |
| 729 |
| 730 def test_sorting_empty_imports(self): |
| 731 self.mod.write('') |
| 732 pymod = self.project.get_pymodule(self.mod) |
| 733 self.assertEquals('', self.import_tools.sort_imports(pymod)) |
| 734 |
| 735 def test_sorting_one_import(self): |
| 736 self.mod.write('import pkg1.mod1\n') |
| 737 pymod = self.project.get_pymodule(self.mod) |
| 738 self.assertEquals('import pkg1.mod1\n', |
| 739 self.import_tools.sort_imports(pymod)) |
| 740 |
| 741 def test_sorting_imports_alphabetically(self): |
| 742 self.mod.write('import pkg2.mod2\nimport pkg1.mod1\n') |
| 743 pymod = self.project.get_pymodule(self.mod) |
| 744 self.assertEquals('import pkg1.mod1\nimport pkg2.mod2\n', |
| 745 self.import_tools.sort_imports(pymod)) |
| 746 |
| 747 def test_sorting_imports_purely_alphabetically(self): |
| 748 self.mod.write('from pkg2 import mod3 as mod0\n' |
| 749 'import pkg2.mod2\nimport pkg1.mod1\n') |
| 750 pymod = self.project.get_pymodule(self.mod) |
| 751 self.project.prefs['sort_imports_alphabetically'] = True |
| 752 self.assertEquals('import pkg1.mod1\nimport pkg2.mod2\n' |
| 753 'from pkg2 import mod3 as mod0\n', |
| 754 self.import_tools.sort_imports(pymod)) |
| 755 |
| 756 def test_sorting_imports_and_froms(self): |
| 757 self.mod.write('import pkg2.mod2\nfrom pkg1 import mod1\n') |
| 758 pymod = self.project.get_pymodule(self.mod) |
| 759 self.assertEquals('import pkg2.mod2\nfrom pkg1 import mod1\n', |
| 760 self.import_tools.sort_imports(pymod)) |
| 761 |
| 762 def test_sorting_imports_and_standard_modules(self): |
| 763 self.mod.write('import pkg1\nimport sys\n') |
| 764 pymod = self.project.get_pymodule(self.mod) |
| 765 self.assertEquals('import sys\n\nimport pkg1\n', |
| 766 self.import_tools.sort_imports(pymod)) |
| 767 |
| 768 def test_sorting_imports_and_standard_modules2(self): |
| 769 self.mod.write('import sys\n\nimport time\n') |
| 770 pymod = self.project.get_pymodule(self.mod) |
| 771 self.assertEquals('import sys\nimport time\n', |
| 772 self.import_tools.sort_imports(pymod)) |
| 773 |
| 774 def test_sorting_only_standard_modules(self): |
| 775 self.mod.write('import sys\n') |
| 776 pymod = self.project.get_pymodule(self.mod) |
| 777 self.assertEquals('import sys\n', |
| 778 self.import_tools.sort_imports(pymod)) |
| 779 |
| 780 def test_sorting_third_party(self): |
| 781 self.mod.write('import pkg1\nimport a_third_party\n') |
| 782 pymod = self.project.get_pymodule(self.mod) |
| 783 self.assertEquals('import a_third_party\n\nimport pkg1\n', |
| 784 self.import_tools.sort_imports(pymod)) |
| 785 |
| 786 def test_sorting_only_third_parties(self): |
| 787 self.mod.write('import a_third_party\na_var = 1\n') |
| 788 pymod = self.project.get_pymodule(self.mod) |
| 789 self.assertEquals('import a_third_party\n\n\na_var = 1\n', |
| 790 self.import_tools.sort_imports(pymod)) |
| 791 |
| 792 def test_simple_handling_long_imports(self): |
| 793 self.mod.write('import pkg1.mod1\n\n\nm = pkg1.mod1\n') |
| 794 pymod = self.project.get_pymodule(self.mod) |
| 795 self.assertEquals( |
| 796 'import pkg1.mod1\n\n\nm = pkg1.mod1\n', |
| 797 self.import_tools.handle_long_imports(pymod, maxdots=2)) |
| 798 |
| 799 def test_handling_long_imports_for_many_dots(self): |
| 800 self.mod.write('import p1.p2.p3.m1\n\n\nm = p1.p2.p3.m1\n') |
| 801 pymod = self.project.get_pymodule(self.mod) |
| 802 self.assertEquals( |
| 803 'from p1.p2.p3 import m1\n\n\nm = m1\n', |
| 804 self.import_tools.handle_long_imports(pymod, maxdots=2)) |
| 805 |
| 806 def test_handling_long_imports_for_their_length(self): |
| 807 self.mod.write('import p1.p2.p3.m1\n\n\nm = p1.p2.p3.m1\n') |
| 808 pymod = self.project.get_pymodule(self.mod) |
| 809 self.assertEquals( |
| 810 'import p1.p2.p3.m1\n\n\nm = p1.p2.p3.m1\n', |
| 811 self.import_tools.handle_long_imports(pymod, maxdots=3, |
| 812 maxlength=20)) |
| 813 |
| 814 def test_handling_long_imports_for_many_dots2(self): |
| 815 self.mod.write('import p1.p2.p3.m1\n\n\nm = p1.p2.p3.m1\n') |
| 816 pymod = self.project.get_pymodule(self.mod) |
| 817 self.assertEquals( |
| 818 'from p1.p2.p3 import m1\n\n\nm = m1\n', |
| 819 self.import_tools.handle_long_imports(pymod, maxdots=3, |
| 820 maxlength=10)) |
| 821 |
| 822 def test_handling_long_imports_with_one_letter_last(self): |
| 823 self.mod.write('import p1.p2.p3.l\n\n\nm = p1.p2.p3.l\n') |
| 824 pymod = self.project.get_pymodule(self.mod) |
| 825 self.assertEquals( |
| 826 'from p1.p2.p3 import l\n\n\nm = l\n', |
| 827 self.import_tools.handle_long_imports(pymod, maxdots=2)) |
| 828 |
| 829 def test_empty_removing_unused_imports_and_eating_blank_lines(self): |
| 830 self.mod.write('import pkg1\nimport pkg2\n\n\nprint(pkg1)\n') |
| 831 pymod = self.project.get_module('mod') |
| 832 module_with_imports = self.import_tools.module_imports(pymod) |
| 833 module_with_imports.remove_unused_imports() |
| 834 self.assertEquals('import pkg1\n\n\nprint(pkg1)\n', |
| 835 module_with_imports.get_changed_source()) |
| 836 |
| 837 def test_sorting_imports_moving_to_top(self): |
| 838 self.mod.write('import mod\ndef f():\n print(mod, pkg1, pkg2)\n' |
| 839 'import pkg1\nimport pkg2\n') |
| 840 pymod = self.project.get_module('mod') |
| 841 self.assertEquals('import mod\nimport pkg1\nimport pkg2\n\n\n' |
| 842 'def f():\n print(mod, pkg1, pkg2)\n', |
| 843 self.import_tools.sort_imports(pymod)) |
| 844 |
| 845 def test_sorting_imports_moving_to_top2(self): |
| 846 self.mod.write('def f():\n print(mod)\nimport mod\n') |
| 847 pymod = self.project.get_module('mod') |
| 848 self.assertEquals('import mod\n\n\ndef f():\n print(mod)\n', |
| 849 self.import_tools.sort_imports(pymod)) |
| 850 |
| 851 def test_sorting_imports_moving_to_top_and_module_docs(self): |
| 852 self.mod.write('"""\ndocs\n"""\ndef f():' |
| 853 '\n print(mod)\nimport mod\n') |
| 854 pymod = self.project.get_module('mod') |
| 855 self.assertEquals( |
| 856 '"""\ndocs\n"""\nimport mod\n\n\ndef f():\n print(mod)\n', |
| 857 self.import_tools.sort_imports(pymod)) |
| 858 |
| 859 def test_sorting_future_imports(self): |
| 860 self.mod.write('import os\nfrom __future__ import devision\n') |
| 861 pymod = self.project.get_module('mod') |
| 862 self.assertEquals( |
| 863 'from __future__ import devision\n\nimport os\n', |
| 864 self.import_tools.sort_imports(pymod)) |
| 865 |
| 866 def test_customized_import_organization(self): |
| 867 self.mod.write('import sys\nimport sys\n') |
| 868 pymod = self.project.get_pymodule(self.mod) |
| 869 self.assertEquals( |
| 870 'import sys\n', |
| 871 self.import_tools.organize_imports(pymod, unused=False)) |
| 872 |
| 873 def test_customized_import_organization2(self): |
| 874 self.mod.write('import sys\n') |
| 875 pymod = self.project.get_pymodule(self.mod) |
| 876 self.assertEquals( |
| 877 'import sys\n', |
| 878 self.import_tools.organize_imports(pymod, unused=False)) |
| 879 |
| 880 def test_customized_import_organization3(self): |
| 881 self.mod.write('import sys\nimport mod\n\n\nvar = 1\nprint(mod.var)\n') |
| 882 pymod = self.project.get_pymodule(self.mod) |
| 883 self.assertEquals( |
| 884 'import sys\n\n\nvar = 1\nprint(var)\n', |
| 885 self.import_tools.organize_imports(pymod, unused=False)) |
| 886 |
| 887 def test_trivial_filtered_expand_stars(self): |
| 888 self.pkg1.get_child('__init__.py').write('var1 = 1\n') |
| 889 self.pkg2.get_child('__init__.py').write('var2 = 1\n') |
| 890 self.mod.write('from pkg1 import *\nfrom pkg2 import *\n\n' |
| 891 'print(var1, var2)\n') |
| 892 pymod = self.project.get_pymodule(self.mod) |
| 893 self.assertEquals( |
| 894 'from pkg1 import *\nfrom pkg2 import *\n\nprint(var1, var2)\n', |
| 895 self.import_tools.expand_stars(pymod, lambda stmt: False)) |
| 896 |
| 897 def _line_filter(self, lineno): |
| 898 def import_filter(import_stmt): |
| 899 return import_stmt.start_line <= lineno < import_stmt.end_line |
| 900 return import_filter |
| 901 |
| 902 def test_filtered_expand_stars(self): |
| 903 self.pkg1.get_child('__init__.py').write('var1 = 1\n') |
| 904 self.pkg2.get_child('__init__.py').write('var2 = 1\n') |
| 905 self.mod.write('from pkg1 import *\nfrom pkg2 import *\n\n' |
| 906 'print(var1, var2)\n') |
| 907 pymod = self.project.get_pymodule(self.mod) |
| 908 self.assertEquals( |
| 909 'from pkg1 import *\nfrom pkg2 import var2\n\nprint(var1, var2)\n', |
| 910 self.import_tools.expand_stars(pymod, self._line_filter(2))) |
| 911 |
| 912 def test_filtered_relative_to_absolute(self): |
| 913 self.mod3.write('var = 1') |
| 914 self.mod2.write('import mod3\n\nprint(mod3.var)\n') |
| 915 pymod = self.project.get_pymodule(self.mod2) |
| 916 self.assertEquals( |
| 917 'import mod3\n\nprint(mod3.var)\n', |
| 918 self.import_tools.relatives_to_absolutes( |
| 919 pymod, lambda stmt: False)) |
| 920 self.assertEquals( |
| 921 'import pkg2.mod3\n\nprint(pkg2.mod3.var)\n', |
| 922 self.import_tools.relatives_to_absolutes( |
| 923 pymod, self._line_filter(1))) |
| 924 |
| 925 def test_filtered_froms_to_normals(self): |
| 926 self.pkg1.get_child('__init__.py').write('var1 = 1\n') |
| 927 self.pkg2.get_child('__init__.py').write('var2 = 1\n') |
| 928 self.mod.write('from pkg1 import var1\nfrom pkg2 import var2\n\n' |
| 929 'print(var1, var2)\n') |
| 930 pymod = self.project.get_pymodule(self.mod) |
| 931 self.assertEquals( |
| 932 'from pkg1 import var1\nfrom pkg2 ' |
| 933 'import var2\n\nprint(var1, var2)\n', |
| 934 self.import_tools.expand_stars(pymod, lambda stmt: False)) |
| 935 self.assertEquals( |
| 936 'from pkg1 import var1\nimport pkg2\n\nprint(var1, pkg2.var2)\n', |
| 937 self.import_tools.froms_to_imports(pymod, self._line_filter(2))) |
| 938 |
| 939 def test_filtered_froms_to_normals2(self): |
| 940 self.pkg1.get_child('__init__.py').write('var1 = 1\n') |
| 941 self.pkg2.get_child('__init__.py').write('var2 = 1\n') |
| 942 self.mod.write('from pkg1 import *\nfrom pkg2 import *\n\n' |
| 943 'print(var1, var2)\n') |
| 944 pymod = self.project.get_pymodule(self.mod) |
| 945 self.assertEquals( |
| 946 'from pkg1 import *\nimport pkg2\n\nprint(var1, pkg2.var2)\n', |
| 947 self.import_tools.froms_to_imports(pymod, self._line_filter(2))) |
| 948 |
| 949 def test_filtered_handle_long_imports(self): |
| 950 self.mod.write('import p1.p2.p3.m1\nimport pkg1.mod1\n\n\n' |
| 951 'm = p1.p2.p3.m1, pkg1.mod1\n') |
| 952 pymod = self.project.get_pymodule(self.mod) |
| 953 self.assertEquals( |
| 954 'import p1.p2.p3.m1\nfrom pkg1 import mod1\n\n\n' |
| 955 'm = p1.p2.p3.m1, mod1\n', |
| 956 self.import_tools.handle_long_imports( |
| 957 pymod, maxlength=5, |
| 958 import_filter=self._line_filter(2))) |
| 959 |
| 960 def test_filtering_and_import_actions_with_more_than_one_phase(self): |
| 961 self.pkg1.get_child('__init__.py').write('var1 = 1\n') |
| 962 self.pkg2.get_child('__init__.py').write('var2 = 1\n') |
| 963 self.mod.write('from pkg1 import *\nfrom pkg2 import *\n\n' |
| 964 'print(var2)\n') |
| 965 pymod = self.project.get_pymodule(self.mod) |
| 966 self.assertEquals( |
| 967 'from pkg2 import *\n\nprint(var2)\n', |
| 968 self.import_tools.expand_stars(pymod, self._line_filter(1))) |
| 969 |
| 970 def test_non_existent_module_and_used_imports(self): |
| 971 self.mod.write( |
| 972 'from does_not_exist import func\n\nfunc()\n') |
| 973 pymod = self.project.get_module('mod') |
| 974 |
| 975 module_with_imports = self.import_tools.module_imports(pymod) |
| 976 imports = module_with_imports.get_used_imports(pymod) |
| 977 self.assertEquals(1, len(imports)) |
| 978 |
| 979 |
| 980 class AddImportTest(unittest.TestCase): |
| 981 |
| 982 def setUp(self): |
| 983 super(AddImportTest, self).setUp() |
| 984 self.project = testutils.sample_project() |
| 985 |
| 986 self.mod1 = testutils.create_module(self.project, 'mod1') |
| 987 self.mod2 = testutils.create_module(self.project, 'mod2') |
| 988 self.pkg = testutils.create_package(self.project, 'pkg') |
| 989 self.mod3 = testutils.create_module(self.project, 'mod3', self.pkg) |
| 990 |
| 991 def tearDown(self): |
| 992 testutils.remove_project(self.project) |
| 993 super(AddImportTest, self).tearDown() |
| 994 |
| 995 def test_normal_imports(self): |
| 996 self.mod2.write('myvar = None\n') |
| 997 self.mod1.write('\n') |
| 998 pymod = self.project.get_module('mod1') |
| 999 result, name = add_import(self.project, pymod, 'mod2', 'myvar') |
| 1000 self.assertEquals('import mod2\n', result) |
| 1001 self.assertEquals('mod2.myvar', name) |
| 1002 |
| 1003 def test_not_reimporting_a_name(self): |
| 1004 self.mod2.write('myvar = None\n') |
| 1005 self.mod1.write('from mod2 import myvar\n') |
| 1006 pymod = self.project.get_module('mod1') |
| 1007 result, name = add_import(self.project, pymod, 'mod2', 'myvar') |
| 1008 self.assertEquals('from mod2 import myvar\n', result) |
| 1009 self.assertEquals('myvar', name) |
| 1010 |
| 1011 def test_adding_import_when_siblings_are_imported(self): |
| 1012 self.mod2.write('var1 = None\nvar2 = None\n') |
| 1013 self.mod1.write('from mod2 import var1\n') |
| 1014 pymod = self.project.get_module('mod1') |
| 1015 result, name = add_import(self.project, pymod, 'mod2', 'var2') |
| 1016 self.assertEquals('from mod2 import var1, var2\n', result) |
| 1017 self.assertEquals('var2', name) |
| 1018 |
| 1019 def test_adding_import_when_the_package_is_imported(self): |
| 1020 self.pkg.get_child('__init__.py').write('var1 = None\n') |
| 1021 self.mod3.write('var2 = None\n') |
| 1022 self.mod1.write('from pkg import var1\n') |
| 1023 pymod = self.project.get_module('mod1') |
| 1024 result, name = add_import(self.project, pymod, 'pkg.mod3', 'var2') |
| 1025 self.assertEquals('from pkg import var1, mod3\n', result) |
| 1026 self.assertEquals('mod3.var2', name) |
| 1027 |
| 1028 def test_adding_import_for_modules_instead_of_names(self): |
| 1029 self.pkg.get_child('__init__.py').write('var1 = None\n') |
| 1030 self.mod3.write('\n') |
| 1031 self.mod1.write('from pkg import var1\n') |
| 1032 pymod = self.project.get_module('mod1') |
| 1033 result, name = add_import(self.project, pymod, 'pkg.mod3', None) |
| 1034 self.assertEquals('from pkg import var1, mod3\n', result) |
| 1035 self.assertEquals('mod3', name) |
| 1036 |
| 1037 def test_adding_import_for_modules_with_normal_duplicate_imports(self): |
| 1038 self.pkg.get_child('__init__.py').write('var1 = None\n') |
| 1039 self.mod3.write('\n') |
| 1040 self.mod1.write('import pkg.mod3\n') |
| 1041 pymod = self.project.get_module('mod1') |
| 1042 result, name = add_import(self.project, pymod, 'pkg.mod3', None) |
| 1043 self.assertEquals('import pkg.mod3\n', result) |
| 1044 self.assertEquals('pkg.mod3', name) |
| 1045 |
| 1046 |
| 1047 def suite(): |
| 1048 result = unittest.TestSuite() |
| 1049 result.addTests(unittest.makeSuite(ImportUtilsTest)) |
| 1050 result.addTests(unittest.makeSuite(AddImportTest)) |
| 1051 return result |
| 1052 |
| 1053 if __name__ == '__main__': |
| 1054 unittest.main() |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1132103009:
Example of refactoring using rope library. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master