Prepare completer for pytest.

use proper unittest class with setup and teardown methods to capture
deprecation warnings; and move support classes and function outside of
the testcase definition.

Make all standalone functions methods.

Beyond this no code change.

IPython/core/tests/test_completer.py

@@ -109,20 +109,62 b' def test_line_split():'
     check_line_split(sp, [ map(str, p) for p in t] )
 
 
-def test_custom_completion_error():
+
+class NamedInstanceMetaclass(type):
+    def __getitem__(cls, item):
+        return cls.get_instance(item)
+
+class NamedInstanceClass(object, metaclass=NamedInstanceMetaclass):
+    def __init__(self, name):
+        if not hasattr(self.__class__, 'instances'):
+            self.__class__.instances = {}
+        self.__class__.instances[name] = self
+
+    @classmethod
+    def _ipython_key_completions_(cls):
+        return cls.instances.keys()
+
+    @classmethod
+    def get_instance(cls, name):
+        return cls.instances[name]
+
+class KeyCompletable(object):
+    def __init__(self, things=()):
+        self.things = things
+
+    def _ipython_key_completions_(self):
+        return list(self.things)
+
+
+class TestCompleter(unittest.TestCase):
+
+    def setUp(self):
+        """
+        We want to silence all PendingDeprecationWarning when testing the completer
+        """
+        self._assertwarns = self.assertWarns(PendingDeprecationWarning)
+        self._assertwarns.__enter__()
+
+    def tearDown(self):
+        try:
+            self._assertwarns.__exit__(None, None, None)
+        except AssertionError:
+            pass
+
+
+    def test_custom_completion_error(self):
     """Test that errors from custom attribute completers are silenced."""
     ip = get_ipython()
     class A(object): pass
-    ip.user_ns['a'] = A()
+        ip.user_ns['x'] = A()
     
     @complete_object.register(A)
     def complete_A(a, existing_completions):
         raise TypeError("this should be silenced")
     
-    ip.complete("a.")
-
+        ip.complete("x.")
 
-def test_unicode_completions():
+    def test_unicode_completions(self):
     ip = get_ipython()
     # Some strings that trigger different types of completion.  Check them both
     # in str and unicode forms
@@ -136,7 +178,7 b' def test_unicode_completions():'
         nt.assert_true(isinstance(text, str))
         nt.assert_true(isinstance(matches, list))
 
-def test_latex_completions():
+    def test_latex_completions(self):
     from IPython.core.latex_symbols import latex_symbols
     import random
     ip = get_ipython()
@@ -159,7 +201,7 b' def test_latex_completions():'
 
 
 
-def test_back_latex_completion():
+    def test_back_latex_completion(self):
     ip = get_ipython()
 
     # do not return more than 1 matches fro \beta, only the latex one.
@@ -167,7 +209,7 b' def test_back_latex_completion():'
     nt.assert_equal(len(matches), 1)
     nt.assert_equal(matches[0], '\\beta')
 
-def test_back_unicode_completion():
+    def test_back_unicode_completion(self):
     ip = get_ipython()
     
     name, matches = ip.complete('\\Ⅴ')
@@ -175,7 +217,7 b' def test_back_unicode_completion():'
     nt.assert_equal(matches[0], '\\ROMAN NUMERAL FIVE')
 
 
-def test_forward_unicode_completion():
+    def test_forward_unicode_completion(self):
     ip = get_ipython()
     
     name, matches = ip.complete('\\ROMAN NUMERAL FIVE')
@@ -184,7 +226,7 b' def test_forward_unicode_completion():'
 
 @nt.nottest # now we have a completion for \jmath
 @decorators.knownfailureif(sys.platform == 'win32', 'Fails if there is a C:\\j... path')
-def test_no_ascii_back_completion():
+    def test_no_ascii_back_completion(self):
     ip = get_ipython()
     with TemporaryWorkingDirectory():  # Avoid any filename completions
         # single ascii letter that don't have yet completions
@@ -214,28 +256,28 b' class CompletionSplitterTestCase(unittest.TestCase):'
         check_line_split(self.sp, t)
 
 
-def test_has_open_quotes1():
+    def test_has_open_quotes1(self):
     for s in ["'", "'''", "'hi' '"]:
         nt.assert_equal(completer.has_open_quotes(s), "'")
 
 
