[core][tests][magic] Remove nose

IPython/core/tests/test_magic.py

@@ -17,8 +17,6 b' from pathlib import Path'
 from textwrap import dedent
 from unittest import TestCase, mock
 
-import nose.tools as nt
-
 import pytest
 
 from IPython import get_ipython
@@ -47,7 +45,8 b' class DummyMagics(magic.Magics): pass'
 
 def test_extract_code_ranges():
     instr = "1 3 5-6 7-9 10:15 17: :10 10- -13 :"
-    expected = [(0, 1), 
+    expected = [
+        (0, 1),
                 (2, 3),
                 (4, 6),
                 (6, 9),
@@ -56,9 +55,10 b' def test_extract_code_ranges():'
                 (None, 9),
                 (9, None),
                 (None, 13),
-                (None, None)]
+        (None, None),
+    ]
     actual = list(code.extract_code_ranges(instr))
-    nt.assert_equal(actual, expected)
+    assert actual == expected
 
 def test_extract_symbols():
     source = """import foo\na = 10\ndef b():\n    return 42\n\n\nclass A: pass\n\n\n"""
@@ -70,7 +70,7 b' def test_extract_symbols():'
                 (["class A: pass\n"], ['a']),
                 ([], ['z'])]
     for symbols, exp in zip(symbols_args, expected):
-        nt.assert_equal(code.extract_symbols(source, symbols), exp)
+        assert code.extract_symbols(source, symbols) == exp
 
 
 def test_extract_symbols_raises_exception_with_non_python_code():
@@ -78,13 +78,13 b' def test_extract_symbols_raises_exception_with_non_python_code():'
               "def hello\n"
               "puts 'Hello world'\n"
               "end")
-    with nt.assert_raises(SyntaxError):
+    with pytest.raises(SyntaxError):
         code.extract_symbols(source, "hello")
 
 
 def test_magic_not_found():
     # magic not found raises UsageError
-    with nt.assert_raises(UsageError):
+    with pytest.raises(UsageError):
         _ip.magic('doesntexist')
 
     # ensure result isn't success when a magic isn't found
@@ -94,7 +94,7 b' def test_magic_not_found():'
 
 def test_cell_magic_not_found():
     # magic not found raises UsageError
-    with nt.assert_raises(UsageError):
+    with pytest.raises(UsageError):
         _ip.run_cell_magic('doesntexist', 'line', 'cell')
 
     # ensure result isn't success when a magic isn't found
@@ -127,7 +127,7 b' def test_config_available_configs():'
 
     stdout = captured.stdout
     config_classes = stdout.strip().split('\n')[1:]
-    nt.assert_list_equal(config_classes, sorted(set(config_classes)))
+    assert config_classes == sorted(set(config_classes))
 
 def test_config_print_class():
     """ test that config with a classname prints the class's options. """
@@ -148,15 +148,14 b' def test_rehashx():'
     _ip.magic('rehashx')
     # Practically ALL ipython development systems will have more than 10 aliases
 
-    nt.assert_true(len(_ip.alias_manager.aliases) > 10)
+    assert len(_ip.alias_manager.aliases) > 10
     for name, cmd in _ip.alias_manager.aliases:
         # we must strip dots from alias names
-        nt.assert_not_in('.', name)
+        assert "." not in name
 
     # rehashx must fill up syscmdlist
     scoms = _ip.db['syscmdlist']
-    nt.assert_true(len(scoms) > 10)
-            
+    assert len(scoms) > 10
 
 
 def test_magic_parse_options():
@@ -170,16 +169,17 b' def test_magic_parse_options():'
         expected = 'c:x'
     else:
         expected = path
-    nt.assert_equal(opts['f'], expected)
+    assert opts["f"] == expected
+
 
 def test_magic_parse_long_options():
     """Magic.parse_options can handle --foo=bar long options"""
     ip = get_ipython()
     m = DummyMagics(ip)
-    opts, _ = m.parse_options('--foo --bar=bubble', 'a', 'foo', 'bar=')
-    nt.assert_in('foo', opts)
-    nt.assert_in('bar', opts)
-    nt.assert_equal(opts['bar'], "bubble")
+    opts, _ = m.parse_options("--foo --bar=bubble", "a", "foo", "bar=")
+    assert "foo" in opts
+    assert "bar" in opts
+    assert opts["bar"] == "bubble"
 
 
 def doctest_hist_f():
