Merge pull request #13115 from kloczek/master

nose2pytest migration batch 1

IPython/core/tests/test_alias.py

@@ -1,65 +1,66 b''
 from IPython.utils.capture import capture_output
 
-import nose.tools as nt
+import pytest
 
 def test_alias_lifecycle():
     name = 'test_alias1'
     cmd = 'echo "Hello"'
     am = _ip.alias_manager
     am.clear_aliases()
     am.define_alias(name, cmd)
     assert am.is_alias(name)
-    nt.assert_equal(am.retrieve_alias(name), cmd)
-    nt.assert_in((name, cmd), am.aliases)
+    assert am.retrieve_alias(name) == cmd
+    assert (name, cmd) in am.aliases
     
     # Test running the alias
     orig_system = _ip.system
     result = []
     _ip.system = result.append
     try:
         _ip.run_cell('%{}'.format(name))
         result = [c.strip() for c in result]
-        nt.assert_equal(result, [cmd])
+        assert result == [cmd]
     finally:
         _ip.system = orig_system
     
     # Test removing the alias
     am.undefine_alias(name)
     assert not am.is_alias(name)
-    with nt.assert_raises(ValueError):
+    with pytest.raises(ValueError):
         am.retrieve_alias(name)
-    nt.assert_not_in((name, cmd), am.aliases)
+    assert (name, cmd) not in am.aliases
     
 
 def test_alias_args_error():
     """Error expanding with wrong number of arguments"""
     _ip.alias_manager.define_alias('parts', 'echo first %s second %s')
     # capture stderr:
     with capture_output() as cap:
         _ip.run_cell('parts 1')
 
-    nt.assert_equal(cap.stderr.split(':')[0], 'UsageError')
+    assert cap.stderr.split(":")[0] == "UsageError"
+
 
 def test_alias_args_commented():
     """Check that alias correctly ignores 'commented out' args"""
     _ip.magic('alias commetarg echo this is %%s a commented out arg')
     
     with capture_output() as cap:
         _ip.run_cell('commetarg')
     
     # strip() is for pytest compat; testing via iptest patch IPython shell
     # in testin.globalipapp and replace the system call which messed up the
     # \r\n
     assert cap.stdout.strip() ==  'this is %s a commented out arg'
 
 def test_alias_args_commented_nargs():
     """Check that alias correctly counts args, excluding those commented out"""
     am = _ip.alias_manager
     alias_name = 'comargcount'
     cmd = 'echo this is %%s a commented out arg and this is not %s'
     
     am.define_alias(alias_name, cmd)
     assert am.is_alias(alias_name)
     
     thealias = am.get_alias(alias_name)
-    nt.assert_equal(thealias.nargs, 1)
+    assert thealias.nargs == 1

IPython/core/tests/test_compilerop.py

@@ -1,73 +1,73 b''
 # coding: utf-8
 """Tests for the compilerop module.
 """
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2010-2011 The IPython Development Team.
 #
 #  Distributed under the terms of the BSD License.
 #
 #  The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Stdlib imports
 import linecache
 import sys
 
 # Third-party imports
-import nose.tools as nt
+import pytest
 
 # Our own imports
 from IPython.core import compilerop
 
 #-----------------------------------------------------------------------------
 # Test functions
 #-----------------------------------------------------------------------------
 
 def test_code_name():
     code = 'x=1'
     name = compilerop.code_name(code)
-    nt.assert_true(name.startswith('<ipython-input-0'))
+    assert name.startswith("<ipython-input-0")
 
 
 def test_code_name2():
     code = 'x=1'
     name = compilerop.code_name(code, 9)
-    nt.assert_true(name.startswith('<ipython-input-9'))
+    assert name.startswith("<ipython-input-9")
 
 
 def test_cache():
     """Test the compiler correctly compiles and caches inputs
     """
     cp = compilerop.CachingCompiler()
     ncache = len(linecache.cache)
     cp.cache('x=1')
-    nt.assert_true(len(linecache.cache) > ncache)
+    assert len(linecache.cache) > ncache
 
 def test_proper_default_encoding():
     # Check we're in a proper Python 2 environment (some imports, such
     # as GTK, can change the default encoding, which can hide bugs.)