-def test_has_open_quotes2():
+    def test_has_open_quotes2(self):
     for s in ['"', '"""', '"hi" "']:
         nt.assert_equal(completer.has_open_quotes(s), '"')
 
 
-def test_has_open_quotes3():
+    def test_has_open_quotes3(self):
     for s in ["''", "''' '''", "'hi' 'ipython'"]:
         nt.assert_false(completer.has_open_quotes(s))
 
 
-def test_has_open_quotes4():
+    def test_has_open_quotes4(self):
     for s in ['""', '""" """', '"hi" "ipython"']:
         nt.assert_false(completer.has_open_quotes(s))
 
 
 @decorators.knownfailureif(sys.platform == 'win32', "abspath completions fail on Windows")
-def test_abspath_file_completions():
+    def test_abspath_file_completions(self):
     ip = get_ipython()
     with TemporaryDirectory() as tmpdir:
         prefix = os.path.join(tmpdir, 'foo')
@@ -255,7 +297,7 b' def test_abspath_file_completions():'
         nt.assert_equal(c, comp)
 
 
-def test_local_file_completions():
+    def test_local_file_completions(self):
     ip = get_ipython()
     with TemporaryWorkingDirectory():
         prefix = './foo'
@@ -275,7 +317,7 b' def test_local_file_completions():'
         nt.assert_true(comp.issubset(set(c)))
 
 
-def test_quoted_file_completions():
+    def test_quoted_file_completions(self):
     ip = get_ipython()
     with TemporaryWorkingDirectory():
         name = "foo'bar"
@@ -306,7 +348,7 b' def test_quoted_file_completions():'
         nt.assert_equal(c, [escaped])
 
 
-def test_jedi():
+    def test_jedi(self):
     """
     A couple of issue we had with Jedi
     """
@@ -340,7 +382,7 b' def test_jedi():'
 
     yield _test_not_complete, 'does not mix types', 'a=(1,"foo");a[0].', 'capitalize'
 
-def test_completion_have_signature():
+    def test_completion_have_signature(self):
     """
     Lets make sure jedi is capable of pulling out the signature of the function we are completing.
     """
@@ -354,7 +396,7 b' def test_completion_have_signature():'
     assert 'encoding' in c.signature, "Signature of function was not found by completer"
 
 
-def test_deduplicate_completions():
+    def test_deduplicate_completions(self):
     """
     Test that completions are correctly deduplicated (even if ranges are not the same)
     """
@@ -372,7 +414,7 b' def test_deduplicate_completions():'
     assert l[0].text == 'zoo'  # and not `it.accumulate`
 
 
