Refactor test_interpreter.

test/test_api/test_interpreter.py

@@ -7,6 +7,7 @@ import jedi
 from jedi._compatibility import is_py33
 from jedi.evaluate.compiled import mixed
 
+
 class _GlobalNameSpace():
     class SideEffectContainer():
         pass
@@ -66,96 +67,104 @@ def test_side_effect_completion():
     assert foo.name == 'foo'
 
 
-class TestInterpreterAPI(TestCase):
-    def check_interpreter_complete(self, source, namespace, completions,
-                                   **kwds):
-        script = jedi.Interpreter(source, [namespace], **kwds)
-        cs = script.completions()
-        actual = [c.name for c in cs]
-        self.assertEqual(sorted(actual), sorted(completions))
+def _assert_interpreter_complete(source, namespace, completions,
+                                 **kwds):
+    script = jedi.Interpreter(source, [namespace], **kwds)
+    cs = script.completions()
+    actual = [c.name for c in cs]
+    assert sorted(actual) == sorted(completions)
 
-    def test_complete_raw_function(self):
-        from os.path import join
-        self.check_interpreter_complete('join("").up',
-                                        locals(),
-                                        ['upper'])
 
-    def test_complete_raw_function_different_name(self):
-        from os.path import join as pjoin
-        self.check_interpreter_complete('pjoin("").up',
-                                        locals(),
-                                        ['upper'])
+def test_complete_raw_function():
+    from os.path import join
+    _assert_interpreter_complete('join("").up',
+                                 locals(),
+                                 ['upper'])
 
-    def test_complete_raw_module(self):
-        import os
-        self.check_interpreter_complete('os.path.join("a").up',
-                                        locals(),
-                                        ['upper'])
 
-    def test_complete_raw_instance(self):
-        import datetime
-        dt = datetime.datetime(2013, 1, 1)
-        completions = ['time', 'timetz', 'timetuple']
-        if is_py33:
-            completions += ['timestamp']
-        self.check_interpreter_complete('(dt - dt).ti',
-                                        locals(),
-                                        completions)
+def test_complete_raw_function_different_name():
+    from os.path import join as pjoin
+    _assert_interpreter_complete('pjoin("").up',
+                                 locals(),
+                                 ['upper'])
 
-    def test_list(self):
-        array = ['haha', 1]
-        self.check_interpreter_complete('array[0].uppe',
-                                        locals(),
-                                        ['upper'])
-        self.check_interpreter_complete('array[0].real',
-                                        locals(),
-                                        [])
 
-        # something different, no index given, still just return the right
-        self.check_interpreter_complete('array[int].real',
-                                        locals(),
-                                        ['real'])
-        self.check_interpreter_complete('array[int()].real',
-                                        locals(),
-                                        ['real'])
-        # inexistent index
-        self.check_interpreter_complete('array[2].upper',
-                                        locals(),
-                                        ['upper'])
+def test_complete_raw_module():
+    import os
+    _assert_interpreter_complete('os.path.join("a").up',
+                                 locals(),
+                                 ['upper'])
 
-    def test_slice(self):
-        class Foo():
-            bar = []
-        baz = 'xbarx'
-        self.check_interpreter_complete('getattr(Foo, baz[1:-1]).append',
-                                        locals(),
-                                        ['append'])
 
-    def test_getitem_side_effects(self):
-        class Foo():
-            def __getitem__(self, index):
-                # possible side effects here, should therefore not call this.
-                return index
+def test_complete_raw_instance():
+    import datetime
+    dt = datetime.datetime(2013, 1, 1)
+    completions = ['time', 'timetz', 'timetuple']
+    if is_py33:
+        completions += ['timestamp']
+    _assert_interpreter_complete('(dt - dt).ti',
+                                 locals(),
+                                 completions)
 
-        foo = Foo()
-        self.check_interpreter_complete('foo[0].', locals(), [])
 
-    def test_property_error(self):
-        class Foo():
-            @property
-            def bar(self):
-                raise ValueError
+def test_list():
+    array = ['haha', 1]
+    _assert_interpreter_complete('array[0].uppe',
+                                 locals(),
+                                 ['upper'])
+    _assert_interpreter_complete('array[0].real',
+                                 locals(),
+                                 [])
 
-        foo = Foo()
-        self.check_interpreter_complete('foo.bar', locals(), ['bar'])
-        self.check_interpreter_complete('foo.bar.baz', locals(), [])
+    # something different, no index given, still just return the right
+    _assert_interpreter_complete('array[int].real',
+                                 locals(),
+                                 ['real'])
+    _assert_interpreter_complete('array[int()].real',
+                                 locals(),
+                                 ['real'])
+    # inexistent index
+    _assert_interpreter_complete('array[2].upper',
+                                 locals(),
+                                 ['upper'])
 
-    def test_param_completion(self):
-        def foo(bar):
-            pass
 
-        lambd = lambda xyz: 3
+def test_slice():
+    class Foo():
+        bar = []
+    baz = 'xbarx'
+    _assert_interpreter_complete('getattr(Foo, baz[1:-1]).append',
+                                 locals(),
+                                 ['append'])
 
-        self.check_interpreter_complete('foo(bar', locals(), ['bar'])
-        # TODO we're not yet using the Python3.5 inspect.signature, yet.
-        assert not jedi.Interpreter('lambd(xyz', [locals()]).completions()
+
+def test_getitem_side_effects():
+    class Foo():
+        def __getitem__(self, index):
+            # possible side effects here, should therefore not call this.
+            return index
+
+    foo = Foo()
+    _assert_interpreter_complete('foo[0].', locals(), [])
+
+
+def test_property_error():
+    class Foo():
+        @property
+        def bar(self):
+            raise ValueError
+
+    foo = Foo()
+    _assert_interpreter_complete('foo.bar', locals(), ['bar'])
+    _assert_interpreter_complete('foo.bar.baz', locals(), [])
+
+
+def test_param_completion():
+    def foo(bar):
+        pass
+
+    lambd = lambda xyz: 3
+
+    _assert_interpreter_complete('foo(bar', locals(), ['bar'])
+    # TODO we're not yet using the Python3.5 inspect.signature, yet.
+    assert not jedi.Interpreter('lambd(xyz', [locals()]).completions()