diff --git a/ropetest/refactor/renametest.py b/ropetest/refactor/renametest.py index e26e79c88..6d8f9cd08 100644 --- a/ropetest/refactor/renametest.py +++ b/ropetest/refactor/renametest.py @@ -41,170 +41,138 @@ def test_simple_global_variable_renaming(self): def test_variable_renaming_only_in_its_scope(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ a_var = 20 def a_func(): a_var = 10 - """ - ), + """), 32, "new_var", ) self.assertEqual( - dedent( - """\ + dedent("""\ a_var = 20 def a_func(): new_var = 10 - """ - ), + """), refactored, ) def test_not_renaming_dot_name(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ replace = True 'aaa'.replace('a', 'b') - """ - ), + """), 1, "new_var", ) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = True 'aaa'.replace('a', 'b') - """ - ), + """), refactored, ) def test_renaming_multiple_names_in_the_same_line(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ a_var = 10 a_var = 10 + a_var / 2 - """ - ), + """), 2, "new_var", ) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 10 new_var = 10 + new_var / 2 - """ - ), + """), refactored, ) def test_renaming_names_when_getting_some_attribute(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ a_var = 'a b c' a_var.split('\\n') - """ - ), + """), 2, "new_var", ) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 'a b c' new_var.split('\\n') - """ - ), + """), refactored, ) def test_renaming_names_when_getting_some_attribute2(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ a_var = 'a b c' a_var.split('\\n') - """ - ), + """), 20, "new_var", ) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 'a b c' new_var.split('\\n') - """ - ), + """), refactored, ) def test_renaming_function_parameters1(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ def f(a_param): print(a_param) - """ - ), + """), 8, "new_param", ) self.assertEqual( - dedent( - """\ + dedent("""\ def f(new_param): print(new_param) - """ - ), + """), refactored, ) def test_renaming_function_parameters2(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ def f(a_param): print(a_param) - """ - ), + """), 30, "new_param", ) self.assertEqual( - dedent( - """\ + dedent("""\ def f(new_param): print(new_param) - """ - ), + """), refactored, ) def test_renaming_occurrences_inside_functions(self): - code = dedent( - """\ + code = dedent("""\ def a_func(p1): a = p1 a_func(1) - """ - ) + """) refactored = self._local_rename(code, code.index("p1") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): a = new_param a_func(1) - """ - ), + """), refactored, ) @@ -232,118 +200,94 @@ def test_renaming_generator_comprehension_loop_variables(self): ) def test_renaming_comprehension_loop_variables_scope(self): - code = dedent( - """\ + code = dedent("""\ [b_var for b_var, c_var in d_var if b_var == c_var] b_var = 10 - """ - ) + """) refactored = self._local_rename(code, code.index("b_var") + 1, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ [new_var for new_var, c_var in d_var if new_var == c_var] b_var = 10 - """ - ), + """), refactored, ) @testutils.only_for_versions_higher("3.8") def test_renaming_inline_assignment(self): - code = dedent( - """\ + code = dedent("""\ while a_var := next(foo): print(a_var) - """ - ) + """) refactored = self._local_rename(code, code.index("a_var") + 1, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ while new_var := next(foo): print(new_var) - """ - ), + """), refactored, ) def test_renaming_arguments_for_normal_args_changing_calls(self): - code = dedent( - """\ + code = dedent("""\ def a_func(p1=None, p2=None): pass a_func(p2=1) - """ - ) + """) refactored = self._local_rename(code, code.index("p2") + 1, "p3") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(p1=None, p3=None): pass a_func(p3=1) - """ - ), + """), refactored, ) def test_renaming_function_parameters_of_class_init(self): - code = dedent( - """\ + code = dedent("""\ class A(object): def __init__(self, a_param): pass a_var = A(a_param=1) - """ - ) + """) refactored = self._local_rename(code, code.index("a_param") + 1, "new_param") - expected = dedent( - """\ + expected = dedent("""\ class A(object): def __init__(self, new_param): pass a_var = A(new_param=1) - """ - ) + """) self.assertEqual(expected, refactored) def test_rename_functions_parameters_and_occurences_in_other_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") mod1.write( - dedent( - """\ + dedent("""\ def a_func(a_param): print(a_param) - """ - ) + """) ) mod2.write( - dedent( - """\ + dedent("""\ from mod1 import a_func a_func(a_param=10) - """ - ) + """) ) self._rename(mod1, mod1.read().index("a_param") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): print(new_param) - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ from mod1 import a_func a_func(new_param=10) - """ - ), + """), mod2.read(), ) @@ -355,35 +299,27 @@ def test_renaming_with_backslash_continued_names(self): @testutils.only_for("3.6") def test_renaming_occurrence_in_f_string(self): - code = dedent( - """\ + code = dedent("""\ a_var = 20 a_string=f'value: {a_var}' - """ - ) - expected = dedent( - """\ + """) + expected = dedent("""\ new_var = 20 a_string=f'value: {new_var}' - """ - ) + """) refactored = self._local_rename(code, 2, "new_var") self.assertEqual(expected, refactored) @testutils.only_for("3.6") def test_renaming_occurrence_in_nested_f_string(self): - code = dedent( - """\ + code = dedent("""\ a_var = 20 a_string=f'{f"{a_var}"}' - """ - ) - expected = dedent( - """\ + """) + expected = dedent("""\ new_var = 20 a_string=f'{f"{new_var}"}' - """ - ) + """) refactored = self._local_rename(code, 2, "new_var") self.assertEqual(expected, refactored) @@ -393,352 +329,284 @@ def test_not_renaming_string_contents_in_f_string(self): "a_var = 20\na_string=f'{\"a_var\"}'\n", 2, "new_var" ) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 20 a_string=f'{"a_var"}' - """ - ), + """), refactored, ) def test_not_renaming_string_contents(self): refactored = self._local_rename("a_var = 20\na_string='a_var'\n", 2, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 20 a_string='a_var' - """ - ), + """), refactored, ) def test_not_renaming_comment_contents(self): refactored = self._local_rename("a_var = 20\n# a_var\n", 2, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 20 # a_var - """ - ), + """), refactored, ) def test_renaming_all_occurrences_in_containing_scope(self): - code = dedent( - """\ + code = dedent("""\ if True: a_var = 1 else: a_var = 20 - """ - ) + """) refactored = self._local_rename(code, 16, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ if True: new_var = 1 else: new_var = 20 - """ - ), + """), refactored, ) def test_renaming_a_variable_with_arguement_name(self): - code = dedent( - """\ + code = dedent("""\ a_var = 10 def a_func(a_var): print(a_var) - """ - ) + """) refactored = self._local_rename(code, 1, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 10 def a_func(a_var): print(a_var) - """ - ), + """), refactored, ) def test_renaming_an_arguement_with_variable_name(self): - code = dedent( - """\ + code = dedent("""\ a_var = 10 def a_func(a_var): print(a_var) - """ - ) + """) refactored = self._local_rename(code, len(code) - 3, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ a_var = 10 def a_func(new_var): print(new_var) - """ - ), + """), refactored, ) def test_renaming_function_with_local_variable_name(self): - code = dedent( - """\ + code = dedent("""\ def a_func(): a_func=20 - a_func()""" - ) + a_func()""") refactored = self._local_rename(code, len(code) - 3, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ def new_func(): a_func=20 - new_func()""" - ), + new_func()"""), refactored, ) def test_renaming_functions(self): - code = dedent( - """\ + code = dedent("""\ def a_func(): pass a_func() - """ - ) + """) refactored = self._local_rename(code, len(code) - 5, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ def new_func(): pass new_func() - """ - ), + """), refactored, ) @testutils.only_for("3.5") def test_renaming_async_function(self): - code = dedent( - """\ + code = dedent("""\ async def a_func(): pass - a_func()""" - ) + a_func()""") refactored = self._local_rename(code, len(code) - 5, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ async def new_func(): pass - new_func()""" - ), + new_func()"""), refactored, ) @testutils.only_for("3.5") def test_renaming_await(self): - code = dedent( - """\ + code = dedent("""\ async def b_func(): pass async def a_func(): - await b_func()""" - ) + await b_func()""") refactored = self._local_rename(code, len(code) - 5, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ async def new_func(): pass async def a_func(): - await new_func()""" - ), + await new_func()"""), refactored, ) def test_renaming_functions_across_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass a_func() - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ import mod1 mod1.a_func() - """ - ) + """) ) self._rename(mod1, len(mod1.read()) - 5, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ def new_func(): pass new_func() - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 mod1.new_func() - """ - ), + """), mod2.read(), ) def test_renaming_functions_across_modules_from_import(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass a_func() - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ from mod1 import a_func a_func() - """ - ) + """) ) self._rename(mod1, len(mod1.read()) - 5, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ def new_func(): pass new_func() - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ from mod1 import new_func new_func() - """ - ), + """), mod2.read(), ) def test_renaming_functions_from_another_module(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass a_func() - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ import mod1 mod1.a_func() - """ - ) + """) ) self._rename(mod2, len(mod2.read()) - 5, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ def new_func(): pass new_func() - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 mod1.new_func() - """ - ), + """), mod2.read(), ) def test_applying_all_changes_together(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ import mod2 mod2.a_func() - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ def a_func(): pass a_func() - """ - ) + """) ) self._rename(mod2, len(mod2.read()) - 5, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ import mod2 mod2.new_func() - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ def new_func(): pass new_func() - """ - ), + """), mod2.read(), ) def test_renaming_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write("from mod1 import a_func\n") @@ -751,21 +619,17 @@ def a_func(): def test_renaming_modules_aliased(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ import mod1 as m m.a_func() - """ - ) + """) ) self._rename(mod1, None, "newmod") self.assertTrue( @@ -777,12 +641,10 @@ def test_renaming_packages(self): pkg = testutils.create_package(self.project, "pkg") mod1 = testutils.create_module(self.project, "mod1", pkg) mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2", pkg) mod2.write("from pkg.mod1 import a_func\n") @@ -794,175 +656,144 @@ def a_func(): def test_module_dependencies(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ class AClass(object): pass - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ import mod1 a_var = mod1.AClass() - """ - ) + """) ) self.project.get_pymodule(mod2).get_attributes()["mod1"] mod1.write( - dedent( - """\ + dedent("""\ def AClass(): return 0 - """ - ) + """) ) self._rename(mod2, len(mod2.read()) - 3, "a_func") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(): return 0 - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 a_var = mod1.a_func() - """ - ), + """), mod2.read(), ) def test_renaming_class_attributes(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ class AClass(object): def __init__(self): self.an_attr = 10 - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ import mod1 a_var = mod1.AClass() - another_var = a_var.an_attr""" - ) + another_var = a_var.an_attr""") ) self._rename(mod1, mod1.read().index("an_attr"), "attr") self.assertEqual( - dedent( - """\ + dedent("""\ class AClass(object): def __init__(self): self.attr = 10 - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 a_var = mod1.AClass() - another_var = a_var.attr""" - ), + another_var = a_var.attr"""), mod2.read(), ) def test_renaming_class_attributes2(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ class AClass(object): def __init__(self): an_attr = 10 self.an_attr = 10 - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ import mod1 a_var = mod1.AClass() - another_var = a_var.an_attr""" - ) + another_var = a_var.an_attr""") ) self._rename(mod1, mod1.read().rindex("an_attr"), "attr") self.assertEqual( - dedent( - """\ + dedent("""\ class AClass(object): def __init__(self): an_attr = 10 self.attr = 10 - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 a_var = mod1.AClass() - another_var = a_var.attr""" - ), + another_var = a_var.attr"""), mod2.read(), ) def test_renaming_methods_in_subclasses(self): mod = testutils.create_module(self.project, "mod1") mod.write( - dedent( - """\ + dedent("""\ class A(object): def a_method(self): pass class B(A): def a_method(self): pass - """ - ) + """) ) self._rename( mod, mod.read().rindex("a_method") + 1, "new_method", in_hierarchy=True ) self.assertEqual( - dedent( - """\ + dedent("""\ class A(object): def new_method(self): pass class B(A): def new_method(self): pass - """ - ), + """), mod.read(), ) def test_renaming_methods_in_sibling_classes(self): mod = testutils.create_module(self.project, "mod1") mod.write( - dedent( - """\ + dedent("""\ class A(object): def a_method(self): pass @@ -972,16 +803,14 @@ def a_method(self): class C(A): def a_method(self): pass - """ - ) + """) ) self._rename( mod, mod.read().rindex("a_method") + 1, "new_method", in_hierarchy=True ) self.assertEqual( - dedent( - """\ + dedent("""\ class A(object): def new_method(self): pass @@ -991,76 +820,65 @@ def new_method(self): class C(A): def new_method(self): pass - """ - ), + """), mod.read(), ) def test_not_renaming_methods_in_hierarchies(self): mod = testutils.create_module(self.project, "mod1") mod.write( - dedent( - """\ + dedent("""\ class A(object): def a_method(self): pass class B(A): def a_method(self): pass - """ - ) + """) ) self._rename( mod, mod.read().rindex("a_method") + 1, "new_method", in_hierarchy=False ) self.assertEqual( - dedent( - """\ + dedent("""\ class A(object): def a_method(self): pass class B(A): def new_method(self): pass - """ - ), + """), mod.read(), ) def test_undoing_refactorings(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass a_func() - """ - ) + """) ) self._rename(mod1, len(mod1.read()) - 5, "new_func") self.project.history.undo() self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(): pass a_func() - """ - ), + """), mod1.read(), ) def test_undoing_renaming_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write("from mod1 import a_func\n") @@ -1079,273 +897,219 @@ def test_rename_in_module_renaming_one_letter_names_for_expressions(self): finder, "new_var", pymodule=pymod, replace_primary=True ) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 10 print(1+new_var) - """ - ), + """), refactored, ) def test_renaming_for_loop_variable(self): - code = dedent( - """\ + code = dedent("""\ for var in range(10): print(var) - """ - ) + """) refactored = self._local_rename(code, code.find("var") + 1, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ for new_var in range(10): print(new_var) - """ - ), + """), refactored, ) @testutils.only_for("3.5") def test_renaming_async_for_loop_variable(self): - code = dedent( - """\ + code = dedent("""\ async def func(): async for var in range(10): print(var) - """ - ) + """) refactored = self._local_rename(code, code.find("var") + 1, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ async def func(): async for new_var in range(10): print(new_var) - """ - ), + """), refactored, ) @testutils.only_for("3.5") def test_renaming_async_with_context_manager(self): - code = dedent( - """\ + code = dedent("""\ def a_cm(): pass async def a_func(): - async with a_cm() as x: pass""" - ) + async with a_cm() as x: pass""") refactored = self._local_rename(code, code.find("a_cm") + 1, "another_cm") - expected = dedent( - """\ + expected = dedent("""\ def another_cm(): pass async def a_func(): - async with another_cm() as x: pass""" - ) + async with another_cm() as x: pass""") self.assertEqual(refactored, expected) @testutils.only_for("3.5") def test_renaming_async_with_as_variable(self): - code = dedent( - """\ + code = dedent("""\ async def func(): async with a_func() as var: print(var) - """ - ) + """) refactored = self._local_rename(code, code.find("var") + 1, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ async def func(): async with a_func() as new_var: print(new_var) - """ - ), + """), refactored, ) def test_renaming_parameters(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param): print(param) a_func(param=hey) - """ - ) + """) refactored = self._local_rename(code, code.find("param") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): print(new_param) a_func(new_param=hey) - """ - ), + """), refactored, ) def test_renaming_assigned_parameters(self): - code = dedent( - """\ + code = dedent("""\ def f(p): p = p + 1 return p f(p=1) - """ - ) + """) refactored = self._local_rename(code, code.find("p"), "arg") self.assertEqual( - dedent( - """\ + dedent("""\ def f(arg): arg = arg + 1 return arg f(arg=1) - """ - ), + """), refactored, ) def test_renaming_parameters_not_renaming_others(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param): print(param) param=10 a_func(param) - """ - ) + """) refactored = self._local_rename(code, code.find("param") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): print(new_param) param=10 a_func(param) - """ - ), + """), refactored, ) def test_renaming_parameters_not_renaming_others2(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param): print(param) param=10 - a_func(param=param)""" - ) + a_func(param=param)""") refactored = self._local_rename(code, code.find("param") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): print(new_param) param=10 - a_func(new_param=param)""" - ), + a_func(new_param=param)"""), refactored, ) def test_renaming_parameters_with_multiple_params(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param1, param2): print(param1) a_func(param1=1, param2=2) - """ - ) + """) refactored = self._local_rename(code, code.find("param1") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param, param2): print(new_param) a_func(new_param=1, param2=2) - """ - ), + """), refactored, ) def test_renaming_parameters_with_multiple_params2(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param1, param2): print(param1) a_func(param1=1, param2=2) - """ - ) + """) refactored = self._local_rename(code, code.rfind("param2") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(param1, new_param): print(param1) a_func(param1=1, new_param=2) - """ - ), + """), refactored, ) def test_renaming_parameters_on_calls(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param): print(param) a_func(param = hey) - """ - ) + """) refactored = self._local_rename(code, code.rfind("param") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): print(new_param) a_func(new_param = hey) - """ - ), + """), refactored, ) def test_renaming_parameters_spaces_before_call(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param): print(param) a_func (param=hey) - """ - ) + """) refactored = self._local_rename(code, code.rfind("param") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): print(new_param) a_func (new_param=hey) - """ - ), + """), refactored, ) def test_renaming_parameter_like_objects_after_keywords(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param): print(param) dict(param=hey) - """ - ) + """) refactored = self._local_rename(code, code.find("param") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): print(new_param) dict(param=hey) - """ - ), + """), refactored, ) @@ -1405,72 +1169,60 @@ def test_renam_resources_use_rename_module_refactor_for_init_dot_py(self): self.assertEqual("import newpkg\nmy_pkg = newpkg", mod1.read()) def test_renaming_global_variables(self): - code = dedent( - """\ + code = dedent("""\ a_var = 1 def a_func(): global a_var var = a_var - """ - ) + """) refactored = self._local_rename(code, code.index("a_var"), "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 1 def a_func(): global new_var var = new_var - """ - ), + """), refactored, ) def test_renaming_global_variables2(self): - code = dedent( - """\ + code = dedent("""\ a_var = 1 def a_func(): global a_var var = a_var - """ - ) + """) refactored = self._local_rename(code, code.rindex("a_var"), "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 1 def a_func(): global new_var var = new_var - """ - ), + """), refactored, ) def test_renaming_when_unsure(self): - code = dedent( - """\ + code = dedent("""\ class C(object): def a_func(self): pass def f(arg): arg.a_func() - """ - ) + """) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_func"), "new_func", unsure=self._true) self.assertEqual( - dedent( - """\ + dedent("""\ class C(object): def new_func(self): pass def f(arg): arg.new_func() - """ - ), + """), mod1.read(), ) @@ -1481,34 +1233,29 @@ def test_renaming_when_unsure_with_confirmation(self): def confirm(occurrence): return False - code = dedent( - """\ + code = dedent("""\ class C(object): def a_func(self): pass def f(arg): arg.a_func() - """ - ) + """) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_func"), "new_func", unsure=confirm) self.assertEqual( - dedent( - """\ + dedent("""\ class C(object): def new_func(self): pass def f(arg): arg.a_func() - """ - ), + """), mod1.read(), ) def test_renaming_when_unsure_not_renaming_knowns(self): - code = dedent( - """\ + code = dedent("""\ class C1(object): def a_func(self): pass @@ -1519,14 +1266,12 @@ def a_func(self): c1.a_func() c2 = C2() c2.a_func() - """ - ) + """) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_func"), "new_func", unsure=self._true) self.assertEqual( - dedent( - """\ + dedent("""\ class C1(object): def new_func(self): pass @@ -1537,135 +1282,112 @@ def a_func(self): c1.new_func() c2 = C2() c2.a_func() - """ - ), + """), mod1.read(), ) def test_renaming_in_strings_and_comments(self): - code = dedent( - """\ + code = dedent("""\ a_var = 1 # a_var - """ - ) + """) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_var"), "new_var", docs=True) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 1 # new_var - """ - ), + """), mod1.read(), ) def test_not_renaming_in_strings_and_comments_where_not_visible(self): - code = dedent( - """\ + code = dedent("""\ def f(): a_var = 1 # a_var - """ - ) + """) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_var"), "new_var", docs=True) self.assertEqual( - dedent( - """\ + dedent("""\ def f(): new_var = 1 # a_var - """ - ), + """), mod1.read(), ) def test_not_renaming_all_text_occurrences_in_strings_and_comments(self): - code = dedent( - """\ + code = dedent("""\ a_var = 1 # a_vard _a_var - """ - ) + """) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_var"), "new_var", docs=True) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 1 # a_vard _a_var - """ - ), + """), mod1.read(), ) def test_renaming_occurrences_in_overwritten_scopes(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ a_var = 20 def f(): print(a_var) def f(): print(a_var) - """ - ), + """), 2, "new_var", ) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 20 def f(): print(new_var) def f(): print(new_var) - """ - ), + """), refactored, ) def test_renaming_occurrences_in_overwritten_scopes2(self): - code = dedent( - """\ + code = dedent("""\ def f(): a_var = 1 print(a_var) def f(): a_var = 1 print(a_var) - """ - ) + """) refactored = self._local_rename(code, code.index("a_var") + 1, "new_var") self.assertEqual(code.replace("a_var", "new_var", 2), refactored) @testutils.only_for_versions_higher("3.5") def test_renaming_in_generalized_dict_unpacking(self): - code = dedent( - """\ + code = dedent("""\ a_var = {**{'stuff': 'can'}, **{'stuff': 'crayon'}} if "stuff" in a_var: print("ya") - """ - ) + """) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) refactored = self._local_rename(code, code.index("a_var") + 1, "new_var") - expected = dedent( - """\ + expected = dedent("""\ new_var = {**{'stuff': 'can'}, **{'stuff': 'crayon'}} if "stuff" in new_var: print("ya") - """ - ) + """) self.assertEqual(expected, refactored) def test_dos_line_ending_and_renaming(self): @@ -1689,38 +1411,30 @@ def test_resources_parameter(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") mod1.write( - dedent( - """\ + dedent("""\ def f(): pass - """ - ) + """) ) mod2.write( - dedent( - """\ + dedent("""\ import mod1 mod1.f() - """ - ) + """) ) self._rename(mod1, mod1.read().rindex("f"), "g", resources=[mod1]) self.assertEqual( - dedent( - """\ + dedent("""\ def g(): pass - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 mod1.f() - """ - ), + """), mod2.read(), ) @@ -1728,80 +1442,64 @@ def test_resources_parameter_not_changing_defining_module(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") mod1.write( - dedent( - """\ + dedent("""\ def f(): pass - """ - ) + """) ) mod2.write( - dedent( - """\ + dedent("""\ import mod1 mod1.f() - """ - ) + """) ) self._rename(mod1, mod1.read().rindex("f"), "g", resources=[mod2]) self.assertEqual( - dedent( - """\ + dedent("""\ def f(): pass - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 mod1.g() - """ - ), + """), mod2.read(), ) # XXX: with variables should not leak @testutils.only_for("2.5") def xxx_test_with_statement_variables_should_not_leak(self): - code = dedent( - """\ + code = dedent("""\ f = 1 with open("1.txt") as f: print(f) - """ - ) + """) if sys.version_info < (2, 6, 0): code = "from __future__ import with_statement\n" + code mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.rindex("f"), "file") - expected = dedent( - """\ + expected = dedent("""\ f = 1 with open("1.txt") as file: print(file) - """ - ) + """) self.assertEqual(expected, mod1.read()) def test_rename_in_list_comprehension(self): - code = dedent( - """\ + code = dedent("""\ some_var = 1 compr = [some_var for some_var in range(10)] - """ - ) + """) offset = code.index("some_var") refactored = self._local_rename(code, offset, "new_var") - expected = dedent( - """\ + expected = dedent("""\ new_var = 1 compr = [some_var for some_var in range(10)] - """ - ) + """) self.assertEqual(refactored, expected) @@ -1816,107 +1514,91 @@ def tearDown(self): def test_simple_case(self): self.mod.write( - dedent( - """\ + dedent("""\ a_var = 1 print(a_var) - """ - ) + """) ) changer = rename.ChangeOccurrences( self.project, self.mod, self.mod.read().index("a_var") ) changer.get_changes("new_var").do() self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 1 print(new_var) - """ - ), + """), self.mod.read(), ) def test_only_performing_inside_scopes(self): self.mod.write( - dedent( - """\ + dedent("""\ a_var = 1 new_var = 2 def f(): print(a_var) - """ - ) + """) ) changer = rename.ChangeOccurrences( self.project, self.mod, self.mod.read().rindex("a_var") ) changer.get_changes("new_var").do() self.assertEqual( - dedent( - """\ + dedent("""\ a_var = 1 new_var = 2 def f(): print(new_var) - """ - ), + """), self.mod.read(), ) def test_only_performing_on_calls(self): self.mod.write( - dedent( - """\ + dedent("""\ def f1(): pass def f2(): pass g = f1 a = f1() - """ - ) + """) ) changer = rename.ChangeOccurrences( self.project, self.mod, self.mod.read().rindex("f1") ) changer.get_changes("f2", only_calls=True).do() self.assertEqual( - dedent( - """\ + dedent("""\ def f1(): pass def f2(): pass g = f1 a = f2() - """ - ), + """), self.mod.read(), ) def test_only_performing_on_reads(self): self.mod.write( - dedent( - """\ + dedent("""\ a = 1 b = 2 print(a) - """ - ) + """) ) changer = rename.ChangeOccurrences( self.project, self.mod, self.mod.read().rindex("a") ) changer.get_changes("b", writes=False).do() self.assertEqual( - dedent( - """\ + dedent("""\ a = 1 b = 2 print(b) - """ - ), + """), self.mod.read(), ) @@ -1940,8 +1622,7 @@ def _rename(self, resource, offset, new_name, **kwds): def test_performing_rename_on_parameters(self): self.mod1.write("def f(arg):\n arg.run()\n") self.mod2.write( - dedent( - """\ + dedent("""\ import mod1 @@ -1953,15 +1634,13 @@ def run(self): pass mod1.f(A()) mod1.f(B()) - """ - ) + """) ) self.pycore.analyze_module(self.mod2) self._rename(self.mod1, self.mod1.read().index("run"), "newrun") self.assertEqual("def f(arg):\n arg.newrun()\n", self.mod1.read()) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 @@ -1973,7 +1652,6 @@ def newrun(self): pass mod1.f(A()) mod1.f(B()) - """ - ), + """), self.mod2.read(), )