From d16f5f6a4ce24ff02cfd8a5d4d6a8875ffd41035 Mon Sep 17 00:00:00 2001 From: David Halter Date: Sat, 20 Apr 2013 21:55:08 +0430 Subject: [PATCH] refactored test_integration, so that those tests can be called from multiple places. --- test/base.py | 32 --------------- test/run.py | 78 +++++++++++++++++++++++++++++++++++- test/test_integration.py | 86 +--------------------------------------- 3 files changed, 77 insertions(+), 119 deletions(-) diff --git a/test/base.py b/test/base.py index 2deb4452..56cfec3c 100644 --- a/test/base.py +++ b/test/base.py @@ -7,10 +7,7 @@ import os from os.path import abspath, dirname import functools -import pytest - import jedi -from jedi._compatibility import is_py25 test_dir = dirname(abspath(__file__)) @@ -63,32 +60,3 @@ def cwd_at(path): os.chdir(oldcwd) return wrapper return decorator - - -_py25_fails = 0 -py25_allowed_fails = 9 - - -def skip_py25_fails(func): - """ - Skip first `py25_allowed_fails` failures in Python 2.5. - - .. todo:: Remove this decorator by implementing "skip tag" for - integration tests. - """ - @functools.wraps(func) - def wrapper(*args, **kwds): - global _py25_fails - try: - func(*args, **kwds) - except AssertionError: - _py25_fails += 1 - if _py25_fails > py25_allowed_fails: - raise - else: - pytest.skip("%d-th failure (there can be %d failures)" % - (_py25_fails, py25_allowed_fails)) - return wrapper - -if not is_py25: - skip_py25_fails = lambda f: f diff --git a/test/run.py b/test/run.py index 102b4ae4..0b384dd5 100755 --- a/test/run.py +++ b/test/run.py @@ -100,7 +100,8 @@ import os import re import jedi -from jedi._compatibility import unicode, StringIO, reduce, is_py25 +from jedi._compatibility import unicode, StringIO, reduce, is_py25, \ + literal_eval TEST_COMPLETIONS = 0 @@ -110,7 +111,6 @@ TEST_USAGES = 3 class IntegrationTestCase(object): - def __init__(self, test_type, correct, line_nr, column, start, line, path=None): self.test_type = test_type @@ -130,6 +130,80 @@ class IntegrationTestCase(object): def script(self): return jedi.Script(self.source, self.line_nr, self.column, self.path) + def run(self, compare_cb): + testers = { + TEST_COMPLETIONS: self.run_completion, + TEST_DEFINITIONS: self.run_definition, + TEST_ASSIGNMENTS: self.run_goto, + TEST_USAGES: self.run_related_name, + } + return testers[self.test_type](compare_cb) + + def run_completion(self, compare_cb): + completions = self.script().complete() + #import cProfile; cProfile.run('script.complete()') + + comp_str = set([c.word for c in completions]) + return compare_cb(self, comp_str, set(literal_eval(self.correct))) + + def run_definition(self, compare_cb): + def definition(correct, correct_start, path): + def defs(line_nr, indent): + s = jedi.Script(script.source, line_nr, indent, path) + return set(s.definition()) + + should_be = set() + number = 0 + for index in re.finditer('(?: +|$)', correct): + if correct == ' ': + continue + # -1 for the comment, +3 because of the comment start `#? ` + start = index.start() + number += 1 + try: + should_be |= defs(self.line_nr - 1, start + correct_start) + except Exception: + print('could not resolve %s indent %s' + % (self.line_nr - 1, start)) + raise + # because the objects have different ids, `repr`, then compare. + should_str = set(r.desc_with_module for r in should_be) + if len(should_str) < number: + raise Exception('Solution @%s not right, ' + 'too few test results: %s' % (self.line_nr - 1, should_str)) + return should_str + + script = self.script() + should_str = definition(self.correct, self.start, script.source_path) + result = script.definition() + is_str = set(r.desc_with_module for r in result) + return compare_cb(self, is_str, should_str) + + def run_goto(self, compare_cb): + result = self.script().goto() + comp_str = str(sorted(str(r.description) for r in result)) + return compare_cb(self, comp_str, self.correct) + + def run_related_name(self, compare_cb): + result = self.script().related_names() + self.correct = self.correct.strip() + compare = sorted((r.module_name, r.start_pos[0], r.start_pos[1]) + for r in result) + wanted = [] + if not self.correct: + positions = [] + else: + positions = literal_eval(self.correct) + for pos_tup in positions: + if type(pos_tup[0]) == str: + # this means that there is a module specified + wanted.append(pos_tup) + else: + wanted.append(('renaming', self.line_nr + pos_tup[0], + pos_tup[1])) + + return compare_cb(self, compare, sorted(wanted)) + def collect_file_tests(lines, lines_to_execute): makecase = lambda t: IntegrationTestCase(t, correct, line_nr, column, diff --git a/test/test_integration.py b/test/test_integration.py index e522f721..6c6901d0 100644 --- a/test/test_integration.py +++ b/test/test_integration.py @@ -1,14 +1,8 @@ import os -import re import pytest from . import base -from .run import \ - TEST_COMPLETIONS, TEST_DEFINITIONS, TEST_ASSIGNMENTS, TEST_USAGES - -import jedi -from jedi._compatibility import literal_eval def assert_case_equal(case, actual, desired): @@ -26,90 +20,12 @@ desired = %s """ % (case, actual, desired) -def run_completion_test(case): - (script, correct, line_nr) = (case.script(), case.correct, case.line_nr) - completions = script.complete() - #import cProfile; cProfile.run('script.complete()') - - comp_str = set([c.word for c in completions]) - assert_case_equal(case, comp_str, set(literal_eval(correct))) - - -def run_definition_test(case): - def definition(correct, correct_start, path): - def defs(line_nr, indent): - s = jedi.Script(script.source, line_nr, indent, path) - return set(s.definition()) - - should_be = set() - number = 0 - for index in re.finditer('(?: +|$)', correct): - if correct == ' ': - continue - # -1 for the comment, +3 because of the comment start `#? ` - start = index.start() - number += 1 - try: - should_be |= defs(line_nr - 1, start + correct_start) - except Exception: - print('could not resolve %s indent %s' % (line_nr - 1, start)) - raise - # because the objects have different ids, `repr` it, then compare it. - should_str = set(r.desc_with_module for r in should_be) - if len(should_str) < number: - raise Exception('Solution @%s not right, too few test results: %s' - % (line_nr - 1, should_str)) - return should_str - - (correct, line_nr, column, start, line) = \ - (case.correct, case.line_nr, case.column, case.start, case.line) - script = case.script() - should_str = definition(correct, start, script.source_path) - result = script.definition() - is_str = set(r.desc_with_module for r in result) - assert_case_equal(case, is_str, should_str) - - -def run_goto_test(case): - (script, correct, line_nr) = (case.script(), case.correct, case.line_nr) - result = script.goto() - comp_str = str(sorted(str(r.description) for r in result)) - assert_case_equal(case, comp_str, correct) - - -def run_related_name_test(case): - (script, correct, line_nr) = (case.script(), case.correct, case.line_nr) - result = script.related_names() - correct = correct.strip() - compare = sorted((r.module_name, r.start_pos[0], r.start_pos[1]) - for r in result) - wanted = [] - if not correct: - positions = [] - else: - positions = literal_eval(correct) - for pos_tup in positions: - if type(pos_tup[0]) == str: - # this means that there is a module specified - wanted.append(pos_tup) - else: - wanted.append(('renaming', line_nr + pos_tup[0], pos_tup[1])) - - assert_case_equal(case, compare, sorted(wanted)) - - def test_integration(case, monkeypatch, pytestconfig): if case.skip is not None: pytest.skip(case.skip) repo_root = base.root_dir monkeypatch.chdir(os.path.join(repo_root, 'jedi')) - testers = { - TEST_COMPLETIONS: run_completion_test, - TEST_DEFINITIONS: run_definition_test, - TEST_ASSIGNMENTS: run_goto_test, - TEST_USAGES: run_related_name_test, - } - base.skip_py25_fails(testers[case.test_type])(case) + case.run(assert_case_equal) def test_refactor(refactor_case):