@@ -263,7 +263,7 b' def doctest_hist_op():'
 
 def test_hist_pof():
     ip = get_ipython()
-    ip.run_cell(u"1+2", store_history=True)
+    ip.run_cell("1+2", store_history=True)
     #raise Exception(ip.history_manager.session_number)
     #raise Exception(list(ip.history_manager._get_range_session()))
     with TemporaryDirectory() as td:
@@ -279,10 +279,10 b' def test_macro():'
     for i, cmd in enumerate(cmds, start=1):
         ip.history_manager.store_inputs(i, cmd)
     ip.magic("macro test 1-3")
-    nt.assert_equal(ip.user_ns["test"].value, "\n".join(cmds)+"\n")
+    assert ip.user_ns["test"].value == "\n".join(cmds) + "\n"
     
     # List macros
-    nt.assert_in("test", ip.magic("macro"))
+    assert "test" in ip.magic("macro")
 
 
 def test_macro_run():
@@ -292,7 +292,7 b' def test_macro_run():'
     cmds = ["a=10", "a+=1", "print(a)", "%macro test 2-3"]
     for cmd in cmds:
         ip.run_cell(cmd, store_history=True)
-    nt.assert_equal(ip.user_ns["test"].value, "a+=1\nprint(a)\n")
+    assert ip.user_ns["test"].value == "a+=1\nprint(a)\n"
     with tt.AssertPrints("12"):
         ip.run_cell("test")
     with tt.AssertPrints("13"):
@@ -306,54 +306,59 b' def test_magic_magic():'
         ip.magic("magic")
     
     stdout = captured.stdout
-    nt.assert_in('%magic', stdout)
-    nt.assert_in('IPython', stdout)
-    nt.assert_in('Available', stdout)
+    assert "%magic" in stdout
+    assert "IPython" in stdout
+    assert "Available" in stdout
 
 
 @dec.skipif_not_numpy
 def test_numpy_reset_array_undec():
     "Test '%reset array' functionality"
-    _ip.ex('import numpy as np')
-    _ip.ex('a = np.empty(2)')
-    nt.assert_in('a', _ip.user_ns)
-    _ip.magic('reset -f array')
-    nt.assert_not_in('a', _ip.user_ns)
+    _ip.ex("import numpy as np")
+    _ip.ex("a = np.empty(2)")
+    assert "a" in _ip.user_ns
+    _ip.magic("reset -f array")
+    assert "a" not in _ip.user_ns
+
 
 def test_reset_out():
     "Test '%reset out' magic"
     _ip.run_cell("parrot = 'dead'", store_history=True)
     # test '%reset -f out', make an Out prompt
     _ip.run_cell("parrot", store_history=True)
-    nt.assert_true('dead' in [_ip.user_ns[x] for x in ('_','__','___')])
-    _ip.magic('reset -f out')
-    nt.assert_false('dead' in [_ip.user_ns[x] for x in ('_','__','___')])
-    nt.assert_equal(len(_ip.user_ns['Out']), 0)
+    assert "dead" in [_ip.user_ns[x] for x in ("_", "__", "___")]
+    _ip.magic("reset -f out")
+    assert "dead" not in [_ip.user_ns[x] for x in ("_", "__", "___")]
+    assert len(_ip.user_ns["Out"]) == 0
+
 
 def test_reset_in():
     "Test '%reset in' magic"
     # test '%reset -f in'
     _ip.run_cell("parrot", store_history=True)
-    nt.assert_true('parrot' in [_ip.user_ns[x] for x in ('_i','_ii','_iii')])
-    _ip.magic('%reset -f in')
-    nt.assert_false('parrot' in [_ip.user_ns[x] for x in ('_i','_ii','_iii')])
-    nt.assert_equal(len(set(_ip.user_ns['In'])), 1)
+    assert "parrot" in [_ip.user_ns[x] for x in ("_i", "_ii", "_iii")]
+    _ip.magic("%reset -f in")
+    assert "parrot" not in [_ip.user_ns[x] for x in ("_i", "_ii", "_iii")]
+    assert len(set(_ip.user_ns["In"])) == 1
+
 
 def test_reset_dhist():
     "Test '%reset dhist' magic"
     _ip.run_cell("tmp = [d for d in _dh]") # copy before clearing