-    nt.assert_equal(sys.getdefaultencoding(), "utf-8")
+    assert sys.getdefaultencoding() == "utf-8"
 
 def test_cache_unicode():
     cp = compilerop.CachingCompiler()
     ncache = len(linecache.cache)
     cp.cache(u"t = 'žćčšđ'")
-    nt.assert_true(len(linecache.cache) > ncache)
+    assert len(linecache.cache) > ncache
 
 def test_compiler_check_cache():
     """Test the compiler properly manages the cache.
     """
     # Rather simple-minded tests that just exercise the API
     cp = compilerop.CachingCompiler()
     cp.cache('x=1', 99)
     # Ensure now that after clearing the cache, our entries survive
     linecache.checkcache()
     for k in linecache.cache:
         if k.startswith('<ipython-input-99'):
             break
     else:
         raise AssertionError('Entry for input-99 missing from linecache')

IPython/core/tests/test_inputtransformer2_line.py

@@ -1,166 +1,168 b''
 """Tests for the line-based transformers in IPython.core.inputtransformer2
 
 Line-based transformers are the simpler ones; token-based transformers are
 more complex. See test_inputtransformer2 for tests for token-based transformers.
 """
-import nose.tools as nt
+import pytest
 
 from IPython.core import inputtransformer2 as ipt2
 
 CELL_MAGIC = ("""\
 %%foo arg
 body 1
 body 2
 """, """\
 get_ipython().run_cell_magic('foo', 'arg', 'body 1\\nbody 2\\n')
 """)
 
 def test_cell_magic():
     for sample, expected in [CELL_MAGIC]:
-        nt.assert_equal(ipt2.cell_magic(sample.splitlines(keepends=True)),
-                        expected.splitlines(keepends=True))
+        assert ipt2.cell_magic(sample.splitlines(keepends=True)) == expected.splitlines(
+            keepends=True
+        )
 
 CLASSIC_PROMPT = ("""\
 >>> for a in range(5):
 ...     print(a)
 """, """\
 for a in range(5):
     print(a)
 """)
 
 CLASSIC_PROMPT_L2 = ("""\
 for a in range(5):
 ...     print(a)
 ...     print(a ** 2)
 """, """\
 for a in range(5):
     print(a)
     print(a ** 2)
 """)
 
 def test_classic_prompt():
     for sample, expected in [CLASSIC_PROMPT, CLASSIC_PROMPT_L2]:
-        nt.assert_equal(ipt2.classic_prompt(sample.splitlines(keepends=True)),
-                        expected.splitlines(keepends=True))
+        assert ipt2.classic_prompt(
+            sample.splitlines(keepends=True)
+        ) == expected.splitlines(keepends=True)
 
 IPYTHON_PROMPT = ("""\
 In [1]: for a in range(5):
    ...:     print(a)
 """, """\
 for a in range(5):
     print(a)
 """)
 
 IPYTHON_PROMPT_L2 = ("""\
 for a in range(5):
    ...:     print(a)
    ...:     print(a ** 2)
 """, """\
 for a in range(5):
     print(a)
     print(a ** 2)
 """)
 
 
 IPYTHON_PROMPT_VI_INS = (
     """\
 [ins] In [11]: def a():
           ...:     123
           ...:
           ...: 123
 """,
     """\
 def a():
     123
 
 123
 """,
 )
 
 IPYTHON_PROMPT_VI_NAV = (
     """\
 [nav] In [11]: def a():
           ...:     123
           ...:
           ...: 123
 """,
     """\
 def a():
     123
 
 123
 """,
 )
 
 
 def test_ipython_prompt():
     for sample, expected in [
         IPYTHON_PROMPT,
         IPYTHON_PROMPT_L2,
         IPYTHON_PROMPT_VI_INS,
         IPYTHON_PROMPT_VI_NAV,
     ]:
