diff --git a/rope/refactor/patchedast.py b/rope/refactor/patchedast.py index 5a8c59dd7..d8ed4e063 100644 --- a/rope/refactor/patchedast.py +++ b/rope/refactor/patchedast.py @@ -97,6 +97,15 @@ def __call__(self, node): node.sorted_children = ast.get_children(node) def _handle(self, node, base_children, eat_parens=False, eat_spaces=False): + if hasattr(node, "region"): + # ???: The same node was seen twice; what should we do? + warnings.warn( + "Node <%s> has been already patched; please report!" + % node.__class__.__name__, + RuntimeWarning, + ) + return + base_children = collections.deque(base_children) self.children_stack.append(base_children) children = collections.deque() diff --git a/rope/refactor/usefunction.py b/rope/refactor/usefunction.py index 20c32005a..b54661124 100644 --- a/rope/refactor/usefunction.py +++ b/rope/refactor/usefunction.py @@ -27,16 +27,16 @@ def _check_returns(self): node = self.pyfunction.get_ast() if _yield_count(node): raise exceptions.RefactoringError( - "Use function should not " "be used on generators." + "Use function should not be used on generatorS." ) returns = _return_count(node) if returns > 1: raise exceptions.RefactoringError( - "usefunction: Function has more " "than one return statement." + "usefunction: Function has more than one return statement." ) if returns == 1 and not _returns_last(node): raise exceptions.RefactoringError( - "usefunction: return should " "be the last statement." + "usefunction: return should be the last statement." ) def get_changes(self, resources=None, task_handle=taskhandle.NullTaskHandle()): diff --git a/ropetest/advanced_oi_test.py b/ropetest/advanced_oi_test.py index 89146de18..6337b2b1f 100644 --- a/ropetest/advanced_oi_test.py +++ b/ropetest/advanced_oi_test.py @@ -1,5 +1,6 @@ -from rope.base.builtins import Str +from textwrap import dedent +from rope.base.builtins import Str try: import unittest2 as unittest except ImportError: @@ -23,7 +24,11 @@ def tearDown(self): def test_simple_dti(self): mod = testutils.create_module(self.project, "mod") - code = 'def a_func(arg):\n return eval("arg")\n' "a_var = a_func(a_func)\n" + code = dedent("""\ + def a_func(arg): + return eval("arg") + a_var = a_func(a_func) + """) mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) @@ -32,10 +37,12 @@ def test_simple_dti(self): def test_module_dti(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") - code = ( - 'import mod1\ndef a_func(arg):\n return eval("arg")\n' - "a_var = a_func(mod1)\n" - ) + code = dedent("""\ + import mod1 + def a_func(arg): + return eval("arg") + a_var = a_func(mod1) + """) mod2.write(code) self.pycore.run_module(mod2).wait_process() pymod2 = self.project.get_pymodule(mod2) @@ -44,12 +51,17 @@ def test_module_dti(self): def test_class_from_another_module_dti(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") - code1 = "class AClass(object):\n pass\n" - code2 = ( - "from mod1 import AClass\n" - '\ndef a_func(arg):\n return eval("arg")\n' - "a_var = a_func(AClass)\n" - ) + code1 = dedent("""\ + class AClass(object): + pass + """) + code2 = dedent("""\ + from mod1 import AClass + + def a_func(arg): + return eval("arg") + a_var = a_func(AClass) + """) mod1.write(code1) mod2.write(code2) self.pycore.run_module(mod2).wait_process() @@ -59,11 +71,14 @@ def test_class_from_another_module_dti(self): def test_class_dti(self): mod = testutils.create_module(self.project, "mod") - code = ( - "class AClass(object):\n pass\n" - '\ndef a_func(arg):\n return eval("arg")\n' - "a_var = a_func(AClass)\n" - ) + code = dedent("""\ + class AClass(object): + pass + + def a_func(arg): + return eval("arg") + a_var = a_func(AClass) + """) mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) @@ -71,11 +86,14 @@ def test_class_dti(self): def test_instance_dti(self): mod = testutils.create_module(self.project, "mod") - code = ( - "class AClass(object):\n pass\n" - '\ndef a_func(arg):\n return eval("arg()")\n' - "a_var = a_func(AClass)\n" - ) + code = dedent("""\ + class AClass(object): + pass + + def a_func(arg): + return eval("arg()") + a_var = a_func(AClass) + """) mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) @@ -85,12 +103,13 @@ def test_instance_dti(self): def test_method_dti(self): mod = testutils.create_module(self.project, "mod") - code = ( - "class AClass(object):\n def a_method(self, arg):\n" - ' return eval("arg()")\n' - "an_instance = AClass()\n" - "a_var = an_instance.a_method(AClass)\n" - ) + code = dedent("""\ + class AClass(object): + def a_method(self, arg): + return eval("arg()") + an_instance = AClass() + a_var = an_instance.a_method(AClass) + """) mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) @@ -100,7 +119,11 @@ def test_method_dti(self): def test_function_argument_dti(self): mod = testutils.create_module(self.project, "mod") - code = "def a_func(arg):\n pass\n" "a_func(a_func)\n" + code = dedent("""\ + def a_func(arg): + pass + a_func(a_func) + """) mod.write(code) self.pycore.run_module(mod).wait_process() pyscope = self.project.get_pymodule(mod).get_scope() @@ -110,12 +133,15 @@ def test_function_argument_dti(self): def test_classes_with_the_same_name(self): mod = testutils.create_module(self.project, "mod") - code = ( - "def a_func(arg):\n class AClass(object):\n" - ' pass\n return eval("arg")\n' - "class AClass(object):\n pass\n" - "a_var = a_func(AClass)\n" - ) + code = dedent("""\ + def a_func(arg): + class AClass(object): + pass + return eval("arg") + class AClass(object): + pass + a_var = a_func(AClass) + """) mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) @@ -123,12 +149,15 @@ def test_classes_with_the_same_name(self): def test_nested_classes(self): mod = testutils.create_module(self.project, "mod") - code = ( - "def a_func():\n class AClass(object):\n" - " pass\n return AClass\n" - 'def another_func(arg):\n return eval("arg")\n' - "a_var = another_func(a_func())\n" - ) + code = dedent("""\ + def a_func(): + class AClass(object): + pass + return AClass + def another_func(arg): + return eval("arg") + a_var = another_func(a_func()) + """) mod.write(code) self.pycore.run_module(mod).wait_process() pyscope = self.project.get_pymodule(mod).get_scope() @@ -139,7 +168,11 @@ def test_nested_classes(self): def test_function_argument_dti2(self): mod = testutils.create_module(self.project, "mod") - code = "def a_func(arg, a_builtin_type):\n pass\n" "a_func(a_func, [])\n" + code = dedent("""\ + def a_func(arg, a_builtin_type): + pass + a_func(a_func, []) + """) mod.write(code) self.pycore.run_module(mod).wait_process() pyscope = self.project.get_pymodule(mod).get_scope() @@ -149,7 +182,11 @@ def test_function_argument_dti2(self): def test_dti_and_concluded_data_invalidation(self): mod = testutils.create_module(self.project, "mod") - code = 'def a_func(arg):\n return eval("arg")\n' "a_var = a_func(a_func)\n" + code = dedent("""\ + def a_func(arg): + return eval("arg") + a_var = a_func(a_func) + """) mod.write(code) pymod = self.project.get_pymodule(mod) pymod["a_var"].get_object() @@ -158,11 +195,13 @@ def test_dti_and_concluded_data_invalidation(self): def test_list_objects_and_dynamicoi(self): mod = testutils.create_module(self.project, "mod") - code = ( - "class C(object):\n pass\n" - 'def a_func(arg):\n return eval("arg")\n' - "a_var = a_func([C()])[0]\n" - ) + code = dedent("""\ + class C(object): + pass + def a_func(arg): + return eval("arg") + a_var = a_func([C()])[0] + """) mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) @@ -172,11 +211,14 @@ def test_list_objects_and_dynamicoi(self): def test_for_loops_and_dynamicoi(self): mod = testutils.create_module(self.project, "mod") - code = ( - "class C(object):\n pass\n" - 'def a_func(arg):\n return eval("arg")\n' - "for c in a_func([C()]):\n a_var = c\n" - ) + code = dedent("""\ + class C(object): + pass + def a_func(arg): + return eval("arg") + for c in a_func([C()]): + a_var = c + """) mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) @@ -186,11 +228,13 @@ def test_for_loops_and_dynamicoi(self): def test_dict_objects_and_dynamicoi(self): mod = testutils.create_module(self.project, "mod") - code = ( - "class C(object):\n pass\n" - 'def a_func(arg):\n return eval("arg")\n' - "a_var = a_func({1: C()})[1]\n" - ) + code = dedent("""\ + class C(object): + pass + def a_func(arg): + return eval("arg") + a_var = a_func({1: C()})[1] + """) mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) @@ -201,17 +245,21 @@ def test_dict_objects_and_dynamicoi(self): def test_dict_keys_and_dynamicoi(self): mod = testutils.create_module(self.project, "mod") if pycompat.PY3: - code = ( - "class C(object):\n pass\n" - 'def a_func(arg):\n return eval("arg")\n' - "a_var = list(a_func({C(): 1}))[0]\n" - ) + code = dedent("""\ + class C(object): + pass + def a_func(arg): + return eval("arg") + a_var = list(a_func({C(): 1}))[0] + """) else: - code = ( - "class C(object):\n pass\n" - 'def a_func(arg):\n return eval("arg")\n' - "a_var = a_func({C(): 1}).keys()[0]\n" - ) + code = dedent("""\ + class C(object): + pass + def a_func(arg): + return eval("arg") + a_var = a_func({C(): 1}).keys()[0] + """) mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) @@ -221,11 +269,15 @@ def test_dict_keys_and_dynamicoi(self): def test_dict_keys_and_dynamicoi2(self): mod = testutils.create_module(self.project, "mod") - code = ( - "class C1(object):\n pass\nclass C2(object):\n pass\n" - 'def a_func(arg):\n return eval("arg")\n' - "a, b = a_func((C1(), C2()))\n" - ) + code = dedent("""\ + class C1(object): + pass + class C2(object): + pass + def a_func(arg): + return eval("arg") + a, b = a_func((C1(), C2())) + """) mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) @@ -238,7 +290,11 @@ def test_dict_keys_and_dynamicoi2(self): def test_strs_and_dynamicoi(self): mod = testutils.create_module(self.project, "mod") - code = 'def a_func(arg):\n return eval("arg")\n' 'a_var = a_func("hey")\n' + code = dedent("""\ + def a_func(arg): + return eval("arg") + a_var = a_func("hey") + """) mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) @@ -247,11 +303,16 @@ def test_strs_and_dynamicoi(self): def test_textual_transformations(self): mod = testutils.create_module(self.project, "mod") - code = ( - "class C(object):\n pass\ndef f():" - "\n pass\na_var = C()\n" - 'a_list = [C()]\na_str = "hey"\na_file = open("file.txt")\n' - ) + code = dedent("""\ + class C(object): + pass + def f(): + pass + a_var = C() + a_list = [C()] + a_str = "hey" + a_file = open("file.txt") + """) mod.write(code) to_pyobject = rope.base.oi.transform.TextualToPyObject(self.project) to_textual = rope.base.oi.transform.PyObjectToTextual(self.project) @@ -284,11 +345,16 @@ def complex_to_textual(pyobject): def test_arguments_with_keywords(self): mod = testutils.create_module(self.project, "mod") - code = ( - "class C1(object):\n pass\nclass C2(object):\n pass\n" - 'def a_func(arg):\n return eval("arg")\n' - "a = a_func(arg=C1())\nb = a_func(arg=C2())\n" - ) + code = dedent("""\ + class C1(object): + pass + class C2(object): + pass + def a_func(arg): + return eval("arg") + a = a_func(arg=C1()) + b = a_func(arg=C2()) + """) mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) @@ -301,11 +367,16 @@ def test_arguments_with_keywords(self): def test_a_function_with_different_returns(self): mod = testutils.create_module(self.project, "mod") - code = ( - "class C1(object):\n pass\nclass C2(object):\n pass\n" - 'def a_func(arg):\n return eval("arg")\n' - "a = a_func(C1())\nb = a_func(C2())\n" - ) + code = dedent("""\ + class C1(object): + pass + class C2(object): + pass + def a_func(arg): + return eval("arg") + a = a_func(C1()) + b = a_func(C2()) + """) mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) @@ -318,12 +389,19 @@ def test_a_function_with_different_returns(self): def test_a_function_with_different_returns2(self): mod = testutils.create_module(self.project, "mod") - code = ( - "class C1(object):\n pass\nclass C2(object):\n pass\n" - "def a_func(p):\n if p == C1:\n return C1()\n" - " else:\n return C2()\n" - "a = a_func(C1)\nb = a_func(C2)\n" - ) + code = dedent("""\ + class C1(object): + pass + class C2(object): + pass + def a_func(p): + if p == C1: + return C1() + else: + return C2() + a = a_func(C1) + b = a_func(C2) + """) mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) @@ -336,13 +414,19 @@ def test_a_function_with_different_returns2(self): def test_ignoring_star_args(self): mod = testutils.create_module(self.project, "mod") - code = ( - "class C1(object):\n pass\nclass C2(object):\n pass\n" - "def a_func(p, *args):" - "\n if p == C1:\n return C1()\n" - " else:\n return C2()\n" - "a = a_func(C1, 1)\nb = a_func(C2, 2)\n" - ) + code = dedent("""\ + class C1(object): + pass + class C2(object): + pass + def a_func(p, *args): + if p == C1: + return C1() + else: + return C2() + a = a_func(C1, 1) + b = a_func(C2, 2) + """) mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) @@ -355,13 +439,19 @@ def test_ignoring_star_args(self): def test_ignoring_double_star_args(self): mod = testutils.create_module(self.project, "mod") - code = ( - "class C1(object):\n pass\nclass C2(object):\n pass\n" - "def a_func(p, *kwds, **args):\n " - "if p == C1:\n return C1()\n" - " else:\n return C2()\n" - "a = a_func(C1, kwd=1)\nb = a_func(C2, kwd=2)\n" - ) + code = dedent("""\ + class C1(object): + pass + class C2(object): + pass + def a_func(p, *kwds, **args): + if p == C1: + return C1() + else: + return C2() + a = a_func(C1, kwd=1) + b = a_func(C2, kwd=2) + """) mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) @@ -374,7 +464,11 @@ def test_ignoring_double_star_args(self): def test_invalidating_data_after_changing(self): mod = testutils.create_module(self.project, "mod") - code = 'def a_func(arg):\n return eval("arg")\n' "a_var = a_func(a_func)\n" + code = dedent("""\ + def a_func(arg): + return eval("arg") + a_var = a_func(a_func) + """) mod.write(code) self.pycore.run_module(mod).wait_process() mod.write(code.replace("a_func", "newfunc")) @@ -386,10 +480,12 @@ def test_invalidating_data_after_moving(self): mod2 = testutils.create_module(self.project, "mod2") mod2.write("class C(object):\n pass\n") mod = testutils.create_module(self.project, "mod") - code = ( - "import mod2\ndef a_func(arg):\n return eval(arg)\n" - 'a_var = a_func("mod2.C")\n' - ) + code = dedent("""\ + import mod2 + def a_func(arg): + return eval(arg) + a_var = a_func("mod2.C") + """) mod.write(code) self.pycore.run_module(mod).wait_process() mod.move("newmod.py") @@ -410,7 +506,13 @@ def tearDown(self): super(NewStaticOITest, self).tearDown() def test_static_oi_for_simple_function_calls(self): - code = "class C(object):\n pass\ndef f(p):\n pass\nf(C())\n" + code = dedent("""\ + class C(object): + pass + def f(p): + pass + f(C()) + """) self.mod.write(code) self.pycore.analyze_module(self.mod) pymod = self.project.get_pymodule(self.mod) @@ -420,15 +522,24 @@ def test_static_oi_for_simple_function_calls(self): self.assertEqual(c_class, p_type) def test_static_oi_not_failing_when_callin_callables(self): - code = "class C(object):\n pass\nC()\n" + code = dedent("""\ + class C(object): + pass + C() + """) self.mod.write(code) self.pycore.analyze_module(self.mod) def test_static_oi_for_nested_calls(self): - code = ( - "class C(object):\n pass\ndef f(p):\n pass\n" - "def g(p):\n return p\nf(g(C()))\n" - ) + code = dedent("""\ + class C(object): + pass + def f(p): + pass + def g(p): + return p + f(g(C())) + """) self.mod.write(code) self.pycore.analyze_module(self.mod) pymod = self.project.get_pymodule(self.mod) @@ -438,7 +549,11 @@ def test_static_oi_for_nested_calls(self): self.assertEqual(c_class, p_type) def test_static_oi_class_methods(self): - code = "class C(object):\n def f(self, p):\n pass\n" "C().f(C())" + code = dedent("""\ + class C(object): + def f(self, p): + pass + C().f(C())""") self.mod.write(code) self.pycore.analyze_module(self.mod) pymod = self.project.get_pymodule(self.mod) @@ -448,7 +563,11 @@ def test_static_oi_class_methods(self): self.assertEqual(c_class, p_type) def test_static_oi_preventing_soi_maximum_recursion_exceptions(self): - code = "item = {}\nfor item in item.keys():\n pass\n" + code = dedent("""\ + item = {} + for item in item.keys(): + pass + """) self.mod.write(code) try: self.pycore.analyze_module(self.mod) @@ -456,10 +575,13 @@ def test_static_oi_preventing_soi_maximum_recursion_exceptions(self): self.fail(str(e)) def test_static_oi_for_infer_return_typs_from_funcs_based_on_params(self): - code = ( - "class C(object):\n pass\ndef func(p):\n return p\n" - "a_var = func(C())\n" - ) + code = dedent("""\ + class C(object): + pass + def func(p): + return p + a_var = func(C()) + """) self.mod.write(code) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C"].get_object() @@ -467,11 +589,16 @@ def test_static_oi_for_infer_return_typs_from_funcs_based_on_params(self): self.assertEqual(c_class, a_var.get_type()) def test_a_function_with_different_returns(self): - code = ( - "class C1(object):\n pass\nclass C2(object):\n pass\n" - "def a_func(arg):\n return arg\n" - "a = a_func(C1())\nb = a_func(C2())\n" - ) + code = dedent("""\ + class C1(object): + pass + class C2(object): + pass + def a_func(arg): + return arg + a = a_func(C1()) + b = a_func(C2()) + """) self.mod.write(code) pymod = self.project.get_pymodule(self.mod) c1_class = pymod["C1"].get_object() @@ -482,11 +609,13 @@ def test_a_function_with_different_returns(self): self.assertEqual(c2_class, b_var.get_type()) def test_not_reporting_out_of_date_information(self): - code = ( - "class C1(object):\n pass\n" - "def f(arg):\n return C1()\na_var = f(" - ")\n" - ) + code = dedent("""\ + class C1(object): + pass + def f(arg): + return C1() + a_var = f() + """) self.mod.write(code) pymod = self.project.get_pymodule(self.mod) c1_class = pymod["C1"].get_object() @@ -502,12 +631,22 @@ def test_not_reporting_out_of_date_information(self): def test_invalidating_concluded_data_in_a_function(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") - mod1.write("def func(arg):\n temp = arg\n return temp\n") + mod1.write( + dedent("""\ + def func(arg): + temp = arg + return temp + """) + ) mod2.write( - "import mod1\n" - "class C1(object):\n pass\n" - "class C2(object):\n pass\n" - "a_var = mod1.func(C1())\n" + dedent("""\ + import mod1 + class C1(object): + pass + class C2(object): + pass + a_var = mod1.func(C1()) + """) ) pymod2 = self.project.get_pymodule(mod2) c1_class = pymod2["C1"].get_object() @@ -522,8 +661,14 @@ def test_invalidating_concluded_data_in_a_function(self): def test_handling_generator_functions_for_strs(self): self.mod.write( - "class C(object):\n pass\ndef f(p):\n yield p()\n" - "for c in f(C):\n a_var = c\n" + dedent("""\ + class C(object): + pass + def f(p): + yield p() + for c in f(C): + a_var = c + """) ) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C"].get_object() @@ -534,19 +679,26 @@ def test_handling_generator_functions_for_strs(self): @unittest.skip("Returning a generator that yields unknowns") def xxx_test_handl_generator_functions_when_unknown_type_is_yielded(self): self.mod.write( - "class C(object):\n pass" - '\ndef f():\n yield eval("C()")\n' - "a_var = f()\n" + dedent("""\ + class C(object): + pass + def f(): + yield eval("C()") + a_var = f() + """) ) pymod = self.project.get_pymodule(self.mod) a_var = pymod["a_var"].get_object() self.assertTrue(isinstance(a_var.get_type(), rope.base.builtins.Generator)) def test_static_oi_for_lists_depending_on_append_function(self): - code = ( - "class C(object):\n pass\nl = list()\n" - "l.append(C())\na_var = l.pop()\n" - ) + code = dedent("""\ + class C(object): + pass + l = list() + l.append(C()) + a_var = l.pop() + """) self.mod.write(code) self.pycore.analyze_module(self.mod) pymod = self.project.get_pymodule(self.mod) @@ -555,9 +707,13 @@ def test_static_oi_for_lists_depending_on_append_function(self): self.assertEqual(c_class, a_var.get_type()) def test_static_oi_for_lists_per_object_for_get_item(self): - code = ( - "class C(object):\n pass\nl = list()\n" "l.append(C())\na_var = l[0]\n" - ) + code = dedent("""\ + class C(object): + pass + l = list() + l.append(C()) + a_var = l[0] + """) self.mod.write(code) self.pycore.analyze_module(self.mod) pymod = self.project.get_pymodule(self.mod) @@ -566,13 +722,18 @@ def test_static_oi_for_lists_per_object_for_get_item(self): self.assertEqual(c_class, a_var.get_type()) def test_static_oi_for_lists_per_object_for_fields(self): - code = ( - "class C(object):\n pass\n" - "class A(object):\n " - "def __init__(self):\n self.l = []\n" - " def set(self):\n self.l.append(C())\n" - "a = A()\na.set()\na_var = a.l[0]\n" - ) + code = dedent("""\ + class C(object): + pass + class A(object): + def __init__(self): + self.l = [] + def set(self): + self.l.append(C()) + a = A() + a.set() + a_var = a.l[0] + """) self.mod.write(code) self.pycore.analyze_module(self.mod) pymod = self.project.get_pymodule(self.mod) @@ -581,7 +742,13 @@ def test_static_oi_for_lists_per_object_for_fields(self): self.assertEqual(c_class, a_var.get_type()) def test_static_oi_for_lists_per_object_for_set_item(self): - code = "class C(object):\n pass\nl = [None]\n" "l[0] = C()\na_var = l[0]\n" + code = dedent("""\ + class C(object): + pass + l = [None] + l[0] = C() + a_var = l[0] + """) self.mod.write(code) self.pycore.analyze_module(self.mod) pymod = self.project.get_pymodule(self.mod) @@ -590,10 +757,15 @@ def test_static_oi_for_lists_per_object_for_set_item(self): self.assertEqual(c_class, a_var.get_type()) def test_static_oi_for_lists_per_object_for_extending_lists(self): - code = ( - "class C(object):\n pass\nl = []\n" - "l.append(C())\nl2 = []\nl2.extend(l)\na_var = l2[0]\n" - ) + code = dedent("""\ + class C(object): + pass + l = [] + l.append(C()) + l2 = [] + l2.extend(l) + a_var = l2[0] + """) self.mod.write(code) self.pycore.analyze_module(self.mod) pymod = self.project.get_pymodule(self.mod) @@ -602,11 +774,14 @@ def test_static_oi_for_lists_per_object_for_extending_lists(self): self.assertEqual(c_class, a_var.get_type()) def test_static_oi_for_lists_per_object_for_iters(self): - code = ( - "class C(object):\n pass\n" - "l = []\nl.append(C())\n" - "for c in l:\n a_var = c\n" - ) + code = dedent("""\ + class C(object): + pass + l = [] + l.append(C()) + for c in l: + a_var = c + """) self.mod.write(code) self.pycore.analyze_module(self.mod) pymod = self.project.get_pymodule(self.mod) @@ -615,10 +790,15 @@ def test_static_oi_for_lists_per_object_for_iters(self): self.assertEqual(c_class, a_var.get_type()) def test_static_oi_for_dicts_depending_on_append_function(self): - code = ( - "class C1(object):\n pass\nclass C2(object):\n pass\n" - "d = {}\nd[C1()] = C2()\na, b = d.popitem()\n" - ) + code = dedent("""\ + class C1(object): + pass + class C2(object): + pass + d = {} + d[C1()] = C2() + a, b = d.popitem() + """) self.mod.write(code) self.pycore.analyze_module(self.mod) pymod = self.project.get_pymodule(self.mod) @@ -630,11 +810,17 @@ def test_static_oi_for_dicts_depending_on_append_function(self): self.assertEqual(c2_class, b_var.get_type()) def test_static_oi_for_dicts_depending_on_for_loops(self): - code = ( - "class C1(object):\n pass\nclass C2(object):\n pass\n" - "d = {}\nd[C1()] = C2()\n" - "for k, v in d.items():\n a = k\n b = v\n" - ) + code = dedent("""\ + class C1(object): + pass + class C2(object): + pass + d = {} + d[C1()] = C2() + for k, v in d.items(): + a = k + b = v + """) self.mod.write(code) self.pycore.analyze_module(self.mod) pymod = self.project.get_pymodule(self.mod) @@ -646,11 +832,17 @@ def test_static_oi_for_dicts_depending_on_for_loops(self): self.assertEqual(c2_class, b_var.get_type()) def test_static_oi_for_dicts_depending_on_update(self): - code = ( - "class C1(object):\n pass\nclass C2(object):\n pass\n" - "d = {}\nd[C1()] = C2()\n" - "d2 = {}\nd2.update(d)\na, b = d2.popitem()\n" - ) + code = dedent("""\ + class C1(object): + pass + class C2(object): + pass + d = {} + d[C1()] = C2() + d2 = {} + d2.update(d) + a, b = d2.popitem() + """) self.mod.write(code) self.pycore.analyze_module(self.mod) pymod = self.project.get_pymodule(self.mod) @@ -662,10 +854,15 @@ def test_static_oi_for_dicts_depending_on_update(self): self.assertEqual(c2_class, b_var.get_type()) def test_static_oi_for_dicts_depending_on_update_on_seqs(self): - code = ( - "class C1(object):\n pass\nclass C2(object):\n pass\n" - "d = {}\nd.update([(C1(), C2())])\na, b = d.popitem()\n" - ) + code = dedent("""\ + class C1(object): + pass + class C2(object): + pass + d = {} + d.update([(C1(), C2())]) + a, b = d.popitem() + """) self.mod.write(code) self.pycore.analyze_module(self.mod) pymod = self.project.get_pymodule(self.mod) @@ -677,9 +874,13 @@ def test_static_oi_for_dicts_depending_on_update_on_seqs(self): self.assertEqual(c2_class, b_var.get_type()) def test_static_oi_for_sets_per_object_for_set_item(self): - code = ( - "class C(object):\n pass\ns = set()\n" "s.add(C())\na_var = s.pop() \n" - ) + code = dedent("""\ + class C(object): + pass + s = set() + s.add(C()) + a_var = s.pop() + """) self.mod.write(code) self.pycore.analyze_module(self.mod) pymod = self.project.get_pymodule(self.mod) @@ -688,12 +889,17 @@ def test_static_oi_for_sets_per_object_for_set_item(self): self.assertEqual(c_class, a_var.get_type()) def test_properties_and_calling_get_property(self): - code = ( - "class C1(object):\n pass\n" - "class C2(object):\n c1 = C1()\n" - " def get_c1(self):\n return self.c1\n" - " p = property(get_c1)\nc2 = C2()\na_var = c2.p\n" - ) + code = dedent("""\ + class C1(object): + pass + class C2(object): + c1 = C1() + def get_c1(self): + return self.c1 + p = property(get_c1) + c2 = C2() + a_var = c2.p + """) self.mod.write(code) pymod = self.project.get_pymodule(self.mod) c1_class = pymod["C1"].get_object() @@ -701,12 +907,14 @@ def test_properties_and_calling_get_property(self): self.assertEqual(c1_class, a_var.get_type()) def test_soi_on_constructors(self): - code = ( - "class C1(object):\n pass\n" - "class C2(object):\n" - " def __init__(self, arg):\n self.attr = arg\n" - "c2 = C2(C1())\na_var = c2.attr" - ) + code = dedent("""\ + class C1(object): + pass + class C2(object): + def __init__(self, arg): + self.attr = arg + c2 = C2(C1()) + a_var = c2.attr""") self.mod.write(code) self.pycore.analyze_module(self.mod) pymod = self.project.get_pymodule(self.mod) @@ -733,8 +941,22 @@ def test_soi_on_typed_assignment(self): def test_not_saving_unknown_function_returns(self): mod2 = testutils.create_module(self.project, "mod2") - self.mod.write("class C(object):\n pass\nl = []\nl.append(C())\n") - mod2.write("import mod\ndef f():\n " "return mod.l.pop()\na_var = f()\n") + self.mod.write( + dedent("""\ + class C(object): + pass + l = [] + l.append(C()) + """) + ) + mod2.write( + dedent("""\ + import mod + def f(): + return mod.l.pop() + a_var = f() + """) + ) pymod = self.project.get_pymodule(self.mod) pymod2 = self.project.get_pymodule(mod2) c_class = pymod["C"].get_object() @@ -747,11 +969,14 @@ def test_not_saving_unknown_function_returns(self): self.assertEqual(c_class, a_var.get_object().get_type()) def test_using_the_best_callinfo(self): - code = ( - "class C1(object):\n pass\n" - "def f(arg1, arg2, arg3):\n pass\n" - 'f("", None, C1())\nf("", C1(), None)\n' - ) + code = dedent("""\ + class C1(object): + pass + def f(arg1, arg2, arg3): + pass + f("", None, C1()) + f("", C1(), None) + """) self.mod.write(code) self.pycore.analyze_module(self.mod) pymod = self.project.get_pymodule(self.mod) @@ -761,9 +986,12 @@ def test_using_the_best_callinfo(self): self.assertEqual(c1_class, arg2.get_type()) def test_call_function_and_parameters(self): - code = ( - "class A(object):\n def __call__(self, p):\n pass\n" 'A()("")\n' - ) + code = dedent("""\ + class A(object): + def __call__(self, p): + pass + A()("") + """) self.mod.write(code) self.pycore.analyze_module(self.mod) scope = self.project.get_pymodule(self.mod).get_scope() @@ -772,7 +1000,13 @@ def test_call_function_and_parameters(self): def test_report_change_in_libutils(self): self.project.prefs["automatic_soa"] = True - code = "class C(object):\n pass\ndef f(p):\n pass\nf(C())\n" + code = dedent("""\ + class C(object): + pass + def f(p): + pass + f(C()) + """) with open(self.mod.real_path, "w") as mod_file: mod_file.write(code) @@ -784,7 +1018,13 @@ def test_report_change_in_libutils(self): self.assertEqual(c_class, p_type) def test_report_libutils_and_analyze_all_modules(self): - code = "class C(object):\n pass\ndef f(p):\n pass\nf(C())\n" + code = dedent("""\ + class C(object): + pass + def f(p): + pass + f(C()) + """) self.mod.write(code) rope.base.libutils.analyze_modules(self.project) pymod = self.project.get_pymodule(self.mod) @@ -796,8 +1036,21 @@ def test_report_libutils_and_analyze_all_modules(self): def test_validation_problems_for_objectdb_retrievals(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") - mod1.write("l = []\nvar = l.pop()\n") - mod2.write("import mod1\n\nclass C(object):\n pass\n" "mod1.l.append(C())\n") + mod1.write( + dedent("""\ + l = [] + var = l.pop() + """) + ) + mod2.write( + dedent("""\ + import mod1 + + class C(object): + pass + mod1.l.append(C()) + """) + ) self.pycore.analyze_module(mod2) pymod2 = self.project.get_pymodule(mod2) @@ -805,25 +1058,46 @@ def test_validation_problems_for_objectdb_retrievals(self): pymod1 = self.project.get_pymodule(mod1) var_pyname = pymod1["var"] self.assertEqual(c_class, var_pyname.get_object().get_type()) - mod2.write('import mod1\n\nmod1.l.append("")\n') + mod2.write( + dedent("""\ + import mod1 + + mod1.l.append("") + """) + ) self.assertNotEqual( c_class, var_pyname.get_object().get_type(), "Class `C` no more exists" ) def test_validation_problems_for_changing_builtin_types(self): mod1 = testutils.create_module(self.project, "mod1") - mod1.write('l = []\nl.append("")\n') + mod1.write( + dedent("""\ + l = [] + l.append("") + """) + ) self.pycore.analyze_module(mod1) - mod1.write('l = {}\nv = l["key"]\n') + mod1.write( + dedent("""\ + l = {} + v = l["key"] + """) + ) pymod1 = self.project.get_pymodule(mod1) # noqa var = pymod1["v"].get_object() # noqa def test_always_returning_containing_class_for_selfs(self): - code = ( - "class A(object):\n def f(p):\n return p\n" - "class B(object):\n pass\nb = B()\nb.f()\n" - ) + code = dedent("""\ + class A(object): + def f(p): + return p + class B(object): + pass + b = B() + b.f() + """) self.mod.write(code) self.pycore.analyze_module(self.mod) pymod = self.project.get_pymodule(self.mod) @@ -833,14 +1107,17 @@ def test_always_returning_containing_class_for_selfs(self): self.assertEqual(a_class, p_type) def test_following_function_calls_when_asked_to(self): - code = ( - "class A(object):\n pass\n" - "class C(object):\n" - " def __init__(self, arg):\n" - " self.attr = arg\n" - "def f(p):\n return C(p)\n" - "c = f(A())\nx = c.attr\n" - ) + code = dedent("""\ + class A(object): + pass + class C(object): + def __init__(self, arg): + self.attr = arg + def f(p): + return C(p) + c = f(A()) + x = c.attr + """) self.mod.write(code) self.pycore.analyze_module(self.mod, followed_calls=1) pymod = self.project.get_pymodule(self.mod) diff --git a/ropetest/builtinstest.py b/ropetest/builtinstest.py index 1892d581c..ec2fe478e 100644 --- a/ropetest/builtinstest.py +++ b/ropetest/builtinstest.py @@ -1,3 +1,4 @@ +from textwrap import dedent try: import unittest2 as unittest except ImportError: @@ -25,7 +26,14 @@ def test_simple_case(self): self.assertTrue("append" in pymod["l"].get_object()) def test_holding_type_information(self): - self.mod.write("class C(object):\n pass\n" "l = [C()]\na_var = l.pop()\n") + self.mod.write( + dedent("""\ + class C(object): + pass + l = [C()] + a_var = l.pop() + """) + ) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C"].get_object() a_var = pymod["a_var"].get_object() @@ -33,9 +41,13 @@ def test_holding_type_information(self): def test_get_items(self): self.mod.write( - "class C(object):" - "\n def __getitem__(self, i):\n return C()\n" - "c = C()\na_var = c[0]" + dedent("""\ + class C(object): + def __getitem__(self, i): + return C() + c = C() + a_var = c[0]""" + ) ) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C"].get_object() @@ -43,14 +55,28 @@ def test_get_items(self): self.assertEqual(c_class, a_var.get_type()) def test_get_items_for_lists(self): - self.mod.write("class C(object):\n pass\nl = [C()]\na_var = l[0]\n") + self.mod.write( + dedent("""\ + class C(object): + pass + l = [C()] + a_var = l[0] + """) + ) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C"].get_object() a_var = pymod["a_var"].get_object() self.assertEqual(c_class, a_var.get_type()) def test_get_items_from_slices(self): - self.mod.write("class C(object):\n pass" "\nl = [C()]\na_var = l[:].pop()\n") + self.mod.write( + dedent("""\ + class C(object): + pass + l = [C()] + a_var = l[:].pop() + """) + ) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C"].get_object() a_var = pymod["a_var"].get_object() @@ -58,7 +84,13 @@ def test_get_items_from_slices(self): def test_simple_for_loops(self): self.mod.write( - "class C(object):\n pass\nl = [C()]\n" "for c in l:\n a_var = c\n" + dedent("""\ + class C(object): + pass + l = [C()] + for c in l: + a_var = c + """) ) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C"].get_object() @@ -67,7 +99,13 @@ def test_simple_for_loops(self): def test_definition_location_for_loop_variables(self): self.mod.write( - "class C(object):\n pass\nl = [C()]\n" "for c in l:\n pass\n" + dedent("""\ + class C(object): + pass + l = [C()] + for c in l: + pass + """) ) pymod = self.project.get_pymodule(self.mod) c_var = pymod["c"] @@ -79,21 +117,38 @@ def test_simple_case_for_dicts(self): self.assertTrue("get" in pymod["d"].get_object()) def test_get_item_for_dicts(self): - self.mod.write("class C(object):\n pass\n" "d = {1: C()}\na_var = d[1]\n") + self.mod.write( + dedent("""\ + class C(object): + pass + d = {1: C()} + a_var = d[1] + """) + ) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C"].get_object() a_var = pymod["a_var"].get_object() self.assertEqual(c_class, a_var.get_type()) def test_dict_function_parent(self): - self.mod.write("d = {1: 2}\n" "a_var = d.keys()") + self.mod.write( + dedent("""\ + d = {1: 2} + a_var = d.keys()""" + ) + ) pymod = self.project.get_pymodule(self.mod) a_var = pymod["d"].get_object()["keys"].get_object() self.assertEqual(type(a_var.parent), Dict) def test_popping_dicts(self): self.mod.write( - "class C(object):\n pass\n" "d = {1: C()}\na_var = d.pop(1)\n" + dedent("""\ + class C(object): + pass + d = {1: C()} + a_var = d.pop(1) + """) ) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C"].get_object() @@ -102,9 +157,15 @@ def test_popping_dicts(self): def test_getting_keys_from_dicts(self): self.mod.write( - "class C1(object):\n pass\n" - "class C2(object):\n pass\n" - "d = {C1(): C2()}\nfor c in d.keys():\n a_var = c\n" + dedent("""\ + class C1(object): + pass + class C2(object): + pass + d = {C1(): C2()} + for c in d.keys(): + a_var = c + """) ) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C1"].get_object() @@ -113,10 +174,15 @@ def test_getting_keys_from_dicts(self): def test_getting_values_from_dicts(self): self.mod.write( - "class C1(object):\n pass\n" - "class C2(object):\n pass\n" - "d = {C1(): C2()}\nfor c in d.values():" - "\n a_var = c\n" + dedent("""\ + class C1(object): + pass + class C2(object): + pass + d = {C1(): C2()} + for c in d.values(): + a_var = c + """) ) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C2"].get_object() @@ -125,9 +191,15 @@ def test_getting_values_from_dicts(self): def test_getting_iterkeys_from_dicts(self): self.mod.write( - "class C1(object):\n pass" - "\nclass C2(object):\n pass\n" - "d = {C1(): C2()}\nfor c in d.keys():\n a_var = c\n" + dedent("""\ + class C1(object): + pass + class C2(object): + pass + d = {C1(): C2()} + for c in d.keys(): + a_var = c + """) ) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C1"].get_object() @@ -136,10 +208,15 @@ def test_getting_iterkeys_from_dicts(self): def test_getting_itervalues_from_dicts(self): self.mod.write( - "class C1(object):\n pass" - "\nclass C2(object):\n pass\n" - "d = {C1(): C2()}\nfor c in d.values():" - "\n a_var = c\n" + dedent("""\ + class C1(object): + pass + class C2(object): + pass + d = {C1(): C2()} + for c in d.values(): + a_var = c + """) ) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C2"].get_object() @@ -148,9 +225,15 @@ def test_getting_itervalues_from_dicts(self): def test_using_copy_for_dicts(self): self.mod.write( - "class C1(object):\n pass" - "\nclass C2(object):\n pass\n" - "d = {C1(): C2()}\nfor c in d.copy():\n a_var = c\n" + dedent("""\ + class C1(object): + pass + class C2(object): + pass + d = {C1(): C2()} + for c in d.copy(): + a_var = c + """) ) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C1"].get_object() @@ -159,9 +242,14 @@ def test_using_copy_for_dicts(self): def test_tuple_assignments_for_items(self): self.mod.write( - "class C1(object):\n pass" - "\nclass C2(object):\n pass\n" - "d = {C1(): C2()}\nkey, value = d.items()[0]\n" + dedent("""\ + class C1(object): + pass + class C2(object): + pass + d = {C1(): C2()} + key, value = d.items()[0] + """) ) pymod = self.project.get_pymodule(self.mod) c1_class = pymod["C1"].get_object() @@ -172,7 +260,14 @@ def test_tuple_assignments_for_items(self): self.assertEqual(c2_class, value.get_type()) def test_tuple_assignment_for_lists(self): - self.mod.write("class C(object):\n pass\n" "l = [C(), C()]\na, b = l\n") + self.mod.write( + dedent("""\ + class C(object): + pass + l = [C(), C()] + a, b = l + """) + ) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C"].get_object() a_var = pymod["a"].get_object() @@ -182,10 +277,16 @@ def test_tuple_assignment_for_lists(self): def test_tuple_assignments_for_iteritems_in_fors(self): self.mod.write( - "class C1(object):\n pass\n" - "class C2(object):\n pass\n" - "d = {C1(): C2()}\n" - "for x, y in d.items():\n a = x;\n b = y\n" + dedent("""\ + class C1(object): + pass + class C2(object): + pass + d = {C1(): C2()} + for x, y in d.items(): + a = x; + b = y + """) ) pymod = self.project.get_pymodule(self.mod) c1_class = pymod["C1"].get_object() @@ -197,9 +298,13 @@ def test_tuple_assignments_for_iteritems_in_fors(self): def test_simple_tuple_assignments(self): self.mod.write( - "class C1(object):" - "\n pass\nclass C2(object):\n pass\n" - "a, b = C1(), C2()\n" + dedent("""\ + class C1(object): + pass + class C2(object): + pass + a, b = C1(), C2() + """) ) pymod = self.project.get_pymodule(self.mod) c1_class = pymod["C1"].get_object() @@ -210,7 +315,13 @@ def test_simple_tuple_assignments(self): self.assertEqual(c2_class, b_var.get_type()) def test_overriding_builtin_names(self): - self.mod.write("class C(object):\n pass\nlist = C\n") + self.mod.write( + dedent("""\ + class C(object): + pass + list = C + """) + ) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C"].get_object() list_var = pymod["list"].get_object() @@ -228,7 +339,13 @@ def test_simple_sets(self): def test_making_lists_using_the_passed_argument_to_init(self): self.mod.write( - "class C(object):\n pass\nl1 = [C()]\n" "l2 = list(l1)\na_var = l2.pop()" + dedent("""\ + class C(object): + pass + l1 = [C()] + l2 = list(l1) + a_var = l2.pop()""" + ) ) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C"].get_object() @@ -237,7 +354,13 @@ def test_making_lists_using_the_passed_argument_to_init(self): def test_making_tuples_using_the_passed_argument_to_init(self): self.mod.write( - "class C(object):\n pass\nl1 = [C()]\n" "l2 = tuple(l1)\na_var = l2[0]" + dedent("""\ + class C(object): + pass + l1 = [C()] + l2 = tuple(l1) + a_var = l2[0]""" + ) ) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C"].get_object() @@ -246,7 +369,13 @@ def test_making_tuples_using_the_passed_argument_to_init(self): def test_making_sets_using_the_passed_argument_to_init(self): self.mod.write( - "class C(object):\n pass\nl1 = [C()]\n" "l2 = set(l1)\na_var = l2.pop()" + dedent("""\ + class C(object): + pass + l1 = [C()] + l2 = set(l1) + a_var = l2.pop()""" + ) ) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C"].get_object() @@ -255,10 +384,15 @@ def test_making_sets_using_the_passed_argument_to_init(self): def test_making_dicts_using_the_passed_argument_to_init(self): self.mod.write( - "class C1(object):\n pass\n" - "class C2(object):\n pass\n" - "l1 = [(C1(), C2())]\n" - "l2 = dict(l1)\na, b = l2.items()[0]" + dedent("""\ + class C1(object): + pass + class C2(object): + pass + l1 = [(C1(), C2())] + l2 = dict(l1) + a, b = l2.items()[0]""" + ) ) pymod = self.project.get_pymodule(self.mod) c1_class = pymod["C1"].get_object() @@ -276,8 +410,13 @@ def test_range_builtin_function(self): def test_reversed_builtin_function(self): self.mod.write( - "class C(object):\n pass\nl = [C()]\n" - "for x in reversed(l):\n a_var = x\n" + dedent("""\ + class C(object): + pass + l = [C()] + for x in reversed(l): + a_var = x + """) ) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C"].get_object() @@ -286,7 +425,12 @@ def test_reversed_builtin_function(self): def test_sorted_builtin_function(self): self.mod.write( - "class C(object):\n pass\nl = [C()]\n" "a_var = sorted(l).pop()\n" + dedent("""\ + class C(object): + pass + l = [C()] + a_var = sorted(l).pop() + """) ) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C"].get_object() @@ -295,11 +439,17 @@ def test_sorted_builtin_function(self): def test_super_builtin_function(self): self.mod.write( - "class C(object):\n pass\n" - "class A(object):\n def a_f(self):\n return C()\n" - "class B(A):\n def b_f(self):\n " - "return super(B, self).a_f()\n" - "a_var = B.b_f()\n" + dedent("""\ + class C(object): + pass + class A(object): + def a_f(self): + return C() + class B(A): + def b_f(self): + return super(B, self).a_f() + a_var = B.b_f() + """) ) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C"].get_object() @@ -307,7 +457,12 @@ def test_super_builtin_function(self): self.assertEqual(c_class, a_var.get_type()) def test_file_builtin_type(self): - self.mod.write('for line in open("file.txt"):\n a_var = line\n') + self.mod.write( + dedent("""\ + for line in open("file.txt"): + a_var = line + """) + ) pymod = self.project.get_pymodule(self.mod) a_var = pymod["a_var"].get_object() self.assertTrue(isinstance(a_var.get_type(), builtins.Str)) @@ -340,9 +495,15 @@ def test_lambdas_that_return_unknown(self): def test_builtin_zip_function(self): self.mod.write( - "class C1(object):\n pass\nclass C2(object):\n pass\n" - "c1_list = [C1()]\nc2_list = [C2()]\n" - "a, b = zip(c1_list, c2_list)[0]" + dedent("""\ + class C1(object): + pass + class C2(object): + pass + c1_list = [C1()] + c2_list = [C2()] + a, b = zip(c1_list, c2_list)[0]""" + ) ) pymod = self.project.get_pymodule(self.mod) c1_class = pymod["C1"].get_object() @@ -354,9 +515,15 @@ def test_builtin_zip_function(self): def test_builtin_zip_function_with_more_than_two_args(self): self.mod.write( - "class C1(object):\n pass\nclass C2(object):\n pass\n" - "c1_list = [C1()]\nc2_list = [C2()]\n" - "a, b, c = zip(c1_list, c2_list, c1_list)[0]" + dedent("""\ + class C1(object): + pass + class C2(object): + pass + c1_list = [C1()] + c2_list = [C2()] + a, b, c = zip(c1_list, c2_list, c1_list)[0]""" + ) ) pymod = self.project.get_pymodule(self.mod) c1_class = pymod["C1"].get_object() @@ -370,8 +537,12 @@ def test_builtin_zip_function_with_more_than_two_args(self): def test_wrong_arguments_to_zip_function(self): self.mod.write( - "class C1(object):\n pass\nc1_list = [C1()]\n" - "a, b = zip(c1_list, 1)[0]" + dedent("""\ + class C1(object): + pass + c1_list = [C1()] + a, b = zip(c1_list, 1)[0]""" + ) ) pymod = self.project.get_pymodule(self.mod) c1_class = pymod["C1"].get_object() @@ -381,8 +552,13 @@ def test_wrong_arguments_to_zip_function(self): def test_enumerate_builtin_function(self): self.mod.write( - "class C(object):\n pass\nl = [C()]\n" - "for i, x in enumerate(l):\n a_var = x\n" + dedent("""\ + class C(object): + pass + l = [C()] + for i, x in enumerate(l): + a_var = x + """) ) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C"].get_object() @@ -396,7 +572,12 @@ def test_builtin_class_get_name(self): ) def test_star_args_and_double_star_args(self): - self.mod.write("def func(p, *args, **kwds):\n pass\n") + self.mod.write( + dedent("""\ + def func(p, *args, **kwds): + pass + """) + ) pymod = self.project.get_pymodule(self.mod) func_scope = pymod["func"].get_object().get_scope() args = func_scope["args"].get_object() @@ -418,8 +599,13 @@ def test_simple_list_generator_expression(self): def test_iter_builtin_function(self): self.mod.write( - "class C(object):\n pass\nl = [C()]\n" - "for c in iter(l):\n a_var = c\n" + dedent("""\ + class C(object): + pass + l = [C()] + for c in iter(l): + a_var = c + """) ) pymod = self.project.get_pymodule(self.mod) c_class = pymod["C"].get_object() @@ -491,12 +677,12 @@ def test_binary_or_left_value_unknown(self): ) def test_unknown_return_object(self): - src = ( - "import sys\n" - "def foo():\n" - " res = set(sys.builtin_module_names)\n" - " if foo: res.add(bar)\n" - ) + src = dedent("""\ + import sys + def foo(): + res = set(sys.builtin_module_names) + if foo: res.add(bar) + """) self.project.prefs["import_dynload_stdmods"] = True self.mod.write(src) self.project.pycore.analyze_module(self.mod) @@ -541,7 +727,12 @@ def test_nonexistent_modules(self): pymod["invalid"].get_object() def test_nonexistent_modules_2(self): - self.mod.write("import invalid\nimport invalid.sub") + self.mod.write( + dedent("""\ + import invalid + import invalid.sub""" + ) + ) pymod = self.project.get_pymodule(self.mod) invalid = pymod["invalid"].get_object() self.assertTrue("sub" in invalid) diff --git a/ropetest/codeanalyzetest.py b/ropetest/codeanalyzetest.py index a42642db0..4f97f4a20 100644 --- a/ropetest/codeanalyzetest.py +++ b/ropetest/codeanalyzetest.py @@ -63,7 +63,10 @@ def _find_primary(self, code, offset): return result def test_keyword_before_parens(self): - code = "if (a_var).an_attr:\n pass\n" + code = dedent("""\ + if (a_var).an_attr: + pass + """) self.assertEqual("(a_var).an_attr", self._find_primary(code, code.index(":"))) def test_inside_parans(self): @@ -115,7 +118,10 @@ def test_word_finder_on_primary_like_keyword(self): self.assertEqual("is_keyword", result) def test_keyword_before_parens_no_space(self): - code = "if(a_var).an_attr:\n pass\n" + code = dedent("""\ + if(a_var).an_attr: + pass + """) self.assertEqual("(a_var).an_attr", self._find_primary(code, code.index(":"))) def test_strings(self): @@ -219,18 +225,27 @@ def test_comments_for_finding_statements3(self): self.assertEqual("var3", self._find_primary(code, 21)) def test_import_statement_finding(self): - code = "import mod\na_var = 10\n" + code = dedent("""\ + import mod + a_var = 10 + """) word_finder = worder.Worder(code) self.assertTrue(word_finder.is_import_statement(code.index("mod") + 1)) self.assertFalse(word_finder.is_import_statement(code.index("a_var") + 1)) def test_import_statement_finding2(self): - code = "import a.b.c.d\nresult = a.b.c.d.f()\n" + code = dedent("""\ + import a.b.c.d + result = a.b.c.d.f() + """) word_finder = worder.Worder(code) self.assertFalse(word_finder.is_import_statement(code.rindex("d") + 1)) def test_word_parens_range(self): - code = "s = str()\ns.title()\n" + code = dedent("""\ + s = str() + s.title() + """) word_finder = worder.Worder(code) result = word_finder.get_word_parens_range(code.rindex("()") - 1) self.assertEqual((len(code) - 3, len(code) - 1), result) @@ -353,7 +368,11 @@ def test_is_on_function_keyword(self): self.assertTrue(finder.is_on_function_call_keyword(len(code) - 1)) def test_get_word_range_with_fstring(self): - code = 'auth = 8\nmy_var = f"some value {auth}"\nprint(auth)\nother_val = "some other"' + code = dedent('''\ + auth = 8 + my_var = f"some value {auth}" + print(auth) + other_val = "some other"''') finder = worder.Worder(code) self.assertEqual(finder.get_word_range(45), (45, 49)) @@ -370,14 +389,22 @@ def tearDown(self): # FIXME: in normal scopes the interpreter raises `UnboundLocalName` # exception, but not in class bodies def xxx_test_global_name_in_class_body(self): - code = "a_var = 10\nclass C(object):\n a_var = a_var\n" + code = dedent("""\ + a_var = 10 + class C(object): + a_var = a_var + """) scope = libutils.get_string_scope(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) result = name_finder.get_pyname_at(len(code) - 3) self.assertEqual(scope["a_var"], result) def test_class_variable_attribute_in_class_body(self): - code = "a_var = 10\nclass C(object):\n a_var = a_var\n" + code = dedent("""\ + a_var = 10 + class C(object): + a_var = a_var + """) scope = libutils.get_string_scope(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) a_var_pyname = scope["C"].get_object()["a_var"] @@ -385,7 +412,12 @@ def test_class_variable_attribute_in_class_body(self): self.assertEqual(a_var_pyname, result) def test_class_variable_attribute_in_class_body2(self): - code = "a_var = 10\nclass C(object):\n a_var \\\n= a_var\n" + code = dedent("""\ + a_var = 10 + class C(object): + a_var \\ + = a_var + """) scope = libutils.get_string_scope(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) a_var_pyname = scope["C"].get_object()["a_var"] @@ -393,7 +425,11 @@ def test_class_variable_attribute_in_class_body2(self): self.assertEqual(a_var_pyname, result) def test_class_method_attribute_in_class_body(self): - code = "class C(object):\n def a_method(self):\n pass\n" + code = dedent("""\ + class C(object): + def a_method(self): + pass + """) scope = libutils.get_string_scope(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) a_method_pyname = scope["C"].get_object()["a_method"] @@ -401,7 +437,11 @@ def test_class_method_attribute_in_class_body(self): self.assertEqual(a_method_pyname, result) def test_inner_class_attribute_in_class_body(self): - code = "class C(object):\n class CC(object):\n pass\n" + code = dedent("""\ + class C(object): + class CC(object): + pass + """) scope = libutils.get_string_scope(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) a_class_pyname = scope["C"].get_object()["CC"] @@ -409,7 +449,11 @@ def test_inner_class_attribute_in_class_body(self): self.assertEqual(a_class_pyname, result) def test_class_method_in_class_body_but_not_indexed(self): - code = "class C(object):\n def func(self, func):\n pass\n" + code = dedent("""\ + class C(object): + def func(self, func): + pass + """) scope = libutils.get_string_scope(self.project, code) a_func_pyname = scope.get_scopes()[0].get_scopes()[0]["func"] name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) @@ -417,7 +461,10 @@ def test_class_method_in_class_body_but_not_indexed(self): self.assertEqual(a_func_pyname, result) def test_function_but_not_indexed(self): - code = "def a_func(a_func):\n pass\n" + code = dedent("""\ + def a_func(a_func): + pass + """) scope = libutils.get_string_scope(self.project, code) a_func_pyname = scope["a_func"] name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) @@ -427,7 +474,12 @@ def test_function_but_not_indexed(self): def test_modules_after_from_statements(self): root_folder = self.project.root mod = testutils.create_module(self.project, "mod", root_folder) - mod.write("def a_func():\n pass\n") + mod.write( + dedent("""\ + def a_func(): + pass + """) + ) code = "from mod import a_func\n" scope = libutils.get_string_scope(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) @@ -437,8 +489,16 @@ def test_modules_after_from_statements(self): def test_renaming_functions_with_from_import_and_parens(self): mod1 = testutils.create_module(self.project, "mod1") - mod1.write("def afunc():\n pass\n") - code = "from mod1 import (\n afunc as func)\n" + mod1.write( + dedent("""\ + def afunc(): + pass + """) + ) + code = dedent("""\ + from mod1 import ( + afunc as func) + """) scope = libutils.get_string_scope(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) mod_pyobject = self.project.get_pymodule(mod1) @@ -452,7 +512,12 @@ def test_relative_modules_after_from_statements(self): pkg2 = testutils.create_package(self.project, "pkg2", pkg1) mod1 = testutils.create_module(self.project, "mod1", pkg1) mod2 = testutils.create_module(self.project, "mod2", pkg2) - mod1.write("def a_func():\n pass\n") + mod1.write( + dedent("""\ + def a_func(): + pass + """) + ) code = "from ..mod1 import a_func\n" mod2.write(code) mod2_scope = self.project.get_pymodule(mod2).get_scope() @@ -475,28 +540,45 @@ def test_relative_modules_after_from_statements2(self): self.assertEqual(pkg2_pyobject, found_pyname.get_object()) def test_get_pyname_at_on_language_keywords(self): - code = "def a_func(a_func):\n pass\n" + code = dedent("""\ + def a_func(a_func): + pass + """) pymod = libutils.get_string_module(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(pymod) with self.assertRaises(exceptions.RopeError): name_finder.get_pyname_at(code.index("pass")) def test_one_liners(self): - code = "var = 1\ndef f(): var = 2\nprint(var)\n" + code = dedent("""\ + var = 1 + def f(): var = 2 + print(var) + """) pymod = libutils.get_string_module(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(pymod) pyname = name_finder.get_pyname_at(code.rindex("var")) self.assertEqual(pymod["var"], pyname) def test_one_liners_with_line_breaks(self): - code = "var = 1\ndef f(\n): var = 2\nprint(var)\n" + code = dedent("""\ + var = 1 + def f( + ): var = 2 + print(var) + """) pymod = libutils.get_string_module(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(pymod) pyname = name_finder.get_pyname_at(code.rindex("var")) self.assertEqual(pymod["var"], pyname) def test_one_liners_with_line_breaks2(self): - code = "var = 1\ndef f(\np): var = 2\nprint(var)\n" + code = dedent("""\ + var = 1 + def f( + p): var = 2 + print(var) + """) pymod = libutils.get_string_module(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(pymod) pyname = name_finder.get_pyname_at(code.rindex("var")) @@ -530,7 +612,10 @@ def test_normal_lines(self): self.assertEqual((1, 1), line_finder.logical_line_in(1)) def test_normal_lines2(self): - code = "another = 10\na_var = 20\n" + code = dedent("""\ + another = 10 + a_var = 20 + """) line_finder = self._logical_finder(code) self.assertEqual((1, 1), line_finder.logical_line_in(1)) self.assertEqual((2, 2), line_finder.logical_line_in(2)) @@ -541,7 +626,12 @@ def test_implicit_continuation(self): self.assertEqual((1, 3), line_finder.logical_line_in(2)) def test_explicit_continuation(self): - code = "print(2)\na_var = (3 + \n 4, \n 5)\n" + code = dedent("""\ + print(2) + a_var = (3 + + 4, + 5) + """) line_finder = self._logical_finder(code) self.assertEqual((2, 4), line_finder.logical_line_in(2)) @@ -551,42 +641,69 @@ def test_explicit_continuation_comments(self): self.assertEqual((2, 2), line_finder.logical_line_in(2)) def test_multiple_indented_ifs(self): - code = ( - "if True:\n if True:\n " - "if True:\n pass\n a = 10\n" - ) + code = dedent("""\ + if True: + if True: + if True: + pass + a = 10 + """) line_finder = self._logical_finder(code) self.assertEqual((5, 5), line_finder.logical_line_in(5)) def test_list_comprehensions_and_fors(self): - code = "a_list = [i\n for i in range(10)]\n" + code = dedent("""\ + a_list = [i + for i in range(10)] + """) line_finder = self._logical_finder(code) self.assertEqual((1, 2), line_finder.logical_line_in(2)) def test_generator_expressions_and_fors(self): - code = "a_list = (i\n for i in range(10))\n" + code = dedent("""\ + a_list = (i + for i in range(10)) + """) line_finder = self._logical_finder(code) self.assertEqual((1, 2), line_finder.logical_line_in(2)) def test_fors_and_block_start(self): - code = "l = range(10)\nfor i in l:\n print(i)\n" + code = dedent("""\ + l = range(10) + for i in l: + print(i) + """) self.assertEqual(2, get_block_start(SourceLinesAdapter(code), 2)) def test_problems_with_inner_indentations(self): - code = ( - "if True:\n if True:\n if True:\n pass\n" - " a = \\\n 1\n" - ) + code = dedent("""\ + if True: + if True: + if True: + pass + a = \\ + 1 + """) line_finder = self._logical_finder(code) self.assertEqual((5, 6), line_finder.logical_line_in(6)) def test_problems_with_inner_indentations2(self): - code = "if True:\n if True:\n pass\n" "a = 1\n" + code = dedent("""\ + if True: + if True: + pass + a = 1 + """) line_finder = self._logical_finder(code) self.assertEqual((4, 4), line_finder.logical_line_in(4)) def test_logical_lines_for_else(self): - code = "if True:\n pass\nelse:\n pass\n" + code = dedent("""\ + if True: + pass + else: + pass + """) line_finder = self._logical_finder(code) self.assertEqual((3, 3), line_finder.logical_line_in(3)) @@ -606,7 +723,12 @@ def test_logical_lines_for_multiline_string_with_escaped_quotes(self): self.assertEqual((2, 2), line_finder.logical_line_in(2)) def test_generating_line_starts(self): - code = "a = 1\na = 2\n\na = 3\n" + code = dedent("""\ + a = 1 + a = 2 + + a = 3 + """) line_finder = self._logical_finder(code) self.assertEqual([1, 2, 4], list(line_finder.generate_starts())) @@ -626,10 +748,13 @@ def test_generating_line_starts_for_multi_line_statements(self): self.assertEqual([2], list(line_finder.generate_starts())) def test_generating_line_starts_and_unmatched_deindents(self): - code = ( - "if True:\n if True:\n if True:\n" - " a = 1\n b = 1\n" - ) + code = dedent("""\ + if True: + if True: + if True: + a = 1 + b = 1 + """) line_finder = self._logical_finder(code) self.assertEqual([4, 5], list(line_finder.generate_starts(4))) diff --git a/ropetest/contrib/codeassisttest.py b/ropetest/contrib/codeassisttest.py index 8bd3d38ae..9e092f210 100644 --- a/ropetest/contrib/codeassisttest.py +++ b/ropetest/contrib/codeassisttest.py @@ -69,77 +69,111 @@ def assert_completion_not_in_result(self, name, scope, result): self.fail("completion <%s> was proposed" % name) def test_completing_global_variables(self): - code = "my_global = 10\nt = my" + code = dedent("""\ + my_global = 10 + t = my""") result = self._assist(code) self.assert_completion_in_result("my_global", "global", result) def test_not_proposing_unmatched_vars(self): - code = "my_global = 10\nt = you" + code = dedent("""\ + my_global = 10 + t = you""") result = self._assist(code) self.assert_completion_not_in_result("my_global", "global", result) def test_not_proposing_unmatched_vars_with_underlined_starting(self): - code = "my_global = 10\nt = your_" + code = dedent("""\ + my_global = 10 + t = your_""") result = self._assist(code) self.assert_completion_not_in_result("my_global", "global", result) def test_not_proposing_local_assigns_as_global_completions(self): - code = "def f(): my_global = 10\nt = my_" + code = dedent("""\ + def f(): my_global = 10 + t = my_""") result = self._assist(code) self.assert_completion_not_in_result("my_global", "global", result) def test_proposing_functions(self): - code = "def my_func(): return 2\nt = my_" + code = dedent("""\ + def my_func(): return 2 + t = my_""") result = self._assist(code) self.assert_completion_in_result("my_func", "global", result) def test_proposing_classes(self): - code = "class Sample(object): pass\nt = Sam" + code = dedent("""\ + class Sample(object): pass + t = Sam""") result = self._assist(code) self.assert_completion_in_result("Sample", "global", result) def test_proposing_each_name_at_most_once(self): - code = "variable = 10\nvariable = 20\nt = vari" + code = dedent("""\ + variable = 10 + variable = 20 + t = vari""") result = self._assist(code) count = len([x for x in result if x.name == "variable" and x.scope == "global"]) self.assertEqual(1, count) def test_throwing_exception_in_case_of_syntax_errors(self): - code = "sample (sdf+)\n" + code = dedent("""\ + sample (sdf+) + """) with self.assertRaises(exceptions.ModuleSyntaxError): self._assist(code, maxfixes=0) def test_fixing_errors_with_maxfixes(self): - code = "def f():\n sldj sldj\ndef g():\n ran" + code = dedent("""\ + def f(): + sldj sldj + def g(): + ran""") result = self._assist(code, maxfixes=2) self.assertTrue(len(result) > 0) def test_ignoring_errors_in_current_line(self): - code = "def my_func():\n return 2\nt = " + code = dedent("""\ + def my_func(): + return 2 + t = """) result = self._assist(code) self.assert_completion_in_result("my_func", "global", result) def test_not_reporting_variables_in_current_line(self): - code = "def my_func(): return 2\nt = my_" + code = dedent("""\ + def my_func(): return 2 + t = my_""") result = self._assist(code) self.assert_completion_not_in_result("my_", "global", result) def test_completion_result(self): - code = "my_global = 10\nt = my" + code = dedent("""\ + my_global = 10 + t = my""") self.assertEqual(len(code) - 2, starting_offset(code, len(code))) def test_completing_imported_names(self): - code = "import sys\na = sy" + code = dedent("""\ + import sys + a = sy""") result = self._assist(code) self.assert_completion_in_result("sys", "imported", result) def test_completing_imported_names_with_as(self): - code = "import sys as mysys\na = mys" + code = dedent("""\ + import sys as mysys + a = mys""") result = self._assist(code) self.assert_completion_in_result("mysys", "imported", result) def test_not_completing_imported_names_with_as(self): - code = "import sys as mysys\na = sy" + code = dedent("""\ + import sys as mysys + a = sy""") result = self._assist(code) self.assert_completion_not_in_result("sys", "global", result) @@ -159,7 +193,9 @@ def test_builtin_instances(self): # we need to have it enabled to make pycore._find_module() # load ``sys`` module. self.project.prefs["import_dynload_stdmods"] = True - code = "from sys import stdout\nstdout.wr" + code = dedent("""\ + from sys import stdout + stdout.wr""") result = self._assist(code) self.assert_completion_in_result("write", "builtin", result) self.assert_completion_in_result("writelines", "builtin", result) @@ -170,136 +206,182 @@ def test_including_keywords(self): self.assert_completion_in_result("for", "keyword", result) def test_not_reporting_proposals_after_dot(self): - code = "a_dict = {}\nkey = 3\na_dict.ke" + code = dedent("""\ + a_dict = {} + key = 3 + a_dict.ke""") result = self._assist(code) self.assert_completion_not_in_result("key", "global", result) def test_proposing_local_variables_in_functions(self): - code = "def f(self):\n my_var = 10\n my_" + code = dedent("""\ + def f(self): + my_var = 10 + my_""") result = self._assist(code) self.assert_completion_in_result("my_var", "local", result) def test_local_variables_override_global_ones(self): - code = "my_var = 20\ndef f(self):\n my_var = 10\n my_" + code = dedent("""\ + my_var = 20 + def f(self): + my_var = 10 + my_""") result = self._assist(code) self.assert_completion_in_result("my_var", "local", result) def test_not_including_class_body_variables(self): - code = ( - "class C(object):\n my_var = 20\n" - " def f(self):\n a = 20\n my_" - ) + code = dedent("""\ + class C(object): + my_var = 20 + def f(self): + a = 20 + my_""") result = self._assist(code) self.assert_completion_not_in_result("my_var", "local", result) def test_nested_functions(self): - code = ( - "def my_func():\n func_var = 20\n " - "def inner_func():\n a = 20\n func" - ) + code = dedent("""\ + def my_func(): + func_var = 20 + def inner_func(): + a = 20 + func""") result = self._assist(code) self.assert_completion_in_result("func_var", "local", result) def test_scope_endpoint_selection(self): - code = "def my_func():\n func_var = 20\n" + code = dedent("""\ + def my_func(): + func_var = 20 + """) result = self._assist(code) self.assert_completion_not_in_result("func_var", "local", result) def test_scope_better_endpoint_selection(self): - code = "if True:\n def f():\n my_var = 10\n my_" + code = dedent("""\ + if True: + def f(): + my_var = 10 + my_""") result = self._assist(code) self.assert_completion_not_in_result("my_var", "local", result) def test_imports_inside_function(self): - code = "def f():\n import sys\n sy" + code = dedent("""\ + def f(): + import sys + sy""") result = self._assist(code) self.assert_completion_in_result("sys", "imported", result) def test_imports_inside_function_dont_mix_with_globals(self): - code = "def f():\n import sys\nsy" + code = dedent("""\ + def f(): + import sys + sy""") result = self._assist(code) self.assert_completion_not_in_result("sys", "local", result) def test_nested_classes_local_names(self): - code = ( - "global_var = 10\n" - "def my_func():\n" - " func_var = 20\n" - " class C(object):\n" - " def another_func(self):\n" - " local_var = 10\n" - " func" - ) + code = dedent("""\ + global_var = 10 + def my_func(): + func_var = 20 + class C(object): + def another_func(self): + local_var = 10 + func""") result = self._assist(code) self.assert_completion_in_result("func_var", "local", result) def test_nested_classes_global(self): - code = ( - "global_var = 10\n" - "def my_func():\n" - " func_var = 20\n" - " class C(object):\n" - " def another_func(self):\n" - " local_var = 10\n" - " globa" - ) + code = dedent("""\ + global_var = 10 + def my_func(): + func_var = 20 + class C(object): + def another_func(self): + local_var = 10 + globa""") result = self._assist(code) self.assert_completion_in_result("global_var", "global", result) def test_nested_classes_global_function(self): - code = ( - "global_var = 10\n" - "def my_func():\n" - " func_var = 20\n" - " class C(object):\n" - " def another_func(self):\n" - " local_var = 10\n" - " my_f" - ) + code = dedent("""\ + global_var = 10 + def my_func(): + func_var = 20 + class C(object): + def another_func(self): + local_var = 10 + my_f""") result = self._assist(code) self.assert_completion_in_result("my_func", "global", result) def test_proposing_function_parameters_in_functions(self): - code = "def my_func(my_param):\n my_var = 20\n my_" + code = dedent("""\ + def my_func(my_param): + my_var = 20 + my_""") result = self._assist(code) self.assert_completion_in_result("my_param", "local", result) def test_proposing_function_keyword_parameters_in_functions(self): - code = ( - "def my_func(my_param, *my_list, **my_kws):\n" " my_var = 20\n" " my_" - ) + code = dedent("""\ + def my_func(my_param, *my_list, **my_kws): + my_var = 20 + my_""") result = self._assist(code) self.assert_completion_in_result("my_param", "local", result) self.assert_completion_in_result("my_list", "local", result) self.assert_completion_in_result("my_kws", "local", result) def test_not_proposing_unmatching_function_parameters_in_functions(self): - code = "def my_func(my_param):\n my_var = 20\n you_" + code = dedent("""\ + def my_func(my_param): + my_var = 20 + you_""") result = self._assist(code) self.assert_completion_not_in_result("my_param", "local", result) def test_ignoring_current_statement(self): - code = "my_var = 10\nmy_tuple = (10, \n my_" + code = dedent("""\ + my_var = 10 + my_tuple = (10, + my_""") result = self._assist(code) self.assert_completion_in_result("my_var", "global", result) def test_ignoring_current_statement_brackets_continuation(self): - code = "my_var = 10\n'hello'[10:\n my_" + code = dedent("""\ + my_var = 10 + 'hello'[10: + my_""") result = self._assist(code) self.assert_completion_in_result("my_var", "global", result) def test_ignoring_current_statement_explicit_continuation(self): - code = "my_var = 10\nmy_var2 = 2 + \\\n my_" + code = dedent("""\ + my_var = 10 + my_var2 = 2 + \\ + my_""") result = self._assist(code) self.assert_completion_in_result("my_var", "global", result) def test_ignor_current_statement_while_the_first_stmnt_of_the_block(self): - code = "my_var = 10\ndef f():\n my_" + code = dedent("""\ + my_var = 10 + def f(): + my_""") result = self._assist(code) self.assert_completion_in_result("my_var", "global", result) def test_ignor_current_stmnt_while_current_line_ends_with_a_colon(self): - code = "my_var = 10\nif my_:\n pass" + code = dedent("""\ + my_var = 10 + if my_: + pass""") result = self._assist(code, 18) self.assert_completion_in_result("my_var", "global", result) @@ -324,12 +406,19 @@ def test_ignoring_string_contents_backslash_plus_backslash(self): self.assert_completion_in_result("my_var", "global", result) def test_not_proposing_later_defined_variables_in_current_block(self): - code = "my_\nmy_var = 10\n" + code = dedent("""\ + my_ + my_var = 10 + """) result = self._assist(code, 3, later_locals=False) self.assert_completion_not_in_result("my_var", "global", result) def test_not_proposing_later_defined_variables_in_current_function(self): - code = "def f():\n my_\n my_var = 10\n" + code = dedent("""\ + def f(): + my_ + my_var = 10 + """) result = self._assist(code, 16, later_locals=False) self.assert_completion_not_in_result("my_var", "local", result) @@ -349,114 +438,125 @@ def test_ignor_str_contents_with_triple_quotes_and_double_backslash(self): self.assert_completion_in_result("my_var", "global", result) def test_reporting_params_when_in_the_first_line_of_a_function(self): - code = "def f(param):\n para" + code = dedent("""\ + def f(param): + para""") result = self._assist(code) self.assert_completion_in_result("param", "local", result) def test_code_assist_when_having_a_two_line_function_header(self): - code = "def f(param1,\n param2):\n para" + code = dedent("""\ + def f(param1, + param2): + para""") result = self._assist(code) self.assert_completion_in_result("param1", "local", result) def test_code_assist_with_function_with_two_line_return(self): - code = "def f(param1, param2):\n return(param1,\n para" + code = dedent("""\ + def f(param1, param2): + return(param1, + para""") result = self._assist(code) self.assert_completion_in_result("param2", "local", result) def test_get_definition_location(self): - code = "def a_func():\n pass\na_func()" + code = dedent("""\ + def a_func(): + pass + a_func()""") result = get_definition_location(self.project, code, len(code) - 3) self.assertEqual((None, 1), result) def test_get_definition_location_underlined_names(self): - code = "def a_sample_func():\n pass\na_sample_func()" + code = dedent("""\ + def a_sample_func(): + pass + a_sample_func()""") result = get_definition_location(self.project, code, len(code) - 11) self.assertEqual((None, 1), result) def test_get_definition_location_dotted_names_method(self): - code = ( - "class AClass(object):\n" - " @staticmethod\n" - " def a_method():\n" - " pass\n" - "AClass.a_method()" - ) + code = dedent("""\ + class AClass(object): + @staticmethod + def a_method(): + pass + AClass.a_method()""") result = get_definition_location(self.project, code, len(code) - 3) self.assertEqual((None, 3), result) def test_get_definition_location_dotted_names_property(self): - code = ( - "class AClass(object):\n" - " @property\n" - " @somedecorator\n" - " def a_method():\n" - " pass\n" - "AClass.a_method()" - ) + code = dedent("""\ + class AClass(object): + @property + @somedecorator + def a_method(): + pass + AClass.a_method()""") result = get_definition_location(self.project, code, len(code) - 3) self.assertEqual((None, 4), result) def test_get_definition_location_dotted_names_free_function(self): - code = "@custom_decorator\n" "def a_method():\n" " pass\n" "a_method()" + code = dedent("""\ + @custom_decorator + def a_method(): + pass + a_method()""") result = get_definition_location(self.project, code, len(code) - 3) self.assertEqual((None, 2), result) @testutils.only_for_versions_higher("3.5") def test_get_definition_location_dotted_names_async_def(self): - code = ( - "class AClass(object):\n" - " @property\n" - " @decorator2\n" - " async def a_method():\n" - " pass\n" - "AClass.a_method()" - ) + code = dedent("""\ + class AClass(object): + @property + @decorator2 + async def a_method(): + pass + AClass.a_method()""") result = get_definition_location(self.project, code, len(code) - 3) self.assertEqual((None, 4), result) def test_get_definition_location_dotted_names_class(self): - code = ( - "@custom_decorator\n" - "class AClass(object):\n" - " def a_method():\n" - " pass\n" - "AClass.a_method()" - ) + code = dedent("""\ + @custom_decorator + class AClass(object): + def a_method(): + pass + AClass.a_method()""") result = get_definition_location(self.project, code, len(code) - 12) self.assertEqual((None, 2), result) def test_get_definition_location_dotted_names_with_space(self): - code = ( - "class AClass(object):\n" - " @staticmethod\n" - " def a_method():\n" - " \n" - " pass\n" - "AClass.a_method()" - ) + code = dedent("""\ + class AClass(object): + @staticmethod + def a_method(): + + pass + AClass.a_method()""") result = get_definition_location(self.project, code, len(code) - 3) self.assertEqual((None, 3), result) def test_get_definition_location_dotted_names_inline_body(self): - code = ( - "class AClass(object):\n" - " @staticmethod\n" - " def a_method(): pass\n" - "AClass.a_method()" - ) + code = dedent("""\ + class AClass(object): + @staticmethod + def a_method(): pass + AClass.a_method()""") result = get_definition_location(self.project, code, len(code) - 3) self.assertEqual((None, 3), result) def test_get_definition_location_dotted_names_inline_body_split_arg(self): - code = ( - "class AClass(object):\n" - " @staticmethod\n" - " def a_method(\n" - " self,\n" - " arg1\n" - " ): pass\n" - "AClass.a_method()" - ) + code = dedent("""\ + class AClass(object): + @staticmethod + def a_method( + self, + arg1 + ): pass + AClass.a_method()""") result = get_definition_location(self.project, code, len(code) - 3) self.assertEqual((None, 3), result) @@ -485,154 +585,193 @@ def test_get_definition_location_unknown(self): self.assertEqual((None, None), result) def test_get_definition_location_dot_spaces(self): - code = ( - "class AClass(object):\n " - "@staticmethod\n def a_method():\n" - " pass\nAClass.\\\n a_method()" - ) + code = dedent("""\ + class AClass(object): + @staticmethod + def a_method(): + pass + AClass.\\ + a_method()""") result = get_definition_location(self.project, code, len(code) - 3) self.assertEqual((None, 3), result) def test_get_definition_location_dot_line_break_inside_parens(self): - code = ( - "class A(object):\n def a_method(self):\n pass\n" - + "(A.\na_method)" - ) + code = dedent("""\ + class A(object): + def a_method(self): + pass + (A. + a_method)""") result = get_definition_location( self.project, code, code.rindex("a_method") + 1 ) self.assertEqual((None, 2), result) def test_if_scopes_in_other_scopes_for_get_definition_location(self): - code = ( - "def f(a_var):\n pass\na_var = 10\n" - + "if True:\n" - + " print(a_var)\n" - ) + code = dedent("""\ + def f(a_var): + pass + a_var = 10 + if True: + print(a_var) + """) result = get_definition_location(self.project, code, len(code) - 3) self.assertEqual((None, 3), result) def test_get_definition_location_false_triple_quoted_string(self): - code = dedent('''\ - def foo(): - a = 0 - p = "foo""" - - def bar(): - a = 1 - a += 1 - ''') + code = dedent( + dedent('''\ + def foo(): + a = 0 + p = "foo""" + + def bar(): + a = 1 + a += 1 + ''') + ) result = get_definition_location(self.project, code, code.index("a += 1")) self.assertEqual((None, 6), result) def test_code_assists_in_parens(self): - code = "def a_func(a_var):\n pass\na_var = 10\na_func(a_" + code = dedent("""\ + def a_func(a_var): + pass + a_var = 10 + a_func(a_""") result = self._assist(code) self.assert_completion_in_result("a_var", "global", result) def test_simple_type_inferencing(self): - code = ( - "class Sample(object):\n" - " def __init__(self, a_param):\n" - " pass\n" - " def a_method(self):\n" - " pass\n" - 'Sample("hey").a_' - ) + code = dedent("""\ + class Sample(object): + def __init__(self, a_param): + pass + def a_method(self): + pass + Sample("hey").a_""") result = self._assist(code) self.assert_completion_in_result("a_method", "attribute", result) def test_proposals_sorter(self): - code = ( - "def my_sample_function(self):\n" - + " my_sample_var = 20\n" - + " my_sample_" - ) + code = dedent("""\ + def my_sample_function(self): + my_sample_var = 20 + my_sample_""") proposals = sorted_proposals(self._assist(code)) self.assertEqual("my_sample_var", proposals[0].name) self.assertEqual("my_sample_function", proposals[1].name) def test_proposals_sorter_for_methods_and_attributes(self): - code = ( - "class A(object):\n" - + " def __init__(self):\n" - + " self.my_a_var = 10\n" - + " def my_b_func(self):\n" - + " pass\n" - + " def my_c_func(self):\n" - + " pass\n" - + "a_var = A()\n" - + "a_var.my_" - ) + code = dedent("""\ + class A(object): + def __init__(self): + self.my_a_var = 10 + def my_b_func(self): + pass + def my_c_func(self): + pass + a_var = A() + a_var.my_""") proposals = sorted_proposals(self._assist(code)) self.assertEqual("my_b_func", proposals[0].name) self.assertEqual("my_c_func", proposals[1].name) self.assertEqual("my_a_var", proposals[2].name) def test_proposals_sorter_for_global_methods_and_funcs(self): - code = "def my_b_func(self):\n" + " pass\n" + "my_a_var = 10\n" + "my_" + code = dedent("""\ + def my_b_func(self): + pass + my_a_var = 10 + my_""") proposals = sorted_proposals(self._assist(code)) self.assertEqual("my_b_func", proposals[0].name) self.assertEqual("my_a_var", proposals[1].name) def test_proposals_sorter_underlined_methods(self): - code = ( - "class A(object):\n" - + " def _my_func(self):\n" - + " self.my_a_var = 10\n" - + " def my_func(self):\n" - + " pass\n" - + "a_var = A()\n" - + "a_var." - ) + code = dedent("""\ + class A(object): + def _my_func(self): + self.my_a_var = 10 + def my_func(self): + pass + a_var = A() + a_var.""") proposals = sorted_proposals(self._assist(code)) self.assertEqual("my_func", proposals[0].name) self.assertEqual("_my_func", proposals[1].name) def test_proposals_sorter_and_scope_prefs(self): - code = ( - "my_global_var = 1\n" "def func(self):\n" " my_local_var = 2\n" " my_" - ) + code = dedent("""\ + my_global_var = 1 + def func(self): + my_local_var = 2 + my_""") result = self._assist(code) proposals = sorted_proposals(result, scopepref=["global", "local"]) self.assertEqual("my_global_var", proposals[0].name) self.assertEqual("my_local_var", proposals[1].name) def test_proposals_sorter_and_type_prefs(self): - code = "my_global_var = 1\n" "def my_global_func(self):\n" " pass\n" "my_" + code = dedent("""\ + my_global_var = 1 + def my_global_func(self): + pass + my_""") result = self._assist(code) proposals = sorted_proposals(result, typepref=["instance", "function"]) self.assertEqual("my_global_var", proposals[0].name) self.assertEqual("my_global_func", proposals[1].name) def test_proposals_sorter_and_missing_type_in_typepref(self): - code = "my_global_var = 1\n" "def my_global_func():\n" " pass\n" "my_" + code = dedent("""\ + my_global_var = 1 + def my_global_func(): + pass + my_""") result = self._assist(code) proposals = sorted_proposals(result, typepref=["function"]) # noqa def test_get_pydoc_unicode(self): - src = u'# coding: utf-8\ndef foo():\n u"юникод-объект"' + src = dedent('''\ + # coding: utf-8 + def foo(): + u"юникод-объект"''') doc = get_doc(self.project, src, src.index("foo") + 1) self.assertTrue(isinstance(doc, unicode)) self.assertTrue(u"юникод-объект" in doc) def test_get_pydoc_utf8_bytestring(self): - src = u'# coding: utf-8\ndef foo():\n "байтстринг"' + src = dedent('''\ + # coding: utf-8 + def foo(): + "байтстринг"''') doc = get_doc(self.project, src, src.index("foo") + 1) self.assertTrue(isinstance(doc, unicode)) self.assertTrue(u"байтстринг" in doc) def test_get_pydoc_for_functions(self): - src = "def a_func():\n" ' """a function"""\n' " a_var = 10\n" "a_func()" + src = dedent('''\ + def a_func(): + """a function""" + a_var = 10 + a_func()''') self.assertTrue(get_doc(self.project, src, len(src) - 4).endswith("a function")) get_doc(self.project, src, len(src) - 4).index("a_func()") def test_get_pydoc_for_classes(self): - src = "class AClass(object):\n pass\n" + src = dedent("""\ + class AClass(object): + pass + """) get_doc(self.project, src, src.index("AClass") + 1).index("AClass") def test_get_pydoc_for_classes_with_init(self): - src = "class AClass(object):\n def __init__(self):\n pass\n" + src = dedent("""\ + class AClass(object): + def __init__(self): + pass + """) get_doc(self.project, src, src.index("AClass") + 1).index("AClass") def test_get_pydoc_for_modules(self): @@ -646,27 +785,27 @@ def test_get_pydoc_for_builtins(self): self.assertTrue(get_doc(self.project, src, src.index("obj")) is not None) def test_get_pydoc_for_methods_should_include_class_name(self): - src = ( - "class AClass(object):\n" - " def a_method(self):\n" - ' """hey"""\n' - " pass\n" - ) + src = dedent('''\ + class AClass(object): + def a_method(self): + """hey""" + pass + ''') doc = get_doc(self.project, src, src.index("a_method") + 1) doc.index("AClass.a_method") doc.index("hey") def test_get_pydoc_for_meths_should_inc_methods_from_super_classes(self): - src = ( - "class A(object):\n" - " def a_method(self):\n" - ' """hey1"""\n' - " pass\n" - "class B(A):\n" - " def a_method(self):\n" - ' """hey2"""\n' - " pass\n" - ) + src = dedent('''\ + class A(object): + def a_method(self): + """hey1""" + pass + class B(A): + def a_method(self): + """hey2""" + pass + ''') doc = get_doc(self.project, src, src.rindex("a_method") + 1) doc.index("A.a_method") doc.index("hey1") @@ -674,156 +813,267 @@ def test_get_pydoc_for_meths_should_inc_methods_from_super_classes(self): doc.index("hey2") def test_get_pydoc_for_classes_should_name_super_classes(self): - src = "class A(object):\n pass\n" "class B(A):\n pass\n" + src = dedent("""\ + class A(object): + pass + class B(A): + pass + """) doc = get_doc(self.project, src, src.rindex("B") + 1) doc.index("B(A)") def test_get_pydoc_for_builtin_functions(self): - src = 's = "hey"\ns.replace\n' + src = dedent("""\ + s = "hey" + s.replace + """) doc = get_doc(self.project, src, src.rindex("replace") + 1) self.assertTrue(doc is not None) def test_commenting_errors_before_offset(self): - src = 'lsjd lsjdf\ns = "hey"\ns.replace()\n' + src = dedent("""\ + lsjd lsjdf + s = "hey" + s.replace() + """) doc = get_doc(self.project, src, src.rindex("replace") + 1) # noqa def test_proposing_variables_defined_till_the_end_of_scope(self): - code = "if True:\n a_v\na_var = 10\n" + code = dedent("""\ + if True: + a_v + a_var = 10 + """) result = self._assist(code, code.index("a_v") + 3) self.assert_completion_in_result("a_var", "global", result) def test_completing_in_uncomplete_try_blocks(self): - code = "try:\n a_var = 10\n a_" + code = dedent("""\ + try: + a_var = 10 + a_""") result = self._assist(code) self.assert_completion_in_result("a_var", "global", result) def test_completing_in_uncomplete_try_blocks_in_functions(self): - code = "def a_func():\n try:\n a_var = 10\n a_" + code = dedent("""\ + def a_func(): + try: + a_var = 10 + a_""") result = self._assist(code) self.assert_completion_in_result("a_var", "local", result) def test_already_complete_try_blocks_with_finally(self): - code = "def a_func():\n try:\n a_var = 10\n a_" + code = dedent("""\ + def a_func(): + try: + a_var = 10 + a_""") result = self._assist(code) self.assert_completion_in_result("a_var", "local", result) def test_already_complete_try_blocks_with_finally2(self): - code = "try:\n a_var = 10\n a_\nfinally:\n pass\n" + code = dedent("""\ + try: + a_var = 10 + a_ + finally: + pass + """) result = self._assist(code, code.rindex("a_") + 2) self.assert_completion_in_result("a_var", "global", result) def test_already_complete_try_blocks_with_except(self): - code = "try:\n a_var = 10\n a_\nexcept Exception:\n pass\n" + code = dedent("""\ + try: + a_var = 10 + a_ + except Exception: + pass + """) result = self._assist(code, code.rindex("a_") + 2) self.assert_completion_in_result("a_var", "global", result) def test_already_complete_try_blocks_with_except2(self): - code = ( - "a_var = 10\ntry:\n " - "another_var = a_\n another_var = 10\n" - "except Exception:\n pass\n" - ) + code = dedent("""\ + a_var = 10 + try: + another_var = a_ + another_var = 10 + except Exception: + pass + """) result = self._assist(code, code.rindex("a_") + 2) self.assert_completion_in_result("a_var", "global", result) def test_completing_ifs_in_uncomplete_try_blocks(self): - code = "try:\n if True:\n a_var = 10\n a_" + code = dedent("""\ + try: + if True: + a_var = 10 + a_""") result = self._assist(code) self.assert_completion_in_result("a_var", "global", result) def test_completing_ifs_in_uncomplete_try_blocks2(self): - code = "try:\n if True:\n a_var = 10\n a_" + code = dedent("""\ + try: + if True: + a_var = 10 + a_""") result = self._assist(code) self.assert_completion_in_result("a_var", "global", result) def test_completing_excepts_in_uncomplete_try_blocks(self): - code = "try:\n pass\nexcept Exc" + code = dedent("""\ + try: + pass + except Exc""") result = self._assist(code) self.assert_completion_in_result("Exception", "builtin", result) def test_and_normal_complete_blocks_and_single_fixing(self): - code = "try:\n range.\nexcept:\n pass\n" + code = dedent("""\ + try: + range. + except: + pass + """) result = self._assist(code, code.index("."), maxfixes=1) # noqa def test_nested_blocks(self): - code = "a_var = 10\ntry:\n try:\n a_v" + code = dedent("""\ + a_var = 10 + try: + try: + a_v""") result = self._assist(code) self.assert_completion_in_result("a_var", "global", result) def test_proposing_function_keywords_when_calling(self): - code = "def f(p):\n pass\nf(p" + code = dedent("""\ + def f(p): + pass + f(p""") result = self._assist(code) self.assert_completion_in_result("p=", "parameter_keyword", result) def test_proposing_function_keywords_when_calling_for_non_functions(self): - code = "f = 1\nf(p" + code = dedent("""\ + f = 1 + f(p""") result = self._assist(code) # noqa def test_proposing_function_keywords_when_calling_extra_spaces(self): - code = "def f(p):\n pass\nf( p" + code = dedent("""\ + def f(p): + pass + f( p""") result = self._assist(code) self.assert_completion_in_result("p=", "parameter_keyword", result) def test_proposing_function_keywords_when_calling_on_second_argument(self): - code = "def f(p1, p2):\n pass\nf(1, p" + code = dedent("""\ + def f(p1, p2): + pass + f(1, p""") result = self._assist(code) self.assert_completion_in_result("p2=", "parameter_keyword", result) def test_proposing_function_keywords_when_calling_not_proposing_args(self): - code = "def f(p1, *args):\n pass\nf(1, a" + code = dedent("""\ + def f(p1, *args): + pass + f(1, a""") result = self._assist(code) self.assert_completion_not_in_result("args=", "parameter_keyword", result) def test_propos_function_kwrds_when_call_with_no_noth_after_parens(self): - code = "def f(p):\n pass\nf(" + code = dedent("""\ + def f(p): + pass + f(""") result = self._assist(code) self.assert_completion_in_result("p=", "parameter_keyword", result) def test_propos_function_kwrds_when_call_with_no_noth_after_parens2(self): - code = "def f(p):\n pass\ndef g():\n h = f\n f(" + code = dedent("""\ + def f(p): + pass + def g(): + h = f + f(""") result = self._assist(code) self.assert_completion_in_result("p=", "parameter_keyword", result) def test_codeassists_before_opening_of_parens(self): - code = "def f(p):\n pass\na_var = 1\nf(1)\n" + code = dedent("""\ + def f(p): + pass + a_var = 1 + f(1) + """) result = self._assist(code, code.rindex("f") + 1) self.assert_completion_not_in_result("a_var", "global", result) def test_codeassist_before_single_line_indents(self): - code = "myvar = 1\nif True:\n (myv\nif True:\n pass\n" + code = dedent("""\ + myvar = 1 + if True: + (myv + if True: + pass + """) result = self._assist(code, code.rindex("myv") + 3) self.assert_completion_not_in_result("myvar", "local", result) def test_codeassist_before_line_indents_in_a_blank_line(self): - code = "myvar = 1\nif True:\n \nif True:\n pass\n" + code = dedent("""\ + myvar = 1 + if True: + + if True: + pass + """) result = self._assist(code, code.rindex(" ") + 4) self.assert_completion_not_in_result("myvar", "local", result) def test_simple_get_calltips(self): - src = "def f():\n pass\nvar = f()\n" + src = dedent("""\ + def f(): + pass + var = f() + """) doc = get_calltip(self.project, src, src.rindex("f")) self.assertEqual("f()", doc) def test_get_calltips_for_classes(self): - src = "class C(object):\n" " def __init__(self):\n pass\nC(" + src = dedent("""\ + class C(object): + def __init__(self): + pass + C(""") doc = get_calltip(self.project, src, len(src) - 1) self.assertEqual("C.__init__(self)", doc) def test_get_calltips_for_objects_with_call(self): - src = ( - "class C(object):\n" - " def __call__(self, p):\n pass\n" - "c = C()\nc(1," - ) + src = dedent("""\ + class C(object): + def __call__(self, p): + pass + c = C() + c(1,""") doc = get_calltip(self.project, src, src.rindex("c")) self.assertEqual("C.__call__(self, p)", doc) def test_get_calltips_and_including_module_name(self): - src = ( - "class C(object):\n" - " def __call__(self, p):\n pass\n" - "c = C()\nc(1," - ) + src = dedent("""\ + class C(object): + def __call__(self, p): + pass + c = C() + c(1,""") mod = testutils.create_module(self.project, "mod") mod.write(src) doc = get_calltip(self.project, src, src.rindex("c"), mod) @@ -835,22 +1085,34 @@ def test_get_calltips_and_including_module_name_2(self): self.assertTrue(doc is None) def test_removing_self_parameter(self): - src = "class C(object):\n" " def f(self):\n" " pass\n" "C().f()" + src = dedent("""\ + class C(object): + def f(self): + pass + C().f()""") doc = get_calltip(self.project, src, src.rindex("f"), remove_self=True) self.assertEqual("C.f()", doc) def test_removing_self_parameter_and_more_than_one_parameter(self): - src = "class C(object):\n" " def f(self, p1):\n" " pass\n" "C().f()" + src = dedent("""\ + class C(object): + def f(self, p1): + pass + C().f()""") doc = get_calltip(self.project, src, src.rindex("f"), remove_self=True) self.assertEqual("C.f(p1)", doc) def test_lambda_calltip(self): - src = "foo = lambda x, y=1: None\n" "foo()" + src = dedent("""\ + foo = lambda x, y=1: None + foo()""") doc = get_calltip(self.project, src, src.rindex("f")) self.assertEqual(doc, "lambda(x, y)") def test_keyword_before_parens(self): - code = "if (1).:\n pass" + code = dedent("""\ + if (1).: + pass""") result = self._assist(code, offset=len("if (1).")) self.assertTrue(result) @@ -858,12 +1120,17 @@ def test_keyword_before_parens(self): # SEE RELATION MATRIX IN `CompletionProposal`'s DOCSTRING def test_local_variable_completion_proposal(self): - code = "def foo():\n xvar = 5\n x" + code = dedent("""\ + def foo(): + xvar = 5 + x""") result = self._assist(code) self.assert_completion_in_result("xvar", "local", result, "instance") def test_global_variable_completion_proposal(self): - code = "yvar = 5\ny" + code = dedent("""\ + yvar = 5 + y""") result = self._assist(code) self.assert_completion_in_result("yvar", "global", result, "instance") @@ -875,19 +1142,26 @@ def test_builtin_variable_completion_proposal(self): ) def test_attribute_variable_completion_proposal(self): - code = ( - "class AClass(object):\n def foo(self):\n " "self.bar = 1\n self.b" - ) + code = dedent("""\ + class AClass(object): + def foo(self): + self.bar = 1 + self.b""") result = self._assist(code) self.assert_completion_in_result("bar", "attribute", result, type="instance") def test_local_class_completion_proposal(self): - code = "def foo():\n class LocalClass(object): pass\n Lo" + code = dedent("""\ + def foo(): + class LocalClass(object): pass + Lo""") result = self._assist(code) self.assert_completion_in_result("LocalClass", "local", result, type="class") def test_global_class_completion_proposal(self): - code = "class GlobalClass(object): pass\nGl" + code = dedent("""\ + class GlobalClass(object): pass + Gl""") result = self._assist(code) self.assert_completion_in_result("GlobalClass", "global", result, type="class") @@ -897,17 +1171,25 @@ def test_builtin_class_completion_proposal(self): self.assert_completion_in_result(varname, "builtin", result, type="class") def test_attribute_class_completion_proposal(self): - code = "class Outer(object):\n class Inner(object): pass\nOuter." + code = dedent("""\ + class Outer(object): + class Inner(object): pass + Outer.""") result = self._assist(code) self.assert_completion_in_result("Inner", "attribute", result, type="class") def test_local_function_completion_proposal(self): - code = "def outer():\n def inner(): pass\n in" + code = dedent("""\ + def outer(): + def inner(): pass + in""") result = self._assist(code) self.assert_completion_in_result("inner", "local", result, type="function") def test_global_function_completion_proposal(self): - code = "def foo(): pass\nf" + code = dedent("""\ + def foo(): pass + f""") result = self._assist(code) self.assert_completion_in_result("foo", "global", result, type="function") @@ -920,27 +1202,40 @@ def test_builtin_function_completion_proposal(self): ) def test_attribute_function_completion_proposal(self): - code = "class Some(object):\n def method(self):\n self." + code = dedent("""\ + class Some(object): + def method(self): + self.""") result = self._assist(code) self.assert_completion_in_result("method", "attribute", result, type="function") def test_local_module_completion_proposal(self): - code = "def foo():\n import types\n t" + code = dedent("""\ + def foo(): + import types + t""") result = self._assist(code) self.assert_completion_in_result("types", "imported", result, type="module") def test_global_module_completion_proposal(self): - code = "import operator\no" + code = dedent("""\ + import operator + o""") result = self._assist(code) self.assert_completion_in_result("operator", "imported", result, type="module") def test_attribute_module_completion_proposal(self): - code = "class Some(object):\n import os\nSome.o" + code = dedent("""\ + class Some(object): + import os + Some.o""") result = self._assist(code) self.assert_completion_in_result("os", "imported", result, type="module") def test_builtin_exception_completion_proposal(self): - code = "def blah():\n Z" + code = dedent("""\ + def blah(): + Z""") result = self._assist(code) self.assert_completion_in_result( "ZeroDivisionError", "builtin", result, type="class" @@ -953,7 +1248,9 @@ def test_keyword_completion_proposal(self): self.assert_completion_in_result("from", "keyword", result, type=None) def test_parameter_keyword_completion_proposal(self): - code = "def func(abc, aloha, alpha, amigo): pass\nfunc(a" + code = dedent("""\ + def func(abc, aloha, alpha, amigo): pass + func(a""") result = self._assist(code) for expected in ("abc=", "aloha=", "alpha=", "amigo="): self.assert_completion_in_result( @@ -971,7 +1268,10 @@ def test_object_path_global(self): ) def test_object_path_attribute(self): - code = "class Foo(object):\n" " attr = 42\n" + code = dedent("""\ + class Foo(object): + attr = 42 + """) resource = testutils.create_module(self.project, "mod") resource.write(code) result = get_canonical_path(self.project, resource, 24) @@ -981,7 +1281,11 @@ def test_object_path_attribute(self): ) def test_object_path_subclass(self): - code = "class Foo(object):\n" " class Bar(object):\n" " pass\n" + code = dedent("""\ + class Foo(object): + class Bar(object): + pass + """) resource = testutils.create_module(self.project, "mod") resource.write(code) result = get_canonical_path(self.project, resource, 30) @@ -991,7 +1295,11 @@ def test_object_path_subclass(self): ) def test_object_path_method_parameter(self): - code = "class Foo(object):\n" " def bar(self, a, b, c):\n" " pass\n" + code = dedent("""\ + class Foo(object): + def bar(self, a, b, c): + pass + """) resource = testutils.create_module(self.project, "mod") resource.write(code) result = get_canonical_path(self.project, resource, 41) @@ -1007,7 +1315,10 @@ def test_object_path_method_parameter(self): ) def test_object_path_variable(self): - code = "def bar(a):\n" " x = a + 42\n" + code = dedent("""\ + def bar(a): + x = a + 42 + """) resource = testutils.create_module(self.project, "mod") resource.write(code) result = get_canonical_path(self.project, resource, 17) @@ -1023,13 +1334,19 @@ def setUp(self): self.project = testutils.sample_project() self.pycore = self.project.pycore samplemod = testutils.create_module(self.project, "samplemod") - code = ( - "class SampleClass(object):\n" - " def sample_method():\n pass\n\n" - "def sample_func():\n pass\n" - "sample_var = 10\n\n" - "def _underlined_func():\n pass\n\n" - ) + code = dedent("""\ + class SampleClass(object): + def sample_method(): + pass + + def sample_func(): + pass + sample_var = 10 + + def _underlined_func(): + pass + + """) samplemod.write(code) package = testutils.create_package(self.project, "package") nestedmod = testutils.create_module(self.project, "nestedmod", package) # noqa @@ -1053,114 +1370,130 @@ def assert_completion_not_in_result(self, name, scope, result): self.fail("completion <%s> was proposed" % name) def test_simple_import(self): - code = "import samplemod\nsample" + code = dedent("""\ + import samplemod + sample""") result = self._assist(code) self.assert_completion_in_result("samplemod", "imported", result) def test_from_import_class(self): - code = "from samplemod import SampleClass\nSample" + code = dedent("""\ + from samplemod import SampleClass + Sample""") result = self._assist(code) self.assert_completion_in_result("SampleClass", "imported", result) def test_from_import_function(self): - code = "from samplemod import sample_func\nsample" + code = dedent("""\ + from samplemod import sample_func + sample""") result = self._assist(code) self.assert_completion_in_result("sample_func", "imported", result) def test_from_import_variable(self): - code = "from samplemod import sample_var\nsample" + code = dedent("""\ + from samplemod import sample_var + sample""") result = self._assist(code) self.assert_completion_in_result("sample_var", "imported", result) def test_from_imports_inside_functions(self): - code = "def f():\n from samplemod import SampleClass\n Sample" + code = dedent("""\ + def f(): + from samplemod import SampleClass + Sample""") result = self._assist(code) self.assert_completion_in_result("SampleClass", "imported", result) def test_from_import_only_imports_imported(self): - code = "from samplemod import sample_func\nSample" + code = dedent("""\ + from samplemod import sample_func + Sample""") result = self._assist(code) self.assert_completion_not_in_result("SampleClass", "global", result) def test_from_import_star(self): - code = "from samplemod import *\nSample" + code = dedent("""\ + from samplemod import * + Sample""") result = self._assist(code) self.assert_completion_in_result("SampleClass", "imported", result) def test_from_import_star2(self): - code = "from samplemod import *\nsample" + code = dedent("""\ + from samplemod import * + sample""") result = self._assist(code) self.assert_completion_in_result("sample_func", "imported", result) self.assert_completion_in_result("sample_var", "imported", result) def test_from_import_star_not_imporing_underlined(self): - code = "from samplemod import *\n_under" + code = dedent("""\ + from samplemod import * + _under""") result = self._assist(code) self.assert_completion_not_in_result("_underlined_func", "global", result) def test_from_package_import_mod(self): - code = "from package import nestedmod\nnest" + code = dedent("""\ + from package import nestedmod + nest""") result = self._assist(code) self.assert_completion_in_result("nestedmod", "imported", result) def test_completing_after_dot(self): - code = ( - "class SampleClass(object):\n" - " def sample_method(self):\n" - " pass\n" - "SampleClass.sam" - ) + code = dedent("""\ + class SampleClass(object): + def sample_method(self): + pass + SampleClass.sam""") result = self._assist(code) self.assert_completion_in_result("sample_method", "attribute", result) def test_completing_after_multiple_dots(self): - code = ( - "class Class1(object):\n" - " class Class2(object):\n" - " def sample_method(self):\n" - " pass\n" - "Class1.Class2.sam" - ) + code = dedent("""\ + class Class1(object): + class Class2(object): + def sample_method(self): + pass + Class1.Class2.sam""") result = self._assist(code) self.assert_completion_in_result("sample_method", "attribute", result) def test_completing_after_self_dot(self): - code = ( - "class Sample(object):\n" - " def method1(self):\n" - " pass\n" - " def method2(self):\n" - " self.m" - ) + code = dedent("""\ + class Sample(object): + def method1(self): + pass + def method2(self): + self.m""") result = self._assist(code) self.assert_completion_in_result("method1", "attribute", result) def test_result_start_offset_for_dotted_completions(self): - code = ( - "class Sample(object):\n" - " def method1(self):\n" - " pass\n" - "Sample.me" - ) + code = dedent("""\ + class Sample(object): + def method1(self): + pass + Sample.me""") self.assertEqual(len(code) - 2, starting_offset(code, len(code))) def test_backslash_after_dots(self): - code = ( - "class Sample(object):\n" - " def a_method(self):\n" - " pass\n" - "Sample.\\\n a_m" - ) + code = dedent("""\ + class Sample(object): + def a_method(self): + pass + Sample.\\ + a_m""") result = self._assist(code) self.assert_completion_in_result("a_method", "attribute", result) def test_not_proposing_global_names_after_dot(self): - code = ( - "class Sample(object):\n" - " def a_method(self):\n" - " pass\n" - "Sample." - ) + code = dedent("""\ + class Sample(object): + def a_method(self): + pass + Sample.""") result = self._assist(code) self.assert_completion_not_in_result("Sample", "global", result) @@ -1168,8 +1501,15 @@ def test_assist_on_relative_imports(self): pkg = testutils.create_package(self.project, "pkg") mod1 = testutils.create_module(self.project, "mod1", pkg) mod2 = testutils.create_module(self.project, "mod2", pkg) - mod1.write("def a_func():\n pass\n") - code = "import mod1\nmod1." + mod1.write( + dedent("""\ + def a_func(): + pass + """) + ) + code = dedent("""\ + import mod1 + mod1.""") result = self._assist(code, resource=mod2) self.assert_completion_in_result("a_func", "imported", result) @@ -1177,8 +1517,16 @@ def test_get_location_on_relative_imports(self): pkg = testutils.create_package(self.project, "pkg") mod1 = testutils.create_module(self.project, "mod1", pkg) mod2 = testutils.create_module(self.project, "mod2", pkg) - mod1.write("def a_func():\n pass\n") - code = "import mod1\nmod1.a_func\n" + mod1.write( + dedent("""\ + def a_func(): + pass + """) + ) + code = dedent("""\ + import mod1 + mod1.a_func + """) result = get_definition_location(self.project, code, len(code) - 2, mod2) self.assertEqual((mod1, 1), result) @@ -1191,21 +1539,39 @@ def test_get_doc_on_relative_imports(self): pkg = testutils.create_package(self.project, "pkg") mod1 = testutils.create_module(self.project, "mod1", pkg) mod2 = testutils.create_module(self.project, "mod2", pkg) - mod1.write('def a_func():\n """hey"""\n pass\n') - code = "import mod1\nmod1.a_func\n" + mod1.write( + dedent('''\ + def a_func(): + """hey""" + pass + ''') + ) + code = dedent("""\ + import mod1 + mod1.a_func + """) result = get_doc(self.project, code, len(code) - 2, mod2) self.assertTrue(result.endswith("hey")) def test_get_doc_on_from_import_module(self): mod1 = testutils.create_module(self.project, "mod1") - mod1.write('"""mod1 docs"""\nvar = 1\n') + mod1.write( + dedent('''\ + """mod1 docs""" + var = 1 + ''') + ) code = "from mod1 import var\n" result = get_doc(self.project, code, code.index("mod1")) result.index("mod1 docs") def test_fixing_errors_with_maxfixes_in_resources(self): mod = testutils.create_module(self.project, "mod") - code = "def f():\n sldj sldj\ndef g():\n ran" + code = dedent("""\ + def f(): + sldj sldj + def g(): + ran""") mod.write(code) result = self._assist(code, maxfixes=2, resource=mod) self.assertTrue(len(result) > 0) @@ -1236,5 +1602,7 @@ def test_completing_names_after_from_import2(self): self.assert_completion_in_result("myvar", "global", result) def test_starting_expression(self): - code = "l = list()\nl.app" + code = dedent("""\ + l = list() + l.app""") self.assertEqual("l.app", starting_expression(code, len(code))) diff --git a/ropetest/contrib/finderrorstest.py b/ropetest/contrib/finderrorstest.py index f829cf1c9..2ec04cf69 100644 --- a/ropetest/contrib/finderrorstest.py +++ b/ropetest/contrib/finderrorstest.py @@ -1,3 +1,5 @@ +from textwrap import dedent + try: import unittest2 as unittest except ImportError: @@ -25,7 +27,12 @@ def test_unresolved_variables(self): self.assertEqual(1, result[0].lineno) def test_defined_later(self): - self.mod.write("print(var)\nvar = 1\n") + self.mod.write( + dedent("""\ + print(var) + var = 1 + """) + ) result = finderrors.find_errors(self.project, self.mod) self.assertEqual(1, len(result)) self.assertEqual(1, result[0].lineno) @@ -41,7 +48,12 @@ def test_ignoring_none(self): self.assertEqual(0, len(result)) def test_bad_attributes(self): - code = "class C(object):\n" " pass\n" "c = C()\n" "print(c.var)\n" + code = dedent("""\ + class C(object): + pass + c = C() + print(c.var) + """) self.mod.write(code) result = finderrors.find_errors(self.project, self.mod) self.assertEqual(1, len(result)) diff --git a/ropetest/contrib/findittest.py b/ropetest/contrib/findittest.py index 555562b3d..63eb9ac3f 100644 --- a/ropetest/contrib/findittest.py +++ b/ropetest/contrib/findittest.py @@ -1,3 +1,5 @@ +from textwrap import dedent + try: import unittest2 as unittest except ImportError: @@ -29,7 +31,12 @@ def test_finding_occurrences_in_more_than_one_module(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") mod1.write("a_var = 1\n") - mod2.write("import mod1\nmy_var = mod1.a_var") + mod2.write( + dedent("""\ + import mod1 + my_var = mod1.a_var""" + ) + ) result = find_occurrences(self.project, mod1, 1) self.assertEqual(2, len(result)) modules = (result[0].resource, result[1].resource) @@ -38,8 +45,13 @@ def test_finding_occurrences_in_more_than_one_module(self): def test_finding_occurrences_matching_when_unsure(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - "class C(object):\n def a_func(self):\n pass\n" - "def f(arg):\n arg.a_func()\n" + dedent("""\ + class C(object): + def a_func(self): + pass + def f(arg): + arg.a_func() + """) ) result = find_occurrences( self.project, mod1, mod1.read().index("a_func"), unsure=True @@ -50,7 +62,12 @@ def test_find_occurrences_resources_parameter(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") mod1.write("a_var = 1\n") - mod2.write("import mod1\nmy_var = mod1.a_var") + mod2.write( + dedent("""\ + import mod1 + my_var = mod1.a_var""" + ) + ) result = find_occurrences(self.project, mod1, 1, resources=[mod1]) self.assertEqual(1, len(result)) self.assertEqual((mod1, 0), (result[0].resource, result[0].offset)) @@ -58,8 +75,14 @@ def test_find_occurrences_resources_parameter(self): def test_find_occurrences_and_class_hierarchies(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - "class A(object):\n def f():\n pass\n" - "class B(A):\n def f():\n pass\n" + dedent("""\ + class A(object): + def f(): + pass + class B(A): + def f(): + pass + """) ) offset = mod1.read().rindex("f") result1 = find_occurrences(self.project, mod1, offset) @@ -69,7 +92,13 @@ def test_find_occurrences_and_class_hierarchies(self): def test_trivial_find_implementations(self): mod1 = testutils.create_module(self.project, "mod1") - mod1.write("class A(object):\n def f(self):\n pass\n") + mod1.write( + dedent("""\ + class A(object): + def f(self): + pass + """) + ) offset = mod1.read().rindex("f(") result = find_implementations(self.project, mod1, offset) self.assertEqual([], result) @@ -77,8 +106,14 @@ def test_trivial_find_implementations(self): def test_find_implementations_and_not_returning_parents(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - "class A(object):\n def f(self):\n pass\n" - "class B(A):\n def f(self):\n pass\n" + dedent("""\ + class A(object): + def f(self): + pass + class B(A): + def f(self): + pass + """) ) offset = mod1.read().rindex("f(") result = find_implementations(self.project, mod1, offset) @@ -87,8 +122,14 @@ def test_find_implementations_and_not_returning_parents(self): def test_find_implementations_real_implementation(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - "class A(object):\n def f(self):\n pass\n" - "class B(A):\n def f(self):\n pass\n" + dedent("""\ + class A(object): + def f(self): + pass + class B(A): + def f(self): + pass + """) ) offset = mod1.read().index("f(") result = find_implementations(self.project, mod1, offset) @@ -103,7 +144,10 @@ def test_find_implementations_real_implementation_simple(self): find_implementations(self.project, mod1, offset) def test_trivial_find_definition(self): - code = "def a_func():\n pass\na_func()" + code = dedent("""\ + def a_func(): + pass + a_func()""") result = find_definition(self.project, code, code.rindex("a_func")) start = code.index("a_func") self.assertEqual(start, result.offset) @@ -114,7 +158,10 @@ def test_trivial_find_definition(self): def test_find_definition_in_other_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write("var = 1\n") - code = "import mod1\nprint(mod1.var)\n" + code = dedent("""\ + import mod1 + print(mod1.var) + """) result = find_definition(self.project, code, code.index("var")) self.assertEqual(mod1, result.resource) self.assertEqual(0, result.offset) diff --git a/ropetest/contrib/generatetest.py b/ropetest/contrib/generatetest.py index f68dc37a5..1375d5b34 100644 --- a/ropetest/contrib/generatetest.py +++ b/ropetest/contrib/generatetest.py @@ -1,3 +1,5 @@ +from textwrap import dedent + try: import unittest2 as unittest except ImportError: @@ -45,30 +47,65 @@ def test_getting_location(self): self.assertEqual((self.mod, 1), generator.get_location()) def test_generating_variable(self): - code = "a_var = name\n" + code = dedent("""\ + a_var = name + """) self.mod.write(code) changes = self._get_generate(code.index("name")).get_changes() self.project.do(changes) - self.assertEqual("name = None\n\n\na_var = name\n", self.mod.read()) + self.assertEqual( + dedent("""\ + name = None + + + a_var = name + """), + self.mod.read(), + ) def test_generating_variable_inserting_before_statement(self): - code = "c = 1\nc = b\n" + code = dedent("""\ + c = 1 + c = b + """) self.mod.write(code) changes = self._get_generate(code.index("b")).get_changes() self.project.do(changes) - self.assertEqual("c = 1\nb = None\n\n\nc = b\n", self.mod.read()) + self.assertEqual( + dedent("""\ + c = 1 + b = None + + + c = b + """), + self.mod.read(), + ) def test_generating_variable_in_local_scopes(self): - code = "def f():\n c = 1\n c = b\n" + code = dedent("""\ + def f(): + c = 1 + c = b + """) self.mod.write(code) changes = self._get_generate(code.index("b")).get_changes() self.project.do(changes) self.assertEqual( - "def f():\n c = 1\n b = None\n c = b\n", self.mod.read() + dedent("""\ + def f(): + c = 1 + b = None + c = b + """), + self.mod.read(), ) def test_generating_variable_in_other_modules(self): - code = "import mod2\nc = mod2.b\n" + code = dedent("""\ + import mod2 + c = mod2.b + """) self.mod.write(code) generator = self._get_generate(code.index("b")) self.project.do(generator.get_changes()) @@ -76,29 +113,45 @@ def test_generating_variable_in_other_modules(self): self.assertEqual("b = None\n", self.mod2.read()) def test_generating_variable_in_classes(self): - code = ( - "class C(object):\n def f(self):\n pass\n" - "c = C()\na_var = c.attr" - ) + code = dedent("""\ + class C(object): + def f(self): + pass + c = C() + a_var = c.attr""") self.mod.write(code) changes = self._get_generate(code.index("attr")).get_changes() self.project.do(changes) self.assertEqual( - "class C(object):\n def f(self):\n " - "pass\n\n attr = None\n" - "c = C()\na_var = c.attr", - self.mod.read(), - ) + dedent("""\ + class C(object): + def f(self): + pass + + attr = None + c = C() + a_var = c.attr""" + ), + self.mod.read(),) def test_generating_variable_in_classes_removing_pass(self): - code = "class C(object):\n pass\nc = C()\na_var = c.attr" + code = dedent("""\ + class C(object): + pass + c = C() + a_var = c.attr""") self.mod.write(code) changes = self._get_generate(code.index("attr")).get_changes() self.project.do(changes) self.assertEqual( - "class C(object):\n\n attr = None\n" "c = C()\na_var = c.attr", - self.mod.read(), - ) + dedent("""\ + class C(object): + + attr = None + c = C() + a_var = c.attr""" + ), + self.mod.read(),) def test_generating_variable_in_packages(self): code = "import pkg\na = pkg.a\n" @@ -114,41 +167,89 @@ def test_generating_classes(self): self.mod.write(code) changes = self._get_generate_class(code.index("C")).get_changes() self.project.do(changes) - self.assertEqual("class C(object):\n pass\n\n\nc = C()\n", self.mod.read()) + self.assertEqual( + dedent("""\ + class C(object): + pass + + + c = C() + """), + self.mod.read(), + ) def test_generating_classes_in_other_module(self): code = "c = C()\n" self.mod.write(code) changes = self._get_generate_class(code.index("C"), self.mod2).get_changes() self.project.do(changes) - self.assertEqual("class C(object):\n pass\n", self.mod2.read()) - self.assertEqual("from mod2 import C\nc = C()\n", self.mod.read()) + self.assertEqual( + dedent("""\ + class C(object): + pass + """), + self.mod2.read(), + ) + self.assertEqual( + dedent("""\ + from mod2 import C + c = C() + """), + self.mod.read(), + ) def test_generating_modules(self): - code = "import pkg\npkg.mod\n" + code = dedent("""\ + import pkg + pkg.mod + """) self.mod.write(code) generator = self._get_generate_module(code.rindex("mod")) self.project.do(generator.get_changes()) mod = self.pkg.get_child("mod.py") self.assertEqual((mod, 1), generator.get_location()) - self.assertEqual("import pkg.mod\npkg.mod\n", self.mod.read()) + self.assertEqual( + dedent("""\ + import pkg.mod + pkg.mod + """), + self.mod.read(), + ) def test_generating_packages(self): - code = "import pkg\npkg.pkg2\n" + code = dedent("""\ + import pkg + pkg.pkg2 + """) self.mod.write(code) generator = self._get_generate_package(code.rindex("pkg2")) self.project.do(generator.get_changes()) pkg2 = self.pkg.get_child("pkg2") init = pkg2.get_child("__init__.py") self.assertEqual((init, 1), generator.get_location()) - self.assertEqual("import pkg.pkg2\npkg.pkg2\n", self.mod.read()) + self.assertEqual( + dedent("""\ + import pkg.pkg2 + pkg.pkg2 + """), + self.mod.read(), + ) def test_generating_function(self): code = "a_func()\n" self.mod.write(code) changes = self._get_generate_function(code.index("a_func")).get_changes() self.project.do(changes) - self.assertEqual("def a_func():\n pass\n\n\na_func()\n", self.mod.read()) + self.assertEqual( + dedent("""\ + def a_func(): + pass + + + a_func() + """), + self.mod.read(), + ) def test_generating_modules_with_empty_primary(self): code = "mod\n" @@ -160,7 +261,10 @@ def test_generating_modules_with_empty_primary(self): self.assertEqual("import mod\nmod\n", self.mod.read()) def test_generating_variable_already_exists(self): - code = "b = 1\nc = b\n" + code = dedent("""\ + b = 1 + c = b + """) self.mod.write(code) with self.assertRaises(exceptions.RefactoringError): self._get_generate(code.index("b")).get_changes() @@ -179,56 +283,112 @@ def test_generating_modules_when_already_exists(self): self.project.do(generator.get_changes()) def test_generating_static_methods(self): - code = "class C(object):\n pass\nC.a_func()\n" + code = dedent("""\ + class C(object): + pass + C.a_func() + """) self.mod.write(code) changes = self._get_generate_function(code.index("a_func")).get_changes() self.project.do(changes) self.assertEqual( - "class C(object):\n\n @staticmethod" - "\n def a_func():\n pass\nC.a_func()\n", + dedent("""\ + class C(object): + + @staticmethod + def a_func(): + pass + C.a_func() + """), self.mod.read(), ) def test_generating_methods(self): - code = "class C(object):\n pass\nc = C()\nc.a_func()\n" + code = dedent("""\ + class C(object): + pass + c = C() + c.a_func() + """) self.mod.write(code) changes = self._get_generate_function(code.index("a_func")).get_changes() self.project.do(changes) self.assertEqual( - "class C(object):\n\n def a_func(self):\n pass\n" - "c = C()\nc.a_func()\n", + dedent("""\ + class C(object): + + def a_func(self): + pass + c = C() + c.a_func() + """), self.mod.read(), ) def test_generating_constructors(self): - code = "class C(object):\n pass\nc = C()\n" + code = dedent("""\ + class C(object): + pass + c = C() + """) self.mod.write(code) changes = self._get_generate_function(code.rindex("C")).get_changes() self.project.do(changes) self.assertEqual( - "class C(object):\n\n def __init__(self):\n pass\n" "c = C()\n", + dedent("""\ + class C(object): + + def __init__(self): + pass + c = C() + """), self.mod.read(), ) def test_generating_calls(self): - code = "class C(object):\n pass\nc = C()\nc()\n" + code = dedent("""\ + class C(object): + pass + c = C() + c() + """) self.mod.write(code) changes = self._get_generate_function(code.rindex("c")).get_changes() self.project.do(changes) self.assertEqual( - "class C(object):\n\n def __call__(self):\n pass\n" - "c = C()\nc()\n", + dedent("""\ + class C(object): + + def __call__(self): + pass + c = C() + c() + """), self.mod.read(), ) def test_generating_calls_in_other_modules(self): - self.mod2.write("class C(object):\n pass\n") - code = "import mod2\nc = mod2.C()\nc()\n" + self.mod2.write( + dedent("""\ + class C(object): + pass + """) + ) + code = dedent("""\ + import mod2 + c = mod2.C() + c() + """) self.mod.write(code) changes = self._get_generate_function(code.rindex("c")).get_changes() self.project.do(changes) self.assertEqual( - "class C(object):\n\n def __call__(self):\n pass\n", + dedent("""\ + class C(object): + + def __call__(self): + pass + """), self.mod2.read(), ) @@ -238,7 +398,14 @@ def test_generating_function_handling_arguments(self): changes = self._get_generate_function(code.index("a_func")).get_changes() self.project.do(changes) self.assertEqual( - "def a_func(arg0):\n pass\n\n\na_func(1)\n", self.mod.read() + dedent("""\ + def a_func(arg0): + pass + + + a_func(1) + """), + self.mod.read(), ) def test_generating_function_handling_keyword_xarguments(self): @@ -246,44 +413,99 @@ def test_generating_function_handling_keyword_xarguments(self): self.mod.write(code) changes = self._get_generate_function(code.index("a_func")).get_changes() self.project.do(changes) - self.assertEqual("def a_func(p):\n pass\n\n\na_func(p=1)\n", self.mod.read()) + self.assertEqual( + dedent("""\ + def a_func(p): + pass + + + a_func(p=1) + """), + self.mod.read(), + ) def test_generating_function_handling_arguments_better_naming(self): - code = "a_var = 1\na_func(a_var)\n" + code = dedent("""\ + a_var = 1 + a_func(a_var) + """) self.mod.write(code) changes = self._get_generate_function(code.index("a_func")).get_changes() self.project.do(changes) self.assertEqual( - "a_var = 1\ndef a_func(a_var):" "\n pass\n\n\na_func(a_var)\n", + dedent("""\ + a_var = 1 + def a_func(a_var): + pass + + + a_func(a_var) + """), self.mod.read(), ) def test_generating_variable_in_other_modules2(self): self.mod2.write("\n\n\nprint(1)\n") - code = "import mod2\nc = mod2.b\n" + code = dedent("""\ + import mod2 + c = mod2.b + """) self.mod.write(code) generator = self._get_generate(code.index("b")) self.project.do(generator.get_changes()) self.assertEqual((self.mod2, 5), generator.get_location()) - self.assertEqual("\n\n\nprint(1)\n\n\nb = None\n", self.mod2.read()) + self.assertEqual( + dedent("""\ + + + + print(1) + + + b = None + """), + self.mod2.read(), + ) def test_generating_function_in_a_suite(self): - code = "if True:\n a_func()\n" + code = dedent("""\ + if True: + a_func() + """) self.mod.write(code) changes = self._get_generate_function(code.index("a_func")).get_changes() self.project.do(changes) self.assertEqual( - "def a_func():\n pass" "\n\n\nif True:\n a_func()\n", self.mod.read() + dedent("""\ + def a_func(): + pass + + + if True: + a_func() + """), + self.mod.read(), ) def test_generating_function_in_a_suite_in_a_function(self): - code = "def f():\n a = 1\n if 1:\n g()\n" + code = dedent("""\ + def f(): + a = 1 + if 1: + g() + """) self.mod.write(code) changes = self._get_generate_function(code.index("g()")).get_changes() self.project.do(changes) self.assertEqual( - "def f():\n a = 1\n def g():\n pass\n" - " if 1:\n g()\n", + dedent("""\ + def f(): + a = 1 + def g(): + pass + if 1: + g() + """), self.mod.read(), ) diff --git a/ropetest/objectinfertest.py b/ropetest/objectinfertest.py index b4e49ef95..0cbf2fb7b 100644 --- a/ropetest/objectinfertest.py +++ b/ropetest/objectinfertest.py @@ -1,3 +1,5 @@ +from textwrap import dedent + try: import unittest2 as unittest except ImportError: @@ -19,27 +21,36 @@ def tearDown(self): super(ObjectInferTest, self).tearDown() def test_simple_type_inferencing(self): - code = "class Sample(object):\n pass\na_var = Sample()\n" + code = dedent("""\ + class Sample(object): + pass + a_var = Sample() + """) scope = libutils.get_string_scope(self.project, code) sample_class = scope["Sample"].get_object() a_var = scope["a_var"].get_object() self.assertEqual(sample_class, a_var.get_type()) def test_simple_type_inferencing_classes_defined_in_holding_scope(self): - code = ( - "class Sample(object):\n pass\n" "def a_func():\n a_var = Sample()\n" - ) + code = dedent("""\ + class Sample(object): + pass + def a_func(): + a_var = Sample() + """) scope = libutils.get_string_scope(self.project, code) sample_class = scope["Sample"].get_object() a_var = scope["a_func"].get_object().get_scope()["a_var"].get_object() self.assertEqual(sample_class, a_var.get_type()) def test_simple_type_inferencing_classes_in_class_methods(self): - code = ( - "class Sample(object):\n pass\n" - "class Another(object):\n" - " def a_method():\n a_var = Sample()\n" - ) + code = dedent("""\ + class Sample(object): + pass + class Another(object): + def a_method(): + a_var = Sample() + """) scope = libutils.get_string_scope(self.project, code) sample_class = scope["Sample"].get_object() another_class = scope["Another"].get_object() @@ -47,11 +58,13 @@ def test_simple_type_inferencing_classes_in_class_methods(self): self.assertEqual(sample_class, a_var.get_type()) def test_simple_type_inferencing_class_attributes(self): - code = ( - "class Sample(object):\n pass\n" - "class Another(object):\n" - " def __init__(self):\n self.a_var = Sample()\n" - ) + code = dedent("""\ + class Sample(object): + pass + class Another(object): + def __init__(self): + self.a_var = Sample() + """) scope = libutils.get_string_scope(self.project, code) sample_class = scope["Sample"].get_object() another_class = scope["Another"].get_object() @@ -59,10 +72,12 @@ def test_simple_type_inferencing_class_attributes(self): self.assertEqual(sample_class, a_var.get_type()) def test_simple_type_inferencing_for_in_class_assignments(self): - code = ( - "class Sample(object):\n pass\n" - "class Another(object):\n an_attr = Sample()\n" - ) + code = dedent("""\ + class Sample(object): + pass + class Another(object): + an_attr = Sample() + """) scope = libutils.get_string_scope(self.project, code) sample_class = scope["Sample"].get_object() another_class = scope["Another"].get_object() @@ -70,148 +85,193 @@ def test_simple_type_inferencing_for_in_class_assignments(self): self.assertEqual(sample_class, an_attr.get_type()) def test_simple_type_inferencing_for_chained_assignments(self): - mod = "class Sample(object):\n pass\n" "copied_sample = Sample" + mod = dedent("""\ + class Sample(object): + pass + copied_sample = Sample""") mod_scope = libutils.get_string_scope(self.project, mod) sample_class = mod_scope["Sample"] copied_sample = mod_scope["copied_sample"] self.assertEqual(sample_class.get_object(), copied_sample.get_object()) def test_following_chained_assignments_avoiding_circles(self): - mod = ( - "class Sample(object):\n pass\n" - "sample_class = Sample\n" - "sample_class = sample_class\n" - ) + mod = dedent("""\ + class Sample(object): + pass + sample_class = Sample + sample_class = sample_class + """) mod_scope = libutils.get_string_scope(self.project, mod) sample_class = mod_scope["Sample"] sample_class_var = mod_scope["sample_class"] self.assertEqual(sample_class.get_object(), sample_class_var.get_object()) def test_function_returned_object_static_type_inference1(self): - src = ( - "class Sample(object):\n pass\n" - "def a_func():\n return Sample\n" - "a_var = a_func()\n" - ) + src = dedent("""\ + class Sample(object): + pass + def a_func(): + return Sample + a_var = a_func() + """) scope = libutils.get_string_scope(self.project, src) sample_class = scope["Sample"] a_var = scope["a_var"] self.assertEqual(sample_class.get_object(), a_var.get_object()) def test_function_returned_object_static_type_inference2(self): - src = ( - "class Sample(object):\n pass\n" - "def a_func():\n return Sample()\n" - "a_var = a_func()\n" - ) + src = dedent("""\ + class Sample(object): + pass + def a_func(): + return Sample() + a_var = a_func() + """) scope = libutils.get_string_scope(self.project, src) sample_class = scope["Sample"].get_object() a_var = scope["a_var"].get_object() self.assertEqual(sample_class, a_var.get_type()) def test_recursive_function_returned_object_static_type_inference(self): - src = ( - "class Sample(object):\n pass\n" - "def a_func():\n" - " if True:\n return Sample()\n" - " else:\n return a_func()\n" - "a_var = a_func()\n" - ) + src = dedent("""\ + class Sample(object): + pass + def a_func(): + if True: + return Sample() + else: + return a_func() + a_var = a_func() + """) scope = libutils.get_string_scope(self.project, src) sample_class = scope["Sample"].get_object() a_var = scope["a_var"].get_object() self.assertEqual(sample_class, a_var.get_type()) def test_func_returned_obj_using_call_spec_func_static_type_infer(self): - src = ( - "class Sample(object):\n" - " def __call__(self):\n return Sample\n" - "sample = Sample()\na_var = sample()" - ) + src = dedent("""\ + class Sample(object): + def __call__(self): + return Sample + sample = Sample() + a_var = sample()""") scope = libutils.get_string_scope(self.project, src) sample_class = scope["Sample"] a_var = scope["a_var"] self.assertEqual(sample_class.get_object(), a_var.get_object()) def test_list_type_inferencing(self): - src = "class Sample(object):\n pass\na_var = [Sample()]\n" + src = dedent("""\ + class Sample(object): + pass + a_var = [Sample()] + """) scope = libutils.get_string_scope(self.project, src) sample_class = scope["Sample"].get_object() a_var = scope["a_var"].get_object() self.assertNotEqual(sample_class, a_var.get_type()) def test_attributed_object_inference(self): - src = ( - "class Sample(object):\n" - " def __init__(self):\n self.a_var = None\n" - " def set(self):\n self.a_var = Sample()\n" - ) + src = dedent("""\ + class Sample(object): + def __init__(self): + self.a_var = None + def set(self): + self.a_var = Sample() + """) scope = libutils.get_string_scope(self.project, src) sample_class = scope["Sample"].get_object() a_var = sample_class["a_var"].get_object() self.assertEqual(sample_class, a_var.get_type()) def test_getting_property_attributes(self): - src = ( - "class A(object):\n pass\n" - "def f(*args):\n return A()\n" - "class B(object):\n p = property(f)\n" - "a_var = B().p\n" - ) + src = dedent("""\ + class A(object): + pass + def f(*args): + return A() + class B(object): + p = property(f) + a_var = B().p + """) pymod = libutils.get_string_module(self.project, src) a_class = pymod["A"].get_object() a_var = pymod["a_var"].get_object() self.assertEqual(a_class, a_var.get_type()) def test_getting_property_attributes_with_method_getters(self): - src = ( - "class A(object):\n pass\n" - "class B(object):\n def p_get(self):\n return A()\n" - " p = property(p_get)\n" - "a_var = B().p\n" - ) + src = dedent("""\ + class A(object): + pass + class B(object): + def p_get(self): + return A() + p = property(p_get) + a_var = B().p + """) pymod = libutils.get_string_module(self.project, src) a_class = pymod["A"].get_object() a_var = pymod["a_var"].get_object() self.assertEqual(a_class, a_var.get_type()) def test_lambda_functions(self): - code = "class C(object):\n pass\n" "l = lambda: C()\na_var = l()" + code = dedent("""\ + class C(object): + pass + l = lambda: C() + a_var = l()""") mod = libutils.get_string_module(self.project, code) c_class = mod["C"].get_object() a_var = mod["a_var"].get_object() self.assertEqual(c_class, a_var.get_type()) def test_mixing_subscript_with_tuple_assigns(self): - code = "class C(object):\n attr = 0\n" "d = {}\nd[0], b = (0, C())\n" + code = dedent("""\ + class C(object): + attr = 0 + d = {} + d[0], b = (0, C()) + """) mod = libutils.get_string_module(self.project, code) c_class = mod["C"].get_object() a_var = mod["b"].get_object() self.assertEqual(c_class, a_var.get_type()) def test_mixing_ass_attr_with_tuple_assignment(self): - code = "class C(object):\n attr = 0\n" "c = C()\nc.attr, b = (0, C())\n" + code = dedent("""\ + class C(object): + attr = 0 + c = C() + c.attr, b = (0, C()) + """) mod = libutils.get_string_module(self.project, code) c_class = mod["C"].get_object() a_var = mod["b"].get_object() self.assertEqual(c_class, a_var.get_type()) def test_mixing_slice_with_tuple_assigns(self): - mod = libutils.get_string_module( - self.project, - "class C(object):\n attr = 0\n" - "d = [None] * 3\nd[0:2], b = ((0,), C())\n", - ) + code = dedent("""\ + class C(object): + attr = 0 + d = [None] * 3 + d[0:2], b = ((0,), C()) + """) + mod = libutils.get_string_module(self.project, code) + c_class = mod["C"].get_object() a_var = mod["b"].get_object() self.assertEqual(c_class, a_var.get_type()) def test_nested_tuple_assignments(self): - mod = libutils.get_string_module( - self.project, - "class C1(object):\n pass\nclass C2(object):\n pass\n" - "a, (b, c) = (C1(), (C2(), C1()))\n", - ) + code = dedent("""\ + class C1(object): + pass + class C2(object): + pass + a, (b, c) = (C1(), (C2(), C1())) + """) + mod = libutils.get_string_module(self.project, code) + c1_class = mod["C1"].get_object() c2_class = mod["C2"].get_object() a_var = mod["a"].get_object() @@ -222,15 +282,23 @@ def test_nested_tuple_assignments(self): self.assertEqual(c1_class, c_var.get_type()) def test_empty_tuples(self): - mod = libutils.get_string_module(self.project, "t = ()\na, b = t\n") + code = dedent("""\ + t = () + a, b = t + """) + mod = libutils.get_string_module(self.project, code) + a = mod["a"].get_object() # noqa def test_handling_generator_functions(self): - code = ( - "class C(object):\n pass\n" - "def f():\n yield C()\n" - "for c in f():\n a_var = c\n" - ) + code = dedent("""\ + class C(object): + pass + def f(): + yield C() + for c in f(): + a_var = c + """) mod = libutils.get_string_module(self.project, code) c_class = mod["C"].get_object() a_var = mod["a_var"].get_object() @@ -238,57 +306,77 @@ def test_handling_generator_functions(self): def test_handling_generator_functions_for_strs(self): mod = testutils.create_module(self.project, "mod") - mod.write('def f():\n yield ""\n' "for s in f():\n a_var = s\n") + mod.write( + dedent("""\ + def f(): + yield "" + for s in f(): + a_var = s + """) + ) pymod = self.project.get_pymodule(mod) a_var = pymod["a_var"].get_object() self.assertTrue(isinstance(a_var.get_type(), rope.base.builtins.Str)) def test_considering_nones_to_be_unknowns(self): - code = ( - "class C(object):\n pass\n" "a_var = None\na_var = C()\na_var = None\n" - ) + code = dedent("""\ + class C(object): + pass + a_var = None + a_var = C() + a_var = None + """) mod = libutils.get_string_module(self.project, code) c_class = mod["C"].get_object() a_var = mod["a_var"].get_object() self.assertEqual(c_class, a_var.get_type()) def test_basic_list_comprehensions(self): - code = ( - "class C(object):\n pass\n" "l = [C() for i in range(1)]\na_var = l[0]\n" - ) + code = dedent("""\ + class C(object): + pass + l = [C() for i in range(1)] + a_var = l[0] + """) mod = libutils.get_string_module(self.project, code) c_class = mod["C"].get_object() a_var = mod["a_var"].get_object() self.assertEqual(c_class, a_var.get_type()) def test_basic_generator_expressions(self): - code = ( - "class C(object):\n pass\n" - "l = (C() for i in range(1))\na_var = list(l)[0]\n" - ) + code = dedent("""\ + class C(object): + pass + l = (C() for i in range(1)) + a_var = list(l)[0] + """) mod = libutils.get_string_module(self.project, code) c_class = mod["C"].get_object() a_var = mod["a_var"].get_object() self.assertEqual(c_class, a_var.get_type()) def test_list_comprehensions_and_loop_var(self): - code = ( - "class C(object):\n pass\n" - "c_objects = [C(), C()]\n" - "l = [c for c in c_objects]\na_var = l[0]\n" - ) + code = dedent("""\ + class C(object): + pass + c_objects = [C(), C()] + l = [c for c in c_objects] + a_var = l[0] + """) mod = libutils.get_string_module(self.project, code) c_class = mod["C"].get_object() a_var = mod["a_var"].get_object() self.assertEqual(c_class, a_var.get_type()) def test_list_comprehensions_and_multiple_loop_var(self): - code = ( - "class C1(object):\n pass\n" - "class C2(object):\n pass\n" - "l = [(c1, c2) for c1 in [C1()] for c2 in [C2()]]\n" - "a, b = l[0]\n" - ) + code = dedent("""\ + class C1(object): + pass + class C2(object): + pass + l = [(c1, c2) for c1 in [C1()] for c2 in [C2()]] + a, b = l[0] + """) mod = libutils.get_string_module(self.project, code) c1_class = mod["C1"].get_object() c2_class = mod["C2"].get_object() @@ -298,12 +386,16 @@ def test_list_comprehensions_and_multiple_loop_var(self): self.assertEqual(c2_class, b_var.get_type()) def test_list_comprehensions_and_multiple_iters(self): - mod = libutils.get_string_module( - self.project, - "class C1(object):\n pass\nclass C2(object):\n pass\n" - "l = [(c1, c2) for c1, c2 in [(C1(), C2())]]\n" - "a, b = l[0]\n", - ) + code = dedent("""\ + class C1(object): + pass + class C2(object): + pass + l = [(c1, c2) for c1, c2 in [(C1(), C2())]] + a, b = l[0] + """) + mod = libutils.get_string_module(self.project, code) + c1_class = mod["C1"].get_object() c2_class = mod["C2"].get_object() a_var = mod["a"].get_object() @@ -312,45 +404,58 @@ def test_list_comprehensions_and_multiple_iters(self): self.assertEqual(c2_class, b_var.get_type()) def test_we_know_the_type_of_catched_exceptions(self): - code = ( - "class MyError(Exception):\n pass\n" - "try:\n raise MyError()\n" - "except MyError as e:\n pass\n" - ) + code = dedent("""\ + class MyError(Exception): + pass + try: + raise MyError() + except MyError as e: + pass + """) mod = libutils.get_string_module(self.project, code) my_error = mod["MyError"].get_object() e_var = mod["e"].get_object() self.assertEqual(my_error, e_var.get_type()) def test_we_know_the_type_of_catched_multiple_excepts(self): - code = ( - "class MyError(Exception):\n pass\n" - "try:\n raise MyError()\n" - "except (MyError, Exception) as e:\n pass\n" - ) + code = dedent("""\ + class MyError(Exception): + pass + try: + raise MyError() + except (MyError, Exception) as e: + pass + """) mod = libutils.get_string_module(self.project, code) my_error = mod["MyError"].get_object() e_var = mod["e"].get_object() self.assertEqual(my_error, e_var.get_type()) def test_using_property_as_decorators(self): - code = ( - "class A(object):\n pass\n" - "class B(object):\n" - " @property\n def f(self):\n return A()\n" - "b = B()\nvar = b.f\n" - ) + code = dedent("""\ + class A(object): + pass + class B(object): + @property + def f(self): + return A() + b = B() + var = b.f + """) mod = libutils.get_string_module(self.project, code) var = mod["var"].get_object() a = mod["A"].get_object() self.assertEqual(a, var.get_type()) def test_using_property_as_decorators_and_passing_parameter(self): - code = ( - "class B(object):\n" - " @property\n def f(self):\n return self\n" - "b = B()\nvar = b.f\n" - ) + code = dedent("""\ + class B(object): + @property + def f(self): + return self + b = B() + var = b.f + """) mod = libutils.get_string_module(self.project, code) var = mod["var"].get_object() a = mod["B"].get_object() diff --git a/ropetest/projecttest.py b/ropetest/projecttest.py index e2728d9e2..14a3e7714 100644 --- a/ropetest/projecttest.py +++ b/ropetest/projecttest.py @@ -1008,10 +1008,12 @@ def test_loading_config_dot_py(self): if not config.exists(): config.create() config.write( - "def set_prefs(prefs):\n" - ' prefs["ignored_resources"] = ["myfile.txt"]\n' - "def project_opened(project):\n" - ' project.root.create_file("loaded")\n' + dedent("""\ + def set_prefs(prefs): + prefs["ignored_resources"] = ["myfile.txt"] + def project_opened(project): + project.root.create_file("loaded") + """) ) self.project.close() self.project = Project(self.project.address, ropefolder=".ropeproject") diff --git a/ropetest/pycoretest.py b/ropetest/pycoretest.py index c0754e883..d2dc4270a 100644 --- a/ropetest/pycoretest.py +++ b/ropetest/pycoretest.py @@ -1,4 +1,5 @@ import sys +from textwrap import dedent from rope.base.builtins import File, BuiltinClass @@ -48,25 +49,35 @@ def test_package(self): def test_simple_class(self): mod = testutils.create_module(self.project, "mod") - mod.write("class SampleClass(object):\n pass\n") + mod.write( + dedent("""\ + class SampleClass(object): + pass + """) + ) mod_element = self.project.get_module("mod") result = mod_element["SampleClass"].get_object() self.assertEqual(get_base_type("Type"), result.get_type()) def test_simple_function(self): mod = testutils.create_module(self.project, "mod") - mod.write("def sample_function():\n pass\n") + mod.write( + dedent("""\ + def sample_function(): + pass + """) + ) mod_element = self.project.get_module("mod") result = mod_element["sample_function"].get_object() self.assertEqual(get_base_type("Function"), result.get_type()) def test_class_methods(self): mod = testutils.create_module(self.project, "mod") - code = ( - "class SampleClass(object):\n" - " def sample_method(self):\n" - " pass\n" - ) + code = dedent("""\ + class SampleClass(object): + def sample_method(self): + pass + """) mod.write(code) mod_element = self.project.get_module("mod") sample_class = mod_element["SampleClass"].get_object() @@ -91,7 +102,12 @@ def test_global_variable_with_type_annotation(self): def test_class_variables(self): mod = testutils.create_module(self.project, "mod") - mod.write("class SampleClass(object):\n var = 10\n") + mod.write( + dedent("""\ + class SampleClass(object): + var = 10 + """) + ) mod_element = self.project.get_module("mod") sample_class = mod_element["SampleClass"].get_object() var = sample_class["var"] # noqa @@ -99,7 +115,11 @@ def test_class_variables(self): def test_class_attributes_set_in_init(self): mod = testutils.create_module(self.project, "mod") mod.write( - "class C(object):\n" " def __init__(self):\n self.var = 20\n" + dedent("""\ + class C(object): + def __init__(self): + self.var = 20 + """) ) mod_element = self.project.get_module("mod") sample_class = mod_element["C"].get_object() @@ -107,13 +127,13 @@ def test_class_attributes_set_in_init(self): def test_class_attributes_set_in_init_overwriting_a_defined(self): mod = testutils.create_module(self.project, "mod") - code = ( - "class C(object):\n" - " def __init__(self):\n" - " self.f = 20\n" - " def f():\n" - " pass\n" - ) + code = dedent("""\ + class C(object): + def __init__(self): + self.f = 20 + def f(): + pass + """) mod.write(code) mod_element = self.project.get_module("mod") sample_class = mod_element["C"].get_object() @@ -122,11 +142,12 @@ def test_class_attributes_set_in_init_overwriting_a_defined(self): def test_classes_inside_other_classes(self): mod = testutils.create_module(self.project, "mod") - code = ( - "class SampleClass(object):\n" - " class InnerClass(object):\n" - " pass\n\n" - ) + code = dedent("""\ + class SampleClass(object): + class InnerClass(object): + pass + + """) mod.write(code) mod_element = self.project.get_module("mod") sample_class = mod_element["SampleClass"].get_object() @@ -154,17 +175,22 @@ def test_imported_as_names(self): self.assertEqual(get_base_type("Module"), imported_mod.get_type()) def test_get_string_module(self): - mod = libutils.get_string_module( - self.project, "class Sample(object):\n pass\n" - ) + code = dedent("""\ + class Sample(object): + pass + """) + mod = libutils.get_string_module(self.project, code) sample_class = mod["Sample"].get_object() self.assertEqual(get_base_type("Type"), sample_class.get_type()) def test_get_string_module_with_extra_spaces(self): - mod = libutils.get_string_module(self.project, "a = 10\n ") # noqa + code = "a = 10\n " + mod = libutils.get_string_module(self.project, code) # noqa def test_parameter_info_for_functions(self): - code = "def func(param1, param2=10, *param3, **param4):\n pass" + code = dedent("""\ + def func(param1, param2=10, *param3, **param4): + pass""") mod = libutils.get_string_module(self.project, code) sample_function = mod["func"] self.assertEqual( @@ -174,24 +200,26 @@ def test_parameter_info_for_functions(self): # FIXME: Not found modules def xxx_test_not_found_module_is_module(self): - mod = libutils.get_string_module(self.project, "import doesnotexist\n") + code = "import doesnotexist\n" + mod = libutils.get_string_module(self.project, code) self.assertEqual( get_base_type("Module"), mod["doesnotexist"].get_object().get_type() ) def test_mixing_scopes_and_objects_hierarchy(self): - mod = libutils.get_string_module(self.project, "var = 200\n") + code = "var = 200\n" + mod = libutils.get_string_module(self.project, code) scope = mod.get_scope() self.assertTrue("var" in scope.get_names()) def test_inheriting_base_class_attributes(self): - code = ( - "class Base(object):\n" - " def method(self):\n" - " pass\n" - "class Derived(Base):\n" - " pass\n" - ) + code = dedent("""\ + class Base(object): + def method(self): + pass + class Derived(Base): + pass + """) mod = libutils.get_string_module(self.project, code) derived = mod["Derived"].get_object() self.assertTrue("method" in derived) @@ -200,29 +228,43 @@ def test_inheriting_base_class_attributes(self): ) def test_inheriting_multiple_base_class_attributes(self): - code = ( - "class Base1(object):\n def method1(self):\n pass\n" - "class Base2(object):\n def method2(self):\n pass\n" - "class Derived(Base1, Base2):\n pass\n" - ) + code = dedent("""\ + class Base1(object): + def method1(self): + pass + class Base2(object): + def method2(self): + pass + class Derived(Base1, Base2): + pass + """) mod = libutils.get_string_module(self.project, code) derived = mod["Derived"].get_object() self.assertTrue("method1" in derived) self.assertTrue("method2" in derived) def test_inherit_multiple_base_class_attrs_with_the_same_name(self): - code = ( - "class Base1(object):\n def method(self):\n pass\n" - "class Base2(object):\n def method(self):\n pass\n" - "class Derived(Base1, Base2):\n pass\n" - ) + code = dedent("""\ + class Base1(object): + def method(self): + pass + class Base2(object): + def method(self): + pass + class Derived(Base1, Base2): + pass + """) mod = libutils.get_string_module(self.project, code) base1 = mod["Base1"].get_object() derived = mod["Derived"].get_object() self.assertEqual(base1["method"].get_object(), derived["method"].get_object()) def test_inheriting_unknown_base_class(self): - code = "class Derived(NotFound):\n" " def f(self):\n" " pass\n" + code = dedent("""\ + class Derived(NotFound): + def f(self): + pass + """) mod = libutils.get_string_module(self.project, code) derived = mod["Derived"].get_object() self.assertTrue("f" in derived) @@ -314,51 +356,79 @@ def test_source_folders_preference(self): self.assertEqual(self.project.find_module("lost"), lost) def test_get_pyname_definition_location(self): - mod = libutils.get_string_module(self.project, "a_var = 20\n") + code = "a_var = 20\n" + mod = libutils.get_string_module(self.project, code) a_var = mod["a_var"] self.assertEqual((mod, 1), a_var.get_definition_location()) def test_get_pyname_definition_location_functions(self): - mod = libutils.get_string_module(self.project, "def a_func():\n pass\n") + code = dedent("""\ + def a_func(): + pass + """) + mod = libutils.get_string_module(self.project, code) a_func = mod["a_func"] self.assertEqual((mod, 1), a_func.get_definition_location()) def test_get_pyname_definition_location_class(self): - code = "class AClass(object):\n pass\n\n" + code = dedent("""\ + class AClass(object): + pass + + """) mod = libutils.get_string_module(self.project, code) a_class = mod["AClass"] self.assertEqual((mod, 1), a_class.get_definition_location()) def test_get_pyname_definition_location_local_variables(self): - mod = libutils.get_string_module( - self.project, "def a_func():\n a_var = 10\n" - ) + code = dedent("""\ + def a_func(): + a_var = 10 + """) + mod = libutils.get_string_module(self.project, code) a_func_scope = mod.get_scope().get_scopes()[0] a_var = a_func_scope["a_var"] self.assertEqual((mod, 2), a_var.get_definition_location()) def test_get_pyname_definition_location_reassigning(self): - mod = libutils.get_string_module(self.project, "a_var = 20\na_var=30\n") + code = dedent("""\ + a_var = 20 + a_var=30 + """) + mod = libutils.get_string_module(self.project, code) a_var = mod["a_var"] self.assertEqual((mod, 1), a_var.get_definition_location()) def test_get_pyname_definition_location_importes(self): testutils.create_module(self.project, "mod") - mod = libutils.get_string_module(self.project, "import mod\n") + code = "import mod\n" + mod = libutils.get_string_module(self.project, code) imported_module = self.project.get_module("mod") module_pyname = mod["mod"] self.assertEqual((imported_module, 1), module_pyname.get_definition_location()) def test_get_pyname_definition_location_imports(self): module_resource = testutils.create_module(self.project, "mod") - module_resource.write("\ndef a_func():\n pass\n") + module_resource.write( + dedent("""\ + + def a_func(): + pass + """) + ) imported_module = self.project.get_module("mod") - mod = libutils.get_string_module(self.project, "from mod import a_func\n") + code = dedent("""\ + from mod import a_func + """) + mod = libutils.get_string_module(self.project, code) a_func = mod["a_func"] self.assertEqual((imported_module, 2), a_func.get_definition_location()) def test_get_pyname_definition_location_parameters(self): - code = "def a_func(param1, param2):\n a_var = param\n" + code = dedent("""\ + def a_func(param1, param2): + a_var = param + """) mod = libutils.get_string_module(self.project, code) a_func_scope = mod.get_scope().get_scopes()[0] param1 = a_func_scope["param1"] @@ -370,31 +440,32 @@ def test_module_get_resource(self): module_resource = testutils.create_module(self.project, "mod") module = self.project.get_module("mod") self.assertEqual(module_resource, module.get_resource()) - string_module = libutils.get_string_module( - self.project, "from mod import a_func\n" - ) + code = dedent("""\ + from mod import a_func + """) + string_module = libutils.get_string_module(self.project, code) self.assertEqual(None, string_module.get_resource()) def test_get_pyname_definition_location_class2(self): - code = ( - "class AClass(object):\n" - " def __init__(self):\n" - " self.an_attr = 10\n" - ) + code = dedent("""\ + class AClass(object): + def __init__(self): + self.an_attr = 10 + """) mod = libutils.get_string_module(self.project, code) a_class = mod["AClass"].get_object() an_attr = a_class["an_attr"] self.assertEqual((mod, 3), an_attr.get_definition_location()) def test_import_not_found_module_get_definition_location(self): - mod = libutils.get_string_module(self.project, "import doesnotexist\n") + code = "import doesnotexist\n" + mod = libutils.get_string_module(self.project, code) does_not_exist = mod["doesnotexist"] self.assertEqual((None, None), does_not_exist.get_definition_location()) def test_from_not_found_module_get_definition_location(self): - mod = libutils.get_string_module( - self.project, "from doesnotexist import Sample\n" - ) + code = "from doesnotexist import Sample\n" + mod = libutils.get_string_module(self.project, code) sample = mod["Sample"] self.assertEqual((None, None), sample.get_definition_location()) @@ -402,21 +473,25 @@ def test_from_package_import_module_get_definition_location(self): pkg = testutils.create_package(self.project, "pkg") testutils.create_module(self.project, "mod", pkg) pkg_mod = self.project.get_module("pkg.mod") - mod = libutils.get_string_module(self.project, "from pkg import mod\n") + code = "from pkg import mod\n" + mod = libutils.get_string_module(self.project, code) imported_mod = mod["mod"] self.assertEqual((pkg_mod, 1), imported_mod.get_definition_location()) def test_get_module_for_defined_pyobjects(self): - mod = libutils.get_string_module( - self.project, "class AClass(object):\n pass\n" - ) + code = dedent("""\ + class AClass(object): + pass + """) + mod = libutils.get_string_module(self.project, code) a_class = mod["AClass"].get_object() self.assertEqual(mod, a_class.get_module()) def test_get_definition_location_for_packages(self): testutils.create_package(self.project, "pkg") init_module = self.project.get_module("pkg.__init__") - mod = libutils.get_string_module(self.project, "import pkg\n") + code = "import pkg\n" + mod = libutils.get_string_module(self.project, code) pkg_pyname = mod["pkg"] self.assertEqual((init_module, 1), pkg_pyname.get_definition_location()) @@ -424,14 +499,14 @@ def test_get_definition_location_for_filtered_packages(self): pkg = testutils.create_package(self.project, "pkg") testutils.create_module(self.project, "mod", pkg) init_module = self.project.get_module("pkg.__init__") - mod = libutils.get_string_module(self.project, "import pkg.mod") + code = "import pkg.mod" + mod = libutils.get_string_module(self.project, code) pkg_pyname = mod["pkg"] self.assertEqual((init_module, 1), pkg_pyname.get_definition_location()) def test_out_of_project_modules(self): - scope = libutils.get_string_scope( - self.project, "import rope.base.project as project\n" - ) + code = "import rope.base.project as project\n" + scope = libutils.get_string_scope(self.project, code) imported_module = scope["project"].get_object() self.assertTrue("Project" in imported_module) @@ -444,8 +519,12 @@ def test_file_encoding_reading(self): self.project.get_module("mod") def test_global_keyword(self): - contents = "a_var = 1\ndef a_func():\n global a_var\n" - mod = libutils.get_string_module(self.project, contents) + code = dedent("""\ + a_var = 1 + def a_func(): + global a_var + """) + mod = libutils.get_string_module(self.project, code) global_var = mod["a_var"] func_scope = mod["a_func"].get_object().get_scope() local_var = func_scope["a_var"] @@ -453,12 +532,12 @@ def test_global_keyword(self): def test_not_leaking_for_vars_inside_parent_scope(self): mod = testutils.create_module(self.project, "mod") - code = ( - "class C(object):\n" - " def f(self):\n" - " for my_var1, my_var2 in []:\n" - " pass\n" - ) + code = dedent("""\ + class C(object): + def f(self): + for my_var1, my_var2 in []: + pass + """) mod.write(code) pymod = self.pycore.resource_to_pyobject(mod) c_class = pymod["C"].get_object() @@ -467,12 +546,12 @@ def test_not_leaking_for_vars_inside_parent_scope(self): def test_not_leaking_for_vars_inside_parent_scope2(self): mod = testutils.create_module(self.project, "mod") - code = ( - "class C(object):\n" - " def f(self):\n" - " for my_var in []:\n" - " pass\n" - ) + code = dedent("""\ + class C(object): + def f(self): + for my_var in []: + pass + """) mod.write(code) pymod = self.pycore.resource_to_pyobject(mod) c_class = pymod["C"].get_object() @@ -480,14 +559,14 @@ def test_not_leaking_for_vars_inside_parent_scope2(self): def test_variables_defined_in_excepts(self): mod = testutils.create_module(self.project, "mod") - code = ( - "try:\n" - " myvar1 = 1\n" - "except:\n" - " myvar2 = 1\n" - "finally:\n" - " myvar3 = 1\n" - ) + code = dedent("""\ + try: + myvar1 = 1 + except: + myvar2 = 1 + finally: + myvar3 = 1 + """) mod.write(code) pymod = self.pycore.resource_to_pyobject(mod) self.assertTrue("myvar1" in pymod) @@ -496,9 +575,11 @@ def test_variables_defined_in_excepts(self): def test_not_leaking_tuple_assigned_names_inside_parent_scope(self): mod = testutils.create_module(self.project, "mod") - code = ( - "class C(object):\n" " def f(self):\n" " var1, var2 = range(2)\n" - ) + code = dedent("""\ + class C(object): + def f(self): + var1, var2 = range(2) + """) mod.write(code) pymod = self.pycore.resource_to_pyobject(mod) c_class = pymod["C"].get_object() @@ -506,7 +587,10 @@ def test_not_leaking_tuple_assigned_names_inside_parent_scope(self): @testutils.only_for("2.5") def test_with_statement_variables(self): - code = "import threading\nwith threading.lock() as var: pass\n" + code = dedent("""\ + import threading + with threading.lock() as var: pass + """) if sys.version_info < (2, 6, 0): code = "from __future__ import with_statement\n" + code pymod = libutils.get_string_module(self.project, code) @@ -514,15 +598,14 @@ def test_with_statement_variables(self): @testutils.only_for("2.5") def test_with_statement_variables_and_tuple_assignment(self): - code = ( - "class A(object):\n" - " def __enter__(self):" - " return (1, 2)\n" - " def __exit__(self, type, value, tb):\n" - " pass\n" - "with A() as (a, b):\n" - " pass\n" - ) + code = dedent("""\ + class A(object): + def __enter__(self): return (1, 2) + def __exit__(self, type, value, tb): + pass + with A() as (a, b): + pass + """) if sys.version_info < (2, 6, 0): code = "from __future__ import with_statement\n" + code pymod = libutils.get_string_module(self.project, code) @@ -531,15 +614,15 @@ def test_with_statement_variables_and_tuple_assignment(self): @testutils.only_for("2.5") def test_with_statement_variable_type(self): - code = ( - "class A(object):\n" - " def __enter__(self):\n" - " return self\n" - " def __exit__(self, type, value, tb):\n" - " pass\n" - "with A() as var:\n" - " pass\n" - ) + code = dedent("""\ + class A(object): + def __enter__(self): + return self + def __exit__(self, type, value, tb): + pass + with A() as var: + pass + """) if sys.version_info < (2, 6, 0): code = "from __future__ import with_statement\n" + code pymod = libutils.get_string_module(self.project, code) @@ -549,20 +632,20 @@ def test_with_statement_variable_type(self): @testutils.only_for("2.7") def test_nested_with_statement_variable_type(self): - code = ( - "class A(object):\n" - " def __enter__(self):\n" - " return self\n" - " def __exit__(self, type, value, tb):\n" - " pass\n" - "class B(object):\n" - " def __enter__(self):\n" - " return self\n" - " def __exit__(self, type, value, tb):\n" - " pass\n" - "with A() as var_a, B() as var_b:\n" - " pass\n" - ) + code = dedent("""\ + class A(object): + def __enter__(self): + return self + def __exit__(self, type, value, tb): + pass + class B(object): + def __enter__(self): + return self + def __exit__(self, type, value, tb): + pass + with A() as var_a, B() as var_b: + pass + """) if sys.version_info < (2, 6, 0): code = "from __future__ import with_statement\n" + code pymod = libutils.get_string_module(self.project, code) @@ -576,16 +659,20 @@ def test_nested_with_statement_variable_type(self): @testutils.only_for("2.5") def test_with_statement_with_no_vars(self): - code = 'with open("file"): pass\n' + code = dedent("""\ + with open("file"): pass + """) if sys.version_info < (2, 6, 0): code = "from __future__ import with_statement\n" + code pymod = libutils.get_string_module(self.project, code) pymod.get_attributes() def test_with_statement(self): - code = "a = 10\n" 'with open("file") as f: pass\n' + code = dedent("""\ + a = 10 + with open("file") as f: pass + """) pymod = libutils.get_string_module(self.project, code) - assigned = pymod.get_attribute("a") self.assertEqual(BuiltinClass, type(assigned.get_object().get_type())) @@ -593,20 +680,31 @@ def test_with_statement(self): self.assertEqual(File, type(assigned.get_object().get_type())) def test_check_for_else_block(self): - code = "for i in range(10):\n" " pass\n" "else:\n" " myvar = 1\n" + code = dedent("""\ + for i in range(10): + pass + else: + myvar = 1 + """) mod = libutils.get_string_module(self.project, code) a_var = mod["myvar"] self.assertEqual((mod, 4), a_var.get_definition_location()) def test_check_names_defined_in_whiles(self): - mod = libutils.get_string_module(self.project, "while False:\n myvar = 1\n") + code = dedent("""\ + while False: + myvar = 1 + """) + mod = libutils.get_string_module(self.project, code) a_var = mod["myvar"] self.assertEqual((mod, 2), a_var.get_definition_location()) def test_get_definition_location_in_tuple_assnames(self): - mod = libutils.get_string_module( - self.project, "def f(x):\n x.z, a = range(2)\n" - ) + code = dedent("""\ + def f(x): + x.z, a = range(2) + """) + mod = libutils.get_string_module(self.project, code) x = mod["f"].get_object().get_scope()["x"] a = mod["f"].get_object().get_scope()["a"] self.assertEqual((mod, 1), x.get_definition_location()) @@ -681,7 +779,12 @@ def test_not_reaching_maximum_recursions_when_importing_variables2(self): def test_pyobject_equality_should_compare_types(self): mod1 = testutils.create_module(self.project, "mod1") - mod1.write('var1 = ""\nvar2 = ""\n') + mod1.write( + dedent("""\ + var1 = "" + var2 = "" + """) + ) pymod1 = self.pycore.resource_to_pyobject(mod1) self.assertEqual(pymod1["var1"].get_object(), pymod1["var2"].get_object()) @@ -692,16 +795,19 @@ def setUp(self): self.project = testutils.sample_project() self.pycore = self.project.pycore samplemod = testutils.create_module(self.project, "samplemod") - code = ( - "class SampleClass(object):\n" - " def sample_method():\n" - " pass\n\n" - "def sample_func():\n" - " pass\n" - "sample_var = 10\n\n" - "def _underlined_func():\n" - " pass\n\n" - ) + code = dedent("""\ + class SampleClass(object): + def sample_method(): + pass + + def sample_func(): + pass + sample_var = 10 + + def _underlined_func(): + pass + + """) samplemod.write(code) package = testutils.create_package(self.project, "package") testutils.create_module(self.project, "nestedmod", package) @@ -711,20 +817,21 @@ def tearDown(self): super(self.__class__, self).tearDown() def test_simple_import(self): - mod = libutils.get_string_module(self.project, "import samplemod\n") + code = "import samplemod\n" + mod = libutils.get_string_module(self.project, code) samplemod = mod["samplemod"].get_object() self.assertEqual(get_base_type("Module"), samplemod.get_type()) def test_from_import_class(self): - mod = libutils.get_string_module( - self.project, "from samplemod import SampleClass\n" - ) + code = "from samplemod import SampleClass\n" + mod = libutils.get_string_module(self.project, code) result = mod["SampleClass"].get_object() self.assertEqual(get_base_type("Type"), result.get_type()) self.assertTrue("sample_func" not in mod.get_attributes()) def test_from_import_star(self): - mod = libutils.get_string_module(self.project, "from samplemod import *\n") + code = "from samplemod import *\n" + mod = libutils.get_string_module(self.project, code) self.assertEqual( get_base_type("Type"), mod["SampleClass"].get_object().get_type() ) @@ -734,7 +841,11 @@ def test_from_import_star(self): self.assertTrue(mod["sample_var"] is not None) def test_from_import_star_overwriting(self): - code = "from samplemod import *\n" "class SampleClass(object):\n pass\n" + code = dedent("""\ + from samplemod import * + class SampleClass(object): + pass + """) mod = libutils.get_string_module(self.project, code) samplemod = self.project.get_module("samplemod") sample_class = samplemod["SampleClass"].get_object() @@ -743,36 +854,41 @@ def test_from_import_star_overwriting(self): ) def test_from_import_star_not_imporing_underlined(self): - mod = libutils.get_string_module(self.project, "from samplemod import *") + code = "from samplemod import *" + mod = libutils.get_string_module(self.project, code) self.assertTrue("_underlined_func" not in mod.get_attributes()) def test_from_import_star_imports_in_functions(self): - mod = libutils.get_string_module( - self.project, "def f():\n from os import *\n" - ) + code = dedent("""\ + def f(): + from os import * + """) + mod = libutils.get_string_module(self.project, code) mod["f"].get_object().get_scope().get_names() def test_from_package_import_mod(self): - mod = libutils.get_string_module( - self.project, "from package import nestedmod\n" - ) + code = "from package import nestedmod\n" + mod = libutils.get_string_module(self.project, code) self.assertEqual( get_base_type("Module"), mod["nestedmod"].get_object().get_type() ) # XXX: Deciding to import everything on import start from packages def xxx_test_from_package_import_star(self): - mod = libutils.get_string_module(self.project, "from package import *\n") + code = "from package import *\n" + mod = libutils.get_string_module(self.project, code) self.assertTrue("nestedmod" not in mod.get_attributes()) def test_unknown_when_module_cannot_be_found(self): - mod = libutils.get_string_module( - self.project, "from doesnotexist import nestedmod\n" - ) + code = "from doesnotexist import nestedmod\n" + mod = libutils.get_string_module(self.project, code) self.assertTrue("nestedmod" in mod) def test_from_import_function(self): - code = "def f():\n from samplemod import SampleClass\n" + code = dedent("""\ + def f(): + from samplemod import SampleClass + """) scope = libutils.get_string_scope(self.project, code) self.assertEqual( get_base_type("Type"), @@ -789,15 +905,33 @@ def test_circular_imports(self): def test_circular_imports2(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") - mod1.write("from mod2 import Sample2\nclass Sample1(object):\n pass\n") - mod2.write("from mod1 import Sample1\nclass Sample2(object):\n pass\n") + mod1.write( + dedent("""\ + from mod2 import Sample2 + class Sample1(object): + pass + """) + ) + mod2.write( + dedent("""\ + from mod1 import Sample1 + class Sample2(object): + pass + """) + ) self.project.get_module("mod1").get_attributes() def test_multi_dot_imports(self): pkg = testutils.create_package(self.project, "pkg") pkg_mod = testutils.create_module(self.project, "mod", pkg) - pkg_mod.write("def sample_func():\n pass\n") - mod = libutils.get_string_module(self.project, "import pkg.mod\n") + pkg_mod.write( + dedent("""\ + def sample_func(): + pass + """) + ) + code = "import pkg.mod\n" + mod = libutils.get_string_module(self.project, code) self.assertTrue("pkg" in mod) self.assertTrue("sample_func" in mod["pkg"].get_object()["mod"].get_object()) @@ -805,9 +939,11 @@ def test_multi_dot_imports2(self): pkg = testutils.create_package(self.project, "pkg") testutils.create_module(self.project, "mod1", pkg) testutils.create_module(self.project, "mod2", pkg) - mod = libutils.get_string_module( - self.project, "import pkg.mod1\nimport pkg.mod2\n" - ) + code = dedent("""\ + import pkg.mod1 + import pkg.mod2 + """) + mod = libutils.get_string_module(self.project, code) package = mod["pkg"].get_object() self.assertEqual(2, len(package.get_attributes())) self.assertTrue("mod1" in package and "mod2" in package) @@ -817,7 +953,10 @@ def test_multi_dot_imports3(self): pkg2 = testutils.create_package(self.project, "pkg2", pkg1) testutils.create_module(self.project, "mod1", pkg2) testutils.create_module(self.project, "mod2", pkg2) - code = "import pkg1.pkg2.mod1\nimport pkg1.pkg2.mod2\n" + code = dedent("""\ + import pkg1.pkg2.mod1 + import pkg1.pkg2.mod2 + """) mod = libutils.get_string_module(self.project, code) package1 = mod["pkg1"].get_object() package2 = package1["pkg2"].get_object() @@ -827,8 +966,14 @@ def test_multi_dot_imports3(self): def test_multi_dot_imports_as(self): pkg = testutils.create_package(self.project, "pkg") mod1 = testutils.create_module(self.project, "mod1", pkg) - mod1.write("def f():\n pass\n") - mod = libutils.get_string_module(self.project, "import pkg.mod1 as mod1\n") + mod1.write( + dedent("""\ + def f(): + pass + """) + ) + code = "import pkg.mod1 as mod1\n" + mod = libutils.get_string_module(self.project, code) module = mod["mod1"].get_object() self.assertTrue("f" in module) @@ -837,7 +982,8 @@ def xxx_test_from_package_import_package(self): pkg1 = testutils.create_package(self.project, "pkg1") pkg2 = testutils.create_package(self.project, "pkg2", pkg1) testutils.create_module(self.project, "mod", pkg2) - mod = libutils.get_string_module(self.project, "from pkg1 import pkg2\n") + code = "from pkg1 import pkg2\n" + mod = libutils.get_string_module(self.project, code) package = mod["pkg2"] self.assertEqual(0, len(package.get_attributes())) @@ -895,19 +1041,26 @@ def test_not_considering_imported_names_as_sub_scopes(self): self.assertEqual(0, len(scope.get_scopes())) def test_not_considering_imported_modules_as_sub_scopes(self): - scope = libutils.get_string_scope(self.project, "import samplemod\n") + code = "import samplemod\n" + scope = libutils.get_string_scope(self.project, code) self.assertEqual(0, len(scope.get_scopes())) def test_inheriting_dotted_base_class(self): - code = ( - "import samplemod\n" "class Derived(samplemod.SampleClass):\n" " pass\n" - ) + code = dedent("""\ + import samplemod + class Derived(samplemod.SampleClass): + pass + """) mod = libutils.get_string_module(self.project, code) derived = mod["Derived"].get_object() self.assertTrue("sample_method" in derived) def test_self_in_methods(self): - code = "class Sample(object):\n" " def func(self):\n" " pass\n" + code = dedent("""\ + class Sample(object): + def func(self): + pass + """) scope = libutils.get_string_scope(self.project, code) sample_class = scope["Sample"].get_object() func_scope = scope.get_scopes()[0].get_scopes()[0] @@ -915,23 +1068,23 @@ def test_self_in_methods(self): self.assertTrue("func" in func_scope["self"].get_object()) def test_none_assignments_in_classes(self): - code = ( - "class C(object):\n" - ' var = ""\n' - " def f(self):\n" - ' self.var += "".join([])\n' - ) + code = dedent("""\ + class C(object): + var = "" + def f(self): + self.var += "".join([]) + """) scope = libutils.get_string_scope(self.project, code) c_class = scope["C"].get_object() self.assertTrue("var" in c_class) def test_self_in_methods_with_decorators(self): - code = ( - "class Sample(object):\n" - " @staticmethod\n" - " def func(self):\n" - " pass\n" - ) + code = dedent("""\ + class Sample(object): + @staticmethod + def func(self): + pass + """) scope = libutils.get_string_scope(self.project, code) sample_class = scope["Sample"].get_object() func_scope = scope.get_scopes()[0].get_scopes()[0] @@ -940,7 +1093,8 @@ def test_self_in_methods_with_decorators(self): def test_location_of_imports_when_importing(self): mod = testutils.create_module(self.project, "mod") mod.write("from samplemod import SampleClass\n") - scope = libutils.get_string_scope(self.project, "from mod import SampleClass\n") + code = "from mod import SampleClass\n" + scope = libutils.get_string_scope(self.project, code) sample_class = scope["SampleClass"] samplemod = self.project.get_module("samplemod") self.assertEqual((samplemod, 1), sample_class.get_definition_location()) @@ -949,7 +1103,8 @@ def test_nested_modules(self): pkg = testutils.create_package(self.project, "pkg") testutils.create_module(self.project, "mod", pkg) imported_module = self.project.get_module("pkg.mod") - scope = libutils.get_string_scope(self.project, "import pkg.mod\n") + code = "import pkg.mod\n" + scope = libutils.get_string_scope(self.project, code) mod_pyobject = scope["pkg"].get_object()["mod"] self.assertEqual((imported_module, 1), mod_pyobject.get_definition_location()) @@ -973,7 +1128,12 @@ def test_relative_froms(self): pkg = testutils.create_package(self.project, "pkg") mod1 = testutils.create_module(self.project, "mod1", pkg) mod2 = testutils.create_module(self.project, "mod2", pkg) - mod1.write("def a_func():\n pass\n") + mod1.write( + dedent("""\ + def a_func(): + pass + """) + ) mod2.write("from mod1 import a_func\n") mod1_object = self.pycore.resource_to_pyobject(mod1) mod2_object = self.pycore.resource_to_pyobject(mod2) @@ -1014,7 +1174,12 @@ def test_new_style_relative_imports2(self): pkg = testutils.create_package(self.project, "pkg") mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2", pkg) - mod1.write("def a_func():\n pass\n") + mod1.write( + dedent("""\ + def a_func(): + pass + """) + ) mod2.write("from ..mod1 import a_func\n") mod1_object = self.pycore.resource_to_pyobject(mod1) mod2_object = self.pycore.resource_to_pyobject(mod2) @@ -1025,8 +1190,18 @@ def test_new_style_relative_imports2(self): def test_invalidating_cache_for_from_imports_after_resource_change(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") - mod2.write("def a_func():\n print(1)\n") - mod1.write("from mod2 import a_func\na_func()\n") + mod2.write( + dedent("""\ + def a_func(): + print(1) + """) + ) + mod1.write( + dedent("""\ + from mod2 import a_func + a_func() + """) + ) pymod1 = self.project.get_module("mod1") pymod2 = self.project.get_module("mod2") @@ -1038,20 +1213,40 @@ def test_invalidating_cache_for_from_imports_after_resource_change(self): def test_invalidating_superclasses_after_change(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") - mod1.write("class A(object):\n def func1(self):\n pass\n") - mod2.write("import mod1\nclass B(mod1.A):\n pass\n") + mod1.write( + dedent("""\ + class A(object): + def func1(self): + pass + """) + ) + mod2.write( + dedent("""\ + import mod1 + class B(mod1.A): + pass + """) + ) b_class = self.project.get_module("mod2")["B"].get_object() self.assertTrue("func1" in b_class) - mod1.write("class A(object):\n def func2(self):\n pass\n") + mod1.write( + dedent("""\ + class A(object): + def func2(self): + pass + """) + ) self.assertTrue("func2" in b_class) def test_caching_pymodule_with_syntax_errors(self): self.project.prefs["ignore_syntax_errors"] = True self.project.prefs["automatic_soa"] = True self.project.pycore._init_automatic_soa() - source = "import sys\nab cd" + source = dedent("""\ + import sys + ab cd""") mod = testutils.create_module(self.project, "mod") mod.write(source) from rope.contrib import fixsyntax @@ -1110,16 +1305,14 @@ def test_python_files_config(self): def test_ignore_bad_imports(self): self.project = testutils.sample_project(ignore_bad_imports=True) - pymod = libutils.get_string_module( - self.project, "import some_nonexistent_module\n" - ) + code = "import some_nonexistent_module\n" + pymod = libutils.get_string_module(self.project, code) self.assertFalse("some_nonexistent_module" in pymod) def test_ignore_bad_imports_for_froms(self): self.project = testutils.sample_project(ignore_bad_imports=True) - pymod = libutils.get_string_module( - self.project, "from some_nonexistent_module import var\n" - ) + code = "from some_nonexistent_module import var\n" + pymod = libutils.get_string_module(self.project, code) self.assertFalse("var" in pymod) def test_reporting_syntax_errors_with_force_errors(self): diff --git a/ropetest/pyscopestest.py b/ropetest/pyscopestest.py index 0f1e0c3d3..6c7ec7609 100644 --- a/ropetest/pyscopestest.py +++ b/ropetest/pyscopestest.py @@ -21,26 +21,35 @@ def tearDown(self): super(PyCoreScopesTest, self).tearDown() def test_simple_scope(self): - scope = libutils.get_string_scope( - self.project, "def sample_func():\n pass\n" - ) + code = dedent("""\ + def sample_func(): + pass + """) + scope = libutils.get_string_scope(self.project, code) + sample_func = scope["sample_func"].get_object() self.assertEqual(get_base_type("Function"), sample_func.get_type()) def test_simple_function_scope(self): - scope = libutils.get_string_scope( - self.project, "def sample_func():\n a = 10\n" - ) + code = dedent("""\ + def sample_func(): + a = 10 + """) + scope = libutils.get_string_scope(self.project, code) + self.assertEqual(1, len(scope.get_scopes())) sample_func_scope = scope.get_scopes()[0] self.assertEqual(1, len(sample_func_scope.get_names())) self.assertEqual(0, len(sample_func_scope.get_scopes())) def test_classes_inside_function_scopes(self): - scope = libutils.get_string_scope( - self.project, - "def sample_func():\n" " class SampleClass(object):\n pass\n", - ) + code = dedent("""\ + def sample_func(): + class SampleClass(object): + pass + """) + scope = libutils.get_string_scope(self.project, code) + self.assertEqual(1, len(scope.get_scopes())) sample_func_scope = scope.get_scopes()[0] # noqa self.assertEqual( @@ -49,9 +58,9 @@ def test_classes_inside_function_scopes(self): ) def test_list_comprehension_scope_inside_assignment(self): - scope = libutils.get_string_scope( - self.project, "a_var = [b_var + d_var for b_var, c_var in e_var]\n" - ) + code = "a_var = [b_var + d_var for b_var, c_var in e_var]\n" + scope = libutils.get_string_scope(self.project, code) + self.assertEqual( list(sorted(scope.get_defined_names())), ["a_var"], @@ -62,36 +71,36 @@ def test_list_comprehension_scope_inside_assignment(self): ) def test_list_comprehension_scope(self): - scope = libutils.get_string_scope( - self.project, "[b_var + d_var for b_var, c_var in e_var]\n" - ) + code = "[b_var + d_var for b_var, c_var in e_var]\n" + scope = libutils.get_string_scope(self.project, code) + self.assertEqual( list(sorted(scope.get_scopes()[0].get_defined_names())), ["b_var", "c_var"], ) def test_set_comprehension_scope(self): - scope = libutils.get_string_scope( - self.project, "{b_var + d_var for b_var, c_var in e_var}\n" - ) + code = "{b_var + d_var for b_var, c_var in e_var}\n" + scope = libutils.get_string_scope(self.project, code) + self.assertEqual( list(sorted(scope.get_scopes()[0].get_defined_names())), ["b_var", "c_var"], ) def test_generator_comprehension_scope(self): - scope = libutils.get_string_scope( - self.project, "(b_var + d_var for b_var, c_var in e_var)\n" - ) + code = "(b_var + d_var for b_var, c_var in e_var)\n" + scope = libutils.get_string_scope(self.project, code) + self.assertEqual( list(sorted(scope.get_scopes()[0].get_defined_names())), ["b_var", "c_var"], ) def test_dict_comprehension_scope(self): - scope = libutils.get_string_scope( - self.project, "{b_var: d_var for b_var, c_var in e_var}\n" - ) + code = "{b_var: d_var for b_var, c_var in e_var}\n" + scope = libutils.get_string_scope(self.project, code) + self.assertEqual( list(sorted(scope.get_scopes()[0].get_defined_names())), ["b_var", "c_var"], @@ -99,10 +108,9 @@ def test_dict_comprehension_scope(self): @testutils.only_for_versions_higher("3.8") def test_inline_assignment(self): - scope = libutils.get_string_scope( - self.project, - """values = (a_var := 2,)""", - ) + code = """values = (a_var := 2,)""" + scope = libutils.get_string_scope(self.project, code) + self.assertEqual( list(sorted(scope.get_defined_names())), ["a_var", "values"], @@ -110,14 +118,15 @@ def test_inline_assignment(self): @testutils.only_for_versions_higher("3.8") def test_inline_assignment_in_comprehensions(self): - scope = libutils.get_string_scope( - self.project, - """[ + code = dedent("""\ + [ (a_var := b_var + (f_var := g_var)) for b_var in [(j_var := i_var) for i_var in c_var] if a_var + (h_var := d_var) - ]""", - ) + ] + """) + scope = libutils.get_string_scope(self.project, code) + self.assertEqual( list(sorted(scope.get_scopes()[0].get_defined_names())), ["a_var", "b_var", "f_var"], @@ -128,14 +137,15 @@ def test_inline_assignment_in_comprehensions(self): ) def test_nested_comprehension(self): - scope = libutils.get_string_scope( - self.project, - """[ + code = dedent("""\ + [ b_var + d_var for b_var, c_var in [ e_var for e_var in f_var ] - ]\n""", - ) + ] + """) + scope = libutils.get_string_scope(self.project, code) + self.assertEqual( list(sorted(scope.get_scopes()[0].get_defined_names())), ["b_var", "c_var"], @@ -146,10 +156,13 @@ def test_nested_comprehension(self): ) def test_simple_class_scope(self): - scope = libutils.get_string_scope( - self.project, - "class SampleClass(object):\n" " def f(self):\n var = 10\n", - ) + code = dedent("""\ + class SampleClass(object): + def f(self): + var = 10 + """) + scope = libutils.get_string_scope(self.project, code) + self.assertEqual(1, len(scope.get_scopes())) sample_class_scope = scope.get_scopes()[0] self.assertTrue("f" in sample_class_scope) @@ -158,19 +171,27 @@ def test_simple_class_scope(self): self.assertTrue("var" in f_in_class) def test_get_lineno(self): - scope = libutils.get_string_scope( - self.project, "\ndef sample_func():\n a = 10\n" - ) + code = dedent("""\ + + def sample_func(): + a = 10 + """) + scope = libutils.get_string_scope(self.project, code) + self.assertEqual(1, len(scope.get_scopes())) sample_func_scope = scope.get_scopes()[0] self.assertEqual(1, scope.get_start()) self.assertEqual(2, sample_func_scope.get_start()) def test_scope_kind(self): - scope = libutils.get_string_scope( - self.project, - "class SampleClass(object):\n pass\n" "def sample_func():\n pass\n", - ) + code = dedent("""\ + class SampleClass(object): + pass + def sample_func(): + pass + """) + scope = libutils.get_string_scope(self.project, code) + sample_class_scope = scope.get_scopes()[0] sample_func_scope = scope.get_scopes()[1] self.assertEqual("Module", scope.get_kind()) @@ -178,23 +199,34 @@ def test_scope_kind(self): self.assertEqual("Function", sample_func_scope.get_kind()) def test_function_parameters_in_scope_names(self): - scope = libutils.get_string_scope( - self.project, "def sample_func(param):\n a = 10\n" - ) + code = dedent("""\ + def sample_func(param): + a = 10 + """) + scope = libutils.get_string_scope(self.project, code) + sample_func_scope = scope.get_scopes()[0] self.assertTrue("param" in sample_func_scope) def test_get_names_contains_only_names_defined_in_a_scope(self): - scope = libutils.get_string_scope( - self.project, "var1 = 10\ndef sample_func(param):\n var2 = 20\n" - ) + code = dedent("""\ + var1 = 10 + def sample_func(param): + var2 = 20 + """) + scope = libutils.get_string_scope(self.project, code) + sample_func_scope = scope.get_scopes()[0] self.assertTrue("var1" not in sample_func_scope) def test_scope_lookup(self): - scope = libutils.get_string_scope( - self.project, "var1 = 10\ndef sample_func(param):\n var2 = 20\n" - ) + code = dedent("""\ + var1 = 10 + def sample_func(param): + var2 = 20 + """) + scope = libutils.get_string_scope(self.project, code) + self.assertTrue(scope.lookup("var2") is None) self.assertEqual( get_base_type("Function"), @@ -204,84 +236,119 @@ def test_scope_lookup(self): self.assertTrue(sample_func_scope.lookup("var1") is not None) def test_function_scopes(self): - scope = libutils.get_string_scope(self.project, "def func():\n var = 10\n") + code = dedent("""\ + def func(): + var = 10 + """) + scope = libutils.get_string_scope(self.project, code) + func_scope = scope.get_scopes()[0] self.assertTrue("var" in func_scope) def test_function_scopes_classes(self): - scope = libutils.get_string_scope( - self.project, "def func():\n class Sample(object):\n pass\n" - ) + code = dedent("""\ + def func(): + class Sample(object): + pass + """) + scope = libutils.get_string_scope(self.project, code) + func_scope = scope.get_scopes()[0] self.assertTrue("Sample" in func_scope) def test_function_getting_scope(self): - mod = libutils.get_string_module(self.project, "def func(): var = 10\n") + code = dedent("""\ + def func(): var = 10 + """) + mod = libutils.get_string_module(self.project, code) + func_scope = mod["func"].get_object().get_scope() self.assertTrue("var" in func_scope) def test_scopes_in_function_scopes(self): - scope = libutils.get_string_scope( - self.project, "def func():\n def inner():\n var = 10\n" - ) + code = dedent("""\ + def func(): + def inner(): + var = 10 + """) + scope = libutils.get_string_scope(self.project, code) + func_scope = scope.get_scopes()[0] inner_scope = func_scope.get_scopes()[0] self.assertTrue("var" in inner_scope) def test_for_variables_in_scopes(self): - scope = libutils.get_string_scope( - self.project, "for a_var in range(10):\n pass\n" - ) + code = dedent("""\ + for a_var in range(10): + pass + """) + scope = libutils.get_string_scope(self.project, code) + self.assertTrue("a_var" in scope) def test_assists_inside_fors(self): - scope = libutils.get_string_scope( - self.project, "for i in range(10):\n a_var = i\n" - ) + code = dedent("""\ + for i in range(10): + a_var = i + """) + scope = libutils.get_string_scope(self.project, code) + self.assertTrue("a_var" in scope) def test_first_parameter_of_a_method(self): - code = "class AClass(object):\n" " def a_func(self, param):\n pass\n" + code = dedent("""\ + class AClass(object): + def a_func(self, param): + pass + """) a_class = libutils.get_string_module(self.project, code)["AClass"].get_object() function_scope = a_class["a_func"].get_object().get_scope() self.assertEqual(a_class, function_scope["self"].get_object().get_type()) self.assertNotEqual(a_class, function_scope["param"].get_object().get_type()) def test_first_parameter_of_static_methods(self): - code = ( - "class AClass(object):\n" - " @staticmethod\n def a_func(param):\n pass\n" - ) + code = dedent("""\ + class AClass(object): + @staticmethod + def a_func(param): + pass + """) a_class = libutils.get_string_module(self.project, code)["AClass"].get_object() function_scope = a_class["a_func"].get_object().get_scope() self.assertNotEqual(a_class, function_scope["param"].get_object().get_type()) def test_first_parameter_of_class_methods(self): - code = ( - "class AClass(object):\n" - " @classmethod\n def a_func(cls):\n pass\n" - ) + code = dedent("""\ + class AClass(object): + @classmethod + def a_func(cls): + pass + """) a_class = libutils.get_string_module(self.project, code)["AClass"].get_object() function_scope = a_class["a_func"].get_object().get_scope() self.assertEqual(a_class, function_scope["cls"].get_object()) def test_first_parameter_with_self_as_name_and_unknown_decorator(self): - code = ( - "def my_decorator(func):\n return func\n" - "class AClass(object):\n" - " @my_decorator\n def a_func(self):\n pass\n" - ) + code = dedent("""\ + def my_decorator(func): + return func + class AClass(object): + @my_decorator + def a_func(self): + pass + """) a_class = libutils.get_string_module(self.project, code)["AClass"].get_object() function_scope = a_class["a_func"].get_object().get_scope() self.assertEqual(a_class, function_scope["self"].get_object().get_type()) def test_inside_class_scope_attribute_lookup(self): - scope = libutils.get_string_scope( - self.project, - "class C(object):\n" - " an_attr = 1\n" - " def a_func(self):\n pass", - ) + code = dedent("""\ + class C(object): + an_attr = 1 + def a_func(self): + pass""") + scope = libutils.get_string_scope(self.project, code) + self.assertEqual(1, len(scope.get_scopes())) c_scope = scope.get_scopes()[0] self.assertTrue("an_attr" in c_scope.get_names()) @@ -290,43 +357,56 @@ def test_inside_class_scope_attribute_lookup(self): self.assertTrue(f_in_c.lookup("an_attr") is None) def test_inside_class_scope_attribute_lookup2(self): - scope = libutils.get_string_scope( - self.project, - "class C(object):\n" - " def __init__(self):\n self.an_attr = 1\n" - " def a_func(self):\n pass", - ) + code = dedent("""\ + class C(object): + def __init__(self): + self.an_attr = 1 + def a_func(self): + pass""") + scope = libutils.get_string_scope(self.project, code) + self.assertEqual(1, len(scope.get_scopes())) c_scope = scope.get_scopes()[0] f_in_c = c_scope.get_scopes()[0] self.assertTrue(f_in_c.lookup("an_attr") is None) def test_get_inner_scope_for_staticmethods(self): - scope = libutils.get_string_scope( - self.project, - "class C(object):\n" - " @staticmethod\n" - " def a_func(self):\n pass\n", - ) + code = dedent("""\ + class C(object): + @staticmethod + def a_func(self): + pass + """) + scope = libutils.get_string_scope(self.project, code) + c_scope = scope.get_scopes()[0] f_in_c = c_scope.get_scopes()[0] self.assertEqual(f_in_c, scope.get_inner_scope_for_line(4)) def test_get_scope_for_offset_for_comprehension(self): - scope = libutils.get_string_scope(self.project, "a = [i for i in range(10)]\n") + code = "a = [i for i in range(10)]\n" + scope = libutils.get_string_scope(self.project, code) + c_scope = scope.get_scopes()[0] self.assertEqual(c_scope, scope.get_inner_scope_for_offset(10)) self.assertEqual(scope, scope.get_inner_scope_for_offset(1)) def test_get_scope_for_offset_for_in_nested_comprehension(self): - scope = libutils.get_string_scope(self.project, "[i for i in [j for j in k]]\n") + code = "[i for i in [j for j in k]]\n" + scope = libutils.get_string_scope(self.project, code) + c_scope = scope.get_scopes()[0] self.assertEqual(c_scope, scope.get_inner_scope_for_offset(5)) inner_scope = c_scope.get_scopes()[0] self.assertEqual(inner_scope, scope.get_inner_scope_for_offset(15)) def test_get_scope_for_offset_for_scope_with_indent(self): - scope = libutils.get_string_scope(self.project, "def f(a):\n" " print(a)\n") + code = dedent("""\ + def f(a): + print(a) + """) + scope = libutils.get_string_scope(self.project, code) + inner_scope = scope.get_scopes()[0] self.assertEqual(inner_scope, scope.get_inner_scope_for_offset(10)) @@ -338,41 +418,59 @@ def test_get_scope_for_offset_for_function_scope_and_async_with_statement(self): async def func(): async with a_func() as var: print(var) - """) + """), ) inner_scope = scope.get_scopes()[0] self.assertEqual(inner_scope, scope.get_inner_scope_for_offset(27)) def test_getting_overwritten_scopes(self): - scope = libutils.get_string_scope( - self.project, "def f():\n pass\ndef f():\n pass\n" - ) + code = dedent("""\ + def f(): + pass + def f(): + pass + """) + scope = libutils.get_string_scope(self.project, code) + self.assertEqual(2, len(scope.get_scopes())) f1_scope = scope.get_scopes()[0] f2_scope = scope.get_scopes()[1] self.assertNotEqual(f1_scope, f2_scope) def test_assigning_builtin_names(self): - mod = libutils.get_string_module(self.project, "range = 1\n") + code = "range = 1\n" + mod = libutils.get_string_module(self.project, code) + range = mod.get_scope().lookup("range") self.assertEqual((mod, 1), range.get_definition_location()) def test_get_inner_scope_and_logical_lines(self): - scope = libutils.get_string_scope( - self.project, - "class C(object):\n" - ' def f():\n s = """\n1\n2\n"""\n a = 1\n', - ) + code = dedent('''\ + class C(object): + def f(): + s = """ + 1 + 2 + """ + a = 1 + ''') + scope = libutils.get_string_scope(self.project, code) + c_scope = scope.get_scopes()[0] f_in_c = c_scope.get_scopes()[0] self.assertEqual(f_in_c, scope.get_inner_scope_for_line(7)) def test_getting_defined_names_for_classes(self): - scope = libutils.get_string_scope( - self.project, - "class A(object):\n def a(self):\n pass\n" - "class B(A):\n def b(self):\n pass\n", - ) + code = dedent("""\ + class A(object): + def a(self): + pass + class B(A): + def b(self): + pass + """) + scope = libutils.get_string_scope(self.project, code) + a_scope = scope["A"].get_object().get_scope() # noqa b_scope = scope["B"].get_object().get_scope() self.assertTrue("a" in b_scope.get_names()) @@ -381,16 +479,21 @@ def test_getting_defined_names_for_classes(self): self.assertTrue("b" in b_scope.get_defined_names()) def test_getting_defined_names_for_modules(self): - scope = libutils.get_string_scope(self.project, "class A(object):\n pass\n") + code = dedent("""\ + class A(object): + pass + """) + scope = libutils.get_string_scope(self.project, code) + self.assertTrue("open" in scope.get_names()) self.assertTrue("A" in scope.get_names()) self.assertTrue("open" not in scope.get_defined_names()) self.assertTrue("A" in scope.get_defined_names()) def test_get_inner_scope_for_list_comprhension_with_many_targets(self): - scope = libutils.get_string_scope( - self.project, "a = [(i, j) for i,j in enumerate(range(10))]\n" - ) + code = "a = [(i, j) for i,j in enumerate(range(10))]\n" + scope = libutils.get_string_scope(self.project, code) + self.assertEqual(len(scope.get_scopes()), 1) self.assertNotIn("i", scope) self.assertNotIn("j", scope) @@ -398,29 +501,32 @@ def test_get_inner_scope_for_list_comprhension_with_many_targets(self): self.assertIn("j", scope.get_scopes()[0]) def test_get_inner_scope_for_generator(self): - scope = libutils.get_string_scope(self.project, "a = (i for i in range(10))\n") + code = "a = (i for i in range(10))\n" + scope = libutils.get_string_scope(self.project, code) + self.assertEqual(len(scope.get_scopes()), 1) self.assertNotIn("i", scope) self.assertIn("i", scope.get_scopes()[0]) def test_get_inner_scope_for_set_comprehension(self): - scope = libutils.get_string_scope(self.project, "a = {i for i in range(10)}\n") + code = "a = {i for i in range(10)}\n" + scope = libutils.get_string_scope(self.project, code) + self.assertEqual(len(scope.get_scopes()), 1) self.assertNotIn("i", scope) self.assertIn("i", scope.get_scopes()[0]) def test_get_inner_scope_for_dict_comprehension(self): - scope = libutils.get_string_scope( - self.project, "a = {i:i for i in range(10)}\n" - ) + code = "a = {i:i for i in range(10)}\n" + scope = libutils.get_string_scope(self.project, code) + self.assertEqual(len(scope.get_scopes()), 1) self.assertNotIn("i", scope) self.assertIn("i", scope.get_scopes()[0]) def test_get_inner_scope_for_nested_list_comprhension(self): - scope = libutils.get_string_scope( - self.project, "a = [[i + j for j in range(10)] for i in range(10)]\n" - ) + code = "a = [[i + j for j in range(10)] for i in range(10)]\n" + scope = libutils.get_string_scope(self.project, code) self.assertEqual(len(scope.get_scopes()), 1) self.assertNotIn("i", scope) diff --git a/ropetest/runmodtest.py b/ropetest/runmodtest.py index 5c66132a8..13031390d 100644 --- a/ropetest/runmodtest.py +++ b/ropetest/runmodtest.py @@ -1,4 +1,5 @@ import os +from textwrap import dedent try: import unittest2 as unittest @@ -52,9 +53,11 @@ def test_making_runner(self): def test_passing_arguments(self): file_path = "sample.py" - function_source = ( - "import sys\ndef get_text():" "\n return str(sys.argv[1:])\n" - ) + function_source = dedent("""\ + import sys + def get_text(): + return str(sys.argv[1:]) + """) self.make_sample_python_file(file_path, function_source) file_resource = self.project.get_resource(file_path) runner = self.pycore.run_module(file_resource, args=["hello", "world"]) @@ -65,9 +68,11 @@ def test_passing_arguments(self): def test_passing_arguments_with_spaces(self): file_path = "sample.py" - function_source = ( - "import sys\ndef get_text():" "\n return str(sys.argv[1:])\n" - ) + function_source = dedent("""\ + import sys + def get_text(): + return str(sys.argv[1:]) + """) self.make_sample_python_file(file_path, function_source) file_resource = self.project.get_resource(file_path) runner = self.pycore.run_module(file_resource, args=["hello world"]) @@ -78,12 +83,15 @@ def test_passing_arguments_with_spaces(self): def test_killing_runner(self): file_path = "sample.py" + code = dedent("""\ + def get_text(): + import time + time.sleep(1) + return 'run' + """) self.make_sample_python_file( file_path, - "def get_text():" - "\n import time" - "\n time.sleep(1)" - "\n return 'run'\n", + code, ) file_resource = self.project.get_resource(file_path) runner = self.pycore.run_module(file_resource) @@ -101,11 +109,12 @@ def test_running_nested_files(self): def test_setting_process_input(self): file_path = "sample.py" - self.make_sample_python_file( - file_path, - "def get_text():" + "\n import sys" - "\n return sys.stdin.readline()\n", - ) + code = dedent("""\ + def get_text(): + import sys + return sys.stdin.readline() + """) + self.make_sample_python_file(file_path, code) temp_file_name = "processtest.tmp" try: temp_file = open(temp_file_name, "w") @@ -122,10 +131,12 @@ def test_setting_process_input(self): def test_setting_process_output(self): file_path = "sample.py" - self.make_sample_python_file( - file_path, - "def get_text():" + "\n print('output text')" "\n return 'run'\n", - ) + code = dedent("""\ + def get_text(): + print('output text') + return 'run' + """) + self.make_sample_python_file(file_path, code) temp_file_name = "processtest.tmp" try: file_resource = self.project.get_resource(file_path) @@ -145,12 +156,13 @@ def test_setting_pythonpath(self): src.get_child("sample.py").write("def f():\n pass\n") self.project.root.create_folder("test") file_path = "test/test.py" - self.make_sample_python_file( - file_path, - "def get_text():\n" - " import sample" - "\n sample.f()\n return'run'\n", - ) + code = dedent("""\ + def get_text(): + import sample + sample.f() + return'run' + """) + self.make_sample_python_file(file_path, code) file_resource = self.project.get_resource(file_path) runner = self.pycore.run_module(file_resource) runner.wait_process() diff --git a/ropetest/type_hinting_test.py b/ropetest/type_hinting_test.py index 668a90c91..8b306c832 100644 --- a/ropetest/type_hinting_test.py +++ b/ropetest/type_hinting_test.py @@ -1,3 +1,5 @@ +from textwrap import dedent + try: import unittest2 as unittest except ImportError: @@ -45,42 +47,41 @@ def run(self, result=None): class DocstringParamHintingTest(AbstractHintingTest): def test_hint_param(self): - code = ( - "class Sample(object):\n" - " def a_method(self, a_arg):\n" - ' """:type a_arg: threading.Thread"""\n' - " a_arg.is_a" - ) + code = dedent('''\ + class Sample(object): + def a_method(self, a_arg): + """:type a_arg: threading.Thread""" + a_arg.is_a''') result = self._assist(code) self.assert_completion_in_result("is_alive", "attribute", result) def test_hierarchical_hint_param(self): - code = ( - "class ISample(object):\n" - " def a_method(self, a_arg):\n" - ' """:type a_arg: threading.Thread"""\n' - "\n\n" - "class Sample(ISample):\n" - " def a_method(self, a_arg):\n" - " a_arg.is_a" - ) + code = dedent('''\ + class ISample(object): + def a_method(self, a_arg): + """:type a_arg: threading.Thread""" + + + class Sample(ISample): + def a_method(self, a_arg): + a_arg.is_a''') result = self._assist(code) self.assert_completion_in_result("is_alive", "attribute", result) class DocstringReturnHintingTest(AbstractHintingTest): def test_hierarchical_hint_rtype(self): - code = ( - "class ISample(object):\n" - " def b_method(self):\n" - ' """:rtype: threading.Thread"""\n' - "\n\n" - "class Sample(ISample):\n" - " def b_method(self):\n" - " pass\n" - " def a_method(self):\n" - " self.b_method().is_a" - ) + code = dedent('''\ + class ISample(object): + def b_method(self): + """:rtype: threading.Thread""" + + + class Sample(ISample): + def b_method(self): + pass + def a_method(self): + self.b_method().is_a''') result = self._assist(code) self.assert_completion_in_result("is_alive", "attribute", result) @@ -396,18 +397,19 @@ def test_parser(self): class RegressionHintingTest(AbstractHintingTest): def test_hierarchical_hint_for_mutable_attr_type(self): """Test for #157, AttributeError: 'PyObject' object has no attribute 'get_doc'""" - code = ( - "class SuperClass(object):\n" - " def __init__(self):\n" - " self.foo = None\n" - "\n\n" - "class SubClass(SuperClass):\n" - " def __init__(self):\n" - " super(SubClass, self).__init__()\n" - " self.bar = 3\n" - "\n\n" - " def foo(self):\n" - " return self.bar" - ) + code = dedent("""\ + class SuperClass(object): + def __init__(self): + self.foo = None + + + class SubClass(SuperClass): + def __init__(self): + super(SubClass, self).__init__() + self.bar = 3 + + + def foo(self): + return self.bar""") result = self._assist(code) self.assert_completion_in_result("bar", "attribute", result)