-    _ip.magic('cd ' + os.path.dirname(nt.__file__))
-    _ip.magic('cd -')
-    nt.assert_true(len(_ip.user_ns['_dh']) > 0)
-    _ip.magic('reset -f dhist')
-    nt.assert_equal(len(_ip.user_ns['_dh']), 0)
+    _ip.magic("cd " + os.path.dirname(pytest.__file__))
+    _ip.magic("cd -")
+    assert len(_ip.user_ns["_dh"]) > 0
+    _ip.magic("reset -f dhist")
+    assert len(_ip.user_ns["_dh"]) == 0
     _ip.run_cell("_dh = [d for d in tmp]") #restore
 
+
 def test_reset_in_length():
     "Test that '%reset in' preserves In[] length"
     _ip.run_cell("print 'foo'")
     _ip.run_cell("reset -f in")
-    nt.assert_equal(len(_ip.user_ns['In']), _ip.displayhook.prompt_count+1)
+    assert len(_ip.user_ns["In"]) == _ip.displayhook.prompt_count + 1
+
 
 class TestResetErrors(TestCase):
 
@@ -395,7 +400,7 b' def test_tb_syntaxerror():'
         sys.stdout = save_stdout
     # trim output, and only check the last line
     last_line = out.rstrip().splitlines()[-1].strip()
-    nt.assert_equal(last_line, "SyntaxError: invalid syntax")
+    assert last_line == "SyntaxError: invalid syntax"
 
 
 def test_time():
@@ -448,18 +453,21 b' def test_multiline_time():'
         a = "ho"
         b = "hey"
         a+b
-        """))
-    nt.assert_equal(ip.user_ns_hidden['_'], 'hohey')
+        """
+        )
+    )
+    assert ip.user_ns_hidden["_"] == "hohey"
+
 
 def test_time_local_ns():
     """
     Test that local_ns is actually global_ns when running a cell magic
     """
     ip = get_ipython()
-    ip.run_cell("%%time\n"
-                "myvar = 1")
-    nt.assert_equal(ip.user_ns['myvar'], 1)
-    del ip.user_ns['myvar']
+    ip.run_cell("%%time\n" "myvar = 1")
+    assert ip.user_ns["myvar"] == 1
+    del ip.user_ns["myvar"]
+
 
 def test_doctest_mode():
     "Toggle doctest_mode twice, it should be a no-op and run without error"
@@ -472,8 +480,8 b' def test_parse_options():'
     # These are only the most minimal of tests, more should be added later.  At
     # the very least we check that basic text/unicode calls work OK.
     m = DummyMagics(_ip)
-    nt.assert_equal(m.parse_options('foo', '')[1], 'foo')
-    nt.assert_equal(m.parse_options(u'foo', '')[1], u'foo')
+    assert m.parse_options("foo", "")[1] == "foo"
+    assert m.parse_options("foo", "")[1] == "foo"
 
 
 def test_parse_options_preserve_non_option_string():
@@ -482,8 +490,8 b' def test_parse_options_preserve_non_option_string():'
     opts, stmt = m.parse_options(
         " -n1  -r 13 _ = 314 + foo", "n:r:", preserve_non_opts=True
     )
-    nt.assert_equal(opts, {"n": "1", "r": "13"})
-    nt.assert_equal(stmt, "_ = 314 + foo")
+    assert opts == {"n": "1", "r": "13"}
+    assert stmt == "_ = 314 + foo"
 
 
 def test_run_magic_preserve_code_block():
@@ -501,13 +509,13 b' def test_dirops():'
     ipdir = os.path.realpath(_ip.ipython_dir)
     try:
         _ip.magic('cd "%s"' % ipdir)
-        nt.assert_equal(curpath(), ipdir)
+        assert curpath() == ipdir
         _ip.magic('cd -')
-        nt.assert_equal(curpath(), startdir)
+        assert curpath() == startdir
         _ip.magic('pushd "%s"' % ipdir)
-        nt.assert_equal(curpath(), ipdir)
+        assert curpath() == ipdir
         _ip.magic('popd')
-        nt.assert_equal(curpath(), startdir)
+        assert curpath() == startdir
     finally:
         os.chdir(startdir)
 
@@ -534,7 +542,7 b' def test_xmode():'
     xmode = _ip.InteractiveTB.mode
     for i in range(4):
         _ip.magic("xmode")
-    nt.assert_equal(_ip.InteractiveTB.mode, xmode)
+    assert _ip.InteractiveTB.mode == xmode
     
 def test_reset_hard():
     monitor = []