-        nt.assert_equal(
-            ipt2.ipython_prompt(sample.splitlines(keepends=True)),
-            expected.splitlines(keepends=True),
-        )
+        assert ipt2.ipython_prompt(
+            sample.splitlines(keepends=True)
+        ) == expected.splitlines(keepends=True)
 
 
 INDENT_SPACES = ("""\
      if True:
         a = 3
 """, """\
 if True:
    a = 3
 """)
 
 INDENT_TABS = ("""\
 \tif True:
 \t\tb = 4
 """, """\
 if True:
 \tb = 4
 """)
 
 def test_leading_indent():
     for sample, expected in [INDENT_SPACES, INDENT_TABS]:
-        nt.assert_equal(ipt2.leading_indent(sample.splitlines(keepends=True)),
-                        expected.splitlines(keepends=True))
+        assert ipt2.leading_indent(
+            sample.splitlines(keepends=True)
+        ) == expected.splitlines(keepends=True)
 
 LEADING_EMPTY_LINES = ("""\
     \t
 
 if True:
     a = 3
 
 b = 4
 """, """\
 if True:
     a = 3
 
 b = 4
 """)
 
 ONLY_EMPTY_LINES = ("""\
     \t
 
 """, """\
     \t
 
 """)
 
 def test_leading_empty_lines():
     for sample, expected in [LEADING_EMPTY_LINES, ONLY_EMPTY_LINES]:
-        nt.assert_equal(
-                ipt2.leading_empty_lines(sample.splitlines(keepends=True)),
-                expected.splitlines(keepends=True))
+        assert ipt2.leading_empty_lines(
+            sample.splitlines(keepends=True)
+        ) == expected.splitlines(keepends=True)
 
 CRLF_MAGIC = ([
     "%%ls\r\n"
 ], [
     "get_ipython().run_cell_magic('ls', '', '')\n"
 ])
 
 def test_crlf_magic():
     for sample, expected in [CRLF_MAGIC]:
-        nt.assert_equal(ipt2.cell_magic(sample), expected)
+        assert ipt2.cell_magic(sample) == expected

IPython/core/tests/test_iplib.py

@@ -1,238 +1,241 b''
 """Tests for the key interactiveshell module, where the main ipython class is defined.
 """
 #-----------------------------------------------------------------------------
 # Module imports
 #-----------------------------------------------------------------------------
 
 # third party
-import nose.tools as nt
+import pytest
 
 # our own packages
 
 #-----------------------------------------------------------------------------
 # Test functions
 #-----------------------------------------------------------------------------
 
 def test_reset():
     """reset must clear most namespaces."""
 
     # Check that reset runs without error
     ip.reset()
 
     # Once we've reset it (to clear of any junk that might have been there from
     # other tests, we can count how many variables are in the user's namespace
     nvars_user_ns = len(ip.user_ns)
     nvars_hidden = len(ip.user_ns_hidden)
 
     # Now add a few variables to user_ns, and check that reset clears them
     ip.user_ns['x'] = 1
     ip.user_ns['y'] = 1
     ip.reset()
     
     # Finally, check that all namespaces have only as many variables as we
     # expect to find in them:
-    nt.assert_equal(len(ip.user_ns), nvars_user_ns)
-    nt.assert_equal(len(ip.user_ns_hidden), nvars_hidden)
+    assert len(ip.user_ns) == nvars_user_ns
+    assert len(ip.user_ns_hidden) == nvars_hidden
 
 
 # Tests for reporting of exceptions in various modes, handling of SystemExit,
 # and %tb functionality.  This is really a mix of testing ultraTB and interactiveshell.
 
 def doctest_tb_plain():
     """
 In [18]: xmode plain
 Exception reporting mode: Plain
 
 In [19]: run simpleerr.py
 Traceback (most recent call last):
   ...line 32, in <module>
     bar(mode)
   ...line 16, in bar
     div0()
   ...line 8, in div0
     x/y
 ZeroDivisionError: ...
     """
 
 
 def doctest_tb_context():
     """
 In [3]: xmode context
 Exception reporting mode: Context
 
 In [4]: run simpleerr.py
 ---------------------------------------------------------------------------
 ZeroDivisionError                         Traceback (most recent call last)
 <BLANKLINE>
 ... in <module>
      29     except IndexError:
      30         mode = 'div'
 ---> 32     bar(mode)
 <BLANKLINE>
 ... in bar(mode)
      14     "bar"
      15     if mode=='div':
 ---> 16         div0()
      17     elif mode=='exit':
      18         try:
 <BLANKLINE>
 ... in div0()
       6     x = 1
       7     y = 0
 ----> 8     x/y
 <BLANKLINE>
 ZeroDivisionError: ...
 """
 
 
 def doctest_tb_verbose():
     """
-In [5]: xmode verbose
-Exception reporting mode: Verbose
+    In [5]: xmode verbose
+    Exception reporting mode: Verbose
+
+    In [6]: run simpleerr.py
+    ---------------------------------------------------------------------------
+    ZeroDivisionError                         Traceback (most recent call last)
+    <BLANKLINE>
+    ... in <module>
+         29     except IndexError:
+         30         mode = 'div'
+    ---> 32     bar(mode)
+            mode = 'div'
+    <BLANKLINE>
+    ... in bar(mode='div')
+         14     "bar"
+         15     if mode=='div':
+    ---> 16         div0()
+         17     elif mode=='exit':
+         18         try:
+    <BLANKLINE>
+    ... in div0()
+          6     x = 1
+          7     y = 0
+    ----> 8     x/y
+            x = 1
+            y = 0
+    <BLANKLINE>
+    ZeroDivisionError: ...
+    """
 
-In [6]: run simpleerr.py
----------------------------------------------------------------------------
-ZeroDivisionError                         Traceback (most recent call last)
-<BLANKLINE>
-... in <module>
-     29     except IndexError:
-     30         mode = 'div'
----> 32     bar(mode)
-        mode = 'div'
-<BLANKLINE>
-... in bar(mode='div')
-     14     "bar"
-     15     if mode=='div':
----> 16         div0()
-     17     elif mode=='exit':
-     18         try:
-<BLANKLINE>
-... in div0()
-      6     x = 1
-      7     y = 0
-----> 8     x/y
-        x = 1
-        y = 0
-<BLANKLINE>
-ZeroDivisionError: ...
-      """
 
 # TODO : Marc 2021 – this seem to fail due
 # to upstream changes in CI for whatever reason.
 # Commenting for now, to revive someday (maybe?)
 # nose won't work in 3.10 anyway and we'll have to disable iptest.
 # thus this likely need to bemigrated to pytest.
 
 
 # def doctest_tb_sysexit():
 #     """
 # In [17]: %xmode plain
 # Exception reporting mode: Plain
 #
 # In [18]: %run simpleerr.py exit
 # An exception has occurred, use %tb to see the full traceback.
 # SystemExit: (1, 'Mode = exit')
 #
 # In [19]: %run simpleerr.py exit 2
 # An exception has occurred, use %tb to see the full traceback.
 # SystemExit: (2, 'Mode = exit')
 #
 # In [20]: %tb
 # Traceback (most recent call last):
 #   File ... in <module>
 #     bar(mode)
 #   File ... line 22, in bar
 #     sysexit(stat, mode)
 #   File ... line 11, in sysexit
 #     raise SystemExit(stat, 'Mode = %s' % mode)
 # SystemExit: (2, 'Mode = exit')
 #
 # In [21]: %xmode context
 # Exception reporting mode: Context
 #
 # In [22]: %tb
 # ---------------------------------------------------------------------------
 # SystemExit                                Traceback (most recent call last)
 # <BLANKLINE>
 # ...<module>
 #      29     except IndexError:
 #      30         mode = 'div'
 # ---> 32     bar(mode)
 # <BLANKLINE>
 # ...bar(mode)
 #      20         except:
 #      21             stat = 1
 # ---> 22         sysexit(stat, mode)
 #      23     else:
 #      24         raise ValueError('Unknown mode')
 # <BLANKLINE>
 # ...sysexit(stat, mode)
 #      10 def sysexit(stat, mode):
 # ---> 11     raise SystemExit(stat, 'Mode = %s' % mode)
 # <BLANKLINE>
 # SystemExit: (2, 'Mode = exit')
 #
 # In [23]: %xmode verbose
 # Exception reporting mode: Verbose
 #
 # In [24]: %tb
 # ---------------------------------------------------------------------------
 # SystemExit                                Traceback (most recent call last)
 # <BLANKLINE>
 # ... in <module>
 #      29     except IndexError:
 #      30         mode = 'div'
 # ---> 32     bar(mode)
 #         mode = 'exit'
 # <BLANKLINE>
 # ... in bar(mode='exit')
 #      20         except:
 #      21             stat = 1
 # ---> 22         sysexit(stat, mode)
 #         mode = 'exit'
 #         stat = 2
 #      23     else:
 #      24         raise ValueError('Unknown mode')
 # <BLANKLINE>
 # ... in sysexit(stat=2, mode='exit')
 #      10 def sysexit(stat, mode):
 # ---> 11     raise SystemExit(stat, 'Mode = %s' % mode)
 #         stat = 2
 #         mode = 'exit'
 # <BLANKLINE>
 # SystemExit: (2, 'Mode = exit')
 #     """
 
 
 def test_run_cell():
     import textwrap