-def test_greedy_completions():
+    def test_greedy_completions(self):
     """
     Test the capability of the Greedy completer. 
 
@@ -406,7 +448,7 b' def test_greedy_completions():'
             yield _, 'a[0].from_', 10, 'a[0].from_bytes', "Should have completed on a[0].from_: %s", Completion(5, 10, 'from_bytes')
 
 
-def test_omit__names():
+    def test_omit__names(self):
     # also happens to test IPCompleter as a configurable
     ip = get_ipython()
     ip._hidden_attr = 1
@@ -469,7 +511,7 b' def test_omit__names():'
     del ip._x
 
 
-def test_limit_to__all__False_ok():
+    def test_limit_to__all__False_ok(self):
     """
     Limit to all is deprecated, once we remove it this test can go away. 
     """
@@ -485,21 +527,21 b' def test_limit_to__all__False_ok():'
     nt.assert_in('d.x', matches)
 
 
-def test_get__all__entries_ok():
+    def test_get__all__entries_ok(self):
     class A(object):
         __all__ = ['x', 1]
     words = completer.get__all__entries(A())
     nt.assert_equal(words, ['x'])
 
 
-def test_get__all__entries_no__all__ok():
+    def test_get__all__entries_no__all__ok(self):
     class A(object):
         pass
     words = completer.get__all__entries(A())
     nt.assert_equal(words, [])
 
 
-def test_func_kw_completions():
+    def test_func_kw_completions(self):
     ip = get_ipython()
     c = ip.Completer
     c.use_jedi = False
@@ -516,7 +558,7 b' def test_func_kw_completions():'
     nt.assert_in('key=', matches)
 
 
-def test_default_arguments_from_docstring():
+    def test_default_arguments_from_docstring(self):
     ip = get_ipython()
     c = ip.Completer
     kwd = c._default_arguments_from_docstring(
@@ -531,7 +573,7 b' def test_default_arguments_from_docstring():'
         '\n Minuit.migrad(self, int ncall=10000, resume=True, int nsplit=1)\n')
     nt.assert_equal(kwd, ['ncall', 'resume', 'nsplit'])
 
-def test_line_magics():
+    def test_line_magics(self):
     ip = get_ipython()
     c = ip.Completer
     s, matches = c.complete(None, 'lsmag')
@@ -540,7 +582,7 b' def test_line_magics():'
     nt.assert_in('%lsmagic', matches)
 
 
-def test_cell_magics():
+    def test_cell_magics(self):
     from IPython.core.magic import register_cell_magic
 
     @register_cell_magic
@@ -556,7 +598,7 b' def test_cell_magics():'
     nt.assert_in('%%_foo_cellm', matches)
 
 
-def test_line_cell_magics():
+    def test_line_cell_magics(self):
     from IPython.core.magic import register_line_cell_magic
 
     @register_line_cell_magic
@@ -581,7 +623,7 b' def test_line_cell_magics():'
     nt.assert_in('%%_bar_cellm', matches)
 
 
-def test_magic_completion_order():
+    def test_magic_completion_order(self):
     ip = get_ipython()
     c = ip.Completer
 
@@ -590,7 +632,7 b' def test_magic_completion_order():'
     nt.assert_equal(matches, ["%timeit", "%%timeit"])
 
 
-def test_magic_completion_shadowing():
+    def test_magic_completion_shadowing(self):
     ip = get_ipython()
     c = ip.Completer
     c.use_jedi = False
@@ -610,7 +652,7 b' def test_magic_completion_shadowing():'
     text, matches = c.complete("mat")
     nt.assert_equal(matches, ["%matplotlib"])
 
-def test_magic_completion_shadowing_explicit():
+    def test_magic_completion_shadowing_explicit(self):
     """
     If the user try to complete a shadowed magic, and explicit % start should
     still return the completions.
@@ -629,7 +671,7 b' def test_magic_completion_shadowing_explicit():'
     text, matches = c.complete("%mat")
     nt.assert_equal(matches, ["%matplotlib"])
 
-def test_magic_config():
+    def test_magic_config(self):
     ip = get_ipython()
     c = ip.Completer
 
@@ -659,7 +701,7 b' def test_magic_config():'
     nt.assert_list_equal(['AliasManager.default_aliases'], matches)
 
 
-def test_magic_color():
+    def test_magic_color(self):
     ip = get_ipython()
     c = ip.Completer
 
@@ -679,7 +721,7 b' def test_magic_color():'
     nt.assert_list_equal(['NoColor'], matches)
 
 
-def test_match_dict_keys():
+    def test_match_dict_keys(self):
     """
     Test that match_dict_keys works on a couple of use case does return what
     expected, and does not crash
@@ -701,7 +743,7 b' def test_match_dict_keys():'
     match_dict_keys
 
 
-def test_dict_key_completion_string():
+    def test_dict_key_completion_string(self):
     """Test dictionary key completion for string keys"""
     ip = get_ipython()
     complete = ip.Completer.complete
@@ -780,7 +822,7 b' def test_dict_key_completion_string():'
         _, matches = complete(line_buffer="d['before-af")
         nt.assert_in('before-after', matches)
 
-def test_dict_key_completion_contexts():
+    def test_dict_key_completion_contexts(self):
     """Test expression contexts in which dict key completion occurs"""
     ip = get_ipython()
     complete = ip.Completer.complete
@@ -831,7 +873,7 b' def test_dict_key_completion_contexts():'
 
 
 
-def test_dict_key_completion_bytes():
+    def test_dict_key_completion_bytes(self):
     """Test handling of bytes in dict key completion"""
     ip = get_ipython()
     complete = ip.Completer.complete
@@ -860,7 +902,7 b' def test_dict_key_completion_bytes():'
         nt.assert_not_in("abd", matches)
 
 
-def test_dict_key_completion_unicode_py3():
+    def test_dict_key_completion_unicode_py3(self):
     """Test handling of unicode in dict key completion"""
     ip = get_ipython()
     complete = ip.Completer.complete
@@ -889,7 +931,7 b' def test_dict_key_completion_unicode_py3():'
 
 
 @dec.skip_without('numpy')
-def test_struct_array_key_completion():
+    def test_struct_array_key_completion(self):
     """Test dict key completion applies to numpy struct arrays"""
     import numpy
     ip = get_ipython()
@@ -915,7 +957,7 b' def test_struct_array_key_completion():'
 
 
 @dec.skip_without('pandas')
-def test_dataframe_key_completion():
+    def test_dataframe_key_completion(self):
     """Test dict key completion applies to pandas DataFrames"""
     import pandas
     ip = get_ipython()
@@ -926,7 +968,7 b' def test_dataframe_key_completion():'
     nt.assert_in("world", matches)
 
 
-def test_dict_key_completion_invalids():
+    def test_dict_key_completion_invalids(self):
     """Smoke test cases dict key completion can't handle"""
     ip = get_ipython()
     complete = ip.Completer.complete