@@ -547,9 +555,9 b' def test_reset_hard():'
     _ip.user_ns["a"] = A()
     _ip.run_cell("a")
     
-    nt.assert_equal(monitor, [])
+    assert monitor == []
     _ip.magic("reset -f")
-    nt.assert_equal(monitor, [1])
+    assert monitor == [1]
     
 class TestXdel(tt.TempFileMixin):
     def test_xdel(self):
@@ -566,12 +574,12 b' class TestXdel(tt.TempFileMixin):'
         _ip.run_cell("a")
         
         monitor = _ip.user_ns["A"].monitor
-        nt.assert_equal(monitor, [])
+        assert monitor == []
         
         _ip.magic("xdel a")
         
         # Check that a's __del__ method has been called.
-        nt.assert_equal(monitor, [1])
+        assert monitor == [1]
 
 def doctest_who():
     """doctest for %who
@@ -661,11 +669,12 b' def test_timeit_special_syntax():'
         ip.user_ns['lmagic_out'] = line
 
     # line mode test
-    _ip.run_line_magic('timeit', '-n1 -r1 %lmagic my line')
-    nt.assert_equal(_ip.user_ns['lmagic_out'], 'my line')
+    _ip.run_line_magic("timeit", "-n1 -r1 %lmagic my line")
+    assert _ip.user_ns["lmagic_out"] == "my line"
     # cell mode test
-    _ip.run_cell_magic('timeit', '-n1 -r1', '%lmagic my line2')
-    nt.assert_equal(_ip.user_ns['lmagic_out'], 'my line2')
+    _ip.run_cell_magic("timeit", "-n1 -r1", "%lmagic my line2")
+    assert _ip.user_ns["lmagic_out"] == "my line2"
+
 
 def test_timeit_return():
     """
@@ -688,7 +697,7 b' def test_timeit_return_quiet():'
     assert (res is not None)
 
 def test_timeit_invalid_return():
-    with nt.assert_raises_regex(SyntaxError, "outside function"):
+    with pytest.raises(SyntaxError):
         _ip.run_line_magic('timeit', 'return')
 
 @dec.skipif(execution.profile is None)
@@ -700,17 +709,19 b' def test_prun_special_syntax():'
         ip.user_ns['lmagic_out'] = line
 
     # line mode test
-    _ip.run_line_magic('prun', '-q %lmagic my line')
-    nt.assert_equal(_ip.user_ns['lmagic_out'], 'my line')
+    _ip.run_line_magic("prun", "-q %lmagic my line")
+    assert _ip.user_ns["lmagic_out"] == "my line"
     # cell mode test
-    _ip.run_cell_magic('prun', '-q', '%lmagic my line2')
-    nt.assert_equal(_ip.user_ns['lmagic_out'], 'my line2')
+    _ip.run_cell_magic("prun", "-q", "%lmagic my line2")
+    assert _ip.user_ns["lmagic_out"] == "my line2"
+
 
 @dec.skipif(execution.profile is None)
 def test_prun_quotes():
     "Test that prun does not clobber string escapes (GH #1302)"
     _ip.magic(r"prun -q x = '\t'")
-    nt.assert_equal(_ip.user_ns['x'], '\t')
+    assert _ip.user_ns["x"] == "\t"
+
 
 def test_extension():
     # Debugging information for failures of this test
@@ -719,14 +730,14 b' def test_extension():'
         print(' ', p)
     print('CWD', os.getcwd())
 
-    nt.assert_raises(ImportError, _ip.magic, "load_ext daft_extension")
+    pytest.raises(ImportError, _ip.magic, "load_ext daft_extension")
     daft_path = os.path.join(os.path.dirname(__file__), "daft_extension")
     sys.path.insert(0, daft_path)
     try:
         _ip.user_ns.pop('arq', None)
         invalidate_caches()   # Clear import caches
         _ip.magic("load_ext daft_extension")
-        nt.assert_equal(_ip.user_ns['arq'], 185)
+        assert _ip.user_ns["arq"] == 185
         _ip.magic("unload_ext daft_extension")
         assert 'arq' not in _ip.user_ns
     finally:
@@ -736,7 +747,7 b' def test_extension():'
 def test_notebook_export_json():
     _ip = get_ipython()
     _ip.history_manager.reset()   # Clear any existing history.
