Example of refactoring using rope library.

tools/telemetry/third_party/rope/ropetest/contrib/codeassisttest.py

+# coding: utf-8
+
+import os.path
+try:
+    import unittest2 as unittest
+except ImportError:
+    import unittest
+
+from rope.base import exceptions
+from rope.contrib.codeassist import (get_definition_location, get_doc,
+                                     starting_expression, code_assist,
+                                     sorted_proposals, starting_offset,
+                                     get_calltip, get_canonical_path)
+from ropetest import testutils
+
+try:
+    unicode
+except NameError:
+    unicode = str
+
+class CodeAssistTest(unittest.TestCase):
+
+    def setUp(self):
+        super(CodeAssistTest, self).setUp()
+        self.project = testutils.sample_project()
+
+    def tearDown(self):
+        testutils.remove_project(self.project)
+        super(CodeAssistTest, self).tearDown()
+
+    def _assist(self, code, offset=None, **args):
+        if offset is None:
+            offset = len(code)
+        return code_assist(self.project, code, offset, **args)
+
+    def test_simple_assist(self):
+        self._assist('', 0)
+
+    def assert_completion_in_result(self, name, scope, result, type=None):
+        for proposal in result:
+            if proposal.name == name:
+                self.assertEqual(scope, proposal.scope,
+                                 "proposal <%s> has wrong scope, expected "
+                                 "%r, got %r" % (name, scope, proposal.scope))
+                if type is not None:
+                    self.assertEqual(type, proposal.type,
+                                     "proposal <%s> has wrong type, expected "
+                                     "%r, got %r" %
+                                     (name, type, proposal.type))
+                return
+        self.fail('completion <%s> not proposed' % name)
+
+    def assert_completion_not_in_result(self, name, scope, result):
+        for proposal in result:
+            if proposal.name == name and proposal.scope == scope:
+                self.fail('completion <%s> was proposed' % name)
+
+    def test_completing_global_variables(self):
+        code = 'my_global = 10\nt = 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'
+        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_'
+        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_'
+        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_'
+        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'
+        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'
+        result = self._assist(code)
+        count = len([x for x in result
+                     if x.name == 'variable' and x.scope == 'global'])
+        self.assertEquals(1, count)
+
+    def test_throwing_exception_in_case_of_syntax_errors(self):
+        code = 'sample (sdf+)\n'
+        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'
+        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 = '
+        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_'
+        result = self._assist(code)
+        self.assert_completion_not_in_result('my_', 'global', result)
+
+    def test_completion_result(self):
+        code = 'my_global = 10\nt = my'
+        self.assertEquals(len(code) - 2, starting_offset(code, len(code)))
+
+    def test_completing_imported_names(self):
+        code = 'import sys\na = 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'
+        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'
+        result = self._assist(code)
+        self.assert_completion_not_in_result('sys', 'global', result)
+
+    def test_including_matching_builtins_types(self):
+        code = 'my_var = Excep'
+        result = self._assist(code)
+        self.assert_completion_in_result('Exception', 'builtin', result)
+        self.assert_completion_not_in_result('zip', 'builtin', result)
+
+    def test_including_matching_builtins_functions(self):
+        code = 'my_var = zi'
+        result = self._assist(code)
+        self.assert_completion_in_result('zip', 'builtin', result)
+
+    def test_builtin_instances(self):
+        # ``import_dynload_stdmods`` pref is disabled for test project.
+        # 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'
+        result = self._assist(code)
+        self.assert_completion_in_result('write', 'builtin', result)
+        self.assert_completion_in_result('writelines', 'builtin', result)
+
+    def test_including_keywords(self):
+        code = 'fo'
+        result = self._assist(code)
+        self.assert_completion_in_result('for', 'keyword', result)
+
+    def test_not_reporting_proposals_after_dot(self):
+        code = 'a_dict = {}\nkey = 3\na_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_'
+        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_'
+        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_'
+        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'
+        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"
+        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_"
+        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"
+        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"
+        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'
+        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'
+        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'
+        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_'
+        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_'
+        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_"
+        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_"
+        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_"
+        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_"
+        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_"
+        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"
+        result = self._assist(code, 18)
+        self.assert_completion_in_result('my_var', 'global', result)
+
+    def test_ignoring_string_contents(self):
+        code = "my_var = '('\nmy_"
+        result = self._assist(code)
+        self.assert_completion_in_result('my_var', 'global', result)
+
+    def test_ignoring_comment_contents(self):
+        code = "my_var = 10 #(\nmy_"
+        result = self._assist(code)
+        self.assert_completion_in_result('my_var', 'global', result)
+
+    def test_ignoring_string_contents_backslash_plus_quotes(self):
+        code = "my_var = '\\''\nmy_"
+        result = self._assist(code)
+        self.assert_completion_in_result('my_var', 'global', result)
+
+    def test_ignoring_string_contents_backslash_plus_backslash(self):
+        code = "my_var = '\\\\'\nmy_"
+        result = self._assist(code)
+        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"
+        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"
+        result = self._assist(code, 16, later_locals=False)
+        self.assert_completion_not_in_result('my_var', 'local', result)
+
+    def test_ignoring_string_contents_with_triple_quotes(self):
+        code = "my_var = '''(\n'('''\nmy_"
+        result = self._assist(code)
+        self.assert_completion_in_result('my_var', 'global', result)
+
+    def test_ignoring_string_contents_with_triple_quotes_and_backslash(self):
+        code = 'my_var = """\\"""("""\nmy_'
+        result = self._assist(code)
+        self.assert_completion_in_result('my_var', 'global', result)
+
+    def test_ignor_str_contents_with_triple_quotes_and_double_backslash(self):
+        code = 'my_var = """\\\\"""\nmy_'
+        result = self._assist(code)
+        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'
+        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'
+        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'
+        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()'
+        result = get_definition_location(self.project, code, len(code) - 3)
+        self.assertEquals((None, 1), result)
+
+    def test_get_definition_location_underlined_names(self):
+        code = 'def a_sample_func():\n    pass\na_sample_func()'
+        result = get_definition_location(self.project, code, len(code) - 11)
+        self.assertEquals((None, 1), result)
+
+    def test_get_definition_location_dotted_names(self):
+        code = 'class AClass(object):\n' \
+               '    @staticmethod\n' \
+               '    def a_method():\n' \
+               '        pass\n' \
+               'AClass.a_method()'
+        result = get_definition_location(self.project, code, len(code) - 3)
+        self.assertEquals((None, 2), result)
+
+    def test_get_definition_location_dotted_module_names(self):
+        module_resource = testutils.create_module(self.project, 'mod')
+        module_resource.write('def a_func():\n    pass\n')
+        code = 'import mod\nmod.a_func()'
+        result = get_definition_location(self.project, code, len(code) - 3)
+        self.assertEquals((module_resource, 1), result)
+
+    def test_get_definition_location_for_nested_packages(self):
+        mod1 = testutils.create_module(self.project, 'mod1')
+        pkg1 = testutils.create_package(self.project, 'pkg1')
+        pkg2 = testutils.create_package(self.project, 'pkg2', pkg1)
+        mod1.write('import pkg1.pkg2.mod2')
+
+        init_dot_py = pkg2.get_child('__init__.py')
+        found_pyname = get_definition_location(self.project, mod1.read(),
+                                               mod1.read().index('pkg2') + 1)
+        self.assertEquals(init_dot_py, found_pyname[0])
+
+    def test_get_definition_location_unknown(self):
+        code = 'a_func()\n'
+        result = get_definition_location(self.project, code, len(code) - 3)
+        self.assertEquals((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()'
+        result = get_definition_location(self.project, code, len(code) - 3)
+        self.assertEquals((None, 2), 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)'
+        result = get_definition_location(self.project, code,
+                                         code.rindex('a_method') + 1)
+        self.assertEquals((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'
+        result = get_definition_location(self.project, code, len(code) - 3)
+        self.assertEquals((None, 3), result)
+
+    def test_code_assists_in_parens(self):
+        code = 'def a_func(a_var):\n    pass\na_var = 10\na_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_'
+        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_'
+        proposals = sorted_proposals(self._assist(code))
+        self.assertEquals('my_sample_var', proposals[0].name)
+        self.assertEquals('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_'
+        proposals = sorted_proposals(self._assist(code))
+        self.assertEquals('my_b_func', proposals[0].name)
+        self.assertEquals('my_c_func', proposals[1].name)
+        self.assertEquals('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_'
+        proposals = sorted_proposals(self._assist(code))
+        self.assertEquals('my_b_func', proposals[0].name)
+        self.assertEquals('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.'
+        proposals = sorted_proposals(self._assist(code))
+        self.assertEquals('my_func', proposals[0].name)
+        self.assertEquals('_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_'
+        result = self._assist(code)
+        proposals = sorted_proposals(result, scopepref=['global', 'local'])
+        self.assertEquals('my_global_var', proposals[0].name)
+        self.assertEquals('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_'
+        result = self._assist(code)
+        proposals = sorted_proposals(result, typepref=['instance', 'function'])
+        self.assertEquals('my_global_var', proposals[0].name)
+        self.assertEquals('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_'
+        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"юникод-объект"'
+        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  "байтстринг"'
+        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()'
+        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'
+        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'
+        get_doc(self.project, src, src.index('AClass') + 1).index('AClass')
+
+    def test_get_pydoc_for_modules(self):
+        mod = testutils.create_module(self.project, 'mod')
+        mod.write('"""a module"""\n')
+        src = 'import mod\nmod'
+        self.assertEquals('a module', get_doc(self.project, src, len(src) - 1))
+
+    def test_get_pydoc_for_builtins(self):
+        src = 'print(object)\n'
+        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'
+        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'
+        doc = get_doc(self.project, src, src.rindex('a_method') + 1)
+        doc.index('A.a_method')
+        doc.index('hey1')
+        doc.index('B.a_method')
+        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'
+        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'
+        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'
+        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'
+        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_'
+        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_'
+        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_'
+        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'
+        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'
+        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'
+        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_'
+        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_'
+        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'
+        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'
+        result = self._assist(code, code.index('.'), maxfixes=1)  # noqa
+
+    def test_nested_blocks(self):
+        code = 'a_var = 10\ntry:\n    try:\n        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'
+        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'
+        result = self._assist(code)  # noqa
+
+    def test_proposing_function_keywords_when_calling_extra_spaces(self):
+        code = 'def f(p):\n    pass\nf( 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'
+        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'
+        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('
+        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('
+        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'
+        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'
+        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'
+        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'
+        doc = get_calltip(self.project, src, src.rindex('f'))
+        self.assertEquals('f()', doc)
+
+    def test_get_calltips_for_classes(self):
+        src = 'class C(object):\n' \
+              '    def __init__(self):\n        pass\nC('
+        doc = get_calltip(self.project, src, len(src) - 1)
+        self.assertEquals('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,'
+        doc = get_calltip(self.project, src, src.rindex('c'))
+        self.assertEquals('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,'
+        mod = testutils.create_module(self.project, 'mod')
+        mod.write(src)
+        doc = get_calltip(self.project, src, src.rindex('c'), mod)
+        self.assertEquals('mod.C.__call__(self, p)', doc)
+
+    def test_get_calltips_and_including_module_name_2(self):
+        src = 'range()\n'
+        doc = get_calltip(self.project, src, 1, ignore_unknown=True)
+        self.assertTrue(doc is None)
+
+    def test_removing_self_parameter(self):
+        src = 'class C(object):\n' \
+              '    def f(self):\n'\
+              '        pass\n' \
+              'C().f()'
+        doc = get_calltip(self.project, src, src.rindex('f'), remove_self=True)
+        self.assertEquals('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()'
+        doc = get_calltip(self.project, src, src.rindex('f'), remove_self=True)
+        self.assertEquals('C.f(p1)', doc)
+
+    def test_lambda_calltip(self):
+        src = 'foo = lambda x, y=1: None\n' \
+              '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'
+        result = self._assist(code, offset=len('if (1).'))
+        self.assertTrue(result)
+
+    # TESTING PROPOSAL'S KINDS AND TYPES.
+    # SEE RELATION MATRIX IN `CompletionProposal`'s DOCSTRING
+
+    def test_local_variable_completion_proposal(self):
+        code = 'def foo():\n  xvar = 5\n  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'
+        result = self._assist(code)
+        self.assert_completion_in_result('yvar', 'global', result, 'instance')
+
+    def test_builtin_variable_completion_proposal(self):
+        for varname in ('False', 'True'):
+            result = self._assist(varname[0])
+            self.assert_completion_in_result(varname, 'builtin', result,
+                                             type='instance')
+
+    def test_attribute_variable_completion_proposal(self):
+        code = 'class AClass(object):\n  def foo(self):\n    ' \
+               'self.bar = 1\n    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'
+        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'
+        result = self._assist(code)
+        self.assert_completion_in_result('GlobalClass', 'global', result,
+                                         type='class')
+
+    def test_builtin_class_completion_proposal(self):
+        for varname in ('object', 'dict', 'file'):
+            result = self._assist(varname[0])
+            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.'
+        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'
+        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'
+        result = self._assist(code)
+        self.assert_completion_in_result('foo', 'global', result,
+                                         type='function')
+
+    def test_builtin_function_completion_proposal(self):
+        code = 'a'
+        result = self._assist(code)
+        for expected in ('all', 'any', 'abs'):
+            self.assert_completion_in_result(expected, 'builtin', result,
+                                             type='function')
+
+    def test_attribute_function_completion_proposal(self):
+        code = 'class Some(object):\n  def method(self):\n    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'
+        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'
+        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'
+        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'
+        result = self._assist(code)
+        self.assert_completion_in_result('ZeroDivisionError', 'builtin',
+                                         result, type='class')
+
+    def test_keyword_completion_proposal(self):
+        code = 'f'
+        result = self._assist(code)
+        self.assert_completion_in_result('for', 'keyword', result, type=None)
+        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'
+        result = self._assist(code)
+        for expected in ('abc=', 'aloha=', 'alpha=', 'amigo='):
+            self.assert_completion_in_result(expected, 'parameter_keyword',
+                                             result, type=None)
+
+    def test_object_path_global(self):
+        code = 'GLOBAL_VARIABLE = 42\n'
+        resource = testutils.create_module(self.project, 'mod')
+        resource.write(code)
+        result = get_canonical_path(self.project, resource, 1)
+        mod_path = os.path.join(self.project.address, 'mod.py')
+        self.assertEquals(
+            result, [(mod_path, 'MODULE'),
+                     ('GLOBAL_VARIABLE', 'VARIABLE')])
+
+    def test_object_path_attribute(self):
+        code = 'class Foo(object):\n' \
+               '    attr = 42\n'
+        resource = testutils.create_module(self.project, 'mod')
+        resource.write(code)
+        result = get_canonical_path(self.project, resource, 24)
+        mod_path = os.path.join(self.project.address, 'mod.py')
+        self.assertEquals(
+            result, [(mod_path, 'MODULE'), ('Foo', 'CLASS'),
+                     ('attr', 'VARIABLE')])
+
+    def test_object_path_subclass(self):
+        code = 'class Foo(object):\n' \
+               '    class Bar(object):\n' \
+               '        pass\n'
+        resource = testutils.create_module(self.project, 'mod')
+        resource.write(code)
+        result = get_canonical_path(self.project, resource, 30)
+        mod_path = os.path.join(self.project.address, 'mod.py')
+        self.assertEquals(
+            result, [(mod_path, 'MODULE'), ('Foo', 'CLASS'),
+                     ('Bar', 'CLASS')])
+
+    def test_object_path_method_parameter(self):
+        code = 'class Foo(object):\n' \
+               '    def bar(self, a, b, c):\n' \
+               '        pass\n'
+        resource = testutils.create_module(self.project, 'mod')
+        resource.write(code)
+        result = get_canonical_path(self.project, resource, 41)
+        mod_path = os.path.join(self.project.address, 'mod.py')
+        self.assertEquals(
+            result, [(mod_path, 'MODULE'), ('Foo', 'CLASS'),
+                     ('bar', 'FUNCTION'), ('b', 'PARAMETER')])
+
+    def test_object_path_variable(self):
+        code = 'def bar(a):\n' \
+               '    x = a + 42\n'
+        resource = testutils.create_module(self.project, 'mod')
+        resource.write(code)
+        result = get_canonical_path(self.project, resource, 17)
+        mod_path = os.path.join(self.project.address, 'mod.py')
+        self.assertEquals(
+            result, [(mod_path, 'MODULE'), ('bar', 'FUNCTION'),
+                     ('x', 'VARIABLE')])
+
+
+class CodeAssistInProjectsTest(unittest.TestCase):
+    def setUp(self):
+        super(CodeAssistInProjectsTest, self).setUp()
+        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'
+        samplemod.write(code)
+        package = testutils.create_package(self.project, 'package')
+        nestedmod = testutils.create_module(self.project,  # noqa
+                                            'nestedmod', package)
+
+    def tearDown(self):
+        testutils.remove_project(self.project)
+        super(self.__class__, self).tearDown()
+
+    def _assist(self, code, resource=None, **kwds):
+        return code_assist(self.project, code, len(code), resource, **kwds)
+
+    def assert_completion_in_result(self, name, scope, result):
+        for proposal in result:
+            if proposal.name == name and proposal.scope == scope:
+                return
+        self.fail('completion <%s> not proposed' % name)
+
+    def assert_completion_not_in_result(self, name, scope, result):
+        for proposal in result:
+            if proposal.name == name and proposal.scope == scope:
+                self.fail('completion <%s> was proposed' % name)
+
+    def test_simple_import(self):
+        code = 'import samplemod\nsample'
+        result = self._assist(code)
+        self.assert_completion_in_result('samplemod', 'imported', result)
+
+    def test_from_import_class(self):
+        code = 'from samplemod import SampleClass\nSample'
+        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'
+        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'
+        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'
+        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'
+        result = self._assist(code)
+        self.assert_completion_not_in_result('SampleClass', 'global', result)
+
+    def test_from_import_star(self):
+        code = 'from samplemod import *\nSample'
+        result = self._assist(code)
+        self.assert_completion_in_result('SampleClass', 'imported', result)
+
+    def test_from_import_star2(self):
+        code = 'from samplemod import *\nsample'
+        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'
+        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'
+        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'
+        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'
+        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'
+        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'
+        self.assertEquals(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'
+        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.'
+        result = self._assist(code)
+        self.assert_completion_not_in_result('Sample', 'global', result)
+
+    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.'
+        result = self._assist(code, resource=mod2)
+        self.assert_completion_in_result('a_func', 'imported', result)
+
+    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'
+        result = get_definition_location(self.project, code,
+                                         len(code) - 2, mod2)
+        self.assertEquals((mod1, 1), result)
+
+    def test_get_definition_location_for_builtins(self):
+        code = 'import sys\n'
+        result = get_definition_location(self.project, code,
+                                         len(code) - 2)
+        self.assertEquals((None, None), result)
+
+    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'
+        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')
+        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'
+        mod.write(code)
+        result = self._assist(code, maxfixes=2, resource=mod)
+        self.assertTrue(len(result) > 0)
+
+    def test_completing_names_after_from_import(self):
+        mod1 = testutils.create_module(self.project, 'mod1')
+        mod2 = testutils.create_module(self.project, 'mod2')
+        mod1.write('myvar = None\n')
+        result = self._assist('from mod1 import myva', resource=mod2)
+        self.assertTrue(len(result) > 0)
+        self.assert_completion_in_result('myvar', 'global', result)
+
+    def test_completing_names_after_from_import_and_sorted_proposals(self):
+        mod1 = testutils.create_module(self.project, 'mod1')
+        mod2 = testutils.create_module(self.project, 'mod2')
+        mod1.write('myvar = None\n')
+        result = self._assist('from mod1 import myva', resource=mod2)
+        result = sorted_proposals(result)
+        self.assertTrue(len(result) > 0)
+        self.assert_completion_in_result('myvar', 'global', result)
+
+    def test_completing_names_after_from_import2(self):
+        mod1 = testutils.create_module(self.project, 'mod1')
+        mod2 = testutils.create_module(self.project, 'mod2')
+        mod1.write('myvar = None\n')
+        result = self._assist('from mod1 import ', resource=mod2)
+        self.assertTrue(len(result) > 0)
+        self.assert_completion_in_result('myvar', 'global', result)
+
+    def test_starting_expression(self):
+        code = 'l = list()\nl.app'
+        self.assertEquals('l.app', starting_expression(code, len(code)))
+
+
+def suite():
+    result = unittest.TestSuite()
+    result.addTests(unittest.makeSuite(CodeAssistTest))
+    result.addTests(unittest.makeSuite(CodeAssistInProjectsTest))
+    return result
+
+if __name__ == '__main__':
+    unittest.main()