@@ -944,14 +986,7 b' def test_dict_key_completion_invalids():'
     _, matches = complete(line_buffer="name_error['")
     _, matches = complete(line_buffer="d['\\")  # incomplete escape
 
-class KeyCompletable(object):
-    def __init__(self, things=()):
-        self.things = things
-
-    def _ipython_key_completions_(self):
-        return list(self.things)
-
-def test_object_key_completion():
+    def test_object_key_completion(self):
     ip = get_ipython()
     ip.user_ns['key_completable'] = KeyCompletable(['qwerty', 'qwick'])
 
@@ -960,25 +995,8 b' def test_object_key_completion():'
     nt.assert_in('qwick', matches)
 
 
-class NamedInstanceMetaclass(type):
-    def __getitem__(cls, item):
-        return cls.get_instance(item)
-
-class NamedInstanceClass(object, metaclass=NamedInstanceMetaclass):
-    def __init__(self, name):
-        if not hasattr(self.__class__, 'instances'):
-            self.__class__.instances = {}
-        self.__class__.instances[name] = self
-
-    @classmethod
-    def _ipython_key_completions_(cls):
-        return cls.instances.keys()
-
-    @classmethod
-    def get_instance(cls, name):
-        return cls.instances[name]
 
-def test_class_key_completion():
+    def test_class_key_completion(self):
     ip = get_ipython()
     NamedInstanceClass('qwerty')
     NamedInstanceClass('qwick')
@@ -988,7 +1006,7 b' def test_class_key_completion():'
     nt.assert_in('qwerty', matches)
     nt.assert_in('qwick', matches)
 
-def test_tryimport():
+    def test_tryimport(self):
     """
     Test that try-import don't crash on trailing dot, and import modules before
     """
@@ -996,32 +1014,32 b' def test_tryimport():'
     assert(try_import("IPython."))
 
 
-def test_aimport_module_completer():
+    def test_aimport_module_completer(self):
     ip = get_ipython()
     _, matches = ip.complete('i', '%aimport i')
     nt.assert_in('io', matches)
     nt.assert_not_in('int', matches)
 
-def test_nested_import_module_completer():
+    def test_nested_import_module_completer(self):
     ip = get_ipython()
     _, matches = ip.complete(None, 'import IPython.co', 17)
     nt.assert_in('IPython.core', matches)
     nt.assert_not_in('import IPython.core', matches)
     nt.assert_not_in('IPython.display', matches)
 
-def test_import_module_completer():
+    def test_import_module_completer(self):
     ip = get_ipython()
     _, matches = ip.complete('i', 'import i')
     nt.assert_in('io', matches)
     nt.assert_not_in('int', matches)
 
-def test_from_module_completer():
+    def test_from_module_completer(self):
     ip = get_ipython()
     _, matches = ip.complete('B', 'from io import B', 16)
     nt.assert_in('BytesIO', matches)
     nt.assert_not_in('BaseException', matches)
 
-def test_snake_case_completion():
+    def test_snake_case_completion(self):
     ip = get_ipython()
     ip.Completer.use_jedi = False
     ip.user_ns['some_three'] = 3
@@ -1030,7 +1048,7 b' def test_snake_case_completion():'
     nt.assert_in('some_three', matches)
     nt.assert_in('some_four', matches)
 
-def test_mix_terms():
+    def test_mix_terms(self):
     ip = get_ipython()
     from textwrap import dedent
     ip.Completer.use_jedi = False