-    ip.run_cell('a = 10\na+=1')
-    ip.run_cell('assert a == 11\nassert 1')
 
-    nt.assert_equal(ip.user_ns['a'], 11)
-    complex = textwrap.dedent("""
+    ip.run_cell("a = 10\na+=1")
+    ip.run_cell("assert a == 11\nassert 1")
+
+    assert ip.user_ns["a"] == 11
+    complex = textwrap.dedent(
+        """
     if 1:
         print "hello"
         if 1:
             print "world"
         
     if 2:
         print "foo"
 
     if 3:
         print "bar"
 
     if 4:
         print "bar"
     
     """)
     # Simply verifies that this kind of input is run
     ip.run_cell(complex)
     
 
 def test_db():
     """Test the internal database used for variable persistence."""
-    ip.db['__unittest_'] = 12
-    nt.assert_equal(ip.db['__unittest_'], 12)
-    del ip.db['__unittest_']
-    assert '__unittest_' not in ip.db
+    ip.db["__unittest_"] = 12
+    assert ip.db["__unittest_"] == 12
+    del ip.db["__unittest_"]
+    assert "__unittest_" not in ip.db

IPython/core/tests/test_logger.py

@@ -1,30 +1,30 b''
 # -*- coding: utf-8 -*-
 """Test IPython.core.logger"""
 
 import os.path
+import pytest
 
-import nose.tools as nt
 from IPython.utils.tempdir import TemporaryDirectory
 
 def test_logstart_inaccessible_file():
     try:
         _ip.logger.logstart(logfname="/")   # Opening that filename will fail.
     except IOError:
         pass
     else:
-        nt.assert_true(False)           # The try block should never pass.
-    
+        assert False  # The try block should never pass.
+
     try:
         _ip.run_cell("a=1")                 # Check it doesn't try to log this
     finally:
         _ip.logger.log_active = False  # If this fails, don't let later tests fail
 
 def test_logstart_unicode():
     with TemporaryDirectory() as tdir:
         logfname = os.path.join(tdir, "test_unicode.log")
         _ip.run_cell("'abc€'")
         try:
             _ip.magic("logstart -to %s" % logfname)
             _ip.run_cell("'abc€'")
         finally:
             _ip.logger.logstop()

IPython/core/tests/test_magic_arguments.py

@@ -1,118 +1,135 b''
 #-----------------------------------------------------------------------------
 # Copyright (C) 2010-2011, IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 import argparse
-from nose.tools import assert_equal
+import pytest
 
 from IPython.core.magic_arguments import (argument, argument_group, kwds,
     magic_arguments, parse_argstring, real_name)
 
 
 @magic_arguments()
 @argument('-f', '--foo', help="an argument")
 def magic_foo1(self, args):
     """ A docstring.
     """
     return parse_argstring(magic_foo1, args)
 
 
 @magic_arguments()
 def magic_foo2(self, args):
     """ A docstring.
     """
     return parse_argstring(magic_foo2, args)
 
 
 @magic_arguments()
 @argument('-f', '--foo', help="an argument")
 @argument_group('Group')
 @argument('-b', '--bar', help="a grouped argument")
 @argument_group('Second Group')
 @argument('-z', '--baz', help="another grouped argument")
 def magic_foo3(self, args):
     """ A docstring.
     """
     return parse_argstring(magic_foo3, args)
 
 
 @magic_arguments()
 @kwds(argument_default=argparse.SUPPRESS)
 @argument('-f', '--foo', help="an argument")
 def magic_foo4(self, args):
     """ A docstring.
     """
     return parse_argstring(magic_foo4, args)
 
 
 @magic_arguments('frobnicate')
 @argument('-f', '--foo', help="an argument")
 def magic_foo5(self, args):
     """ A docstring.
     """
     return parse_argstring(magic_foo5, args)
 
 
 @magic_arguments()
 @argument('-f', '--foo', help="an argument")
 def magic_magic_foo(self, args):
     """ A docstring.
     """
     return parse_argstring(magic_magic_foo, args)
 
 
 @magic_arguments()
 @argument('-f', '--foo', help="an argument")
 def foo(self, args):
     """ A docstring.
     """
     return parse_argstring(foo, args)
 
 
 def test_magic_arguments():
-    assert_equal(magic_foo1.__doc__, '::\n\n  %foo1 [-f FOO]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n')
-    assert_equal(getattr(magic_foo1, 'argcmd_name', None), None)
-    assert_equal(real_name(magic_foo1), 'foo1')
-    assert_equal(magic_foo1(None, ''), argparse.Namespace(foo=None))
-    assert hasattr(magic_foo1, 'has_arguments')
-
-    assert_equal(magic_foo2.__doc__, '::\n\n  %foo2\n\n A docstring.\n')
-    assert_equal(getattr(magic_foo2, 'argcmd_name', None), None)
-    assert_equal(real_name(magic_foo2), 'foo2')
-    assert_equal(magic_foo2(None, ''), argparse.Namespace())
-    assert hasattr(magic_foo2, 'has_arguments')
-
-    assert_equal(magic_foo3.__doc__, '::\n\n  %foo3 [-f FOO] [-b BAR] [-z BAZ]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n\nGroup:\n  -b BAR, --bar BAR  a grouped argument\n\nSecond Group:\n  -z BAZ, --baz BAZ  another grouped argument\n')
-    assert_equal(getattr(magic_foo3, 'argcmd_name', None), None)
-    assert_equal(real_name(magic_foo3), 'foo3')
-    assert_equal(magic_foo3(None, ''),
-                       argparse.Namespace(bar=None, baz=None, foo=None))
-    assert hasattr(magic_foo3, 'has_arguments')
-
-    assert_equal(magic_foo4.__doc__, '::\n\n  %foo4 [-f FOO]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n')
-    assert_equal(getattr(magic_foo4, 'argcmd_name', None), None)
-    assert_equal(real_name(magic_foo4), 'foo4')
-    assert_equal(magic_foo4(None, ''), argparse.Namespace())
-    assert hasattr(magic_foo4, 'has_arguments')
-
-    assert_equal(magic_foo5.__doc__, '::\n\n  %frobnicate [-f FOO]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n')
-    assert_equal(getattr(magic_foo5, 'argcmd_name', None), 'frobnicate')
-    assert_equal(real_name(magic_foo5), 'frobnicate')
-    assert_equal(magic_foo5(None, ''), argparse.Namespace(foo=None))
-    assert hasattr(magic_foo5, 'has_arguments')
-
-    assert_equal(magic_magic_foo.__doc__, '::\n\n  %magic_foo [-f FOO]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n')
-    assert_equal(getattr(magic_magic_foo, 'argcmd_name', None), None)
-    assert_equal(real_name(magic_magic_foo), 'magic_foo')
-    assert_equal(magic_magic_foo(None, ''), argparse.Namespace(foo=None))
-    assert hasattr(magic_magic_foo, 'has_arguments')
-
-    assert_equal(foo.__doc__, '::\n\n  %foo [-f FOO]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n')
-    assert_equal(getattr(foo, 'argcmd_name', None), None)
-    assert_equal(real_name(foo), 'foo')
-    assert_equal(foo(None, ''), argparse.Namespace(foo=None))
-    assert hasattr(foo, 'has_arguments')
+    assert (
+        magic_foo1.__doc__
+        == "::\n\n  %foo1 [-f FOO]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n"
+    )
+    assert getattr(magic_foo1, "argcmd_name", None) == None
+    assert real_name(magic_foo1) == "foo1"
+    assert magic_foo1(None, "") == argparse.Namespace(foo=None)
+    assert hasattr(magic_foo1, "has_arguments")
+
+    assert magic_foo2.__doc__ == "::\n\n  %foo2\n\n A docstring.\n"
+    assert getattr(magic_foo2, "argcmd_name", None) == None
+    assert real_name(magic_foo2) == "foo2"
+    assert magic_foo2(None, "") == argparse.Namespace()
+    assert hasattr(magic_foo2, "has_arguments")
+
+    assert (
+        magic_foo3.__doc__
+        == "::\n\n  %foo3 [-f FOO] [-b BAR] [-z BAZ]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n\nGroup:\n  -b BAR, --bar BAR  a grouped argument\n\nSecond Group:\n  -z BAZ, --baz BAZ  another grouped argument\n"
+    )
+    assert getattr(magic_foo3, "argcmd_name", None) == None
+    assert real_name(magic_foo3) == "foo3"
+    assert magic_foo3(None, "") == argparse.Namespace(bar=None, baz=None, foo=None)
+    assert hasattr(magic_foo3, "has_arguments")
+
+    assert (
+        magic_foo4.__doc__
+        == "::\n\n  %foo4 [-f FOO]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n"
+    )
+    assert getattr(magic_foo4, "argcmd_name", None) == None
+    assert real_name(magic_foo4) == "foo4"
+    assert magic_foo4(None, "") == argparse.Namespace()
+    assert hasattr(magic_foo4, "has_arguments")
+
+    assert (
+        magic_foo5.__doc__
+        == "::\n\n  %frobnicate [-f FOO]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n"
+    )
+    assert getattr(magic_foo5, "argcmd_name", None) == "frobnicate"
+    assert real_name(magic_foo5) == "frobnicate"
+    assert magic_foo5(None, "") == argparse.Namespace(foo=None)
+    assert hasattr(magic_foo5, "has_arguments")
+
+    assert (
+        magic_magic_foo.__doc__
+        == "::\n\n  %magic_foo [-f FOO]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n"
+    )
+    assert getattr(magic_magic_foo, "argcmd_name", None) == None
+    assert real_name(magic_magic_foo) == "magic_foo"
+    assert magic_magic_foo(None, "") == argparse.Namespace(foo=None)
+    assert hasattr(magic_magic_foo, "has_arguments")
+
+    assert (
+        foo.__doc__
+        == "::\n\n  %foo [-f FOO]\n\n A docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n"
+    )
+    assert getattr(foo, "argcmd_name", None) == None
+    assert real_name(foo) == "foo"
+    assert foo(None, "") == argparse.Namespace(foo=None)
+    assert hasattr(foo, "has_arguments")

IPython/core/tests/test_prefilter.py

@@ -1,127 +1,127 b''
 """Tests for input manipulation machinery."""
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
-import nose.tools as nt
+import pytest
 
 from IPython.core.prefilter import AutocallChecker
 
 #-----------------------------------------------------------------------------
 # Tests
 #-----------------------------------------------------------------------------
 
 def test_prefilter():
     """Test user input conversions"""
 
     # pairs of (raw, expected correct) input
     pairs = [ ('2+2','2+2'),
              ]
 
     for raw, correct in pairs:
-        nt.assert_equal(ip.prefilter(raw), correct)
+        assert ip.prefilter(raw) == correct
 
 def test_prefilter_shadowed():
     def dummy_magic(line): pass
 
     prev_automagic_state = ip.automagic
     ip.automagic = True
     ip.autocall = 0
 
     try:
         # These should not be transformed - they are shadowed by other names
         for name in ['if', 'zip', 'get_ipython']: # keyword, builtin, global
             ip.register_magic_function(dummy_magic, magic_name=name)
-            res = ip.prefilter(name+' foo')
-            nt.assert_equal(res, name+' foo')
-            del ip.magics_manager.magics['line'][name]
+            res = ip.prefilter(name + " foo")
+            assert res == name + " foo"
+            del ip.magics_manager.magics["line"][name]
 
         # These should be transformed
         for name in ['fi', 'piz', 'nohtypi_teg']:
             ip.register_magic_function(dummy_magic, magic_name=name)
-            res = ip.prefilter(name+' foo')
-            nt.assert_not_equal(res, name+' foo')
-            del ip.magics_manager.magics['line'][name]
+            res = ip.prefilter(name + " foo")
+            assert res != name + " foo"
+            del ip.magics_manager.magics["line"][name]
 
     finally:
         ip.automagic = prev_automagic_state
 
 def test_autocall_binops():
     """See https://github.com/ipython/ipython/issues/81"""
     ip.magic('autocall 2')
     f = lambda x: x
     ip.user_ns['f'] = f
     try:
-        nt.assert_equal(ip.prefilter('f 1'),'f(1)')
-        for t in ['f +1', 'f -1']:
-            nt.assert_equal(ip.prefilter(t), t)
+        assert ip.prefilter("f 1") == "f(1)"
+        for t in ["f +1", "f -1"]:
+            assert ip.prefilter(t) == t
 
         # Run tests again with a more permissive exclude_regexp, which will
         # allow transformation of binary operations ('f -1' -> 'f(-1)').
         pm = ip.prefilter_manager
         ac = AutocallChecker(shell=pm.shell, prefilter_manager=pm,
                              config=pm.config)
         try:
             ac.priority = 1
             ac.exclude_regexp = r'^[,&^\|\*/]|^is |^not |^in |^and |^or '
             pm.sort_checkers()
 
-            nt.assert_equal(ip.prefilter('f -1'), 'f(-1)')
-            nt.assert_equal(ip.prefilter('f +1'), 'f(+1)')
+            assert ip.prefilter("f -1") == "f(-1)"
+            assert ip.prefilter("f +1") == "f(+1)"
         finally:
             pm.unregister_checker(ac)
     finally:
         ip.magic('autocall 0')
         del ip.user_ns['f']
 
 
 def test_issue_114():
     """Check that multiline string literals don't expand as magic
     see http://github.com/ipython/ipython/issues/114"""
 
     template = '"""\n%s\n"""'
     # Store the current value of multi_line_specials and turn it off before
     # running test, since it could be true (case in which the test doesn't make
     # sense, as multiline string literals *will* expand as magic in that case).
     msp = ip.prefilter_manager.multi_line_specials
     ip.prefilter_manager.multi_line_specials = False
     try:
         for mgk in ip.magics_manager.lsmagic()['line']:
             raw = template % mgk
-            nt.assert_equal(ip.prefilter(raw), raw)
+            assert ip.prefilter(raw) == raw
     finally:
         ip.prefilter_manager.multi_line_specials = msp
 
 
 def test_prefilter_attribute_errors():
     """Capture exceptions thrown by user objects on attribute access.
 
     See http://github.com/ipython/ipython/issues/988."""
 
     class X(object):
         def __getattr__(self, k):
             raise ValueError('broken object')
         def __call__(self, x):
             return x
 
     # Create a callable broken object
     ip.user_ns['x'] = X()
     ip.magic('autocall 2')
     try:
         # Even if x throws an attribute error when looking at its rewrite
         # attribute, we should not crash.  So the test here is simply making
         # the prefilter call and not having an exception.
         ip.prefilter('x 1')
     finally:
         del ip.user_ns['x']
         ip.magic('autocall 0')
 
 
 def test_autocall_should_support_unicode():
     ip.magic('autocall 2')
     ip.user_ns['π'] = lambda x: x
     try:
-        nt.assert_equal(ip.prefilter('π 3'),'π(3)')
+        assert ip.prefilter("π 3") == "π(3)"
     finally:
         ip.magic('autocall 0')
         del ip.user_ns['π']