-    cmds = [u"a=1", u"def b():\n  return a**2", u"print('noël, été', b())"]
+    cmds = ["a=1", "def b():\n  return a**2", "print('noël, été', b())"]
     for i, cmd in enumerate(cmds, start=1):
         _ip.history_manager.store_inputs(i, cmd)
     with TemporaryDirectory() as td:
@@ -797,11 +808,11 b' class CellMagicTestCase(TestCase):'
 
     def check_ident(self, magic):
         # Manually called, we get the result
-        out = _ip.run_cell_magic(magic, 'a', 'b')
-        nt.assert_equal(out, ('a','b'))
+        out = _ip.run_cell_magic(magic, "a", "b")
+        assert out == ("a", "b")
         # Via run_cell, it goes into the user's namespace via displayhook
-        _ip.run_cell('%%' + magic +' c\nd\n')
-        nt.assert_equal(_ip.user_ns['_'], ('c','d\n'))
+        _ip.run_cell("%%" + magic + " c\nd\n")
+        assert _ip.user_ns["_"] == ("c", "d\n")
 
     def test_cell_magic_func_deco(self):
         "Cell magic using simple decorator"
@@ -844,7 +855,7 b' class CellMagicTestCase(TestCase):'
         self.check_ident('cellm4')
         # Check that nothing is registered as 'cellm33'
         c33 = _ip.find_cell_magic('cellm33')
-        nt.assert_equal(c33, None)
+        assert c33 == None
 
 def test_file():
     """Basic %%writefile"""
@@ -856,8 +867,9 b' def test_file():'
             'line2',
         ]))
         s = Path(fname).read_text()
-        nt.assert_in('line1\n', s)
-        nt.assert_in('line2', s)
+        assert "line1\n" in s
+        assert "line2" in s
+
 
 @dec.skip_win32
 def test_file_single_quote():
@@ -870,8 +882,9 b' def test_file_single_quote():'
             'line2',
         ]))
         s = Path(fname).read_text()
-        nt.assert_in('line1\n', s)
-        nt.assert_in('line2', s)
+        assert "line1\n" in s
+        assert "line2" in s
+
 
 @dec.skip_win32
 def test_file_double_quote():
@@ -884,8 +897,9 b' def test_file_double_quote():'
             'line2',
         ]))
         s = Path(fname).read_text()
-        nt.assert_in('line1\n', s)
-        nt.assert_in('line2', s)
+        assert "line1\n" in s
+        assert "line2" in s
+
 
 def test_file_var_expand():
     """%%writefile $filename"""
@@ -898,8 +912,9 b' def test_file_var_expand():'
             'line2',
         ]))
         s = Path(fname).read_text()
-        nt.assert_in('line1\n', s)
-        nt.assert_in('line2', s)
+        assert "line1\n" in s
+        assert "line2" in s
+
 
 def test_file_unicode():
     """%%writefile with unicode cell"""
@@ -912,8 +927,9 b' def test_file_unicode():'
         ]))
         with io.open(fname, encoding='utf-8') as f:
             s = f.read()
-        nt.assert_in(u'liné1\n', s)
-        nt.assert_in(u'liné2', s)
+        assert "liné1\n" in s
+        assert "liné2" in s
+
 
 def test_file_amend():
     """%%writefile -a amends files"""
@@ -929,8 +945,9 b' def test_file_amend():'
             'line4',
         ]))
         s = Path(fname).read_text()
-        nt.assert_in('line1\n', s)
-        nt.assert_in('line3\n', s)
+        assert "line1\n" in s
+        assert "line3\n" in s
+
 
 def test_file_spaces():
     """%%file with spaces in filename"""
@@ -942,14 +959,16 b' def test_file_spaces():'
             'line2',
         ]))
         s = Path(fname).read_text()
-        nt.assert_in('line1\n', s)
-        nt.assert_in('line2', s)
+        assert "line1\n" in s
+        assert "line2" in s
+
     
 def test_script_config():
     ip = get_ipython()
     ip.config.ScriptMagics.script_magics = ['whoda']
     sm = script.ScriptMagics(shell=ip)
-    nt.assert_in('whoda', sm.magics['cell'])
+    assert "whoda" in sm.magics["cell"]
+
 
 @dec.skip_iptest_but_not_pytest
 @dec.skip_win32
@@ -962,7 +981,8 b' def test_script_out():'
     ip = get_ipython()
     ip.run_cell_magic("script", "--out output sh", "echo 'hi'")
     assert asyncio.get_event_loop().is_running() is False
