|
|
# coding: utf-8
"""Support classes and functions for the elpy test code.
Elpy uses a bit of a peculiar test setup to avoid redundancy. For thetests of the two backends, we provide generic test cases for generictests and for specific callback tests.
These mixins can be included in the actual test classes. We can't addthese tests to a BackendTestCase subclass directly because the testdiscovery would find them there and try to run them, which would fail.
"""
import osimport shutilimport sysimport tempfileimport unittestimport re
from elpy.tests import compatfrom elpy.rpc import Faultfrom elpy import jedibackend
class BackendTestCase(unittest.TestCase): """Base class for backend tests.
This class sets up a project root directory and provides an easy way to create files within the project root.
"""
def setUp(self): """Create the project root and make sure it gets cleaned up.""" super(BackendTestCase, self).setUp() self.project_root = tempfile.mkdtemp(prefix="elpy-test") self.addCleanup(shutil.rmtree, self.project_root, True)
def project_file(self, relname, contents): """Create a file named relname within the project root.
Write contents into that file.
"""
full_name = os.path.join(self.project_root, relname) try: os.makedirs(os.path.dirname(full_name)) except OSError: pass if compat.PYTHON3: fobj = open(full_name, "w", encoding="utf-8") else: fobj = open(full_name, "w") with fobj as f: f.write(contents) return full_name
class GenericRPCTests(object): """Generic RPC test methods.
This is a mixin to add tests that should be run for all RPC methods that follow the generic (filename, source, offset) calling conventions.
"""
METHOD = None
def rpc(self, filename, source, offset): method = getattr(self.backend, self.METHOD) return method(filename, source, offset)
def test_should_not_fail_on_inexisting_file(self): filename = self.project_root + "/doesnotexist.py" self.rpc(filename, "", 0)
def test_should_not_fail_on_empty_file(self): filename = self.project_file("test.py", "") self.rpc(filename, "", 0)
def test_should_not_fail_if_file_is_none(self): self.rpc(None, "", 0)
def test_should_not_fail_for_module_syntax_errors(self): source, offset = source_and_offset( "class Foo(object):\n" " def bar(self):\n" " foo(_|_" " bar(" "\n" " def a(self):\n" " pass\n" "\n" " def b(self):\n" " pass\n" "\n" " def b(self):\n" " pass\n" "\n" " def b(self):\n" " pass\n" "\n" " def b(self):\n" " pass\n" "\n" " def b(self):\n" " pass\n" ) filename = self.project_file("test.py", source)
self.rpc(filename, source, offset)
def test_should_not_fail_for_bad_indentation(self): source, offset = source_and_offset( "def foo():\n" " print(23)_|_\n" " print(17)\n") filename = self.project_file("test.py", source)
self.rpc(filename, source, offset)
# @unittest.skipIf((3, 3) <= sys.version_info < (3, 4), # "Bug in jedi for Python 3.3") def test_should_not_fail_for_relative_import(self): source, offset = source_and_offset( "from .. import foo_|_" ) filename = self.project_file("test.py", source)
self.rpc(filename, source, offset)
def test_should_not_fail_on_keyword(self): source, offset = source_and_offset( "_|_try:\n" " pass\n" "except:\n" " pass\n") filename = self.project_file("test.py", source)
self.rpc(filename, source, offset)
def test_should_not_fail_with_bad_encoding(self): source, offset = source_and_offset( u'# coding: utf-8X_|_\n' ) filename = self.project_file("test.py", source)
self.rpc(filename, source, offset)
def test_should_not_fail_with_form_feed_characters(self): # Bug in Jedi: jedi#424 source, offset = source_and_offset( "\f\n" "class Test(object):_|_\n" " pass" ) filename = self.project_file("test.py", source)
self.rpc(filename, source, offset)
def test_should_not_fail_for_dictionaries_in_weird_places(self): # Bug in Jedi: jedi#417 source, offset = source_and_offset( "import json\n" "\n" "def foo():\n" " json.loads(_|_\n" "\n" " json.load.return_value = {'foo': [],\n" " 'bar': True}\n" "\n" " c = Foo()\n" ) filename = self.project_file("test.py", source)
self.rpc(filename, source, offset)
def test_should_not_break_with_binary_characters_in_docstring(self): # Bug in Jedi: jedi#427 template = '''\
class Foo(object): def __init__(self): """
COMMUNITY instance that this conversion belongs to. DISPERSY_VERSION is the dispersy conversion identifier (on the wire version; must be one byte). COMMUNIY_VERSION is the community conversion identifier (on the wire version; must be one byte).
COMMUNIY_VERSION may not be '\\x00' or '\\xff'. '\\x00' is used by the DefaultConversion until a proper conversion instance can be made for the Community. '\\xff' is reserved for when more than one byte is needed as a version indicator. """
pass
x = Foo()x._|_'''
source, offset = source_and_offset(template) filename = self.project_file("test.py", source)
self.rpc(filename, source, offset)
def test_should_not_fail_for_def_without_name(self): # Bug jedi#429 source, offset = source_and_offset( "def_|_():\n" " if True:\n" " return True\n" " else:\n" " return False\n" ) filename = self.project_file("project.py", source)
self.rpc(filename, source, offset)
def test_should_not_fail_on_lambda(self): # Bug #272 / jedi#431, jedi#572 source, offset = source_and_offset( "map(lambda_|_" ) filename = self.project_file("project.py", source)
self.rpc(filename, source, offset)
def test_should_not_fail_on_literals(self): # Bug #314, #344 / jedi#466 source = u'lit = u"""\\\n# -*- coding: utf-8 -*-\n"""\n' offset = 0 filename = self.project_file("project.py", source)
self.rpc(filename, source, offset)
def test_should_not_fail_with_args_as_args(self): # Bug #347 in rope_py3k source, offset = source_and_offset( "def my_function(*args):\n" " ret_|_" ) filename = self.project_file("project.py", source)
self.rpc(filename, source, offset)
def test_should_not_fail_for_unicode_chars_in_string(self): # Bug #358 / jedi#482 source = '''\
# coding: utf-8
logging.info(u"Saving «{}»...".format(title))requests.get(u"https://web.archive.org/save/{}".format(url))'''
offset = 57 filename = self.project_file("project.py", source)
self.rpc(filename, source, offset)
def test_should_not_fail_for_bad_escape_sequence(self): # Bug #360 / jedi#485 source = r"v = '\x'" offset = 8 filename = self.project_file("project.py", source)
self.rpc(filename, source, offset)
def test_should_not_fail_for_coding_declarations_in_strings(self): # Bug #314 / jedi#465 / python#22221 source = u'lit = """\\\n# -*- coding: utf-8 -*-\n"""' offset = 8 filename = self.project_file("project.py", source)
self.rpc(filename, source, offset)
def test_should_not_fail_if_root_vanishes(self): # Bug #353 source, offset = source_and_offset( "import foo\n" "foo._|_" ) filename = self.project_file("project.py", source) shutil.rmtree(self.project_root)
self.rpc(filename, source, offset)
# For some reason, this breaks a lot of other tests. Couldn't # figure out why. # # def test_should_not_fail_for_sys_path(self): # # Bug #365 / jedi#486 # source, offset = source_and_offset( # "import sys\n" # "\n" # "sys.path.index(_|_\n" # ) # filename = self.project_file("project.py", source) # # self.rpc(filename, source, offset)
def test_should_not_fail_for_key_error(self): # Bug #561, #564, #570, #588, #593, #599 / jedi#572, jedi#579, # jedi#590 source, offset = source_and_offset( "map(lambda_|_" ) filename = self.project_file("project.py", source)
self.rpc(filename, source, offset)
def test_should_not_fail_for_badly_defined_global_variable(self): # Bug #519 / jedi#610 source, offset = source_and_offset( """\
def funct1(): global global_dict_var global_dict_var = dict()
def funct2(): global global_dict_var q = global_dict_var.copy_|_() print(q)""")
filename = self.project_file("project.py", source)
self.rpc(filename, source, offset)
def test_should_not_fail_with_mergednamesdict(self): # Bug #563 / jedi#589 source, offset = source_and_offset( u'from email import message_|_' ) filename = self.project_file("project.py", source)
self.rpc(filename, source, offset)
class RPCGetCompletionsTests(GenericRPCTests): METHOD = "rpc_get_completions"
def test_should_complete_builtin(self): source, offset = source_and_offset("o_|_")
expected = self.BUILTINS actual = [cand['name'] for cand in self.backend.rpc_get_completions("test.py", source, offset)]
for candidate in expected: self.assertIn(candidate, actual)
if sys.version_info >= (3, 5) or sys.version_info < (3, 0): JSON_COMPLETIONS = ["SONDecoder", "SONEncoder", "SONDecodeError"] else: JSON_COMPLETIONS = ["SONDecoder", "SONEncoder"]
def test_should_complete_imports(self): source, offset = source_and_offset("import json\n" "json.J_|_") filename = self.project_file("test.py", source) completions = self.backend.rpc_get_completions(filename, source, offset) self.assertEqual( sorted([cand['suffix'] for cand in completions]), sorted(self.JSON_COMPLETIONS))
def test_should_complete_top_level_modules_for_import(self): source, offset = source_and_offset("import multi_|_") filename = self.project_file("test.py", source) completions = self.backend.rpc_get_completions(filename, source, offset) if compat.PYTHON3: expected = ["processing"] else: expected = ["file", "processing"] self.assertEqual(sorted([cand['suffix'] for cand in completions]), sorted(expected))
def test_should_complete_packages_for_import(self): source, offset = source_and_offset("import email.mi_|_") filename = self.project_file("test.py", source) completions = self.backend.rpc_get_completions(filename, source, offset) if sys.version_info < (3, 0): compl = [u'me', u'METext'] else: compl = ['me'] self.assertEqual([cand['suffix'] for cand in completions], compl)
def test_should_not_complete_for_import(self): source, offset = source_and_offset("import foo.Conf_|_") filename = self.project_file("test.py", source) completions = self.backend.rpc_get_completions(filename, source, offset) self.assertEqual([cand['suffix'] for cand in completions], [])
# @unittest.skipIf((3, 3) <= sys.version_info < (3, 4), # "Bug in jedi for Python 3.3") def test_should_not_fail_for_short_module(self): source, offset = source_and_offset("from .. import foo_|_") filename = self.project_file("test.py", source) completions = self.backend.rpc_get_completions(filename, source, offset) self.assertIsNotNone(completions)
def test_should_complete_sys(self): source, offset = source_and_offset("import sys\nsys._|_") filename = self.project_file("test.py", source) completions = self.backend.rpc_get_completions(filename, source, offset) self.assertIn('path', [cand['suffix'] for cand in completions])
def test_should_find_with_trailing_text(self): source, offset = source_and_offset( "import threading\nthreading.T_|_mumble mumble")
expected = ["Thread", "ThreadError", "Timer"] actual = [cand['name'] for cand in self.backend.rpc_get_completions("test.py", source, offset)]
for candidate in expected: self.assertIn(candidate, actual)
def test_should_find_completion_different_package(self): # See issue #74 self.project_file("project/__init__.py", "") source1 = ("class Add:\n" " def add(self, a, b):\n" " return a + b\n") self.project_file("project/add.py", source1) source2, offset = source_and_offset( "from project.add import Add\n" "class Calculator:\n" " def add(self, a, b):\n" " c = Add()\n" " c.ad_|_\n") file2 = self.project_file("project/calculator.py", source2) proposals = self.backend.rpc_get_completions(file2, source2, offset) self.assertEqual(["add"], [proposal["name"] for proposal in proposals])
def test_should_return_nothing_when_no_completion(self): source, offset = source_and_offset("nothingcancompletethis_|_") self.assertEqual([], self.backend.rpc_get_completions("test.py", source, offset))
def test_should_handle_jedi16(self): backup = self.backend.rpc_get_completions self.backend.rpc_get_completions = self.backend.rpc_get_completions_jedi16 self.test_should_complete_builtin() self.backend.rpc_get_completions = backup
class RPCGetCompletionDocstringTests(object): def test_should_return_docstring(self): source, offset = source_and_offset("import json\n" "json.JSONEnc_|_") filename = self.project_file("test.py", source) completions = self.backend.rpc_get_completions(filename, source, offset) completions.sort(key=lambda p: p["name"]) prop = completions[0] self.assertEqual(prop["name"], "JSONEncoder")
docs = self.backend.rpc_get_completion_docstring("JSONEncoder")
self.assertIn("Extensible JSON", docs)
def test_should_return_none_if_unknown(self): docs = self.backend.rpc_get_completion_docstring("Foo")
self.assertIsNone(docs)
def test_should_return_none_if_on_a_builtin(self): source, offset = source_and_offset("a = 12\n" "print(12_|_)") filename = self.project_file("test.py", source) completions = self.backend.rpc_get_docstring(filename, source, offset) self.assertIsNone(completions)
def test_should_handle_jedi16(self): backup = self.backend.rpc_get_docstring self.backend.rpc_get_docstring = self.backend.rpc_get_docstring_jedi16 self.test_should_return_docstring() self.backend.rpc_get_docstring = backup
class RPCGetCompletionLocationTests(object): def test_should_return_location(self): source, offset = source_and_offset("donaudampfschiff = 1\n" "donau_|_") filename = self.project_file("test.py", source) completions = self.backend.rpc_get_completions(filename, source, offset) prop = completions[0] self.assertEqual(prop["name"], "donaudampfschiff")
loc = self.backend.rpc_get_completion_location("donaudampfschiff")
self.assertEqual((filename, 1), loc)
def test_should_return_none_if_unknown(self): docs = self.backend.rpc_get_completion_location("Foo")
self.assertIsNone(docs)
class RPCGetDefinitionTests(GenericRPCTests): METHOD = "rpc_get_definition"
def test_should_return_definition_location_same_file(self): source, offset = source_and_offset("import threading\n" "def test_function(a, b):\n" " return a + b\n" "\n" "test_func_|_tion(\n") filename = self.project_file("test.py", source)
location = self.backend.rpc_get_definition(filename, source, offset)
self.assertEqual(location[0], filename) # On def or on the function name self.assertIn(location[1], (17, 21))
def test_should_return_location_in_same_file_if_not_saved(self): source, offset = source_and_offset( "import threading\n" "\n" "\n" "def other_function():\n" " test_f_|_unction(1, 2)\n" "\n" "\n" "def test_function(a, b):\n" " return a + b\n") filename = self.project_file("test.py", "")
location = self.backend.rpc_get_definition(filename, source, offset)
self.assertEqual(location[0], filename) # def or function name self.assertIn(location[1], (67, 71))
def test_should_return_location_in_different_file(self): source1 = ("def test_function(a, b):\n" " return a + b\n") file1 = self.project_file("test1.py", source1) source2, offset = source_and_offset("from test1 import test_function\n" "test_funct_|_ion(1, 2)\n") file2 = self.project_file("test2.py", source2)
definition = self.backend.rpc_get_definition(file2, source2, offset)
self.assertEqual(definition[0], file1) # Either on the def or on the function name self.assertIn(definition[1], (0, 4))
def test_should_return_none_if_location_not_found(self): source, offset = source_and_offset("test_f_|_unction()\n") filename = self.project_file("test.py", source)
definition = self.backend.rpc_get_definition(filename, source, offset)
self.assertIsNone(definition)
def test_should_return_none_if_outside_of_symbol(self): source, offset = source_and_offset("test_function(_|_)\n") filename = self.project_file("test.py", source)
definition = self.backend.rpc_get_definition(filename, source, offset)
self.assertIsNone(definition)
def test_should_return_definition_location_different_package(self): # See issue #74 self.project_file("project/__init__.py", "") source1 = ("class Add:\n" " def add(self, a, b):\n" " return a + b\n") file1 = self.project_file("project/add.py", source1) source2, offset = source_and_offset( "from project.add import Add\n" "class Calculator:\n" " def add(self, a, b):\n" " return Add_|_().add(a, b)\n") file2 = self.project_file("project/calculator.py", source2)
location = self.backend.rpc_get_definition(file2, source2, offset)
self.assertEqual(location[0], file1) # class or class name self.assertIn(location[1], (0, 6))
def test_should_find_variable_definition(self): source, offset = source_and_offset("SOME_VALUE = 1\n" "\n" "variable = _|_SOME_VALUE\n") filename = self.project_file("test.py", source) self.assertEqual(self.backend.rpc_get_definition(filename, source, offset), (filename, 0))
def test_should_handle_jedi16(self): backup = self.backend.rpc_get_definition self.backend.rpc_get_definition = self.backend.rpc_get_definition_jedi16 self.test_should_return_definition_location_same_file() self.backend.rpc_get_definition = backup
class RPCGetAssignmentTests(): METHOD = "rpc_get_assignment"
def test_should_raise_fault(self): if jedibackend.JEDISUP17: with self.assertRaises(Fault): self.backend.rpc_get_assignment("test.py", "dummy code", 1)
def test_should_handle_jedi16(self): backup = self.backend.rpc_get_assignment self.backend.rpc_get_assignment = self.backend.rpc_get_assignment_jedi16 source, offset = source_and_offset("import threading\n" "def test_function(a, b):\n" " return a + b\n" "\n" "test_func_|_tion(\n") filename = self.project_file("test.py", source)
location = self.backend.rpc_get_assignment(filename, source, offset)
self.assertEqual(location[0], filename) # On def or on the function name self.assertIn(location[1], (17, 21)) self.backend.rpc_get_assignment = backup
class RPCGetCalltipTests(GenericRPCTests): METHOD = "rpc_get_calltip"
def test_should_get_calltip(self): expected = self.THREAD_CALLTIP source, offset = source_and_offset( "import threading\nthreading.Thread(_|_") filename = self.project_file("test.py", source) calltip = self.backend.rpc_get_calltip(filename, source, offset) self.assertEqual(calltip, expected) calltip = self.backend.rpc_get_calltip_or_oneline_docstring(filename, source, offset) calltip.pop('kind') self.assertEqual(calltip, expected)
def test_should_get_calltip_even_after_parens(self): source, offset = source_and_offset( "import threading\nthreading.Thread(foo()_|_") filename = self.project_file("test.py", source) actual = self.backend.rpc_get_calltip(filename, source, offset) self.assertEqual(self.THREAD_CALLTIP, actual) actual = self.backend.rpc_get_calltip_or_oneline_docstring(filename, source, offset) actual.pop('kind') self.assertEqual(self.THREAD_CALLTIP, actual)
def test_should_get_calltip_at_closing_paren(self): source, offset = source_and_offset( "import threading\nthreading.Thread(_|_)") filename = self.project_file("test.py", source) actual = self.backend.rpc_get_calltip(filename, source, offset) self.assertEqual(self.THREAD_CALLTIP, actual) actual = self.backend.rpc_get_calltip_or_oneline_docstring(filename, source, offset) self.assertEqual(actual['kind'], "oneline_doc")
def test_should_not_missing_attribute_get_definition(self): # Bug #627 / jedi#573 source, offset = source_and_offset( "import threading\nthreading.Thread(_|_)") filename = self.project_file("test.py", source)
self.backend.rpc_get_calltip(filename, source, offset)
def test_should_return_none_for_bad_identifier(self): source, offset = source_and_offset( "froblgoo(_|_") filename = self.project_file("test.py", source) calltip = self.backend.rpc_get_calltip(filename, source, offset) self.assertIsNone(calltip) calltip = self.backend.rpc_get_calltip_or_oneline_docstring(filename, source, offset) self.assertIsNone(calltip)
def test_should_remove_self_argument(self): source, offset = source_and_offset( "d = dict()\n" "d.keys(_|_") filename = self.project_file("test.py", source)
actual = self.backend.rpc_get_calltip(filename, source, offset) self.assertEqual(self.KEYS_CALLTIP, actual) actual = self.backend.rpc_get_calltip_or_oneline_docstring(filename, source, offset) actual.pop('kind') self.assertEqual(self.KEYS_CALLTIP, actual)
def test_should_remove_package_prefix(self): source, offset = source_and_offset( "import decimal\n" "d = decimal.Decimal('1.5')\n" "d.radix(_|_") filename = self.project_file("test.py", source)
actual = self.backend.rpc_get_calltip(filename, source, offset) self.assertEqual(self.RADIX_CALLTIP, actual) actual = self.backend.rpc_get_calltip_or_oneline_docstring(filename, source, offset) actual.pop('kind') self.assertEqual(self.RADIX_CALLTIP, actual)
def test_should_return_none_outside_of_all(self): filename = self.project_file("test.py", "") source, offset = source_and_offset("import thr_|_eading\n") calltip = self.backend.rpc_get_calltip(filename, source, offset) self.assertIsNone(calltip) calltip = self.backend.rpc_get_calltip_or_oneline_docstring(filename, source, offset) self.assertIsNotNone(calltip)
def test_should_find_calltip_different_package(self): # See issue #74 self.project_file("project/__init__.py", "") source1 = ("class Add:\n" " def add(self, a, b):\n" " return a + b\n") self.project_file("project/add.py", source1) source2, offset = source_and_offset( "from project.add import Add\n" "class Calculator:\n" " def add(self, a, b):\n" " c = Add()\n" " c.add(_|_\n") file2 = self.project_file("project/calculator.py", source2)
actual = self.backend.rpc_get_calltip(file2, source2, offset) self.assertEqual(self.ADD_CALLTIP, actual) actual = self.backend.rpc_get_calltip_or_oneline_docstring(file2, source2, offset) actual.pop('kind') self.assertEqual(self.ADD_CALLTIP, actual)
def test_should_return_oneline_docstring_if_no_calltip(self): source, offset = source_and_offset( "def foo(a, b):\n fo_|_o(1 + 2)") filename = self.project_file("test.py", source) calltip = self.backend.rpc_get_calltip_or_oneline_docstring(filename, source, offset) self.assertEqual(calltip['kind'], 'oneline_doc') self.assertEqual(calltip['doc'], 'No documentation')
def test_should_handle_jedi16(self): backup = self.backend.rpc_get_calltip self.backend.rpc_get_calltip = self.backend.rpc_get_calltip_jedi16 self.test_should_get_calltip() self.backend.rpc_get_calltip = backup
class RPCGetDocstringTests(GenericRPCTests): METHOD = "rpc_get_docstring"
def check_docstring(self, docstring):
def first_line(s): return s[:s.index("\n")] match = re.match(self.JSON_LOADS_REGEX, first_line(docstring)) self.assertIsNotNone(match)
def test_should_get_docstring(self): source, offset = source_and_offset( "import json\njson.loads_|_(") filename = self.project_file("test.py", source) docstring = self.backend.rpc_get_docstring(filename, source, offset) self.check_docstring(docstring)
def test_should_return_none_for_bad_identifier(self): source, offset = source_and_offset( "froblgoo_|_(\n") filename = self.project_file("test.py", source) docstring = self.backend.rpc_get_docstring(filename, source, offset) self.assertIsNone(docstring)
def test_should_handle_jedi16(self): backup = self.backend.rpc_get_docstring self.backend.rpc_get_docstring = self.backend.rpc_get_docstring_jedi16 self.test_should_get_docstring() self.backend.rpc_get_docstring = backup
class RPCGetOnelineDocstringTests(GenericRPCTests): METHOD = "rpc_get_oneline_docstring"
def check_docstring(self, docstring):
self.assertEqual(docstring['doc'], self.JSON_LOADS_DOCSTRING)
def check_module_docstring(self, docstring):
self.assertEqual(docstring['doc'], self.JSON_DOCSTRING)
def test_should_get_oneline_docstring(self): source, offset = source_and_offset( "import json\njson.loads_|_(") filename = self.project_file("test.py", source) docstring = self.backend.rpc_get_oneline_docstring(filename, source, offset) self.check_docstring(docstring) docstring = self.backend.rpc_get_calltip_or_oneline_docstring(filename, source, offset) docstring.pop('kind') self.check_docstring(docstring)
def test_should_get_oneline_docstring_for_modules(self): source, offset = source_and_offset( "import json_|_\njson.loads(") filename = self.project_file("test.py", source) docstring = self.backend.rpc_get_oneline_docstring(filename, source, offset) self.check_module_docstring(docstring) docstring = self.backend.rpc_get_calltip_or_oneline_docstring(filename, source, offset) docstring.pop('kind') self.check_module_docstring(docstring)
def test_should_return_none_for_bad_identifier(self): source, offset = source_and_offset( "froblgoo_|_(\n") filename = self.project_file("test.py", source) docstring = self.backend.rpc_get_oneline_docstring(filename, source, offset) self.assertIsNone(docstring) docstring = self.backend.rpc_get_calltip_or_oneline_docstring(filename, source, offset) self.assertIsNone(docstring)
def test_should_handle_jedi16(self): backup = self.backend.rpc_get_oneline_docstring self.backend.rpc_get_oneline_docstring = self.backend.rpc_get_oneline_docstring_jedi16 self.test_should_get_oneline_docstring() self.test_should_get_oneline_docstring_for_modules() self.test_should_return_none_for_bad_identifier() self.backend.rpc_get_oneline_docstring = backup
@unittest.skipIf(not jedibackend.JEDISUP17, "Refactoring not available with jedi<17")@unittest.skipIf(sys.version_info < (3, 6), "Jedi refactoring not available for python < 3.6")class RPCGetRenameDiffTests(object): METHOD = "rpc_get_rename_diff"
def test_should_return_rename_diff(self): source, offset = source_and_offset("def foo(a, b):\n" " print(a_|_)\n" " return b") new_name = "c" diff = self.backend.rpc_get_rename_diff("test.py", source, offset, new_name) assert diff['success'] self.assertIn("-def foo(a, b):\n" "- print(a)\n" "+def foo(c, b):\n" "+ print(c)", diff['diff'])
def test_should_fail_for_invalid_symbol_at_point(self): source, offset = source_and_offset("def foo(a, b):\n" " print(12_|_)\n" " return b") new_name = "c" diff = self.backend.rpc_get_rename_diff("test.py", source, offset, new_name) self.assertFalse(diff['success'])
@unittest.skipIf(not jedibackend.JEDISUP17, "Refactoring not available with jedi<17")@unittest.skipIf(sys.version_info < (3, 6), "Jedi refactoring not available for python < 3.6")class RPCGetExtractFunctionDiffTests(object): METHOD = "rpc_get_extract_function_diff"
def test_should_return_function_extraction_diff(self): source, offset = source_and_offset("print(a)\n" "return b_|_\n") new_name = "foo" diff = self.backend.rpc_get_extract_function_diff( "test.py", source, offset, new_name, line_beg=1, line_end=2, col_beg=0, col_end=8) assert diff['success'] self.assertIn('-print(a)\n' '-return b\n' '+def foo(a, b):\n' '+ print(a)\n' '+ return b\n', diff['diff'])
@unittest.skipIf(not jedibackend.JEDISUP17, "Refactoring not available with jedi<17")@unittest.skipIf(sys.version_info < (3, 6), "Jedi refactoring not available for python < 3.6")class RPCGetExtractVariableDiffTests(object): METHOD = "rpc_get_extract_variable_diff"
def test_should_return_variable_extraction_diff(self): source, offset = source_and_offset("b = 12\n" "a = 2\n" "print_|_(a + 1 + b/2)\n") new_name = "c" diff = self.backend.rpc_get_extract_variable_diff( "test.py", source, offset, new_name, line_beg=3, line_end=3, col_beg=7, col_end=16) assert diff['success'] self.assertIn("-print(a + 1 + b/2)\n+c = a + 1 + b/2\n+print(c)\n", diff['diff'])
@unittest.skipIf(not jedibackend.JEDISUP17, "Refactoring not available with jedi<17")@unittest.skipIf(sys.version_info < (3, 6), "Jedi refactoring not available for python < 3.6")class RPCGetInlineDiffTests(object): METHOD = "rpc_get_inline_diff"
def test_should_return_inline_diff(self): source, offset = source_and_offset("foo = 3.1\n" "bar = foo + 1\n" "x = int(ba_|_r)\n") diff = self.backend.rpc_get_inline_diff("test.py", source, offset) assert diff['success'] self.assertIn("-bar = foo + 1\n-x = int(bar)\n+x = int(foo + 1)", diff['diff'])
def test_should_error_on_refactoring_failure(self): source, offset = source_and_offset("foo = 3.1\n" "bar = foo + 1\n" "x = in_|_t(bar)\n") diff = self.backend.rpc_get_inline_diff("test.py", source, offset) self.assertFalse(diff['success'])
class RPCGetNamesTests(GenericRPCTests): METHOD = "rpc_get_names"
def test_shouldreturn_names_in_same_file(self): filename = self.project_file("test.py", "") source, offset = source_and_offset( "def foo(x, y):\n" " return x + y\n" "c = _|_foo(5, 2)\n")
names = self.backend.rpc_get_names(filename, source, offset)
self.assertEqual(names, [{'name': 'foo', 'filename': filename, 'offset': 4}, {'name': 'x', 'filename': filename, 'offset': 8}, {'name': 'y', 'filename': filename, 'offset': 11}, {'name': 'x', 'filename': filename, 'offset': 26}, {'name': 'y', 'filename': filename, 'offset': 30}, {'name': 'c', 'filename': filename, 'offset': 32}, {'name': 'foo', 'filename': filename, 'offset': 36}])
def test_should_not_fail_without_symbol(self): filename = self.project_file("test.py", "")
names = self.backend.rpc_get_names(filename, "", 0)
self.assertEqual(names, [])
def test_should_handle_jedi16(self): backup = self.backend.rpc_get_names self.backend.rpc_get_names = self.backend.rpc_get_names_jedi16 self.test_shouldreturn_names_in_same_file() self.test_should_not_fail_without_symbol() self.backend.rpc_get_names = backup
class RPCGetUsagesTests(GenericRPCTests): METHOD = "rpc_get_usages"
def test_should_return_uses_in_same_file(self): filename = self.project_file("test.py", "") source, offset = source_and_offset( "def foo(x):\n" " return _|_x + x\n")
usages = self.backend.rpc_get_usages(filename, source, offset)
self.assertEqual(usages, [{'name': 'x', 'offset': 8, 'filename': filename}, {'name': 'x', 'filename': filename, 'offset': 23}, {'name': u'x', 'filename': filename, 'offset': 27}])
def test_should_return_uses_in_other_file(self): file1 = self.project_file("file1.py", "") file2 = self.project_file("file2.py", "\n\n\n\n\nx = 5") source, offset = source_and_offset( "import file2\n" "file2._|_x\n")
usages = self.backend.rpc_get_usages(file1, source, offset)
self.assertEqual(usages, [{'name': 'x', 'filename': file1, 'offset': 19}, {'name': 'x', 'filename': file2, 'offset': 5}])
def test_should_not_fail_without_symbol(self): filename = self.project_file("file.py", "")
usages = self.backend.rpc_get_usages(filename, "", 0)
self.assertEqual(usages, [])
def test_should_handle_jedi16(self): backup = self.backend.rpc_get_usages self.backend.rpc_get_usages = self.backend.rpc_get_usages_jedi16 self.test_should_return_uses_in_same_file() self.test_should_return_uses_in_other_file() self.test_should_not_fail_without_symbol() self.backend.rpc_get_usages = backup
def source_and_offset(source): """Return a source and offset from a source description.
>>> source_and_offset("hello, _|_world") ("hello, world", 7) >>> source_and_offset("_|_hello, world") ("hello, world", 0) >>> source_and_offset("hello, world_|_") ("hello, world", 12) """
offset = source.index("_|_") return source[:offset] + source[offset + 3:], offset
|