-    nt.assert_equal(ip.user_ns['output'], 'hi\n')
+    assert ip.user_ns["output"] == "hi\n"
+
 
 @dec.skip_iptest_but_not_pytest
 @dec.skip_win32
@@ -974,7 +994,7 b' def test_script_err():'
     assert asyncio.get_event_loop().is_running() is False
     ip.run_cell_magic("script", "--err error sh", "echo 'hello' >&2")
     assert asyncio.get_event_loop().is_running() is False
-    nt.assert_equal(ip.user_ns['error'], 'hello\n')
+    assert ip.user_ns["error"] == "hello\n"
 
 
 @dec.skip_iptest_but_not_pytest
@@ -988,8 +1008,8 b' def test_script_out_err():'
     ip.run_cell_magic(
         "script", "--out output --err error sh", "echo 'hi'\necho 'hello' >&2"
     )
-    nt.assert_equal(ip.user_ns["output"], "hi\n")
-    nt.assert_equal(ip.user_ns["error"], "hello\n")
+    assert ip.user_ns["output"] == "hi\n"
+    assert ip.user_ns["error"] == "hello\n"
 
 
 @dec.skip_iptest_but_not_pytest
@@ -1000,10 +1020,11 b' def test_script_out_err():'
 async def test_script_bg_out():
     ip = get_ipython()
     ip.run_cell_magic("script", "--bg --out output sh", "echo 'hi'")
-    nt.assert_equal((await ip.user_ns["output"].read()), b"hi\n")
+    assert (await ip.user_ns["output"].read()) == b"hi\n"
     ip.user_ns["output"].close()
     asyncio.get_event_loop().stop()
 
+
 @dec.skip_iptest_but_not_pytest
 @dec.skip_win32
 @pytest.mark.skipif(
@@ -1012,7 +1033,7 b' async def test_script_bg_out():'
 async def test_script_bg_err():
     ip = get_ipython()
     ip.run_cell_magic("script", "--bg --err error sh", "echo 'hello' >&2")
-    nt.assert_equal((await ip.user_ns["error"].read()), b"hello\n")
+    assert (await ip.user_ns["error"].read()) == b"hello\n"
     ip.user_ns["error"].close()
 
 
@@ -1026,8 +1047,8 b' async def test_script_bg_out_err():'
     ip.run_cell_magic(
         "script", "--bg --out output --err error sh", "echo 'hi'\necho 'hello' >&2"
     )
-    nt.assert_equal((await ip.user_ns["output"].read()), b"hi\n")
-    nt.assert_equal((await ip.user_ns["error"].read()), b"hello\n")
+    assert (await ip.user_ns["output"].read()) == b"hi\n"
+    assert (await ip.user_ns["error"].read()) == b"hello\n"
     ip.user_ns["output"].close()
     ip.user_ns["error"].close()
 
@@ -1040,7 +1061,7 b' def test_script_defaults():'
         except Exception:
             pass
         else:
-            nt.assert_in(cmd, ip.magics_manager.magics['cell'])
+            assert cmd in ip.magics_manager.magics["cell"]
 
 
 @magics_class
@@ -1060,19 +1081,20 b' def test_line_cell_info():'
     """%%foo and %foo magics are distinguishable to inspect"""
     ip = get_ipython()
     ip.magics_manager.register(FooFoo)
-    oinfo = ip.object_inspect('foo')
-    nt.assert_true(oinfo['found'])
-    nt.assert_true(oinfo['ismagic'])
+    oinfo = ip.object_inspect("foo")
+    assert oinfo["found"] is True
+    assert oinfo["ismagic"] is True
+
+    oinfo = ip.object_inspect("%%foo")
+    assert oinfo["found"] is True
+    assert oinfo["ismagic"] is True
+    assert oinfo["docstring"] == FooFoo.cell_foo.__doc__
     
-    oinfo = ip.object_inspect('%%foo')
-    nt.assert_true(oinfo['found'])
-    nt.assert_true(oinfo['ismagic'])
-    nt.assert_equal(oinfo['docstring'], FooFoo.cell_foo.__doc__)
+    oinfo = ip.object_inspect("%foo")
+    assert oinfo["found"] is True
+    assert oinfo["ismagic"] is True
+    assert oinfo["docstring"] == FooFoo.line_foo.__doc__
 
-    oinfo = ip.object_inspect('%foo')
-    nt.assert_true(oinfo['found'])
-    nt.assert_true(oinfo['ismagic'])
-    nt.assert_equal(oinfo['docstring'], FooFoo.line_foo.__doc__)
 
 def test_multiple_magics():
     ip = get_ipython()
@@ -1080,9 +1102,10 b' def test_multiple_magics():'
     foo2 = FooFoo(ip)
     mm = ip.magics_manager
     mm.register(foo1)
-    nt.assert_true(mm.magics['line']['foo'].__self__ is foo1)
+    assert mm.magics["line"]["foo"].__self__ is foo1
     mm.register(foo2)
-    nt.assert_true(mm.magics['line']['foo'].__self__ is foo2)
+    assert mm.magics["line"]["foo"].__self__ is foo2
+
 
 def test_alias_magic():
     """Test %alias_magic."""
@@ -1090,48 +1113,49 b' def test_alias_magic():'
     mm = ip.magics_manager
 
     # Basic operation: both cell and line magics are created, if possible.
-    ip.run_line_magic('alias_magic', 'timeit_alias timeit')
-    nt.assert_in('timeit_alias', mm.magics['line'])
-    nt.assert_in('timeit_alias', mm.magics['cell'])
+    ip.run_line_magic("alias_magic", "timeit_alias timeit")
+    assert "timeit_alias" in mm.magics["line"]
+    assert "timeit_alias" in mm.magics["cell"]
 
     # --cell is specified, line magic not created.
-    ip.run_line_magic('alias_magic', '--cell timeit_cell_alias timeit')
-    nt.assert_not_in('timeit_cell_alias', mm.magics['line'])
-    nt.assert_in('timeit_cell_alias', mm.magics['cell'])
+    ip.run_line_magic("alias_magic", "--cell timeit_cell_alias timeit")
+    assert "timeit_cell_alias" not in mm.magics["line"]
+    assert "timeit_cell_alias" in mm.magics["cell"]
 
     # Test that line alias is created successfully.
-    ip.run_line_magic('alias_magic', '--line env_alias env')
-    nt.assert_equal(ip.run_line_magic('env', ''),
-                    ip.run_line_magic('env_alias', ''))
+    ip.run_line_magic("alias_magic", "--line env_alias env")
+    assert ip.run_line_magic("env", "") == ip.run_line_magic("env_alias", "")
 
     # Test that line alias with parameters passed in is created successfully.
-    ip.run_line_magic('alias_magic', '--line history_alias history --params ' + shlex.quote('3'))
-    nt.assert_in('history_alias', mm.magics['line'])
+    ip.run_line_magic(
+        "alias_magic", "--line history_alias history --params " + shlex.quote("3")
+    )
+    assert "history_alias" in mm.magics["line"]
 
 
 def test_save():
     """Test %save."""
     ip = get_ipython()
     ip.history_manager.reset()   # Clear any existing history.
-    cmds = [u"a=1", u"def b():\n  return a**2", u"print(a, b())"]
+    cmds = ["a=1", "def b():\n  return a**2", "print(a, b())"]
     for i, cmd in enumerate(cmds, start=1):
         ip.history_manager.store_inputs(i, cmd)
     with TemporaryDirectory() as tmpdir:
         file = os.path.join(tmpdir, "testsave.py")
         ip.run_line_magic("save", "%s 1-10" % file)
         content = Path(file).read_text()
-        nt.assert_equal(content.count(cmds[0]), 1)
-        nt.assert_in("coding: utf-8", content)
+        assert content.count(cmds[0]) == 1
+        assert "coding: utf-8" in content
         ip.run_line_magic("save", "-a %s 1-10" % file)
         content = Path(file).read_text()
-        nt.assert_equal(content.count(cmds[0]), 2)
-        nt.assert_in("coding: utf-8", content)
+        assert content.count(cmds[0]) == 2
+        assert "coding: utf-8" in content
 
 
 def test_save_with_no_args():
     ip = get_ipython()
     ip.history_manager.reset()  # Clear any existing history.
-    cmds = [u"a=1", u"def b():\n    return a**2", u"print(a, b())", "%save"]
+    cmds = ["a=1", "def b():\n    return a**2", "print(a, b())", "%save"]
     for i, cmd in enumerate(cmds, start=1):
         ip.history_manager.store_inputs(i, cmd)
 
@@ -1148,7 +1172,7 b' def test_save_with_no_args():'
             print(a, b())
             """
         )
-        nt.assert_equal(content, expected_content)
+        assert content == expected_content
 
 
 def test_store():
@@ -1157,17 +1181,17 b' def test_store():'
     ip.run_line_magic('load_ext', 'storemagic')
     
     # make sure the storage is empty
-    ip.run_line_magic('store', '-z')
-    ip.user_ns['var'] = 42
-    ip.run_line_magic('store', 'var')
-    ip.user_ns['var'] = 39
-    ip.run_line_magic('store', '-r')
-    nt.assert_equal(ip.user_ns['var'], 42)
+    ip.run_line_magic("store", "-z")
+    ip.user_ns["var"] = 42
+    ip.run_line_magic("store", "var")
+    ip.user_ns["var"] = 39
+    ip.run_line_magic("store", "-r")
+    assert ip.user_ns["var"] == 42
 
-    ip.run_line_magic('store', '-d var')
-    ip.user_ns['var'] = 39
-    ip.run_line_magic('store' , '-r')
-    nt.assert_equal(ip.user_ns['var'], 39)
+    ip.run_line_magic("store", "-d var")
+    ip.user_ns["var"] = 39
+    ip.run_line_magic("store", "-r")
+    assert ip.user_ns["var"] == 39
 
 
 def _run_edit_test(arg_s, exp_filename=None,
@@ -1181,27 +1205,27 b' def _run_edit_test(arg_s, exp_filename=None,'
     filename, lineno, is_temp = M._find_edit_target(ip, args, opts, last_call)
         
     if exp_filename is not None:
-        nt.assert_equal(exp_filename, filename)
+        assert exp_filename == filename
     if exp_contents is not None:
         with io.open(filename, 'r', encoding='utf-8') as f:
             contents = f.read()
-        nt.assert_equal(exp_contents, contents)
+        assert exp_contents == contents
     if exp_lineno != -1:
-        nt.assert_equal(exp_lineno, lineno)
+        assert exp_lineno == lineno
     if exp_is_temp is not None:
-        nt.assert_equal(exp_is_temp, is_temp)
+        assert exp_is_temp == is_temp
 
 
 def test_edit_interactive():
     """%edit on interactively defined objects"""
     ip = get_ipython()
     n = ip.execution_count
-    ip.run_cell(u"def foo(): return 1", store_history=True)
+    ip.run_cell("def foo(): return 1", store_history=True)
     
     try:
         _run_edit_test("foo")
     except code.InteractivelyDefined as e:
-        nt.assert_equal(e.index, n)
+        assert e.index == n
     else:
         raise AssertionError("Should have raised InteractivelyDefined")
 
@@ -1210,7 +1234,7 b' def test_edit_cell():'
     """%edit [cell id]"""
     ip = get_ipython()
     
-    ip.run_cell(u"def foo(): return 1", store_history=True)
+    ip.run_cell("def foo(): return 1", store_history=True)
     
     # test
     _run_edit_test("1", exp_contents=ip.user_ns['In'][1], exp_is_temp=True)
@@ -1234,17 +1258,18 b' def test_ls_magic():'
     lsmagic = ip.magic('lsmagic')
     with warnings.catch_warnings(record=True) as w:
         j = json_formatter(lsmagic)
-    nt.assert_equal(sorted(j), ['cell', 'line'])
-    nt.assert_equal(w, []) # no warnings
+    assert sorted(j) == ["cell", "line"]
+    assert w == []  # no warnings
+
 
 def test_strip_initial_indent():
     def sii(s):
         lines = s.splitlines()
         return '\n'.join(code.strip_initial_indent(lines))
 
-    nt.assert_equal(sii("  a = 1\nb = 2"), "a = 1\nb = 2")
-    nt.assert_equal(sii("  a\n    b\nc"), "a\n  b\nc")
-    nt.assert_equal(sii("a\n  b"), "a\n  b")
+    assert sii("  a = 1\nb = 2") == "a = 1\nb = 2"
+    assert sii("  a\n    b\nc") == "a\n  b\nc"
+    assert sii("a\n  b") == "a\n  b"
 
 def test_logging_magic_quiet_from_arg():
     _ip.config.LoggingMagics.quiet = False
@@ -1336,6 +1361,6 b' def test_run_module_from_import_hook():'
             _ip.run_cell("import my_tmp")
 
         output = "Loaded my_tmp\nI just ran a script\nLoaded my_tmp\n"
-        nt.assert_equal(output, captured.stdout)
+        assert output == captured.stdout
 
         sys.meta_path.pop(0)