Merge pull request #13206 from sgaist/nose_cleanup_first_step

Nose cleanup first step

.pre-commit-config.yaml

@@ -0,0 +1,16 b''
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v3.2.0
+    hooks:
+    -   id: trailing-whitespace
+    -   id: end-of-file-fixer
+    -   id: check-yaml
+    -   id: check-added-large-files
+
+-   repo: https://github.com/akaihola/darker
+    rev: 1.3.1
+    hooks:
+    -   id: darker
+

IPython/core/tests/test_application.py

@@ -4,8 +4,6 b''
 import os
 import tempfile
 
-import nose.tools as nt
-
 from traitlets import Unicode
 
 from IPython.core.application import BaseIPythonApplication
@@ -65,9 +63,8 b' def test_cli_priority():'
             f.write("c.TestApp.test = 'config file'")
 
         app = TestApp()
-        app.initialize(['--profile-dir', td])
-        nt.assert_equal(app.test, 'config file')
+        app.initialize(["--profile-dir", td])
+        assert app.test == "config file"
         app = TestApp()
-        app.initialize(['--profile-dir', td, '--TestApp.test=cli'])
-        nt.assert_equal(app.test, 'cli')
-
+        app.initialize(["--profile-dir", td, "--TestApp.test=cli"])
+        assert app.test == "cli"

IPython/core/tests/test_async_helpers.py

@@ -4,7 +4,6 b' Test for async helpers.'
 Should only trigger on python 3.5+ or will have syntax errors.
 """
 from itertools import chain, repeat
-import nose.tools as nt
 from textwrap import dedent, indent
 from unittest import TestCase
 from IPython.testing.decorators import skip_without
@@ -24,10 +23,10 b' from IPython.core.async_helpers import _should_be_async'
 
 class AsyncTest(TestCase):
     def test_should_be_async(self):
-        nt.assert_false(_should_be_async("False"))
-        nt.assert_true(_should_be_async("await bar()"))
-        nt.assert_true(_should_be_async("x = await bar()"))
-        nt.assert_false(
+        self.assertFalse(_should_be_async("False"))
+        self.assertTrue(_should_be_async("await bar()"))
+        self.assertTrue(_should_be_async("x = await bar()"))
+        self.assertFalse(
             _should_be_async(
                 dedent(
                     """
@@ -298,7 +297,7 b' class AsyncTest(TestCase):'
         import asyncio
         await asyncio.sleep(0)
         """)
-        with nt.assert_raises(TypeError):
+        with self.assertRaises(TypeError):
             res.raise_error()
 
     @skip_without('trio')
@@ -308,7 +307,7 b' class AsyncTest(TestCase):'
         import trio
         await trio.sleep(0)
         """)
-        with nt.assert_raises(RuntimeError):
+        with self.assertRaises(RuntimeError):
             res.raise_error()
 
 

IPython/core/tests/test_completer.py

@@ -11,8 +11,6 b' import unittest'
 
 from contextlib import contextmanager
 
-import nose.tools as nt
-
 from traitlets.config.loader import Config
 from IPython import get_ipython
 from IPython.core import completer
@@ -27,7 +25,6 b' from IPython.core.completer import ('
     match_dict_keys,
     _deduplicate_completions,
 )
-from nose.tools import assert_in, assert_not_in
 
 # -----------------------------------------------------------------------------
 # Test functions
@@ -150,7 +147,7 b' def test_protect_filename():'
     # run the actual tests
     for s1, s2 in pairs:
         s1p = completer.protect_filename(s1)
-        nt.assert_equal(s1p, s2)
+        assert s1p == s2
 
 
 def check_line_split(splitter, test_specs):
@@ -158,7 +155,7 b' def check_line_split(splitter, test_specs):'
         cursor_pos = len(part1)
         line = part1 + part2
         out = splitter.split_line(line, cursor_pos)
-        nt.assert_equal(out, split)
+        assert out == split
 
 
 def test_line_split():
@@ -267,8 +264,8 b' class TestCompleter(unittest.TestCase):'
             # should be thrown and the return value should be a pair of text, list
             # values.
             text, matches = ip.complete(t)
-            nt.assert_true(isinstance(text, str))
-            nt.assert_true(isinstance(matches, list))
+            self.assertIsInstance(text, str)
+            self.assertIsInstance(matches, list)
 
     def test_latex_completions(self):
         from IPython.core.latex_symbols import latex_symbols
@@ -279,16 +276,16 b' class TestCompleter(unittest.TestCase):'
         keys = random.sample(latex_symbols.keys(), 10)
         for k in keys:
             text, matches = ip.complete(k)
-            nt.assert_equal(text, k)
-            nt.assert_equal(matches, [latex_symbols[k]])
+            self.assertEqual(text, k)
+            self.assertEqual(matches, [latex_symbols[k]])
         # Test a more complex line
         text, matches = ip.complete("print(\\alpha")
-        nt.assert_equal(text, "\\alpha")
-        nt.assert_equal(matches[0], latex_symbols["\\alpha"])
+        self.assertEqual(text, "\\alpha")
+        self.assertEqual(matches[0], latex_symbols["\\alpha"])
         # Test multiple matching latex symbols
         text, matches = ip.complete("\\al")
-        nt.assert_in("\\alpha", matches)
-        nt.assert_in("\\aleph", matches)
+        self.assertIn("\\alpha", matches)
+        self.assertIn("\\aleph", matches)
 
     def test_latex_no_results(self):
         """
@@ -296,30 +293,30 b' class TestCompleter(unittest.TestCase):'
         """
         ip = get_ipython()
         text, matches = ip.Completer.latex_matches("\\really_i_should_match_nothing")
-        nt.assert_equal(text, "")
-        nt.assert_equal(matches, ())
+        self.assertEqual(text, "")
+        self.assertEqual(matches, ())
 
     def test_back_latex_completion(self):
         ip = get_ipython()
 
         # do not return more than 1 matches for \beta, only the latex one.
         name, matches = ip.complete("\\β")
-        nt.assert_equal(matches, ['\\beta'])
+        self.assertEqual(matches, ["\\beta"])
 
     def test_back_unicode_completion(self):
         ip = get_ipython()
 
         name, matches = ip.complete("\\Ⅴ")
-        nt.assert_equal(matches, ("\\ROMAN NUMERAL FIVE",))
+        self.assertEqual(matches, ("\\ROMAN NUMERAL FIVE",))
 
     def test_forward_unicode_completion(self):
         ip = get_ipython()
 
         name, matches = ip.complete("\\ROMAN NUMERAL FIVE")
-        nt.assert_equal(matches, ["Ⅴ"] ) # This is not a V
-        nt.assert_equal(matches, ["\u2164"] ) # same as above but explicit.
+        self.assertEqual(matches, ["Ⅴ"])  # This is not a V
+        self.assertEqual(matches, ["\u2164"])  # same as above but explicit.
 
-    @nt.nottest  # now we have a completion for \jmath
+    @unittest.skip("now we have a completion for \jmath")
     @decorators.knownfailureif(
         sys.platform == "win32", "Fails if there is a C:\\j... path"
     )
@@ -329,7 +326,7 b' class TestCompleter(unittest.TestCase):'
             # single ascii letter that don't have yet completions
             for letter in "jJ":
                 name, matches = ip.complete("\\" + letter)
-                nt.assert_equal(matches, [])
+                self.assertEqual(matches, [])
 
     class CompletionSplitterTestCase(unittest.TestCase):
         def setUp(self):
@@ -337,8 +334,8 b' class TestCompleter(unittest.TestCase):'
 
         def test_delim_setting(self):
             self.sp.delims = " "
-            nt.assert_equal(self.sp.delims, " ")
-            nt.assert_equal(self.sp._delim_expr, r"[\ ]")
+            self.assertEqual(self.sp.delims, " ")
+            self.assertEqual(self.sp._delim_expr, r"[\ ]")
 
         def test_spaces(self):
             """Test with only spaces as split chars."""
@@ -348,19 +345,19 b' class TestCompleter(unittest.TestCase):'
 
     def test_has_open_quotes1(self):
         for s in ["'", "'''", "'hi' '"]:
-            nt.assert_equal(completer.has_open_quotes(s), "'")
+            self.assertEqual(completer.has_open_quotes(s), "'")
 
     def test_has_open_quotes2(self):
         for s in ['"', '"""', '"hi" "']:
-            nt.assert_equal(completer.has_open_quotes(s), '"')
+            self.assertEqual(completer.has_open_quotes(s), '"')
 
     def test_has_open_quotes3(self):
         for s in ["''", "''' '''", "'hi' 'ipython'"]:
-            nt.assert_false(completer.has_open_quotes(s))
+            self.assertFalse(completer.has_open_quotes(s))
 
     def test_has_open_quotes4(self):
         for s in ['""', '""" """', '"hi" "ipython"']:
-            nt.assert_false(completer.has_open_quotes(s))
+            self.assertFalse(completer.has_open_quotes(s))
 
     @decorators.knownfailureif(
         sys.platform == "win32", "abspath completions fail on Windows"
@@ -376,13 +373,13 b' class TestCompleter(unittest.TestCase):'
 
             # Check simple completion
             c = ip.complete(prefix)[1]
-            nt.assert_equal(c, names)
+            self.assertEqual(c, names)
 
             # Now check with a function call
             cmd = 'a = f("%s' % prefix
             c = ip.complete(prefix, cmd)[1]
             comp = [prefix + s for s in suffixes]
-            nt.assert_equal(c, comp)
+            self.assertEqual(c, comp)
 
     def test_local_file_completions(self):
         ip = get_ipython()
@@ -395,13 +392,13 b' class TestCompleter(unittest.TestCase):'
 
             # Check simple completion
             c = ip.complete(prefix)[1]
-            nt.assert_equal(c, names)
+            self.assertEqual(c, names)
 
             # Now check with a function call
             cmd = 'a = f("%s' % prefix
             c = ip.complete(prefix, cmd)[1]
             comp = {prefix + s for s in suffixes}
-            nt.assert_true(comp.issubset(set(c)))
+            self.assertTrue(comp.issubset(set(c)))
 
     def test_quoted_file_completions(self):
         ip = get_ipython()
@@ -417,21 +414,21 b' class TestCompleter(unittest.TestCase):'
             c = ip.Completer._complete(
                 cursor_line=0, cursor_pos=len(text), full_text=text
             )[1]
-            nt.assert_equal(c, [escaped])
+            self.assertEqual(c, [escaped])
 
             # Double quote requires no escape
             text = 'open("foo'
             c = ip.Completer._complete(
                 cursor_line=0, cursor_pos=len(text), full_text=text
             )[1]
-            nt.assert_equal(c, [name])
+            self.assertEqual(c, [name])
 
             # No quote requires an escape
             text = "%ls foo"
             c = ip.Completer._complete(
                 cursor_line=0, cursor_pos=len(text), full_text=text
             )[1]
-            nt.assert_equal(c, [escaped])
+            self.assertEqual(c, [escaped])
 
     def test_all_completions_dups(self):
         """
@@ -537,18 +534,18 b' class TestCompleter(unittest.TestCase):'
         ip = get_ipython()
         ip.ex("a=list(range(5))")
         _, c = ip.complete(".", line="a[0].")
-        nt.assert_false(".real" in c, "Shouldn't have completed on a[0]: %s" % c)
+        self.assertFalse(".real" in c, "Shouldn't have completed on a[0]: %s" % c)
 
         def _(line, cursor_pos, expect, message, completion):
             with greedy_completion(), provisionalcompleter():
                 ip.Completer.use_jedi = False
                 _, c = ip.complete(".", line=line, cursor_pos=cursor_pos)
-                nt.assert_in(expect, c, message % c)
+                self.assertIn(expect, c, message % c)
 
                 ip.Completer.use_jedi = True
                 with provisionalcompleter():
                     completions = ip.Completer.completions(line, cursor_pos)
-                nt.assert_in(completion, completions)
+                self.assertIn(completion, completions)
 
         with provisionalcompleter():
             yield _, "a[0].", 5, "a[0].real", "Should have completed on a[0].: %s", Completion(
@@ -575,13 +572,13 b' class TestCompleter(unittest.TestCase):'
         with provisionalcompleter():
             c.use_jedi = False
             s, matches = c.complete("ip.")
-            nt.assert_in("ip.__str__", matches)
-            nt.assert_in("ip._hidden_attr", matches)
+            self.assertIn("ip.__str__", matches)
+            self.assertIn("ip._hidden_attr", matches)
 
             # c.use_jedi = True
             # completions = set(c.completions('ip.', 3))
-            # nt.assert_in(Completion(3, 3, '__str__'), completions)
-            # nt.assert_in(Completion(3,3, "_hidden_attr"), completions)
+            # self.assertIn(Completion(3, 3, '__str__'), completions)
+            # self.assertIn(Completion(3,3, "_hidden_attr"), completions)
 
         cfg = Config()
         cfg.IPCompleter.omit__names = 1
@@ -589,13 +586,13 b' class TestCompleter(unittest.TestCase):'
         with provisionalcompleter():
             c.use_jedi = False
             s, matches = c.complete("ip.")
-            nt.assert_not_in("ip.__str__", matches)
-            # nt.assert_in('ip._hidden_attr', matches)
+            self.assertNotIn("ip.__str__", matches)
+            # self.assertIn('ip._hidden_attr', matches)
 
             # c.use_jedi = True
             # completions = set(c.completions('ip.', 3))
-            # nt.assert_not_in(Completion(3,3,'__str__'), completions)
-            # nt.assert_in(Completion(3,3, "_hidden_attr"), completions)
+            # self.assertNotIn(Completion(3,3,'__str__'), completions)
+            # self.assertIn(Completion(3,3, "_hidden_attr"), completions)
 
         cfg = Config()
         cfg.IPCompleter.omit__names = 2
@@ -603,22 +600,22 b' class TestCompleter(unittest.TestCase):'
         with provisionalcompleter():
             c.use_jedi = False
             s, matches = c.complete("ip.")
-            nt.assert_not_in("ip.__str__", matches)
-            nt.assert_not_in("ip._hidden_attr", matches)
+            self.assertNotIn("ip.__str__", matches)
+            self.assertNotIn("ip._hidden_attr", matches)
 
             # c.use_jedi = True
             # completions = set(c.completions('ip.', 3))
-            # nt.assert_not_in(Completion(3,3,'__str__'), completions)
-            # nt.assert_not_in(Completion(3,3, "_hidden_attr"), completions)
+            # self.assertNotIn(Completion(3,3,'__str__'), completions)
+            # self.assertNotIn(Completion(3,3, "_hidden_attr"), completions)
 
         with provisionalcompleter():
             c.use_jedi = False
             s, matches = c.complete("ip._x.")
-            nt.assert_in("ip._x.keys", matches)
+            self.assertIn("ip._x.keys", matches)
 
             # c.use_jedi = True
             # completions = set(c.completions('ip._x.', 6))
-            # nt.assert_in(Completion(6,6, "keys"), completions)
+            # self.assertIn(Completion(6,6, "keys"), completions)
 
         del ip._hidden_attr
         del ip._x
@@ -636,21 +633,21 b' class TestCompleter(unittest.TestCase):'
         cfg.IPCompleter.limit_to__all__ = False
         c.update_config(cfg)
         s, matches = c.complete("d.")
-        nt.assert_in("d.x", matches)
+        self.assertIn("d.x", matches)
 
     def test_get__all__entries_ok(self):
         class A:
             __all__ = ["x", 1]
 
         words = completer.get__all__entries(A())
-        nt.assert_equal(words, ["x"])
+        self.assertEqual(words, ["x"])
 
     def test_get__all__entries_no__all__ok(self):
         class A:
             pass
 
         words = completer.get__all__entries(A())
-        nt.assert_equal(words, [])
+        self.assertEqual(words, [])
 
     def test_func_kw_completions(self):
         ip = get_ipython()
@@ -658,39 +655,39 b' class TestCompleter(unittest.TestCase):'
         c.use_jedi = False
         ip.ex("def myfunc(a=1,b=2): return a+b")
         s, matches = c.complete(None, "myfunc(1,b")
-        nt.assert_in("b=", matches)
+        self.assertIn("b=", matches)
         # Simulate completing with cursor right after b (pos==10):
         s, matches = c.complete(None, "myfunc(1,b)", 10)
-        nt.assert_in("b=", matches)
+        self.assertIn("b=", matches)
         s, matches = c.complete(None, 'myfunc(a="escaped\\")string",b')
-        nt.assert_in("b=", matches)
+        self.assertIn("b=", matches)
         # builtin function
         s, matches = c.complete(None, "min(k, k")
-        nt.assert_in("key=", matches)
+        self.assertIn("key=", matches)
 
     def test_default_arguments_from_docstring(self):
         ip = get_ipython()
         c = ip.Completer
         kwd = c._default_arguments_from_docstring("min(iterable[, key=func]) -> value")
-        nt.assert_equal(kwd, ["key"])
+        self.assertEqual(kwd, ["key"])
         # with cython type etc
         kwd = c._default_arguments_from_docstring(
             "Minuit.migrad(self, int ncall=10000, resume=True, int nsplit=1)\n"
         )
-        nt.assert_equal(kwd, ["ncall", "resume", "nsplit"])
+        self.assertEqual(kwd, ["ncall", "resume", "nsplit"])
         # white spaces
         kwd = c._default_arguments_from_docstring(
             "\n Minuit.migrad(self, int ncall=10000, resume=True, int nsplit=1)\n"
         )
-        nt.assert_equal(kwd, ["ncall", "resume", "nsplit"])
+        self.assertEqual(kwd, ["ncall", "resume", "nsplit"])
 
     def test_line_magics(self):
         ip = get_ipython()
         c = ip.Completer
         s, matches = c.complete(None, "lsmag")
-        nt.assert_in("%lsmagic", matches)
+        self.assertIn("%lsmagic", matches)
         s, matches = c.complete(None, "%lsmag")
-        nt.assert_in("%lsmagic", matches)
+        self.assertIn("%lsmagic", matches)
 
     def test_cell_magics(self):
         from IPython.core.magic import register_cell_magic
@@ -703,9 +700,9 b' class TestCompleter(unittest.TestCase):'
         c = ip.Completer
 
         s, matches = c.complete(None, "_foo_ce")
-        nt.assert_in("%%_foo_cellm", matches)
+        self.assertIn("%%_foo_cellm", matches)
         s, matches = c.complete(None, "%%_foo_ce")
-        nt.assert_in("%%_foo_cellm", matches)
+        self.assertIn("%%_foo_cellm", matches)
 
     def test_line_cell_magics(self):
         from IPython.core.magic import register_line_cell_magic
@@ -722,14 +719,14 b' class TestCompleter(unittest.TestCase):'
         # and this will show a difference if the same name is both a line and cell
         # magic.
         s, matches = c.complete(None, "_bar_ce")
-        nt.assert_in("%_bar_cellm", matches)
-        nt.assert_in("%%_bar_cellm", matches)
+        self.assertIn("%_bar_cellm", matches)
+        self.assertIn("%%_bar_cellm", matches)
         s, matches = c.complete(None, "%_bar_ce")
-        nt.assert_in("%_bar_cellm", matches)
-        nt.assert_in("%%_bar_cellm", matches)
+        self.assertIn("%_bar_cellm", matches)
+        self.assertIn("%%_bar_cellm", matches)
         s, matches = c.complete(None, "%%_bar_ce")
-        nt.assert_not_in("%_bar_cellm", matches)
-        nt.assert_in("%%_bar_cellm", matches)
+        self.assertNotIn("%_bar_cellm", matches)
+        self.assertIn("%%_bar_cellm", matches)
 
     def test_magic_completion_order(self):
         ip = get_ipython()
@@ -737,7 +734,7 b' class TestCompleter(unittest.TestCase):'
 
         # Test ordering of line and cell magics.
         text, matches = c.complete("timeit")
-        nt.assert_equal(matches, ["%timeit", "%%timeit"])
+        self.assertEqual(matches, ["%timeit", "%%timeit"])
 
     def test_magic_completion_shadowing(self):
         ip = get_ipython()
@@ -746,18 +743,18 b' class TestCompleter(unittest.TestCase):'
 
         # Before importing matplotlib, %matplotlib magic should be the only option.
         text, matches = c.complete("mat")
-        nt.assert_equal(matches, ["%matplotlib"])
+        self.assertEqual(matches, ["%matplotlib"])
 
         # The newly introduced name should shadow the magic.
         ip.run_cell("matplotlib = 1")
         text, matches = c.complete("mat")
-        nt.assert_equal(matches, ["matplotlib"])
+        self.assertEqual(matches, ["matplotlib"])
 
         # After removing matplotlib from namespace, the magic should again be
         # the only option.
         del ip.user_ns["matplotlib"]
         text, matches = c.complete("mat")
-        nt.assert_equal(matches, ["%matplotlib"])
+        self.assertEqual(matches, ["%matplotlib"])
 
     def test_magic_completion_shadowing_explicit(self):
         """
@@ -769,62 +766,62 b' class TestCompleter(unittest.TestCase):'
 
         # Before importing matplotlib, %matplotlib magic should be the only option.
         text, matches = c.complete("%mat")
-        nt.assert_equal(matches, ["%matplotlib"])
+        self.assertEqual(matches, ["%matplotlib"])
 
         ip.run_cell("matplotlib = 1")
 
         # After removing matplotlib from namespace, the magic should still be
         # the only option.
         text, matches = c.complete("%mat")
-        nt.assert_equal(matches, ["%matplotlib"])
+        self.assertEqual(matches, ["%matplotlib"])
 
     def test_magic_config(self):
         ip = get_ipython()
         c = ip.Completer
 
         s, matches = c.complete(None, "conf")
-        nt.assert_in("%config", matches)
+        self.assertIn("%config", matches)
         s, matches = c.complete(None, "conf")
-        nt.assert_not_in("AliasManager", matches)
+        self.assertNotIn("AliasManager", matches)
         s, matches = c.complete(None, "config ")
-        nt.assert_in("AliasManager", matches)
+        self.assertIn("AliasManager", matches)
         s, matches = c.complete(None, "%config ")
-        nt.assert_in("AliasManager", matches)
+        self.assertIn("AliasManager", matches)
         s, matches = c.complete(None, "config Ali")
-        nt.assert_list_equal(["AliasManager"], matches)
+        self.assertListEqual(["AliasManager"], matches)
         s, matches = c.complete(None, "%config Ali")
-        nt.assert_list_equal(["AliasManager"], matches)
+        self.assertListEqual(["AliasManager"], matches)
         s, matches = c.complete(None, "config AliasManager")
-        nt.assert_list_equal(["AliasManager"], matches)
+        self.assertListEqual(["AliasManager"], matches)
         s, matches = c.complete(None, "%config AliasManager")
-        nt.assert_list_equal(["AliasManager"], matches)
+        self.assertListEqual(["AliasManager"], matches)
         s, matches = c.complete(None, "config AliasManager.")
-        nt.assert_in("AliasManager.default_aliases", matches)
+        self.assertIn("AliasManager.default_aliases", matches)
         s, matches = c.complete(None, "%config AliasManager.")
-        nt.assert_in("AliasManager.default_aliases", matches)
+        self.assertIn("AliasManager.default_aliases", matches)
         s, matches = c.complete(None, "config AliasManager.de")
-        nt.assert_list_equal(["AliasManager.default_aliases"], matches)
+        self.assertListEqual(["AliasManager.default_aliases"], matches)
         s, matches = c.complete(None, "config AliasManager.de")
-        nt.assert_list_equal(["AliasManager.default_aliases"], matches)
+        self.assertListEqual(["AliasManager.default_aliases"], matches)
 
     def test_magic_color(self):
         ip = get_ipython()
         c = ip.Completer
 
         s, matches = c.complete(None, "colo")
-        nt.assert_in("%colors", matches)
+        self.assertIn("%colors", matches)
         s, matches = c.complete(None, "colo")
-        nt.assert_not_in("NoColor", matches)
+        self.assertNotIn("NoColor", matches)
         s, matches = c.complete(None, "%colors")  # No trailing space
-        nt.assert_not_in("NoColor", matches)
+        self.assertNotIn("NoColor", matches)
         s, matches = c.complete(None, "colors ")
-        nt.assert_in("NoColor", matches)
+        self.assertIn("NoColor", matches)
         s, matches = c.complete(None, "%colors ")
-        nt.assert_in("NoColor", matches)
+        self.assertIn("NoColor", matches)
         s, matches = c.complete(None, "colors NoCo")
-        nt.assert_list_equal(["NoColor"], matches)
+        self.assertListEqual(["NoColor"], matches)
         s, matches = c.complete(None, "%colors NoCo")
-        nt.assert_list_equal(["NoColor"], matches)
+        self.assertListEqual(["NoColor"], matches)
 
     def test_match_dict_keys(self):
         """
@@ -884,34 +881,34 b' class TestCompleter(unittest.TestCase):'
 
         # check completion at different stages
         _, matches = complete(line_buffer="d[")
-        nt.assert_in("'abc'", matches)
-        nt.assert_not_in("'abc']", matches)
+        self.assertIn("'abc'", matches)
+        self.assertNotIn("'abc']", matches)
 
         _, matches = complete(line_buffer="d['")
-        nt.assert_in("abc", matches)
-        nt.assert_not_in("abc']", matches)
+        self.assertIn("abc", matches)
+        self.assertNotIn("abc']", matches)
 
         _, matches = complete(line_buffer="d['a")
-        nt.assert_in("abc", matches)
-        nt.assert_not_in("abc']", matches)
+        self.assertIn("abc", matches)
+        self.assertNotIn("abc']", matches)
 
         # check use of different quoting
         _, matches = complete(line_buffer='d["')
-        nt.assert_in("abc", matches)
-        nt.assert_not_in('abc"]', matches)
+        self.assertIn("abc", matches)
+        self.assertNotIn('abc"]', matches)
 
         _, matches = complete(line_buffer='d["a')
-        nt.assert_in("abc", matches)
-        nt.assert_not_in('abc"]', matches)
+        self.assertIn("abc", matches)
+        self.assertNotIn('abc"]', matches)
 
         # check sensitivity to following context
         _, matches = complete(line_buffer="d[]", cursor_pos=2)
-        nt.assert_in("'abc'", matches)
+        self.assertIn("'abc'", matches)
 
         _, matches = complete(line_buffer="d['']", cursor_pos=3)
-        nt.assert_in("abc", matches)
-        nt.assert_not_in("abc'", matches)
-        nt.assert_not_in("abc']", matches)
+        self.assertIn("abc", matches)
+        self.assertNotIn("abc'", matches)
+        self.assertNotIn("abc']", matches)
 
         # check multiple solutions are correctly returned and that noise is not
         ip.user_ns["d"] = {
@@ -925,111 +922,110 b' class TestCompleter(unittest.TestCase):'
         }
 
         _, matches = complete(line_buffer="d['a")
-        nt.assert_in("abc", matches)
-        nt.assert_in("abd", matches)
-        nt.assert_not_in("bad", matches)
-        nt.assert_not_in("abe", matches)
-        nt.assert_not_in("abf", matches)
+        self.assertIn("abc", matches)
+        self.assertIn("abd", matches)
+        self.assertNotIn("bad", matches)
+        self.assertNotIn("abe", matches)
+        self.assertNotIn("abf", matches)
         assert not any(m.endswith(("]", '"', "'")) for m in matches), matches
 
         # check escaping and whitespace
         ip.user_ns["d"] = {"a\nb": None, "a'b": None, 'a"b': None, "a word": None}
         _, matches = complete(line_buffer="d['a")
-        nt.assert_in("a\\nb", matches)
-        nt.assert_in("a\\'b", matches)
-        nt.assert_in('a"b', matches)
-        nt.assert_in("a word", matches)
+        self.assertIn("a\\nb", matches)
+        self.assertIn("a\\'b", matches)
+        self.assertIn('a"b', matches)
+        self.assertIn("a word", matches)
         assert not any(m.endswith(("]", '"', "'")) for m in matches), matches
 
         # - can complete on non-initial word of the string
         _, matches = complete(line_buffer="d['a w")
-        nt.assert_in("word", matches)
+        self.assertIn("word", matches)
 
         # - understands quote escaping
         _, matches = complete(line_buffer="d['a\\'")
-        nt.assert_in("b", matches)
+        self.assertIn("b", matches)
 
         # - default quoting should work like repr
         _, matches = complete(line_buffer="d[")
-        nt.assert_in('"a\'b"', matches)
+        self.assertIn('"a\'b"', matches)
 
         # - when opening quote with ", possible to match with unescaped apostrophe
         _, matches = complete(line_buffer="d[\"a'")
-        nt.assert_in("b", matches)
+        self.assertIn("b", matches)
 
         # need to not split at delims that readline won't split at
         if "-" not in ip.Completer.splitter.delims:
             ip.user_ns["d"] = {"before-after": None}
             _, matches = complete(line_buffer="d['before-af")
-            nt.assert_in("before-after", matches)
+            self.assertIn("before-after", matches)
 
         # check completion on tuple-of-string keys at different stage - on first key
         ip.user_ns["d"] = {('foo', 'bar'): None}
         _, matches = complete(line_buffer="d[")
-        nt.assert_in("'foo'", matches)
-        nt.assert_not_in("'foo']", matches)
-        nt.assert_not_in("'bar'", matches)
-        nt.assert_not_in("foo", matches)
-        nt.assert_not_in("bar", matches)
+        self.assertIn("'foo'", matches)
+        self.assertNotIn("'foo']", matches)
+        self.assertNotIn("'bar'", matches)
+        self.assertNotIn("foo", matches)
+        self.assertNotIn("bar", matches)
 
         # - match the prefix
         _, matches = complete(line_buffer="d['f")
-        nt.assert_in("foo", matches)
-        nt.assert_not_in("foo']", matches)
-        nt.assert_not_in("foo\"]", matches)
+        self.assertIn("foo", matches)
+        self.assertNotIn("foo']", matches)
+        self.assertNotIn('foo"]', matches)
         _, matches = complete(line_buffer="d['foo")
-        nt.assert_in("foo", matches)
+        self.assertIn("foo", matches)
 
         # - can complete on second key
         _, matches = complete(line_buffer="d['foo', ")
-        nt.assert_in("'bar'", matches)
+        self.assertIn("'bar'", matches)
         _, matches = complete(line_buffer="d['foo', 'b")
-        nt.assert_in("bar", matches)
-        nt.assert_not_in("foo", matches)
+        self.assertIn("bar", matches)
+        self.assertNotIn("foo", matches)
 
         # - does not propose missing keys
         _, matches = complete(line_buffer="d['foo', 'f")
-        nt.assert_not_in("bar", matches)
-        nt.assert_not_in("foo", matches)
+        self.assertNotIn("bar", matches)
+        self.assertNotIn("foo", matches)
 
         # check sensitivity to following context
         _, matches = complete(line_buffer="d['foo',]", cursor_pos=8)
-        nt.assert_in("'bar'", matches)
-        nt.assert_not_in("bar", matches)
-        nt.assert_not_in("'foo'", matches)
-        nt.assert_not_in("foo", matches)
+        self.assertIn("'bar'", matches)
+        self.assertNotIn("bar", matches)
+        self.assertNotIn("'foo'", matches)
+        self.assertNotIn("foo", matches)
 
         _, matches = complete(line_buffer="d['']", cursor_pos=3)
-        nt.assert_in("foo", matches)
+        self.assertIn("foo", matches)
         assert not any(m.endswith(("]", '"', "'")) for m in matches), matches
 
         _, matches = complete(line_buffer='d[""]', cursor_pos=3)
-        nt.assert_in("foo", matches)
+        self.assertIn("foo", matches)
         assert not any(m.endswith(("]", '"', "'")) for m in matches), matches
 
         _, matches = complete(line_buffer='d["foo","]', cursor_pos=9)
-        nt.assert_in("bar", matches)
+        self.assertIn("bar", matches)
         assert not any(m.endswith(("]", '"', "'")) for m in matches), matches
 
         _, matches = complete(line_buffer='d["foo",]', cursor_pos=8)
-        nt.assert_in("'bar'", matches)
-        nt.assert_not_in("bar", matches)
+        self.assertIn("'bar'", matches)
+        self.assertNotIn("bar", matches)
 
         # Can complete with longer tuple keys
         ip.user_ns["d"] = {('foo', 'bar', 'foobar'): None}
 
         # - can complete second key
         _, matches = complete(line_buffer="d['foo', 'b")
-        nt.assert_in('bar', matches)
-        nt.assert_not_in('foo', matches)
-        nt.assert_not_in('foobar', matches)
+        self.assertIn("bar", matches)
+        self.assertNotIn("foo", matches)
+        self.assertNotIn("foobar", matches)
 
         # - can complete third key
         _, matches = complete(line_buffer="d['foo', 'bar', 'fo")
-        nt.assert_in('foobar', matches)
-        nt.assert_not_in('foo', matches)
-        nt.assert_not_in('bar', matches)
-
+        self.assertIn("foobar", matches)
+        self.assertNotIn("foo", matches)
+        self.assertNotIn("bar", matches)
 
     def test_dict_key_completion_contexts(self):
         """Test expression contexts in which dict key completion occurs"""
@@ -1046,16 +1042,16 b' class TestCompleter(unittest.TestCase):'
 
         def assert_no_completion(**kwargs):
             _, matches = complete(**kwargs)
-            nt.assert_not_in("abc", matches)
-            nt.assert_not_in("abc'", matches)
-            nt.assert_not_in("abc']", matches)
-            nt.assert_not_in("'abc'", matches)
-            nt.assert_not_in("'abc']", matches)
+            self.assertNotIn("abc", matches)
+            self.assertNotIn("abc'", matches)
+            self.assertNotIn("abc']", matches)
+            self.assertNotIn("'abc'", matches)
+            self.assertNotIn("'abc']", matches)
 
         def assert_completion(**kwargs):
             _, matches = complete(**kwargs)
-            nt.assert_in("'abc'", matches)
-            nt.assert_not_in("'abc']", matches)
+            self.assertIn("'abc'", matches)
+            self.assertNotIn("'abc']", matches)
 
         # no completion after string closed, even if reopened
         assert_no_completion(line_buffer="d['a'")
@@ -1071,7 +1067,7 b' class TestCompleter(unittest.TestCase):'
         # greedy flag
         def assert_completion(**kwargs):
             _, matches = complete(**kwargs)
-            nt.assert_in("get()['abc']", matches)
+            self.assertIn("get()['abc']", matches)
 
         assert_no_completion(line_buffer="get()[")
         with greedy_completion():
@@ -1089,25 +1085,25 b' class TestCompleter(unittest.TestCase):'
         ip.user_ns["d"] = {"abc": None, b"abd": None}
 
         _, matches = complete(line_buffer="d[")
-        nt.assert_in("'abc'", matches)
-        nt.assert_in("b'abd'", matches)
+        self.assertIn("'abc'", matches)
+        self.assertIn("b'abd'", matches)
 
         if False:  # not currently implemented
             _, matches = complete(line_buffer="d[b")
-            nt.assert_in("b'abd'", matches)
-            nt.assert_not_in("b'abc'", matches)
+            self.assertIn("b'abd'", matches)
+            self.assertNotIn("b'abc'", matches)
 
             _, matches = complete(line_buffer="d[b'")
-            nt.assert_in("abd", matches)
-            nt.assert_not_in("abc", matches)
+            self.assertIn("abd", matches)
+            self.assertNotIn("abc", matches)
 
             _, matches = complete(line_buffer="d[B'")
-            nt.assert_in("abd", matches)
-            nt.assert_not_in("abc", matches)
+            self.assertIn("abd", matches)
+            self.assertNotIn("abc", matches)
 
             _, matches = complete(line_buffer="d['")
-            nt.assert_in("abc", matches)
-            nt.assert_not_in("abd", matches)
+            self.assertIn("abc", matches)
+            self.assertNotIn("abd", matches)
 
     def test_dict_key_completion_unicode_py3(self):
         """Test handling of unicode in dict key completion"""
@@ -1120,20 +1116,20 b' class TestCompleter(unittest.TestCase):'
         if sys.platform != "win32":
             # Known failure on Windows
             _, matches = complete(line_buffer="d['a\\u05d0")
-            nt.assert_in("u05d0", matches)  # tokenized after \\
+            self.assertIn("u05d0", matches)  # tokenized after \\
 
         # query using character
         _, matches = complete(line_buffer="d['a\u05d0")
-        nt.assert_in("a\u05d0", matches)
+        self.assertIn("a\u05d0", matches)
 
         with greedy_completion():
             # query using escape
             _, matches = complete(line_buffer="d['a\\u05d0")
-            nt.assert_in("d['a\\u05d0']", matches)  # tokenized after \\
+            self.assertIn("d['a\\u05d0']", matches)  # tokenized after \\
 
             # query using character
             _, matches = complete(line_buffer="d['a\u05d0")
-            nt.assert_in("d['a\u05d0']", matches)
+            self.assertIn("d['a\u05d0']", matches)
 
     @dec.skip_without("numpy")
     def test_struct_array_key_completion(self):
@@ -1144,8 +1140,8 b' class TestCompleter(unittest.TestCase):'
         complete = ip.Completer.complete
         ip.user_ns["d"] = numpy.array([], dtype=[("hello", "f"), ("world", "f")])
         _, matches = complete(line_buffer="d['")
-        nt.assert_in("hello", matches)
-        nt.assert_in("world", matches)
+        self.assertIn("hello", matches)
+        self.assertIn("world", matches)
         # complete on the numpy struct itself
         dt = numpy.dtype(
             [("my_head", [("my_dt", ">u4"), ("my_df", ">u4")]), ("my_data", ">f4", 5)]
@@ -1153,14 +1149,14 b' class TestCompleter(unittest.TestCase):'
         x = numpy.zeros(2, dtype=dt)
         ip.user_ns["d"] = x[1]
         _, matches = complete(line_buffer="d['")
-        nt.assert_in("my_head", matches)
-        nt.assert_in("my_data", matches)
+        self.assertIn("my_head", matches)
+        self.assertIn("my_data", matches)
         # complete on a nested level
         with greedy_completion():
             ip.user_ns["d"] = numpy.zeros(2, dtype=dt)
             _, matches = complete(line_buffer="d[1]['my_head']['")
-            nt.assert_true(any(["my_dt" in m for m in matches]))
-            nt.assert_true(any(["my_df" in m for m in matches]))
+            self.assertTrue(any(["my_dt" in m for m in matches]))
+            self.assertTrue(any(["my_df" in m for m in matches]))
 
     @dec.skip_without("pandas")
     def test_dataframe_key_completion(self):
@@ -1171,8 +1167,8 b' class TestCompleter(unittest.TestCase):'
         complete = ip.Completer.complete
         ip.user_ns["d"] = pandas.DataFrame({"hello": [1], "world": [2]})
         _, matches = complete(line_buffer="d['")
-        nt.assert_in("hello", matches)
-        nt.assert_in("world", matches)
+        self.assertIn("hello", matches)
+        self.assertIn("world", matches)
 
     def test_dict_key_completion_invalids(self):
         """Smoke test cases dict key completion can't handle"""
@@ -1197,8 +1193,8 b' class TestCompleter(unittest.TestCase):'
         ip.user_ns["key_completable"] = KeyCompletable(["qwerty", "qwick"])
 
         _, matches = ip.Completer.complete(line_buffer="key_completable['qw")
-        nt.assert_in("qwerty", matches)
-        nt.assert_in("qwick", matches)
+        self.assertIn("qwerty", matches)
+        self.assertIn("qwick", matches)
 
     def test_class_key_completion(self):
         ip = get_ipython()
@@ -1207,8 +1203,8 b' class TestCompleter(unittest.TestCase):'
         ip.user_ns["named_instance_class"] = NamedInstanceClass
 
         _, matches = ip.Completer.complete(line_buffer="named_instance_class['qw")
-        nt.assert_in("qwerty", matches)
-        nt.assert_in("qwick", matches)
+        self.assertIn("qwerty", matches)
+        self.assertIn("qwick", matches)
 
     def test_tryimport(self):
         """
@@ -1221,27 +1217,27 b' class TestCompleter(unittest.TestCase):'
     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)
+        self.assertIn("io", matches)
+        self.assertNotIn("int", matches)
 
     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)
+        self.assertIn("IPython.core", matches)
+        self.assertNotIn("import IPython.core", matches)
+        self.assertNotIn("IPython.display", matches)
 
     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)
+        self.assertIn("io", matches)
+        self.assertNotIn("int", matches)
 
     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)
+        self.assertIn("BytesIO", matches)
+        self.assertNotIn("BaseException", matches)
 
     def test_snake_case_completion(self):
         ip = get_ipython()
@@ -1249,8 +1245,8 b' class TestCompleter(unittest.TestCase):'
         ip.user_ns["some_three"] = 3
         ip.user_ns["some_four"] = 4
         _, matches = ip.complete("s_", "print(s_f")
-        nt.assert_in("some_three", matches)
-        nt.assert_in("some_four", matches)
+        self.assertIn("some_three", matches)
+        self.assertIn("some_four", matches)
 
     def test_mix_terms(self):
         ip = get_ipython()
@@ -1274,5 +1270,5 b' class TestCompleter(unittest.TestCase):'
             )
         )
         _, matches = ip.complete(None, "test.meth(")
-        nt.assert_in("meth_arg1=", matches)
-        nt.assert_not_in("meth2_arg1=", matches)
+        self.assertIn("meth_arg1=", matches)
+        self.assertNotIn("meth2_arg1=", matches)

IPython/core/tests/test_completerlib.py

@@ -14,8 +14,6 b' import tempfile'
 import unittest
 from os.path import join
 
-import nose.tools as nt
-
 from IPython.core.completerlib import magic_run_completer, module_completion, try_import
 from IPython.utils.tempdir import TemporaryDirectory
 from IPython.testing.decorators import onlyif_unicode_paths
@@ -140,7 +138,7 b' def test_import_invalid_module():'
 
         s = set( module_completion('import foo') )
         intersection = s.intersection(invalid_module_names)
-        nt.assert_equal(intersection, set())
+        assert intersection == set()
 
         assert valid_module_names.issubset(s), valid_module_names.intersection(s)
 
@@ -153,15 +151,15 b' def test_bad_module_all():'
     testsdir = os.path.dirname(__file__)
     sys.path.insert(0, testsdir)
     try:
-        results = module_completion('from bad_all import ')
-        nt.assert_in('puppies', results)
+        results = module_completion("from bad_all import ")
+        assert "puppies" in results
         for r in results:
-            nt.assert_is_instance(r, str)
+            assert isinstance(r, str)
 
         # bad_all doesn't contain submodules, but this completion
         # should finish without raising an exception:
         results = module_completion("import bad_all.")
-        nt.assert_equal(results, [])
+        assert results == []
     finally:
         sys.path.remove(testsdir)
 
@@ -189,6 +187,6 b' def test_valid_exported_submodules():'
     """
     results = module_completion("import os.pa")
     # ensure we get a valid submodule:
-    nt.assert_in("os.path", results)
+    assert "os.path" in results
     # ensure we don't get objects that aren't submodules:
-    nt.assert_not_in("os.pathconf", results)
+    assert "os.pathconf" not in results

IPython/core/tests/test_debugger.py

@@ -18,8 +18,6 b' from tempfile import NamedTemporaryFile'
 from textwrap import dedent
 from unittest.mock import patch
 
-import nose.tools as nt
-
 from IPython.core import debugger
 from IPython.testing import IPYTHON_TESTING_TIMEOUT_SCALE
 from IPython.testing.decorators import skip_win32
@@ -66,13 +64,13 b' def test_longer_repr():'
     a = '1234567890'* 7
     ar = "'1234567890123456789012345678901234567890123456789012345678901234567890'"
     a_trunc = "'123456789012...8901234567890'"
-    nt.assert_equal(trepr(a), a_trunc)
+    assert trepr(a) == a_trunc
     # The creation of our tracer modifies the repr module's repr function
     # in-place, since that global is used directly by the stdlib's pdb module.
     with warnings.catch_warnings():
         warnings.simplefilter('ignore', DeprecationWarning)
         debugger.Tracer()
-    nt.assert_equal(trepr(a), ar)
+    assert trepr(a) == ar
 
 def test_ipdb_magics():
     '''Test calling some IPython magics from ipdb.

IPython/core/tests/test_display.py

@@ -7,7 +7,7 b' import warnings'
 
 from unittest import mock
 
-import nose.tools as nt
+import pytest
 
 from IPython import display
 from IPython.core.getipython import get_ipython
@@ -22,15 +22,15 b' def test_image_size():'
     """Simple test for display.Image(args, width=x,height=y)"""
     thisurl = 'http://www.google.fr/images/srpr/logo3w.png'
     img = display.Image(url=thisurl, width=200, height=200)
-    nt.assert_equal(u'<img src="%s" width="200" height="200"/>' % (thisurl), img._repr_html_())
+    assert '<img src="%s" width="200" height="200"/>' % (thisurl) == img._repr_html_()
     img = display.Image(url=thisurl, metadata={'width':200, 'height':200})
-    nt.assert_equal(u'<img src="%s" width="200" height="200"/>' % (thisurl), img._repr_html_())
+    assert '<img src="%s" width="200" height="200"/>' % (thisurl) == img._repr_html_()
     img = display.Image(url=thisurl, width=200)
-    nt.assert_equal(u'<img src="%s" width="200"/>' % (thisurl), img._repr_html_())
+    assert '<img src="%s" width="200"/>' % (thisurl) == img._repr_html_()
     img = display.Image(url=thisurl)
-    nt.assert_equal(u'<img src="%s"/>' % (thisurl), img._repr_html_())
+    assert '<img src="%s"/>' % (thisurl) == img._repr_html_()
     img = display.Image(url=thisurl, unconfined=True)
-    nt.assert_equal(u'<img src="%s" class="unconfined"/>' % (thisurl), img._repr_html_())
+    assert '<img src="%s" class="unconfined"/>' % (thisurl) == img._repr_html_()
 
 
 def test_image_mimes():
@@ -39,7 +39,7 b' def test_image_mimes():'
         mime = display.Image._MIMETYPES[format]
         img = display.Image(b'garbage', format=format)
         data, metadata = fmt(img)
-        nt.assert_equal(sorted(data), sorted([mime, 'text/plain']))
+        assert sorted(data) == sorted([mime, "text/plain"])
 
 
 def test_geojson():
@@ -60,17 +60,20 b' def test_geojson():'
             "attribution": "Celestia/praesepe",
             "minZoom": 0,
             "maxZoom": 18,
-        })
-    nt.assert_equal(u'<IPython.core.display.GeoJSON object>', str(gj))
+        },
+    )
+    assert "<IPython.core.display.GeoJSON object>" == str(gj)
+
 
 def test_retina_png():
     here = os.path.dirname(__file__)
     img = display.Image(os.path.join(here, "2x2.png"), retina=True)
-    nt.assert_equal(img.height, 1)
-    nt.assert_equal(img.width, 1)
+    assert img.height == 1
+    assert img.width == 1
     data, md = img._repr_png_()
-    nt.assert_equal(md['width'], 1)
-    nt.assert_equal(md['height'], 1)
+    assert md["width"] == 1
+    assert md["height"] == 1
+
 
 def test_embed_svg_url():
     import gzip
@@ -102,18 +105,20 b' def test_embed_svg_url():'
 
     with mock.patch('urllib.request.urlopen', side_effect=mocked_urlopen):
         svg = display.SVG(url=url)
-        nt.assert_true(svg._repr_svg_().startswith('<svg'))
-        svg = display.SVG(url=url + 'z')
-        nt.assert_true(svg._repr_svg_().startswith('<svg'))
+        assert svg._repr_svg_().startswith("<svg") is True
+        svg = display.SVG(url=url + "z")
+        assert svg._repr_svg_().startswith("<svg") is True
+
 
 def test_retina_jpeg():
     here = os.path.dirname(__file__)
     img = display.Image(os.path.join(here, "2x2.jpg"), retina=True)
-    nt.assert_equal(img.height, 1)
-    nt.assert_equal(img.width, 1)
+    assert img.height == 1
+    assert img.width == 1
     data, md = img._repr_jpeg_()
-    nt.assert_equal(md['width'], 1)
-    nt.assert_equal(md['height'], 1)
+    assert md["width"] == 1
+    assert md["height"] == 1
+
 
 def test_base64image():
     display.Image("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABAQMAAAAl21bKAAAAA1BMVEUAAACnej3aAAAAAWJLR0QAiAUdSAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB94BCRQnOqNu0b4AAAAKSURBVAjXY2AAAAACAAHiIbwzAAAAAElFTkSuQmCC")
@@ -121,18 +126,30 b' def test_base64image():'
 def test_image_filename_defaults():
     '''test format constraint, and validity of jpeg and png'''
     tpath = ipath.get_ipython_package_dir()
-    nt.assert_raises(ValueError, display.Image, filename=os.path.join(tpath, 'testing/tests/badformat.zip'),
-                     embed=True)
-    nt.assert_raises(ValueError, display.Image)
-    nt.assert_raises(ValueError, display.Image, data='this is not an image', format='badformat', embed=True)
-    # check both paths to allow packages to test at build and install time
+    pytest.raises(
+        ValueError,
+        display.Image,
+        filename=os.path.join(tpath, "testing/tests/badformat.zip"),
+        embed=True,
+    )
+    pytest.raises(ValueError, display.Image)
+    pytest.raises(
+        ValueError,
+        display.Image,
+        data="this is not an image",
+        format="badformat",
+        embed=True,
+    )
+    # check boths paths to allow packages to test at build and install time
     imgfile = os.path.join(tpath, 'core/tests/2x2.png')
     img = display.Image(filename=imgfile)
-    nt.assert_equal('png', img.format)
-    nt.assert_is_not_none(img._repr_png_())
-    img = display.Image(filename=os.path.join(tpath, 'testing/tests/logo.jpg'), embed=False)
-    nt.assert_equal('jpeg', img.format)
-    nt.assert_is_none(img._repr_jpeg_())
+    assert "png" == img.format
+    assert img._repr_png_() is not None
+    img = display.Image(
+        filename=os.path.join(tpath, "testing/tests/logo.jpg"), embed=False
+    )
+    assert "jpeg" == img.format
+    assert img._repr_jpeg_() is None
 
 def _get_inline_config():
     from matplotlib_inline.config import InlineBackend
@@ -171,9 +188,9 b' def test_set_matplotlib_formats():'
         display.set_matplotlib_formats(*formats)
         for mime, f in formatters.items():
             if mime in active_mimes:
-                nt.assert_in(Figure, f)
+                assert Figure in f
             else:
-                nt.assert_not_in(Figure, f)
+                assert Figure not in f
 
 
 @dec.skip_without("ipykernel")
@@ -192,7 +209,7 b' def test_set_matplotlib_formats_kwargs():'
     expected["base64"] = True
     expected["fmt"] = "png"
     expected.update(cfg.print_figure_kwargs)
-    nt.assert_equal(formatter_kwargs, expected)
+    assert formatter_kwargs == expected
 
 def test_display_available():
     """
@@ -214,26 +231,27 b' def test_display_available():'
 
 def test_textdisplayobj_pretty_repr():
      p = display.Pretty("This is a simple test")
-     nt.assert_equal(repr(p), '<IPython.core.display.Pretty object>')
-     nt.assert_equal(p.data, 'This is a simple test')
+    assert repr(p) == "<IPython.core.display.Pretty object>"
+    assert p.data == "This is a simple test"
 
      p._show_mem_addr = True
-     nt.assert_equal(repr(p), object.__repr__(p))
+    assert repr(p) == object.__repr__(p)
+
 
 def test_displayobject_repr():
-    h = display.HTML('<br />')
-    nt.assert_equal(repr(h), '<IPython.core.display.HTML object>')
+    h = display.HTML("<br />")
+    assert repr(h) == "<IPython.core.display.HTML object>"
     h._show_mem_addr = True
-    nt.assert_equal(repr(h), object.__repr__(h))
+    assert repr(h) == object.__repr__(h)
     h._show_mem_addr = False
-    nt.assert_equal(repr(h), '<IPython.core.display.HTML object>')
+    assert repr(h) == "<IPython.core.display.HTML object>"
 
-    j = display.Javascript('')
-    nt.assert_equal(repr(j), '<IPython.core.display.Javascript object>')
+    j = display.Javascript("")
+    assert repr(j) == "<IPython.core.display.Javascript object>"
     j._show_mem_addr = True
-    nt.assert_equal(repr(j), object.__repr__(j))
+    assert repr(j) == object.__repr__(j)
     j._show_mem_addr = False
-    nt.assert_equal(repr(j), '<IPython.core.display.Javascript object>')
+    assert repr(j) == "<IPython.core.display.Javascript object>"
 
 @mock.patch('warnings.warn')
 def test_encourage_iframe_over_html(m_warn):
@@ -255,18 +273,22 b' def test_encourage_iframe_over_html(m_warn):'
 
 def test_progress():
     p = display.ProgressBar(10)
-    nt.assert_in('0/10',repr(p))
-    p.html_width = '100%'
+    assert "0/10" in repr(p)
+    p.html_width = "100%"
     p.progress = 5
-    nt.assert_equal(p._repr_html_(), "<progress style='width:100%' max='10' value='5'></progress>")
+    assert (
+        p._repr_html_() == "<progress style='width:100%' max='10' value='5'></progress>"
+    )
+
 
 def test_progress_iter():
     with capture_output(display=False) as captured:
         for i in display.ProgressBar(5):
             out = captured.stdout
-            nt.assert_in('{0}/5'.format(i), out)
+            assert "{0}/5".format(i) in out
     out = captured.stdout
-    nt.assert_in('5/5', out)
+    assert "5/5" in out
+
 
 def test_json():
     d = {'a': 5}
@@ -284,13 +306,13 b' def test_json():'
         display.JSON(d, expanded=True, root='custom'),
     ]
     for j, md in zip(json_objs, metadata):
-        nt.assert_equal(j._repr_json_(), (d, md))
+        assert j._repr_json_() == (d, md)
 
     with warnings.catch_warnings(record=True) as w:
         warnings.simplefilter("always")
         j = display.JSON(json.dumps(d))
-        nt.assert_equal(len(w), 1)
-        nt.assert_equal(j._repr_json_(), (d, metadata[0]))
+        assert len(w) == 1
+        assert j._repr_json_() == (d, metadata[0])
 
     json_objs = [
         display.JSON(lis),
@@ -299,23 +321,24 b' def test_json():'
         display.JSON(lis, expanded=True, root='custom'),
     ]
     for j, md in zip(json_objs, metadata):
-        nt.assert_equal(j._repr_json_(), (lis, md))
+        assert j._repr_json_() == (lis, md)
 
     with warnings.catch_warnings(record=True) as w:
         warnings.simplefilter("always")
         j = display.JSON(json.dumps(lis))
-        nt.assert_equal(len(w), 1)
-        nt.assert_equal(j._repr_json_(), (lis, metadata[0]))
+        assert len(w) == 1
+        assert j._repr_json_() == (lis, metadata[0])
+
 
 def test_video_embedding():
     """use a tempfile, with dummy-data, to ensure that video embedding doesn't crash"""
     v = display.Video("http://ignored")
     assert not v.embed
     html = v._repr_html_()
-    nt.assert_not_in('src="data:', html)
-    nt.assert_in('src="http://ignored"', html)
+    assert 'src="data:' not in html
+    assert 'src="http://ignored"' in html
 
-    with nt.assert_raises(ValueError):
+    with pytest.raises(ValueError):
         v = display.Video(b'abc')
 
     with NamedFileInTemporaryDirectory('test.mp4') as f:
@@ -325,52 +348,53 b' def test_video_embedding():'
         v = display.Video(f.name)
         assert not v.embed
         html = v._repr_html_()
-        nt.assert_not_in('src="data:', html)
+        assert 'src="data:' not in html
 
         v = display.Video(f.name, embed=True)
         html = v._repr_html_()
-        nt.assert_in('src="data:video/mp4;base64,YWJj"',html)
+        assert 'src="data:video/mp4;base64,YWJj"' in html
 
         v = display.Video(f.name, embed=True, mimetype='video/other')
         html = v._repr_html_()
-        nt.assert_in('src="data:video/other;base64,YWJj"',html)
+        assert 'src="data:video/other;base64,YWJj"' in html
 
         v = display.Video(b'abc', embed=True, mimetype='video/mp4')
         html = v._repr_html_()
-        nt.assert_in('src="data:video/mp4;base64,YWJj"',html)
+        assert 'src="data:video/mp4;base64,YWJj"' in html
 
         v = display.Video(u'YWJj', embed=True, mimetype='video/xyz')
         html = v._repr_html_()
-        nt.assert_in('src="data:video/xyz;base64,YWJj"',html)
+        assert 'src="data:video/xyz;base64,YWJj"' in html
 
 def test_html_metadata():
     s = "<h1>Test</h1>"
     h = display.HTML(s, metadata={"isolated": True})
-    nt.assert_equal(h._repr_html_(), (s, {"isolated": True}))
+    assert h._repr_html_() == (s, {"isolated": True})
+
 
 def test_display_id():
     ip = get_ipython()
     with mock.patch.object(ip.display_pub, 'publish') as pub:
         handle = display.display('x')
-        nt.assert_is(handle, None)
+        assert handle is None
         handle = display.display('y', display_id='secret')
-        nt.assert_is_instance(handle, display.DisplayHandle)
+        assert isinstance(handle, display.DisplayHandle)
         handle2 = display.display('z', display_id=True)
-        nt.assert_is_instance(handle2, display.DisplayHandle)
-    nt.assert_not_equal(handle.display_id, handle2.display_id)
+        assert isinstance(handle2, display.DisplayHandle)
+    assert handle.display_id != handle2.display_id
 
-    nt.assert_equal(pub.call_count, 3)
+    assert pub.call_count == 3
     args, kwargs = pub.call_args_list[0]
-    nt.assert_equal(args, ())
-    nt.assert_equal(kwargs, {
+    assert args == ()
+    assert kwargs == {
         'data': {
             'text/plain': repr('x')
         },
         'metadata': {},
-    })
+    }
     args, kwargs = pub.call_args_list[1]
-    nt.assert_equal(args, ())
-    nt.assert_equal(kwargs, {
+    assert args == ()
+    assert kwargs == {
         'data': {
             'text/plain': repr('y')
         },
@@ -378,10 +402,10 b' def test_display_id():'
         'transient': {
             'display_id': handle.display_id,
         },
-    })
+    }
     args, kwargs = pub.call_args_list[2]
-    nt.assert_equal(args, ())
-    nt.assert_equal(kwargs, {
+    assert args == ()
+    assert kwargs == {
         'data': {
             'text/plain': repr('z')
         },
@@ -389,19 +413,19 b' def test_display_id():'
         'transient': {
             'display_id': handle2.display_id,
         },
-    })
+    }
 
 
 def test_update_display():
     ip = get_ipython()
     with mock.patch.object(ip.display_pub, 'publish') as pub:
-        with nt.assert_raises(TypeError):
+        with pytest.raises(TypeError):
             display.update_display('x')
         display.update_display('x', display_id='1')
         display.update_display('y', display_id='2')
     args, kwargs = pub.call_args_list[0]
-    nt.assert_equal(args, ())
-    nt.assert_equal(kwargs, {
+    assert args == ()
+    assert kwargs == {
         'data': {
             'text/plain': repr('x')
         },
@@ -410,10 +434,10 b' def test_update_display():'
             'display_id': '1',
         },
         'update': True,
-    })
+    }
     args, kwargs = pub.call_args_list[1]
-    nt.assert_equal(args, ())
-    nt.assert_equal(kwargs, {
+    assert args == ()
+    assert kwargs == {
         'data': {
             'text/plain': repr('y')
         },
@@ -422,22 +446,22 b' def test_update_display():'
             'display_id': '2',
         },
         'update': True,
-    })
+    }
 
 
 def test_display_handle():
     ip = get_ipython()
     handle = display.DisplayHandle()
-    nt.assert_is_instance(handle.display_id, str)
-    handle = display.DisplayHandle('my-id')
-    nt.assert_equal(handle.display_id, 'my-id')
-    with mock.patch.object(ip.display_pub, 'publish') as pub:
-        handle.display('x')
-        handle.update('y')
+    assert isinstance(handle.display_id, str)
+    handle = display.DisplayHandle("my-id")
+    assert handle.display_id == "my-id"
+    with mock.patch.object(ip.display_pub, "publish") as pub:
+        handle.display("x")
+        handle.update("y")
 
     args, kwargs = pub.call_args_list[0]
-    nt.assert_equal(args, ())
-    nt.assert_equal(kwargs, {
+    assert args == ()
+    assert kwargs == {
         'data': {
             'text/plain': repr('x')
         },
@@ -445,10 +469,10 b' def test_display_handle():'
         'transient': {
             'display_id': handle.display_id,
         }
-    })
+    }
     args, kwargs = pub.call_args_list[1]
-    nt.assert_equal(args, ())
-    nt.assert_equal(kwargs, {
+    assert args == ()
+    assert kwargs == {
         'data': {
             'text/plain': repr('y')
         },
@@ -457,34 +481,31 b' def test_display_handle():'
             'display_id': handle.display_id,
         },
         'update': True,
-    })
+    }
 
 
 def test_image_alt_tag():
     """Simple test for display.Image(args, alt=x,)"""
     thisurl = "http://example.com/image.png"
     img = display.Image(url=thisurl, alt="an image")
-    nt.assert_equal(u'<img src="%s" alt="an image"/>' % (thisurl), img._repr_html_())
+    assert '<img src="%s" alt="an image"/>' % (thisurl) == img._repr_html_()
     img = display.Image(url=thisurl, unconfined=True, alt="an image")
-    nt.assert_equal(
-        u'<img src="%s" class="unconfined" alt="an image"/>' % (thisurl),
-        img._repr_html_(),
+    assert (
+        '<img src="%s" class="unconfined" alt="an image"/>' % (thisurl)
+        == img._repr_html_()
     )
     img = display.Image(url=thisurl, alt='>"& <')
-    nt.assert_equal(
-        u'<img src="%s" alt="&gt;&quot;&amp; &lt;"/>' % (thisurl), img._repr_html_()
-    )
+    assert '<img src="%s" alt="&gt;&quot;&amp; &lt;"/>' % (thisurl) == img._repr_html_()
 
     img = display.Image(url=thisurl, metadata={"alt": "an image"})
-    nt.assert_equal(img.alt, "an image")
-
+    assert img.alt == "an image"
     here = os.path.dirname(__file__)
     img = display.Image(os.path.join(here, "2x2.png"), alt="an image")
-    nt.assert_equal(img.alt, "an image")
+    assert img.alt == "an image"
     _, md = img._repr_png_()
-    nt.assert_equal(md["alt"], "an image")
+    assert md["alt"] == "an image"
 
 
[e-mail](FileNotFoundError)
 def test_image_bad_filename_raises_proper_exception():
+    with pytest.raises(FileNotFoundError):
     display.Image("/this/file/does/not/exist/")._repr_png_()

IPython/core/tests/test_events.py

@@ -1,6 +1,5 b''
 import unittest
 from unittest.mock import Mock
-import nose.tools as nt
 
 from IPython.core import events
 import IPython.testing.tools as tt
@@ -40,9 +39,9 b' class CallbackTests(unittest.TestCase):'
         def cb2():
             ...
 
-        self.em.register('ping_received', cb1)
-        nt.assert_raises(ValueError, self.em.unregister, 'ping_received', cb2)
-        self.em.unregister('ping_received', cb1)
+        self.em.register("ping_received", cb1)
+        self.assertRaises(ValueError, self.em.unregister, "ping_received", cb2)
+        self.em.unregister("ping_received", cb1)
 
     def test_cb_error(self):
         cb = Mock(side_effect=ValueError)

IPython/core/tests/test_extension.py

@@ -1,7 +1,5 b''
 import os.path
 
-import nose.tools as nt
-
 import IPython.testing.tools as tt
 from IPython.utils.syspathcontext import prepended_to_syspath
 from IPython.utils.tempdir import TemporaryDirectory
@@ -93,4 +91,4 b' def test_extension_builtins():'
 
 def test_non_extension():
     em = get_ipython().extension_manager
-    nt.assert_equal(em.load_extension('sys'), "no load function")
+    assert em.load_extension("sys") == "no load function"

IPython/core/tests/test_formatters.py

@@ -7,7 +7,7 b' try:'
     import numpy
 except:
     numpy = None
-import nose.tools as nt
+import pytest
 
 from IPython import get_ipython
 from traitlets.config import Config
@@ -96,23 +96,24 b' def test_bad_precision():'
     f = PlainTextFormatter()
     def set_fp(p):
         f.float_precision=p
-    nt.assert_raises(ValueError, set_fp, '%')
-    nt.assert_raises(ValueError, set_fp, '%.3f%i')
-    nt.assert_raises(ValueError, set_fp, 'foo')
-    nt.assert_raises(ValueError, set_fp, -1)
+
+    pytest.raises(ValueError, set_fp, "%")
+    pytest.raises(ValueError, set_fp, "%.3f%i")
+    pytest.raises(ValueError, set_fp, "foo")
+    pytest.raises(ValueError, set_fp, -1)
 
 def test_for_type():
     f = PlainTextFormatter()
     
     # initial return, None
-    nt.assert_is(f.for_type(C, foo_printer), None)
+    assert f.for_type(C, foo_printer) is None
     # no func queries
-    nt.assert_is(f.for_type(C), foo_printer)
+    assert f.for_type(C) is foo_printer
     # shouldn't change anything
-    nt.assert_is(f.for_type(C), foo_printer)
+    assert f.for_type(C) is foo_printer
     # None should do the same
-    nt.assert_is(f.for_type(C, None), foo_printer)
-    nt.assert_is(f.for_type(C, None), foo_printer)
+    assert f.for_type(C, None) is foo_printer
+    assert f.for_type(C, None) is foo_printer
 
 def test_for_type_string():
     f = PlainTextFormatter()
@@ -120,13 +121,13 b' def test_for_type_string():'
     type_str = '%s.%s' % (C.__module__, 'C')
     
     # initial return, None
-    nt.assert_is(f.for_type(type_str, foo_printer), None)
+    assert f.for_type(type_str, foo_printer) is None
     # no func queries
-    nt.assert_is(f.for_type(type_str), foo_printer)
-    nt.assert_in(_mod_name_key(C), f.deferred_printers)
-    nt.assert_is(f.for_type(C), foo_printer)
-    nt.assert_not_in(_mod_name_key(C), f.deferred_printers)
-    nt.assert_in(C, f.type_printers)
+    assert f.for_type(type_str) is foo_printer
+    assert _mod_name_key(C) in f.deferred_printers
+    assert f.for_type(C) is foo_printer
+    assert _mod_name_key(C) not in f.deferred_printers
+    assert C in f.type_printers
 
 def test_for_type_by_name():
     f = PlainTextFormatter()
@@ -134,21 +135,22 b' def test_for_type_by_name():'
     mod = C.__module__
     
     # initial return, None
-    nt.assert_is(f.for_type_by_name(mod, 'C', foo_printer), None)
+    assert f.for_type_by_name(mod, "C", foo_printer) is None
     # no func queries
-    nt.assert_is(f.for_type_by_name(mod, 'C'), foo_printer)
+    assert f.for_type_by_name(mod, "C") is foo_printer
     # shouldn't change anything
-    nt.assert_is(f.for_type_by_name(mod, 'C'), foo_printer)
+    assert f.for_type_by_name(mod, "C") is foo_printer
     # None should do the same
-    nt.assert_is(f.for_type_by_name(mod, 'C', None), foo_printer)
-    nt.assert_is(f.for_type_by_name(mod, 'C', None), foo_printer)
+    assert f.for_type_by_name(mod, "C", None) is foo_printer
+    assert f.for_type_by_name(mod, "C", None) is foo_printer
+
 
 def test_lookup():
     f = PlainTextFormatter()
     
     f.for_type(C, foo_printer)
-    nt.assert_is(f.lookup(C()), foo_printer)
-    with nt.assert_raises(KeyError):
+    assert f.lookup(C()) is foo_printer
+    with pytest.raises(KeyError):
         f.lookup(A())
 
 def test_lookup_string():
@@ -156,16 +158,16 b' def test_lookup_string():'
     type_str = '%s.%s' % (C.__module__, 'C')
     
     f.for_type(type_str, foo_printer)
-    nt.assert_is(f.lookup(C()), foo_printer)
+    assert f.lookup(C()) is foo_printer
     # should move from deferred to imported dict
-    nt.assert_not_in(_mod_name_key(C), f.deferred_printers)
-    nt.assert_in(C, f.type_printers)
+    assert _mod_name_key(C) not in f.deferred_printers
+    assert C in f.type_printers
 
 def test_lookup_by_type():
     f = PlainTextFormatter()
     f.for_type(C, foo_printer)
-    nt.assert_is(f.lookup_by_type(C), foo_printer)
-    with nt.assert_raises(KeyError):
+    assert f.lookup_by_type(C) is foo_printer
+    with pytest.raises(KeyError):
         f.lookup_by_type(A)
 
 def test_lookup_by_type_string():
@@ -174,69 +176,69 b' def test_lookup_by_type_string():'
     f.for_type(type_str, foo_printer)
     
     # verify insertion
-    nt.assert_in(_mod_name_key(C), f.deferred_printers)
-    nt.assert_not_in(C, f.type_printers)
+    assert _mod_name_key(C) in f.deferred_printers
+    assert C not in f.type_printers
     
-    nt.assert_is(f.lookup_by_type(type_str), foo_printer)
+    assert f.lookup_by_type(type_str) is foo_printer
     # lookup by string doesn't cause import
-    nt.assert_in(_mod_name_key(C), f.deferred_printers)
-    nt.assert_not_in(C, f.type_printers)
+    assert _mod_name_key(C) in f.deferred_printers
+    assert C not in f.type_printers
     
-    nt.assert_is(f.lookup_by_type(C), foo_printer)
+    assert f.lookup_by_type(C) is foo_printer
     # should move from deferred to imported dict
-    nt.assert_not_in(_mod_name_key(C), f.deferred_printers)
-    nt.assert_in(C, f.type_printers)
+    assert _mod_name_key(C) not in f.deferred_printers
+    assert C in f.type_printers
 
 def test_in_formatter():
     f = PlainTextFormatter()
     f.for_type(C, foo_printer)
     type_str = '%s.%s' % (C.__module__, 'C')
-    nt.assert_in(C, f)
-    nt.assert_in(type_str, f)
+    assert C in f
+    assert type_str in f
 
 def test_string_in_formatter():
     f = PlainTextFormatter()
     type_str = '%s.%s' % (C.__module__, 'C')
     f.for_type(type_str, foo_printer)
-    nt.assert_in(type_str, f)
-    nt.assert_in(C, f)
+    assert type_str in f
+    assert C in f
 
 def test_pop():
     f = PlainTextFormatter()
     f.for_type(C, foo_printer)
-    nt.assert_is(f.lookup_by_type(C), foo_printer)
-    nt.assert_is(f.pop(C, None), foo_printer)
+    assert f.lookup_by_type(C) is foo_printer
+    assert f.pop(C, None) is foo_printer
     f.for_type(C, foo_printer)
-    nt.assert_is(f.pop(C), foo_printer)
-    with nt.assert_raises(KeyError):
+    assert f.pop(C) is foo_printer
+    with pytest.raises(KeyError):
         f.lookup_by_type(C)
-    with nt.assert_raises(KeyError):
+    with pytest.raises(KeyError):
         f.pop(C)
-    with nt.assert_raises(KeyError):
+    with pytest.raises(KeyError):
         f.pop(A)
-    nt.assert_is(f.pop(A, None), None)
+    assert f.pop(A, None) is None
 
 def test_pop_string():
     f = PlainTextFormatter()
     type_str = '%s.%s' % (C.__module__, 'C')
     
-    with nt.assert_raises(KeyError):
+    with pytest.raises(KeyError):
         f.pop(type_str)
     
     f.for_type(type_str, foo_printer)
     f.pop(type_str)
-    with nt.assert_raises(KeyError):
+    with pytest.raises(KeyError):
         f.lookup_by_type(C)
-    with nt.assert_raises(KeyError):
+    with pytest.raises(KeyError):
         f.pop(type_str)
 
     f.for_type(C, foo_printer)
-    nt.assert_is(f.pop(type_str, None), foo_printer)
-    with nt.assert_raises(KeyError):
+    assert f.pop(type_str, None) is foo_printer
+    with pytest.raises(KeyError):
         f.lookup_by_type(C)
-    with nt.assert_raises(KeyError):
+    with pytest.raises(KeyError):
         f.pop(type_str)
-    nt.assert_is(f.pop(type_str, None), None)
+    assert f.pop(type_str, None) is None
     
 
 def test_error_method():
@@ -247,10 +249,10 b' def test_error_method():'
     bad = BadHTML()
     with capture_output() as captured:
         result = f(bad)
-    nt.assert_is(result, None)
-    nt.assert_in("Traceback", captured.stdout)
-    nt.assert_in("Bad HTML", captured.stdout)
-    nt.assert_in("_repr_html_", captured.stdout)
+    assert result is None
+    assert "Traceback" in captured.stdout
+    assert "Bad HTML" in captured.stdout
+    assert "_repr_html_" in captured.stdout
 
 def test_nowarn_notimplemented():
     f = HTMLFormatter()
@@ -260,7 +262,7 b' def test_nowarn_notimplemented():'
     h = HTMLNotImplemented()
     with capture_output() as captured:
         result = f(h)
-    nt.assert_is(result, None)
+    assert result is None
     assert "" == captured.stderr
     assert "" == captured.stdout
 
@@ -270,10 +272,10 b' def test_warn_error_for_type():'
     f.for_type(int, lambda i: name_error)
     with capture_output() as captured:
         result = f(5)
-    nt.assert_is(result, None)
-    nt.assert_in("Traceback", captured.stdout)
-    nt.assert_in("NameError", captured.stdout)
-    nt.assert_in("name_error", captured.stdout)
+    assert result is None
+    assert "Traceback" in captured.stdout
+    assert "NameError" in captured.stdout
+    assert "name_error" in captured.stdout
 
 def test_error_pretty_method():
     f = PlainTextFormatter()
@@ -283,11 +285,11 b' def test_error_pretty_method():'
     bad = BadPretty()
     with capture_output() as captured:
         result = f(bad)
-    nt.assert_is(result, None)
-    nt.assert_in("Traceback", captured.stdout)
-    nt.assert_in("_repr_pretty_", captured.stdout)
-    nt.assert_in("given", captured.stdout)
-    nt.assert_in("argument", captured.stdout)
+    assert result is None
+    assert "Traceback" in captured.stdout
+    assert "_repr_pretty_" in captured.stdout
+    assert "given" in captured.stdout
+    assert "argument" in captured.stdout
 
 
 def test_bad_repr_traceback():
@@ -296,10 +298,10 b' def test_bad_repr_traceback():'
     with capture_output() as captured:
         result = f(bad)
     # catches error, returns None
-    nt.assert_is(result, None)
-    nt.assert_in("Traceback", captured.stdout)
-    nt.assert_in("__repr__", captured.stdout)
-    nt.assert_in("ValueError", captured.stdout)
+    assert result is None
+    assert "Traceback" in captured.stdout
+    assert "__repr__" in captured.stdout
+    assert "ValueError" in captured.stdout
 
 
 class MakePDF(object):
@@ -319,8 +321,8 b' def test_print_method_bound():'
             return "hello"
     with capture_output() as captured:
         result = f(MyHTML)
-    nt.assert_is(result, None)
-    nt.assert_not_in("FormatterWarning", captured.stderr)
+    assert result is None
+    assert "FormatterWarning" not in captured.stderr
 
     with capture_output() as captured:
         result = f(MyHTML())
@@ -341,8 +343,8 b' def test_print_method_weird():'
     with capture_output() as captured:
         result = f(text_hat)
     
-    nt.assert_is(result, None)
-    nt.assert_not_in("FormatterWarning", captured.stderr)
+    assert result is None
+    assert "FormatterWarning" not in captured.stderr
 
     class CallableMagicHat(object):
         def __getattr__(self, key):
@@ -362,8 +364,8 b' def test_print_method_weird():'
     with capture_output() as captured:
         result = f(bad)
     
-    nt.assert_is(result, None)
-    nt.assert_not_in("FormatterWarning", captured.stderr)
+    assert result is None
+    assert "FormatterWarning" not in captured.stderr
 
 
 def test_format_config():
@@ -372,12 +374,12 b' def test_format_config():'
     cfg = Config()
     with capture_output() as captured:
         result = f(cfg)
-    nt.assert_is(result, None)
+    assert result is None
     assert captured.stderr == ""
 
     with capture_output() as captured:
         result = f(Config)
-    nt.assert_is(result, None)
+    assert result is None
     assert captured.stderr == ""
 
 

IPython/core/tests/test_handlers.py

@@ -4,9 +4,6 b''
 # Module imports
 #-----------------------------------------------------------------------------
 
-# third party
-import nose.tools as nt
-
 # our own packages
 from IPython.core import autocall
 from IPython.testing import tools as tt
@@ -91,4 +88,4 b' def test_handlers():'
         ])
     ip.magic('autocall 1')
 
-    nt.assert_equal(failures, [])
+    assert failures == []

IPython/core/tests/test_history.py

@@ -13,9 +13,6 b' import tempfile'
 from datetime import datetime
 import sqlite3
 
-# third party
-import nose.tools as nt
-
 # our own packages
 from traitlets.config.loader import Config
 from IPython.utils.tempdir import TemporaryDirectory
@@ -23,7 +20,7 b' from IPython.core.history import HistoryManager, extract_hist_ranges'
 from IPython.testing.decorators import skipif
 
 def test_proper_default_encoding():
-    nt.assert_equal(sys.getdefaultencoding(), "utf-8")
+    assert sys.getdefaultencoding() == "utf-8"
 
 @skipif(sqlite3.sqlite_version_info > (3,24,0))
 def test_history():
@@ -34,7 +31,7 b' def test_history():'
         hist_file = tmp_path / "history.sqlite"
         try:
             ip.history_manager = HistoryManager(shell=ip, hist_file=hist_file)
-            hist = [u'a=1', u'def f():\n    test = 1\n    return test', u"b='€Æ¾÷ß'"]
+            hist = ["a=1", "def f():\n    test = 1\n    return test", "b='€Æ¾÷ß'"]
             for i, h in enumerate(hist, start=1):
                 ip.history_manager.store_inputs(i, h)
 
@@ -43,13 +40,15 b' def test_history():'
             ip.history_manager.output_hist_reprs[3] = "spam"
             ip.history_manager.store_output(3)
 
-            nt.assert_equal(ip.history_manager.input_hist_raw, [''] + hist)
+            assert ip.history_manager.input_hist_raw == [""] + hist
 
             # Detailed tests for _get_range_session
             grs = ip.history_manager._get_range_session
-            nt.assert_equal(list(grs(start=2,stop=-1)), list(zip([0], [2], hist[1:-1])))
-            nt.assert_equal(list(grs(start=-2)), list(zip([0,0], [2,3], hist[-2:])))
-            nt.assert_equal(list(grs(output=True)), list(zip([0,0,0], [1,2,3], zip(hist, [None,None,'spam']))))
+            assert list(grs(start=2, stop=-1)) == list(zip([0], [2], hist[1:-1]))
+            assert list(grs(start=-2)) == list(zip([0, 0], [2, 3], hist[-2:]))
+            assert list(grs(output=True)) == list(
+                zip([0, 0, 0], [1, 2, 3], zip(hist, [None, None, "spam"]))
+            )
 
             # Check whether specifying a range beyond the end of the current
             # session results in an error (gh-804)
@@ -63,17 +62,14 b' def test_history():'
 
             # New session
             ip.history_manager.reset()
-            newcmds = [u"z=5",
-                       u"class X(object):\n    pass",
-                       u"k='p'",
-                       u"z=5"]
+            newcmds = ["z=5", "class X(object):\n    pass", "k='p'", "z=5"]
             for i, cmd in enumerate(newcmds, start=1):
                 ip.history_manager.store_inputs(i, cmd)
             gothist = ip.history_manager.get_range(start=1, stop=4)
-            nt.assert_equal(list(gothist), list(zip([0,0,0],[1,2,3], newcmds)))
+            assert list(gothist) == list(zip([0, 0, 0], [1, 2, 3], newcmds))
             # Previous session:
             gothist = ip.history_manager.get_range(-1, 1, 4)
-            nt.assert_equal(list(gothist), list(zip([1,1,1],[1,2,3], hist)))
+            assert list(gothist) == list(zip([1, 1, 1], [1, 2, 3], hist))
 
             newhist = [(2, i, c) for (i, c) in enumerate(newcmds, 1)]
 
@@ -82,62 +78,61 b' def test_history():'
                                                     include_latest=True)
             expected = [(1, 3, (hist[-1], "spam"))] \
                 + [(s, n, (c, None)) for (s, n, c) in newhist]
-            nt.assert_equal(list(gothist), expected)
+            assert list(gothist) == expected
 
             gothist = ip.history_manager.get_tail(2)
             expected = newhist[-3:-1]
-            nt.assert_equal(list(gothist), expected)
+            assert list(gothist) == expected
 
             # Check get_hist_search
 
             gothist = ip.history_manager.search("*test*")
-            nt.assert_equal(list(gothist), [(1,2,hist[1])] )
+            assert list(gothist) == [(1, 2, hist[1])]
 
             gothist = ip.history_manager.search("*=*")
-            nt.assert_equal(list(gothist),
-                            [(1, 1, hist[0]),
+            assert list(gothist) == [
+                (1, 1, hist[0]),
                              (1, 2, hist[1]),
                              (1, 3, hist[2]),
                              newhist[0],
                              newhist[2],
-                             newhist[3]])
+                newhist[3],
+            ]
 
             gothist = ip.history_manager.search("*=*", n=4)
-            nt.assert_equal(list(gothist),
-                            [(1, 3, hist[2]),
+            assert list(gothist) == [
+                (1, 3, hist[2]),
                              newhist[0],
                              newhist[2],
-                             newhist[3]])
+                newhist[3],
+            ]
 
             gothist = ip.history_manager.search("*=*", unique=True)
-            nt.assert_equal(list(gothist),
-                            [(1, 1, hist[0]),
+            assert list(gothist) == [
+                (1, 1, hist[0]),
                              (1, 2, hist[1]),
                              (1, 3, hist[2]),
                              newhist[2],
-                             newhist[3]])
+                newhist[3],
+            ]
 
             gothist = ip.history_manager.search("*=*", unique=True, n=3)
-            nt.assert_equal(list(gothist),
-                            [(1, 3, hist[2]),
-                             newhist[2],
-                             newhist[3]])
+            assert list(gothist) == [(1, 3, hist[2]), newhist[2], newhist[3]]
 
             gothist = ip.history_manager.search("b*", output=True)
-            nt.assert_equal(list(gothist), [(1,3,(hist[2],"spam"))] )
+            assert list(gothist) == [(1, 3, (hist[2], "spam"))]
 
             # Cross testing: check that magic %save can get previous session.
             testfilename = (tmp_path / "test.py").resolve()
             ip.magic("save " + str(testfilename) + " ~1/1-3")
-            with io.open(testfilename, encoding='utf-8') as testfile:
-                nt.assert_equal(testfile.read(),
-                                        u"# coding: utf-8\n" + u"\n".join(hist)+u"\n")
+            with io.open(testfilename, encoding="utf-8") as testfile:
+                assert testfile.read() == "# coding: utf-8\n" + "\n".join(hist) + "\n"
 
             # Duplicate line numbers - check that it doesn't crash, and
             # gets a new session
             ip.history_manager.store_inputs(1, "rogue")
             ip.history_manager.writeout_cache()
-            nt.assert_equal(ip.history_manager.session_number, 3)
+            assert ip.history_manager.session_number == 3
         finally:
             # Ensure saving thread is shut down before we try to clean up the files
             ip.history_manager.save_thread.stop()
@@ -158,14 +153,14 b' def test_extract_hist_ranges():'
                 (-7, 1, 6),
                 (-10, 1, None)]
     actual = list(extract_hist_ranges(instr))
-    nt.assert_equal(actual, expected)
+    assert actual == expected
 
 
 def test_extract_hist_ranges_empty_str():
     instr = ""
     expected = [(0, 1, None)]  # 0 == current session, None == to end
     actual = list(extract_hist_ranges(instr))
-    nt.assert_equal(actual, expected)
+    assert actual == expected
 
 
 def test_magic_rerun():
@@ -173,14 +168,14 b' def test_magic_rerun():'
     ip = get_ipython()
     ip.run_cell("a = 10", store_history=True)
     ip.run_cell("a += 1", store_history=True)
-    nt.assert_equal(ip.user_ns["a"], 11)
+    assert ip.user_ns["a"] == 11
     ip.run_cell("%rerun", store_history=True)
-    nt.assert_equal(ip.user_ns["a"], 12)
+    assert ip.user_ns["a"] == 12
 
 def test_timestamp_type():
     ip = get_ipython()
     info = ip.history_manager.get_session_info()
-    nt.assert_true(isinstance(info[1], datetime))
+    assert isinstance(info[1], datetime)
 
 def test_hist_file_config():
     cfg = Config()
@@ -188,7 +183,7 b' def test_hist_file_config():'
     cfg.HistoryManager.hist_file = Path(tfile.name)
     try:
         hm = HistoryManager(shell=get_ipython(), config=cfg)
-        nt.assert_equal(hm.hist_file, cfg.HistoryManager.hist_file)
+        assert hm.hist_file == cfg.HistoryManager.hist_file
     finally:
         try:
             Path(tfile.name).unlink()
@@ -210,14 +205,14 b' def test_histmanager_disabled():'
         cfg.HistoryManager.hist_file = hist_file
         try:
             ip.history_manager = HistoryManager(shell=ip, config=cfg)
-            hist = [u'a=1', u'def f():\n    test = 1\n    return test', u"b='€Æ¾÷ß'"]
+            hist = ["a=1", "def f():\n    test = 1\n    return test", "b='€Æ¾÷ß'"]
             for i, h in enumerate(hist, start=1):
                 ip.history_manager.store_inputs(i, h)
-            nt.assert_equal(ip.history_manager.input_hist_raw, [''] + hist)
+            assert ip.history_manager.input_hist_raw == [""] + hist
             ip.history_manager.reset()
             ip.history_manager.end_session()
         finally:
             ip.history_manager = hist_manager_ori
 
     # hist_file should not be created
-    nt.assert_false(hist_file.exists())
+    assert hist_file.exists() is False

IPython/core/tests/test_hooks.py

@@ -6,7 +6,6 b''
 # Imports
 #-----------------------------------------------------------------------------
 
-import nose.tools as nt
 from IPython.core.error import TryNext
 from IPython.core.hooks import CommandChainDispatcher
 
@@ -38,27 +37,26 b' class Fail(object):'
 
 def test_command_chain_dispatcher_ff():
     """Test two failing hooks"""
-    fail1 = Fail(u'fail1')
-    fail2 = Fail(u'fail2')
-    dp = CommandChainDispatcher([(0, fail1),
-                                 (10, fail2)])
+    fail1 = Fail("fail1")
+    fail2 = Fail("fail2")
+    dp = CommandChainDispatcher([(0, fail1), (10, fail2)])
 
     try:
         dp()
     except TryNext as e:
-        nt.assert_equal(str(e), u'fail2')
+        assert str(e) == "fail2"
     else:
         assert False, "Expected exception was not raised."
 
-    nt.assert_true(fail1.called)
-    nt.assert_true(fail2.called)
+    assert fail1.called is True
+    assert fail2.called is True
 
 def test_command_chain_dispatcher_fofo():
     """Test a mixture of failing and succeeding hooks."""
-    fail1 = Fail(u'fail1')
-    fail2 = Fail(u'fail2')
-    okay1 = Okay(u'okay1')
-    okay2 = Okay(u'okay2')
+    fail1 = Fail("fail1")
+    fail2 = Fail("fail2")
+    okay1 = Okay("okay1")
+    okay2 = Okay("okay2")
 
     dp = CommandChainDispatcher([(0, fail1),
                                  # (5, okay1), # add this later
@@ -66,12 +64,12 b' def test_command_chain_dispatcher_fofo():'
                                  (15, okay2)])
     dp.add(okay1, 5)
 
-    nt.assert_equal(dp(), u'okay1')
+    assert dp() == "okay1"
 
-    nt.assert_true(fail1.called)
-    nt.assert_true(okay1.called)
-    nt.assert_false(fail2.called)
-    nt.assert_false(okay2.called)
+    assert fail1.called is True
+    assert okay1.called is True
+    assert fail2.called is False
+    assert okay2.called is False
 
 def test_command_chain_dispatcher_eq_priority():
     okay1 = Okay(u'okay1')

IPython/core/tests/test_inputsplitter.py

@@ -8,8 +8,6 b''
 import unittest
 import sys
 
-import nose.tools as nt
-
 from IPython.core import inputsplitter as isp
 from IPython.core.inputtransformer import InputTransformer
 from IPython.core.tests.test_inputtransformer import syntax, syntax_ml
@@ -98,10 +96,10 b' def test_remove_comments():'
 
 def test_get_input_encoding():
     encoding = isp.get_input_encoding()
-    nt.assert_true(isinstance(encoding, str))
+    assert isinstance(encoding, str)
     # simple-minded check that at least encoding a simple string works with the
     # encoding we got.
-    nt.assert_equal(u'test'.encode(encoding), b'test')
+    assert "test".encode(encoding) == b"test"
 
 
 class NoInputEncodingTestCase(unittest.TestCase):
@@ -527,38 +525,38 b" if __name__ == '__main__':"
 # Tests for cell magics support
 
 def test_last_blank():
-    nt.assert_false(isp.last_blank(''))
-    nt.assert_false(isp.last_blank('abc'))
-    nt.assert_false(isp.last_blank('abc\n'))
-    nt.assert_false(isp.last_blank('abc\na'))
+    assert isp.last_blank("") is False
+    assert isp.last_blank("abc") is False
+    assert isp.last_blank("abc\n") is False
+    assert isp.last_blank("abc\na") is False
 
-    nt.assert_true(isp.last_blank('\n'))
-    nt.assert_true(isp.last_blank('\n '))
-    nt.assert_true(isp.last_blank('abc\n '))
-    nt.assert_true(isp.last_blank('abc\n\n'))
-    nt.assert_true(isp.last_blank('abc\nd\n\n'))
-    nt.assert_true(isp.last_blank('abc\nd\ne\n\n'))
-    nt.assert_true(isp.last_blank('abc \n \n \n\n'))
+    assert isp.last_blank("\n") is True
+    assert isp.last_blank("\n ") is True
+    assert isp.last_blank("abc\n ") is True
+    assert isp.last_blank("abc\n\n") is True
+    assert isp.last_blank("abc\nd\n\n") is True
+    assert isp.last_blank("abc\nd\ne\n\n") is True
+    assert isp.last_blank("abc \n \n \n\n") is True
 
 
 def test_last_two_blanks():
-    nt.assert_false(isp.last_two_blanks(''))
-    nt.assert_false(isp.last_two_blanks('abc'))
-    nt.assert_false(isp.last_two_blanks('abc\n'))
-    nt.assert_false(isp.last_two_blanks('abc\n\na'))
-    nt.assert_false(isp.last_two_blanks('abc\n \n'))
-    nt.assert_false(isp.last_two_blanks('abc\n\n'))
-
-    nt.assert_true(isp.last_two_blanks('\n\n'))
-    nt.assert_true(isp.last_two_blanks('\n\n '))
-    nt.assert_true(isp.last_two_blanks('\n \n'))
-    nt.assert_true(isp.last_two_blanks('abc\n\n '))
-    nt.assert_true(isp.last_two_blanks('abc\n\n\n'))
-    nt.assert_true(isp.last_two_blanks('abc\n\n \n'))
-    nt.assert_true(isp.last_two_blanks('abc\n\n \n '))
-    nt.assert_true(isp.last_two_blanks('abc\n\n \n \n'))
-    nt.assert_true(isp.last_two_blanks('abc\nd\n\n\n'))
-    nt.assert_true(isp.last_two_blanks('abc\nd\ne\nf\n\n\n'))
+    assert isp.last_two_blanks("") is False
+    assert isp.last_two_blanks("abc") is False
+    assert isp.last_two_blanks("abc\n") is False
+    assert isp.last_two_blanks("abc\n\na") is False
+    assert isp.last_two_blanks("abc\n \n") is False
+    assert isp.last_two_blanks("abc\n\n") is False
+
+    assert isp.last_two_blanks("\n\n") is True
+    assert isp.last_two_blanks("\n\n ") is True
+    assert isp.last_two_blanks("\n \n") is True
+    assert isp.last_two_blanks("abc\n\n ") is True
+    assert isp.last_two_blanks("abc\n\n\n") is True
+    assert isp.last_two_blanks("abc\n\n \n") is True
+    assert isp.last_two_blanks("abc\n\n \n ") is True
+    assert isp.last_two_blanks("abc\n\n \n \n") is True
+    assert isp.last_two_blanks("abc\nd\n\n\n") is True
+    assert isp.last_two_blanks("abc\nd\ne\nf\n\n\n") is True
 
 
 class CellMagicsCommon(object):
@@ -567,11 +565,11 b' class CellMagicsCommon(object):'
         src = "%%cellm line\nbody\n"
         out = self.sp.transform_cell(src)
         ref = "get_ipython().run_cell_magic('cellm', 'line', 'body')\n"
-        nt.assert_equal(out, ref)
+        assert out == ref
     
     def test_cellmagic_help(self):
         self.sp.push('%%cellm?')
-        nt.assert_false(self.sp.push_accepts_more())
+        assert self.sp.push_accepts_more() is False
 
     def tearDown(self):
         self.sp.reset()
@@ -582,13 +580,13 b' class CellModeCellMagics(CellMagicsCommon, unittest.TestCase):'
 
     def test_incremental(self):
         sp = self.sp
-        sp.push('%%cellm firstline\n')
-        nt.assert_true(sp.push_accepts_more()) #1
-        sp.push('line2\n')
-        nt.assert_true(sp.push_accepts_more()) #2
-        sp.push('\n')
+        sp.push("%%cellm firstline\n")
+        assert sp.push_accepts_more() is True  # 1
+        sp.push("line2\n")
+        assert sp.push_accepts_more() is True  # 2
+        sp.push("\n")
         # This should accept a blank line and carry on until the cell is reset
-        nt.assert_true(sp.push_accepts_more()) #3
+        assert sp.push_accepts_more() is True  # 3
     
     def test_no_strip_coding(self):
         src = '\n'.join([
@@ -597,7 +595,7 b' class CellModeCellMagics(CellMagicsCommon, unittest.TestCase):'
             'print(u"üñîçø∂é")',
         ])
         out = self.sp.transform_cell(src)
-        nt.assert_in('# coding: utf-8', out)
+        assert "# coding: utf-8" in out
 
 
 class LineModeCellMagics(CellMagicsCommon, unittest.TestCase):
@@ -605,11 +603,12 b' class LineModeCellMagics(CellMagicsCommon, unittest.TestCase):'
 
     def test_incremental(self):
         sp = self.sp
-        sp.push('%%cellm line2\n')
-        nt.assert_true(sp.push_accepts_more()) #1
-        sp.push('\n')
+        sp.push("%%cellm line2\n")
+        assert sp.push_accepts_more() is True  # 1
+        sp.push("\n")
         # In this case, a blank line should end the cell magic
-        nt.assert_false(sp.push_accepts_more()) #2
+        assert sp.push_accepts_more() is False  # 2
+
 
 indentation_samples = [
     ('a = 1', 0),

IPython/core/tests/test_inputtransformer.py

@@ -1,5 +1,4 b''
 import tokenize
-import nose.tools as nt
 
 from IPython.testing import tools as tt
 
@@ -25,7 +24,7 b' def transform_checker(tests, transformer, **kwargs):'
                 out = transformer.reset()
             else:
                 out = transformer.push(inp)
-            nt.assert_equal(out, tr)
+            assert out == tr
     finally:
         transformer.reset()
 

IPython/core/tests/test_inputtransformer2.py

@@ -4,7 +4,6 b' Line-based transformers are the simpler ones; token-based transformers are'
 more complex. See test_inputtransformer2_line for tests for line-based
 transformations.
 """
-import nose.tools as nt
 import string
 
 from IPython.core import inputtransformer2 as ipt2
@@ -147,9 +146,10 b' def check_make_token_by_line_never_ends_empty():'
     """
     from string import printable
     for c in printable:
-        nt.assert_not_equal(make_tokens_by_line(c)[-1], [])
+        assert make_tokens_by_line(c)[-1] != []
         for k in printable:
-            nt.assert_not_equal(make_tokens_by_line(c+k)[-1], [])
+            assert make_tokens_by_line(c + k)[-1] != []
+
 
 def check_find(transformer, case, match=True):
     sample, expected_start, _  = case
@@ -157,21 +157,21 b' def check_find(transformer, case, match=True):'
     res = transformer.find(tbl)
     if match:
         # start_line is stored 0-indexed, expected values are 1-indexed
-        nt.assert_equal((res.start_line+1, res.start_col), expected_start)
+        assert (res.start_line + 1, res.start_col) == expected_start
         return res
     else:
-        nt.assert_is(res, None)
+        assert res is None
 
 def check_transform(transformer_cls, case):
     lines, start, expected = case
     transformer = transformer_cls(start)
-    nt.assert_equal(transformer.transform(lines), expected)
+    assert transformer.transform(lines) == expected
 
 def test_continued_line():
     lines = MULTILINE_MAGIC_ASSIGN[0]
-    nt.assert_equal(ipt2.find_end_of_continued_line(lines, 1), 2)
+    assert ipt2.find_end_of_continued_line(lines, 1) == 2
 
-    nt.assert_equal(ipt2.assemble_continued_line(lines, (1, 5), 2), "foo    bar")
+    assert ipt2.assemble_continued_line(lines, (1, 5), 2) == "foo    bar"
 
 def test_find_assign_magic():
     check_find(ipt2.MagicAssign, MULTILINE_MAGIC_ASSIGN)
@@ -217,12 +217,12 b' def test_find_help():'
         check_find(ipt2.HelpEnd, case)
 
     tf = check_find(ipt2.HelpEnd, HELP_CONTINUED_LINE)
-    nt.assert_equal(tf.q_line, 1)
-    nt.assert_equal(tf.q_col, 3)
+    assert tf.q_line == 1
+    assert tf.q_col == 3
 
     tf = check_find(ipt2.HelpEnd, HELP_MULTILINE)
-    nt.assert_equal(tf.q_line, 1)
-    nt.assert_equal(tf.q_col, 8)
+    assert tf.q_line == 1
+    assert tf.q_col == 8
 
     # ? in a comment does not trigger help
     check_find(ipt2.HelpEnd, (["foo # bar?\n"], None, None), match=False)
@@ -231,16 +231,16 b' def test_find_help():'
 
 def test_transform_help():
     tf = ipt2.HelpEnd((1, 0), (1, 9))
-    nt.assert_equal(tf.transform(HELP_IN_EXPR[0]), HELP_IN_EXPR[2])
+    assert tf.transform(HELP_IN_EXPR[0]) == HELP_IN_EXPR[2]
 
     tf = ipt2.HelpEnd((1, 0), (2, 3))
-    nt.assert_equal(tf.transform(HELP_CONTINUED_LINE[0]), HELP_CONTINUED_LINE[2])
+    assert tf.transform(HELP_CONTINUED_LINE[0]) == HELP_CONTINUED_LINE[2]
 
     tf = ipt2.HelpEnd((1, 0), (2, 8))
-    nt.assert_equal(tf.transform(HELP_MULTILINE[0]), HELP_MULTILINE[2])
+    assert tf.transform(HELP_MULTILINE[0]) == HELP_MULTILINE[2]
 
     tf = ipt2.HelpEnd((1, 0), (1, 0))
-    nt.assert_equal(tf.transform(HELP_UNICODE[0]), HELP_UNICODE[2])
+    assert tf.transform(HELP_UNICODE[0]) == HELP_UNICODE[2]
 
 def test_find_assign_op_dedent():
     """
@@ -250,31 +250,34 b' def test_find_assign_op_dedent():'
         def __init__(self, s):
             self.string = s
 
-    nt.assert_equal(_find_assign_op([Tk(s) for s in ('','a','=','b')]), 2)
-    nt.assert_equal(_find_assign_op([Tk(s) for s in ('','(', 'a','=','b', ')', '=' ,'5')]), 6)
+    assert _find_assign_op([Tk(s) for s in ("", "a", "=", "b")]) == 2
+    assert (
+        _find_assign_op([Tk(s) for s in ("", "(", "a", "=", "b", ")", "=", "5")]) == 6
+    )
+
 
 def test_check_complete():
     cc = ipt2.TransformerManager().check_complete
-    nt.assert_equal(cc("a = 1"), ("complete", None))
-    nt.assert_equal(cc("for a in range(5):"), ("incomplete", 4))
-    nt.assert_equal(cc("for a in range(5):\n    if a > 0:"), ("incomplete", 8))
-    nt.assert_equal(cc("raise = 2"), ("invalid", None))
-    nt.assert_equal(cc("a = [1,\n2,"), ("incomplete", 0))
-    nt.assert_equal(cc("(\n))"), ("incomplete", 0))
-    nt.assert_equal(cc("\\\r\n"), ("incomplete", 0))
-    nt.assert_equal(cc("a = '''\n   hi"), ("incomplete", 3))
-    nt.assert_equal(cc("def a():\n x=1\n global x"), ("invalid", None))
-    nt.assert_equal(cc("a \\ "), ("invalid", None))  # Nothing allowed after backslash
-    nt.assert_equal(cc("1\\\n+2"), ("complete", None))
-    nt.assert_equal(cc("exit"), ("complete", None))
+    assert cc("a = 1") == ("complete", None)
+    assert cc("for a in range(5):") == ("incomplete", 4)
+    assert cc("for a in range(5):\n    if a > 0:") == ("incomplete", 8)
+    assert cc("raise = 2") == ("invalid", None)
+    assert cc("a = [1,\n2,") == ("incomplete", 0)
+    assert cc("(\n))") == ("incomplete", 0)
+    assert cc("\\\r\n") == ("incomplete", 0)
+    assert cc("a = '''\n   hi") == ("incomplete", 3)
+    assert cc("def a():\n x=1\n global x") == ("invalid", None)
+    assert cc("a \\ ") == ("invalid", None)  # Nothing allowed after backslash
+    assert cc("1\\\n+2") == ("complete", None)
+    assert cc("exit") == ("complete", None)
 
     example = dedent("""
         if True:
             a=1""" )
 
-    nt.assert_equal(cc(example), ('incomplete', 4))
-    nt.assert_equal(cc(example+'\n'), ('complete', None))
-    nt.assert_equal(cc(example+'\n    '), ('complete', None))
+    assert cc(example) == ("incomplete", 4)
+    assert cc(example + "\n") == ("complete", None)
+    assert cc(example + "\n    ") == ("complete", None)
 
     # no need to loop on all the letters/numbers.
     short = '12abAB'+string.printable[62:]
@@ -284,7 +287,8 b' def test_check_complete():'
         for k in short:
             cc(c+k)
 
-    nt.assert_equal(cc("def f():\n  x=0\n  \\\n  "), ('incomplete', 2))
+    assert cc("def f():\n  x=0\n  \\\n  ") == ("incomplete", 2)
+
 
 def test_check_complete_II():
     """
@@ -294,7 +298,7 b' def test_check_complete_II():'
 
     """
     cc = ipt2.TransformerManager().check_complete
-    nt.assert_equal(cc('''def foo():\n    """'''), ('incomplete', 4))
+    assert cc('''def foo():\n    """''') == ("incomplete", 4)
 
 
 def test_check_complete_invalidates_sunken_brackets():
@@ -303,16 +307,16 b' def test_check_complete_invalidates_sunken_brackets():'
     interpreted as invalid
     """
     cc = ipt2.TransformerManager().check_complete
-    nt.assert_equal(cc(")"), ("invalid", None))
-    nt.assert_equal(cc("]"), ("invalid", None))
-    nt.assert_equal(cc("}"), ("invalid", None))
-    nt.assert_equal(cc(")("), ("invalid", None))
-    nt.assert_equal(cc("]["), ("invalid", None))
-    nt.assert_equal(cc("}{"), ("invalid", None))
-    nt.assert_equal(cc("]()("), ("invalid", None))
-    nt.assert_equal(cc("())("), ("invalid", None))
-    nt.assert_equal(cc(")[]("), ("invalid", None))
-    nt.assert_equal(cc("()]("), ("invalid", None))
+    assert cc(")") == ("invalid", None)
+    assert cc("]") == ("invalid", None)
+    assert cc("}") == ("invalid", None)
+    assert cc(")(") == ("invalid", None)
+    assert cc("][") == ("invalid", None)
+    assert cc("}{") == ("invalid", None)
+    assert cc("]()(") == ("invalid", None)
+    assert cc("())(") == ("invalid", None)
+    assert cc(")[](") == ("invalid", None)
+    assert cc("()](") == ("invalid", None)
 
 
 def test_null_cleanup_transformer():

IPython/core/tests/test_interactiveshell.py

@@ -21,8 +21,6 b' from unittest import mock'
 
 from os.path import join
 
-import nose.tools as nt
-
 from IPython.core.error import InputRejected
 from IPython.core.inputtransformer import InputTransformer
 from IPython.core import interactiveshell
@@ -220,32 +218,38 b' class InteractiveShellTestCase(unittest.TestCase):'
     def test_var_expand_local(self):
         """Test local variable expansion in !system and %magic calls"""
         # !system
-        ip.run_cell('def test():\n'
+        ip.run_cell(
+            "def test():\n"
                     '    lvar = "ttt"\n'
-                    '    ret = !echo {lvar}\n'
-                    '    return ret[0]\n')
-        res = ip.user_ns['test']()
-        nt.assert_in('ttt', res)
+            "    ret = !echo {lvar}\n"
+            "    return ret[0]\n"
+        )
+        res = ip.user_ns["test"]()
+        self.assertIn("ttt", res)
         
         # %magic
-        ip.run_cell('def makemacro():\n'
+        ip.run_cell(
+            "def makemacro():\n"
                     '    macroname = "macro_var_expand_locals"\n'
-                    '    %macro {macroname} codestr\n')
-        ip.user_ns['codestr'] = "str(12)"
-        ip.run_cell('makemacro()')
-        nt.assert_in('macro_var_expand_locals', ip.user_ns)
+            "    %macro {macroname} codestr\n"
+        )
+        ip.user_ns["codestr"] = "str(12)"
+        ip.run_cell("makemacro()")
+        self.assertIn("macro_var_expand_locals", ip.user_ns)
     
     def test_var_expand_self(self):
         """Test variable expansion with the name 'self', which was failing.
         
         See https://github.com/ipython/ipython/issues/1878#issuecomment-7698218
         """
-        ip.run_cell('class cTest:\n'
+        ip.run_cell(
+            "class cTest:\n"
                     '  classvar="see me"\n'
-                    '  def test(self):\n'
-                    '    res = !echo Variable: {self.classvar}\n'
-                    '    return res[0]\n')
-        nt.assert_in('see me', ip.user_ns['cTest']().test())
+            "  def test(self):\n"
+            "    res = !echo Variable: {self.classvar}\n"
+            "    return res[0]\n"
+        )
+        self.assertIn("see me", ip.user_ns["cTest"]().test())
     
     def test_bad_var_expand(self):
         """var_expand on invalid formats shouldn't raise"""
@@ -346,7 +350,7 b' class InteractiveShellTestCase(unittest.TestCase):'
         info = dict(found=True, isalias=False, ismagic=True,
                     namespace = 'IPython internal', obj= lmagic.__wrapped__,
                     parent = None)
-        nt.assert_equal(lfind, info)
+        self.assertEqual(lfind, info)
         
     def test_ofind_cell_magic(self):
         from IPython.core.magic import register_cell_magic
@@ -360,7 +364,7 b' class InteractiveShellTestCase(unittest.TestCase):'
         info = dict(found=True, isalias=False, ismagic=True,
                     namespace = 'IPython internal', obj= cmagic.__wrapped__,
                     parent = None)
-        nt.assert_equal(find, info)
+        self.assertEqual(find, info)
 
     def test_ofind_property_with_error(self):
         class A(object):
@@ -372,7 +376,7 b' class InteractiveShellTestCase(unittest.TestCase):'
         found = ip._ofind('a.foo', [('locals', locals())])
         info = dict(found=True, isalias=False, ismagic=False,
                     namespace='locals', obj=A.foo, parent=a)
-        nt.assert_equal(found, info)
+        self.assertEqual(found, info)
 
     def test_ofind_multiple_attribute_lookups(self):
         class A(object):
@@ -387,7 +391,7 b' class InteractiveShellTestCase(unittest.TestCase):'
         found = ip._ofind('a.a.a.foo', [('locals', locals())])
         info = dict(found=True, isalias=False, ismagic=False,
                     namespace='locals', obj=A.foo, parent=a.a.a)
-        nt.assert_equal(found, info)
+        self.assertEqual(found, info)
 
     def test_ofind_slotted_attributes(self):
         class A(object):
@@ -399,12 +403,12 b' class InteractiveShellTestCase(unittest.TestCase):'
         found = ip._ofind('a.foo', [('locals', locals())])
         info = dict(found=True, isalias=False, ismagic=False,
                     namespace='locals', obj=a.foo, parent=a)
-        nt.assert_equal(found, info)
+        self.assertEqual(found, info)
 
         found = ip._ofind('a.bar', [('locals', locals())])
         info = dict(found=False, isalias=False, ismagic=False,
                     namespace=None, obj=None, parent=a)
-        nt.assert_equal(found, info)
+        self.assertEqual(found, info)
 
     def test_ofind_prefers_property_to_instance_level_attribute(self):
         class A(object):
@@ -412,10 +416,10 b' class InteractiveShellTestCase(unittest.TestCase):'
             def foo(self):
                 return 'bar'
         a = A()
-        a.__dict__['foo'] = 'baz'
-        nt.assert_equal(a.foo, 'bar')
-        found = ip._ofind('a.foo', [('locals', locals())])
-        nt.assert_is(found['obj'], A.foo)
+        a.__dict__["foo"] = "baz"
+        self.assertEqual(a.foo, "bar")
+        found = ip._ofind("a.foo", [("locals", locals())])
+        self.assertIs(found["obj"], A.foo)
 
     def test_custom_syntaxerror_exception(self):
         called = []
@@ -819,7 +823,7 b' class TestAstTransformError(unittest.TestCase):'
             ip.run_cell("1 + 2")
         
         # This should have been removed.
-        nt.assert_not_in(err_transformer, ip.ast_transformers)
+        self.assertNotIn(err_transformer, ip.ast_transformers)
 
 
 class StringRejector(ast.NodeTransformer):
@@ -889,20 +893,20 b' def test_user_variables():'
     keys = {'dummy', 'doesnotexist'}
     r = ip.user_expressions({ key:key for key in keys})
 
-    nt.assert_equal(keys, set(r.keys()))
-    dummy = r['dummy']
-    nt.assert_equal({'status', 'data', 'metadata'}, set(dummy.keys()))
-    nt.assert_equal(dummy['status'], 'ok')
-    data = dummy['data']
-    metadata = dummy['metadata']
-    nt.assert_equal(data.get('text/html'), d._repr_html_())
+    assert keys == set(r.keys())
+    dummy = r["dummy"]
+    assert {"status", "data", "metadata"} == set(dummy.keys())
+    assert dummy["status"] == "ok"
+    data = dummy["data"]
+    metadata = dummy["metadata"]
+    assert data.get("text/html") == d._repr_html_()
     js, jsmd = d._repr_javascript_()
-    nt.assert_equal(data.get('application/javascript'), js)
-    nt.assert_equal(metadata.get('application/javascript'), jsmd)
+    assert data.get("application/javascript") == js
+    assert metadata.get("application/javascript") == jsmd
     
-    dne = r['doesnotexist']
-    nt.assert_equal(dne['status'], 'error')
-    nt.assert_equal(dne['ename'], 'NameError')
+    dne = r["doesnotexist"]
+    assert dne["status"] == "error"
+    assert dne["ename"] == "NameError"
     
     # back to text only
     ip.display_formatter.active_types = ['text/plain']
@@ -917,17 +921,17 b' def test_user_expression():'
     r = ip.user_expressions(query)
     import pprint
     pprint.pprint(r)
-    nt.assert_equal(set(r.keys()), set(query.keys()))
-    a = r['a']
-    nt.assert_equal({'status', 'data', 'metadata'}, set(a.keys()))
-    nt.assert_equal(a['status'], 'ok')
-    data = a['data']
-    metadata = a['metadata']
-    nt.assert_equal(data.get('text/plain'), '3')
-    
-    b = r['b']
-    nt.assert_equal(b['status'], 'error')
-    nt.assert_equal(b['ename'], 'ZeroDivisionError')
+    assert set(r.keys()) == set(query.keys())
+    a = r["a"]
+    assert {"status", "data", "metadata"} == set(a.keys())
+    assert a["status"] == "ok"
+    data = a["data"]
+    metadata = a["metadata"]
+    assert data.get("text/plain") == "3"
+
+    b = r["b"]
+    assert b["status"] == "error"
+    assert b["ename"] == "ZeroDivisionError"
     
     # back to text only
     ip.display_formatter.active_types = ['text/plain']
@@ -1030,8 +1034,8 b' def test_custom_exc_count():'
     ip.run_cell("def foo()", store_history=True)
     # restore default excepthook
     ip.set_custom_exc((), None)
-    nt.assert_equal(hook.call_count, 1)
-    nt.assert_equal(ip.execution_count, before + 1)
+    assert hook.call_count == 1
+    assert ip.execution_count == before + 1
 
 
 def test_run_cell_async():

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)

IPython/core/tests/test_magic_terminal.py

@@ -11,8 +11,6 b' import sys'
 from io import StringIO
 from unittest import TestCase
 
-import nose.tools as nt
-
 from IPython.testing import tools as tt
 
 #-----------------------------------------------------------------------------
@@ -93,16 +91,16 b' class PasteTestCase(TestCase):'
         ip.hooks.clipboard_get = self.original_clip
        
     def test_paste(self):
-        ip.user_ns.pop('x', None)
-        self.paste('x = 1')
-        nt.assert_equal(ip.user_ns['x'], 1)
-        ip.user_ns.pop('x')
+        ip.user_ns.pop("x", None)
+        self.paste("x = 1")
+        self.assertEqual(ip.user_ns["x"], 1)
+        ip.user_ns.pop("x")
 
     def test_paste_pyprompt(self):
-        ip.user_ns.pop('x', None)
-        self.paste('>>> x=2')
-        nt.assert_equal(ip.user_ns['x'], 2)
-        ip.user_ns.pop('x')
+        ip.user_ns.pop("x", None)
+        self.paste(">>> x=2")
+        self.assertEqual(ip.user_ns["x"], 2)
+        ip.user_ns.pop("x")
 
     def test_paste_py_multi(self):
         self.paste("""
@@ -111,35 +109,38 b' class PasteTestCase(TestCase):'
         >>> for i in x:
         ...     y.append(i**2)
         ... 
-        """)
-        nt.assert_equal(ip.user_ns['x'], [1,2,3])
-        nt.assert_equal(ip.user_ns['y'], [1,4,9])
+        """
+        )
+        self.assertEqual(ip.user_ns["x"], [1, 2, 3])
+        self.assertEqual(ip.user_ns["y"], [1, 4, 9])
 
     def test_paste_py_multi_r(self):
         "Now, test that self.paste -r works"
         self.test_paste_py_multi()
-        nt.assert_equal(ip.user_ns.pop('x'), [1,2,3])
-        nt.assert_equal(ip.user_ns.pop('y'), [1,4,9])
-        nt.assert_false('x' in ip.user_ns)
-        ip.magic('paste -r')
-        nt.assert_equal(ip.user_ns['x'], [1,2,3])
-        nt.assert_equal(ip.user_ns['y'], [1,4,9])
+        self.assertEqual(ip.user_ns.pop("x"), [1, 2, 3])
+        self.assertEqual(ip.user_ns.pop("y"), [1, 4, 9])
+        self.assertFalse("x" in ip.user_ns)
+        ip.magic("paste -r")
+        self.assertEqual(ip.user_ns["x"], [1, 2, 3])
+        self.assertEqual(ip.user_ns["y"], [1, 4, 9])
 
     def test_paste_email(self):
         "Test pasting of email-quoted contents"
         self.paste("""\
         >> def foo(x):
         >>     return x + 1
-        >> xx = foo(1.1)""")
-        nt.assert_equal(ip.user_ns['xx'], 2.1)
+        >> xx = foo(1.1)"""
+        )
+        self.assertEqual(ip.user_ns["xx"], 2.1)
 
     def test_paste_email2(self):
         "Email again; some programs add a space also at each quoting level"
         self.paste("""\
         > > def foo(x):
         > >     return x + 1
-        > > yy = foo(2.1)     """)
-        nt.assert_equal(ip.user_ns['yy'], 3.1)
+        > > yy = foo(2.1)     """
+        )
+        self.assertEqual(ip.user_ns["yy"], 3.1)
 
     def test_paste_email_py(self):
         "Email quoting of interactive input"
@@ -147,8 +148,9 b' class PasteTestCase(TestCase):'
         >> >>> def f(x):
         >> ...   return x+1
         >> ... 
-        >> >>> zz = f(2.5)      """)
-        nt.assert_equal(ip.user_ns['zz'], 3.5)
+        >> >>> zz = f(2.5)      """
+        )
+        self.assertEqual(ip.user_ns["zz"], 3.5)
 
     def test_paste_echo(self):
         "Also test self.paste echoing, by temporarily faking the writer"
@@ -163,8 +165,8 b' class PasteTestCase(TestCase):'
             out = w.getvalue()
         finally:
             ip.write = writer
-        nt.assert_equal(ip.user_ns['a'], 100)
-        nt.assert_equal(ip.user_ns['b'], 200)
+        self.assertEqual(ip.user_ns["a"], 100)
+        self.assertEqual(ip.user_ns["b"], 200)
         assert out == code+"\n## -- End pasted text --\n"
 
     def test_paste_leading_commas(self):
@@ -174,10 +176,9 b' class PasteTestCase(TestCase):'
 a = """
 ,1,2,3
 """'''
-        ip.user_ns.pop('foo', None)
-        tm.store_or_execute(s, 'foo')
-        nt.assert_in('foo', ip.user_ns)
-
+        ip.user_ns.pop("foo", None)
+        tm.store_or_execute(s, "foo")
+        self.assertIn("foo", ip.user_ns)
 
     def test_paste_trailing_question(self):
         "Test pasting sources with trailing question marks"
@@ -189,4 +190,4 b' def funcfoo():'
 '''
         ip.user_ns.pop('funcfoo', None)
         self.paste(s)
-        nt.assert_equal(ip.user_ns['funcfoo'](), 'fooresult')
+        self.assertEqual(ip.user_ns["funcfoo"](), "fooresult")

IPython/core/tests/test_oinspect.py

@@ -9,8 +9,6 b' from inspect import signature, Signature, Parameter'
 import os
 import re
 
-import nose.tools as nt
-
 from .. import oinspect
 
 from decorator import decorator
@@ -38,7 +36,7 b' def setup_module():'
 # defined, if any code is inserted above, the following line will need to be
 # updated.  Do NOT insert any whitespace between the next line and the function
 # definition below.
-THIS_LINE_NUMBER = 41  # Put here the actual number of this line
+THIS_LINE_NUMBER = 39  # Put here the actual number of this line
 
 from unittest import TestCase
 
@@ -97,7 +95,7 b' def test_find_file_decorated2():'
 
 def test_find_file_magic():
     run = ip.find_line_magic('run')
-    nt.assert_not_equal(oinspect.find_file(run), None)
+    assert oinspect.find_file(run) is not None
 
 
 # A few generic objects we can then inspect in the tests below
@@ -169,11 +167,11 b' def test_info():'
     "Check that Inspector.info fills out various fields as expected."
     i = inspector.info(Call, oname="Call")
     assert i["type_name"] == "type"
-    expted_class = str(type(type))  # <class 'type'> (Python 3) or <type 'type'>
-    assert i["base_class"] == expted_class
-    nt.assert_regex(
-        i["string_form"],
+    expected_class = str(type(type))  # <class 'type'> (Python 3) or <type 'type'>
+    assert i["base_class"] == expected_class
+    assert re.search(
         "<class 'IPython.core.tests.test_oinspect.Call'( at 0x[0-9a-f]{1,9})?>",
+        i["string_form"],
     )
     fname = __file__
     if fname.endswith(".pyc"):
@@ -184,12 +182,12 b' def test_info():'
     assert i["definition"] == None
     assert i["docstring"] == Call.__doc__
     assert i["source"] == None
-    nt.assert_true(i["isclass"])
+    assert i["isclass"] is True
     assert i["init_definition"] == "Call(x, y=1)"
     assert i["init_docstring"] == Call.__init__.__doc__
 
     i = inspector.info(Call, detail_level=1)
-    nt.assert_not_equal(i["source"], None)
+    assert i["source"] is not None
     assert i["docstring"] == None
 
     c = Call(1)
@@ -221,7 +219,7 b' def test_info_serialliar():'
 
     # Nested attribute access should be cut off at 100 levels deep to avoid
     # infinite loops: https://github.com/ipython/ipython/issues/9122
-    nt.assert_less(fib_tracker[0], 9000)
+    assert fib_tracker[0] < 9000
 
 def support_function_one(x, y=2, *a, **kw):
     """A simple function."""
@@ -230,7 +228,8 b' def test_calldef_none():'
     # We should ignore __call__ for all of these.
     for obj in [support_function_one, SimpleClass().method, any, str.upper]:
         i = inspector.info(obj)
-        nt.assert_is(i['call_def'], None)
+        assert i["call_def"] is None
+
 
 def f_kwarg(pos, *, kwonly):
     pass
@@ -266,7 +265,7 b' def test_getdoc():'
 
 def test_empty_property_has_no_source():
     i = inspector.info(property(), detail_level=1)
-    nt.assert_is(i['source'], None)
+    assert i["source"] is None
 
 
 def test_property_sources():
@@ -288,14 +287,14 b' def test_property_sources():'
         adder = property(simple_add) 
 
     i = inspector.info(A.foo, detail_level=1)
-    nt.assert_in('def foo(self):', i['source'])
-    nt.assert_in('lambda self, v:', i['source'])
+    assert "def foo(self):" in i["source"]
+    assert "lambda self, v:" in i["source"]
 
     i = inspector.info(A.dname, detail_level=1)
-    nt.assert_in('def dirname(p)', i['source'])
+    assert "def dirname(p)" in i["source"]
     
     i = inspector.info(A.adder, detail_level=1)
-    nt.assert_in('def simple_add(a, b)', i['source'])
+    assert "def simple_add(a, b)" in i["source"]
 
 
 def test_property_docstring_is_in_info_for_detail_level_0():
@@ -396,14 +395,14 b' def test_pinfo_magic():'
 def test_init_colors():
     # ensure colors are not present in signature info
     info = inspector.info(HasSignature)
-    init_def = info['init_definition']
-    nt.assert_not_in('[0m', init_def)
+    init_def = info["init_definition"]
+    assert "[0m" not in init_def
 
 
 def test_builtin_init():
     info = inspector.info(list)
     init_def = info['init_definition']
-    nt.assert_is_not_none(init_def)
+    assert init_def is not None
 
 
 def test_render_signature_short():
@@ -428,7 +427,7 b' def test_render_signature_long():'
         signature(long_function),
         long_function.__name__,
     )
-    nt.assert_in(sig, [
+    assert sig in [
         # Python >=3.9
         '''\
 long_function(
@@ -452,4 +451,4 b' long_function('
     let_us_make_sure_this_is_looong:Union[str, NoneType]=None,
 ) -> bool\
 ''',
-    ])
+    ]

IPython/core/tests/test_paths.py

@@ -6,7 +6,6 b' import tempfile'
 import warnings
 from unittest.mock import patch
 
-import nose.tools as nt
 from testpath import modified_env, assert_isdir, assert_isfile
 
 from IPython import paths
@@ -52,7 +51,7 b' def test_get_ipython_dir_1():'
             modified_env({'IPYTHONDIR': env_ipdir}):
         ipdir = paths.get_ipython_dir()
 
-    nt.assert_equal(ipdir, env_ipdir)
+    assert ipdir == env_ipdir
 
 def test_get_ipython_dir_2():
     """test_get_ipython_dir_2, Testcase to see if we can call get_ipython_dir without Exceptions."""
@@ -66,7 +65,7 b' def test_get_ipython_dir_2():'
                          }):
         ipdir = paths.get_ipython_dir()
 
-    nt.assert_equal(ipdir, os.path.join("someplace", ".ipython"))
+    assert ipdir == os.path.join("someplace", ".ipython")
 
 def test_get_ipython_dir_3():
     """test_get_ipython_dir_3, move XDG if defined, and .ipython doesn't exist."""
@@ -81,10 +80,10 b' def test_get_ipython_dir_3():'
                 }), warnings.catch_warnings(record=True) as w:
             ipdir = paths.get_ipython_dir()
 
-        nt.assert_equal(ipdir, os.path.join(tmphome.name, ".ipython"))
+        assert ipdir == os.path.join(tmphome.name, ".ipython")
         if sys.platform != 'darwin':
-            nt.assert_equal(len(w), 1)
-            nt.assert_in('Moving', str(w[0]))
+            assert len(w) == 1
+            assert "Moving" in str(w[0])
     finally:
         tmphome.cleanup()
 
@@ -106,10 +105,11 b' def test_get_ipython_dir_4():'
         }), warnings.catch_warnings(record=True) as w:
             ipdir = paths.get_ipython_dir()
 
-        nt.assert_equal(ipdir, os.path.join(HOME_TEST_DIR, ".ipython"))
+        assert ipdir == os.path.join(HOME_TEST_DIR, ".ipython")
         if sys.platform != 'darwin':
-            nt.assert_equal(len(w), 1)
-            nt.assert_in('Ignoring', str(w[0]))
+            assert len(w) == 1
+            assert "Ignoring" in str(w[0])
+
 
 def test_get_ipython_dir_5():
     """test_get_ipython_dir_5, use .ipython if exists and XDG defined, but doesn't exist."""
@@ -128,7 +128,7 b' def test_get_ipython_dir_5():'
         }):
             ipdir = paths.get_ipython_dir()
 
-        nt.assert_equal(ipdir, IP_TEST_DIR)
+        assert ipdir == IP_TEST_DIR
 
 def test_get_ipython_dir_6():
     """test_get_ipython_dir_6, use home over XDG if defined and neither exist."""
@@ -146,8 +146,8 b' def test_get_ipython_dir_6():'
             }), warnings.catch_warnings(record=True) as w:
         ipdir = paths.get_ipython_dir()
 
-    nt.assert_equal(ipdir, os.path.join(HOME_TEST_DIR, '.ipython'))
-    nt.assert_equal(len(w), 0)
+    assert ipdir == os.path.join(HOME_TEST_DIR, ".ipython")
+    assert len(w) == 0
 
 def test_get_ipython_dir_7():
     """test_get_ipython_dir_7, test home directory expansion on IPYTHONDIR"""
@@ -155,7 +155,8 b' def test_get_ipython_dir_7():'
     with modified_env({'IPYTHONDIR': os.path.join('~', 'somewhere')}), \
             patch.object(paths, '_writable_dir', return_value=True):
         ipdir = paths.get_ipython_dir()
-    nt.assert_equal(ipdir, os.path.join(home_dir, 'somewhere'))
+    assert ipdir == os.path.join(home_dir, "somewhere")
+
 
 @skip_win32
 def test_get_ipython_dir_8():
@@ -164,14 +165,16 b' def test_get_ipython_dir_8():'
         # test only when HOME directory actually writable
         return
 
-    with patch.object(paths, '_writable_dir', lambda path: bool(path)), \
-            patch.object(paths, 'get_xdg_dir', return_value=None), \
-            modified_env({
-                'IPYTHON_DIR': None,
-                'IPYTHONDIR': None,
-                'HOME': '/',
-            }):
-        nt.assert_equal(paths.get_ipython_dir(), '/.ipython')
+    with patch.object(paths, "_writable_dir", lambda path: bool(path)), patch.object(
+        paths, "get_xdg_dir", return_value=None
+    ), modified_env(
+        {
+            "IPYTHON_DIR": None,
+            "IPYTHONDIR": None,
+            "HOME": "/",
+        }
+    ):
+        assert paths.get_ipython_dir() == "/.ipython"
 
 
 def test_get_ipython_cache_dir():
@@ -181,18 +184,16 b' def test_get_ipython_cache_dir():'
             os.makedirs(os.path.join(HOME_TEST_DIR, ".cache"))
             with modified_env({'XDG_CACHE_HOME': None}):
                 ipdir = paths.get_ipython_cache_dir()
-            nt.assert_equal(os.path.join(HOME_TEST_DIR, ".cache", "ipython"),
-                            ipdir)
+            assert os.path.join(HOME_TEST_DIR, ".cache", "ipython") == ipdir
             assert_isdir(ipdir)
 
             # test env override
             with modified_env({"XDG_CACHE_HOME": XDG_CACHE_DIR}):
                 ipdir = paths.get_ipython_cache_dir()
             assert_isdir(ipdir)
-            nt.assert_equal(ipdir, os.path.join(XDG_CACHE_DIR, "ipython"))
+            assert ipdir == os.path.join(XDG_CACHE_DIR, "ipython")
         else:
-            nt.assert_equal(paths.get_ipython_cache_dir(),
-                            paths.get_ipython_dir())
+            assert paths.get_ipython_cache_dir() == paths.get_ipython_dir()
 
 def test_get_ipython_package_dir():
     ipdir = paths.get_ipython_package_dir()

IPython/core/tests/test_profile.py

@@ -27,8 +27,6 b' import tempfile'
 from pathlib import Path
 from unittest import TestCase
 
-import nose.tools as nt
-
 from IPython.core.profileapp import list_profiles_in, list_bundled_profiles
 from IPython.core.profiledir import ProfileDir
 
@@ -139,14 +137,14 b' def test_list_profiles_in():'
             found_unicode = True
             break
     if dec.unicode_paths:
-        nt.assert_true(found_unicode)
-    nt.assert_equal(set(profiles), {'foo', 'hello'})
+        assert found_unicode is True
+    assert set(profiles) == {"foo", "hello"}
 
 
 def test_list_bundled_profiles():
     # This variable will need to be updated when a new profile gets bundled
     bundled = sorted(list_bundled_profiles())
-    nt.assert_equal(bundled, [])
+    assert bundled == []
 
 
 def test_profile_create_ipython_dir():
@@ -167,4 +165,3 b' def test_profile_create_ipython_dir():'
         assert Path(profile_dir).exists()
         ipython_config = profile_dir / "ipython_config.py"
         assert Path(ipython_config).exists()
-        

IPython/core/tests/test_pylabtools.py

@@ -12,12 +12,10 b' import matplotlib'
 matplotlib.use('Agg')
 from matplotlib.figure import Figure
 
-from nose import SkipTest
-import nose.tools as nt
-
 from matplotlib import pyplot as plt
-import matplotlib_inline
+from matplotlib_inline import backend_inline
 import numpy as np
+import pytest
 
 from IPython.core.getipython import get_ipython
 from IPython.core.interactiveshell import InteractiveShell
@@ -30,7 +28,7 b' from IPython.testing import decorators as dec'
 def test_figure_to_svg():
     # simple empty-figure test
     fig = plt.figure()
-    nt.assert_equal(pt.print_figure(fig, 'svg'), None)
+    assert pt.print_figure(fig, "svg") is None
 
     plt.close('all')
 
@@ -39,8 +37,9 b' def test_figure_to_svg():'
     ax = fig.add_subplot(1,1,1)
     ax.plot([1,2,3])
     plt.draw()
-    svg = pt.print_figure(fig, 'svg')[:100].lower()
-    nt.assert_in(u'doctype svg', svg)
+    svg = pt.print_figure(fig, "svg")[:100].lower()
+    assert "doctype svg" in svg
+
 
 def _check_pil_jpeg_bytes():
     """Skip if PIL can't write JPEGs to BytesIO objects"""
@@ -53,7 +52,7 b' def _check_pil_jpeg_bytes():'
         img.save(buf, 'jpeg')
     except Exception as e:
         ename = e.__class__.__name__
-        raise SkipTest("PIL can't write JPEG to BytesIO: %s: %s" % (ename, e)) from e
+        raise pytest.skip("PIL can't write JPEG to BytesIO: %s: %s" % (ename, e)) from e
 
 @dec.skip_without("PIL.Image")
 def test_figure_to_jpeg():
@@ -69,7 +68,7 b' def test_figure_to_jpeg():'
 def test_retina_figure():
     # simple empty-figure test
     fig = plt.figure()
-    nt.assert_equal(pt.retina_figure(fig), None)
+    assert pt.retina_figure(fig) == None
     plt.close('all')
 
     fig = plt.figure()
@@ -78,8 +77,9 b' def test_retina_figure():'
     plt.draw()
     png, md = pt.retina_figure(fig)
     assert png.startswith(_PNG)
-    nt.assert_in('width', md)
-    nt.assert_in('height', md)
+    assert "width" in md
+    assert "height" in md
+
 
 _fmt_mime_map = {
     'png': 'image/png',
@@ -95,9 +95,9 b' def test_select_figure_formats_str():'
         pt.select_figure_formats(ip, fmt)
         for mime, f in ip.display_formatter.formatters.items():
             if mime == active_mime:
-                nt.assert_in(Figure, f)
+                assert Figure in f
             else:
-                nt.assert_not_in(Figure, f)
+                assert Figure not in f
 
 def test_select_figure_formats_kwargs():
     ip = get_ipython()
@@ -134,24 +134,25 b' def test_select_figure_formats_set():'
         pt.select_figure_formats(ip, fmts)
         for mime, f in ip.display_formatter.formatters.items():
             if mime in active_mimes:
-                nt.assert_in(Figure, f)
+                assert Figure in f
             else:
-                nt.assert_not_in(Figure, f)
+                assert Figure not in f
 
 def test_select_figure_formats_bad():
     ip = get_ipython()
-    with nt.assert_raises(ValueError):
+    with pytest.raises(ValueError):
         pt.select_figure_formats(ip, 'foo')
-    with nt.assert_raises(ValueError):
+    with pytest.raises(ValueError):
         pt.select_figure_formats(ip, {'png', 'foo'})
-    with nt.assert_raises(ValueError):
+    with pytest.raises(ValueError):
         pt.select_figure_formats(ip, ['retina', 'pdf', 'bar', 'bad'])
 
 def test_import_pylab():
     ns = {}
     pt.import_pylab(ns, import_all=False)
-    nt.assert_true('plt' in ns)
-    nt.assert_equal(ns['np'], np)
+    assert "plt" in ns
+    assert ns["np"] == np
+
 
 from traitlets.config import Config
 
@@ -182,15 +183,13 b' class TestPylabSwitch(object):'
         pt.activate_matplotlib = act_mpl
         self._save_ip = pt.import_pylab
         pt.import_pylab = lambda *a,**kw:None
-        self._save_cis = matplotlib_inline.backend_inline.configure_inline_support
-        matplotlib_inline.backend_inline.configure_inline_support = (
-            lambda *a, **kw: None
-        )
+        self._save_cis = backend_inline.configure_inline_support
+        backend_inline.configure_inline_support = lambda *a, **kw: None
 
     def teardown(self):
         pt.activate_matplotlib = self._save_am
         pt.import_pylab = self._save_ip
-        matplotlib_inline.backend_inline.configure_inline_support = self._save_cis
+        backend_inline.configure_inline_support = self._save_cis
         import matplotlib
         matplotlib.rcParams = self._saved_rcParams
         matplotlib.rcParamsOrig = self._saved_rcParamsOrig
@@ -199,68 +198,68 b' class TestPylabSwitch(object):'
 
         s = self.Shell()
         gui, backend = s.enable_matplotlib(None)
-        nt.assert_equal(gui, 'qt')
-        nt.assert_equal(s.pylab_gui_select, 'qt')
+        assert gui == "qt"
+        assert s.pylab_gui_select == "qt"
 
-        gui, backend = s.enable_matplotlib('inline')
-        nt.assert_equal(gui, 'inline')
-        nt.assert_equal(s.pylab_gui_select, 'qt')
+        gui, backend = s.enable_matplotlib("inline")
+        assert gui == "inline"
+        assert s.pylab_gui_select == "qt"
 
-        gui, backend = s.enable_matplotlib('qt')
-        nt.assert_equal(gui, 'qt')
-        nt.assert_equal(s.pylab_gui_select, 'qt')
+        gui, backend = s.enable_matplotlib("qt")
+        assert gui == "qt"
+        assert s.pylab_gui_select == "qt"
 
-        gui, backend = s.enable_matplotlib('inline')
-        nt.assert_equal(gui, 'inline')
-        nt.assert_equal(s.pylab_gui_select, 'qt')
+        gui, backend = s.enable_matplotlib("inline")
+        assert gui == "inline"
+        assert s.pylab_gui_select == "qt"
 
         gui, backend = s.enable_matplotlib()
-        nt.assert_equal(gui, 'qt')
-        nt.assert_equal(s.pylab_gui_select, 'qt')
+        assert gui == "qt"
+        assert s.pylab_gui_select == "qt"
 
     def test_inline(self):
         s = self.Shell()
-        gui, backend = s.enable_matplotlib('inline')
-        nt.assert_equal(gui, 'inline')
-        nt.assert_equal(s.pylab_gui_select, None)
+        gui, backend = s.enable_matplotlib("inline")
+        assert gui == "inline"
+        assert s.pylab_gui_select == None
 
-        gui, backend = s.enable_matplotlib('inline')
-        nt.assert_equal(gui, 'inline')
-        nt.assert_equal(s.pylab_gui_select, None)
+        gui, backend = s.enable_matplotlib("inline")
+        assert gui == "inline"
+        assert s.pylab_gui_select == None
 
-        gui, backend = s.enable_matplotlib('qt')
-        nt.assert_equal(gui, 'qt')
-        nt.assert_equal(s.pylab_gui_select, 'qt')
+        gui, backend = s.enable_matplotlib("qt")
+        assert gui == "qt"
+        assert s.pylab_gui_select == "qt"
 
     def test_inline_twice(self):
         "Using '%matplotlib inline' twice should not reset formatters"
 
         ip = self.Shell()
-        gui, backend = ip.enable_matplotlib('inline')
-        nt.assert_equal(gui, 'inline')
+        gui, backend = ip.enable_matplotlib("inline")
+        assert gui == "inline"
 
         fmts =  {'png'}
         active_mimes = {_fmt_mime_map[fmt] for fmt in fmts}
         pt.select_figure_formats(ip, fmts)
 
-        gui, backend = ip.enable_matplotlib('inline')
-        nt.assert_equal(gui, 'inline')
+        gui, backend = ip.enable_matplotlib("inline")
+        assert gui == "inline"
 
         for mime, f in ip.display_formatter.formatters.items():
             if mime in active_mimes:
-                nt.assert_in(Figure, f)
+                assert Figure in f
             else:
-                nt.assert_not_in(Figure, f)
+                assert Figure not in f
 
     def test_qt_gtk(self):
         s = self.Shell()
-        gui, backend = s.enable_matplotlib('qt')
-        nt.assert_equal(gui, 'qt')
-        nt.assert_equal(s.pylab_gui_select, 'qt')
+        gui, backend = s.enable_matplotlib("qt")
+        assert gui == "qt"
+        assert s.pylab_gui_select == "qt"
 
-        gui, backend = s.enable_matplotlib('gtk')
-        nt.assert_equal(gui, 'qt')
-        nt.assert_equal(s.pylab_gui_select, 'qt')
+        gui, backend = s.enable_matplotlib("gtk")
+        assert gui == "qt"
+        assert s.pylab_gui_select == "qt"
 
 
 def test_no_gui_backends():

IPython/core/tests/test_run.py

@@ -26,8 +26,7 b' import textwrap'
 import unittest
 from unittest.mock import patch
 
-import nose.tools as nt
-from nose import SkipTest
+import pytest
 
 from IPython.testing import decorators as dec
 from IPython.testing import tools as tt
@@ -188,7 +187,7 b' class TestMagicRunPass(tt.TempFileMixin):'
         bid1 = id(_ip.user_ns['__builtins__'])
         self.run_tmpfile()
         bid2 = id(_ip.user_ns['__builtins__'])
-        nt.assert_equal(bid1, bid2)
+        assert bid1 == bid2
 
     def test_builtins_type(self):
         """Check that the type of __builtins__ doesn't change with %run.
@@ -199,7 +198,7 b' class TestMagicRunPass(tt.TempFileMixin):'
         """
         _ip = get_ipython()
         self.run_tmpfile()
-        nt.assert_equal(type(_ip.user_ns['__builtins__']),type(sys))
+        assert type(_ip.user_ns["__builtins__"]) == type(sys)
         
     def test_run_profile( self ):
         """Test that the option -p, which invokes the profiler, do not
@@ -232,9 +231,9 b' class TestMagicRunSimple(tt.TempFileMixin):'
         src = ("class foo: pass\n"
                "def f(): return foo()")
         self.mktmp(src)
-        _ip.magic('run %s' % self.fname)
-        _ip.run_cell('t = isinstance(f(), foo)')
-        nt.assert_true(_ip.user_ns['t'])
+        _ip.magic("run %s" % self.fname)
+        _ip.run_cell("t = isinstance(f(), foo)")
+        assert _ip.user_ns["t"] is True
 
     def test_obj_del(self):
         """Test that object's __del__ methods are called on exit."""
@@ -242,7 +241,7 b' class TestMagicRunSimple(tt.TempFileMixin):'
             try:
                 import win32api
             except ImportError as e:
-                raise SkipTest("Test requires pywin32") from e
+                raise unittest.SkipTest("Test requires pywin32") from e
         src = ("class A(object):\n"
                "    def __del__(self):\n"
                "        print('object A deleted')\n"
@@ -258,34 +257,33 b' class TestMagicRunSimple(tt.TempFileMixin):'
         # see ticket https://github.com/ipython/ipython/issues/238
         
         with tt.TempFileMixin() as empty:
-            empty.mktmp('')
+            empty.mktmp("")
             # On Windows, the filename will have \users in it, so we need to use the
             # repr so that the \u becomes \\u.
-            src = ("ip = get_ipython()\n"
+            src = (
+                "ip = get_ipython()\n"
                    "for i in range(5):\n"
                    "   try:\n"
                    "       ip.magic(%r)\n"
                    "   except NameError as e:\n"
                    "       print(i)\n"
-                   "       break\n" % ('run ' + empty.fname))
+                "       break\n" % ("run " + empty.fname)
+            )
             self.mktmp(src)
-            _ip.magic('run %s' % self.fname)
-            _ip.run_cell('ip == get_ipython()')
-            nt.assert_equal(_ip.user_ns['i'], 4)
+            _ip.magic("run %s" % self.fname)
+            _ip.run_cell("ip == get_ipython()")
+            assert _ip.user_ns["i"] == 4
     
     def test_run_second(self):
-        """Test that running a second file doesn't clobber the first, gh-3547
-        """
-        self.mktmp("avar = 1\n"
-                   "def afunc():\n"
-                   "  return avar\n")
+        """Test that running a second file doesn't clobber the first, gh-3547"""
+        self.mktmp("avar = 1\n" "def afunc():\n" "  return avar\n")
 
         with tt.TempFileMixin() as empty:
             empty.mktmp("")
             
-            _ip.magic('run %s' % self.fname)
-            _ip.magic('run %s' % empty.fname)
-            nt.assert_equal(_ip.user_ns['afunc'](), 1)
+            _ip.magic("run %s" % self.fname)
+            _ip.magic("run %s" % empty.fname)
+            assert _ip.user_ns["afunc"]() == 1
 
     @dec.skip_win32
     def test_tclass(self):
@@ -312,15 +310,15 b' tclass.py: deleting object: C-third'
         self.mktmp(src)
         _ip.run_cell("zz = 23")
         try:
-            _ip.magic('run -i %s' % self.fname)
-            nt.assert_equal(_ip.user_ns['yy'], 23)
+            _ip.magic("run -i %s" % self.fname)
+            assert _ip.user_ns["yy"] == 23
         finally:
             _ip.magic('reset -f')
             
         _ip.run_cell("zz = 23")
         try:
-            _ip.magic('run -i %s' % self.fname)
-            nt.assert_equal(_ip.user_ns['yy'], 23)
+            _ip.magic("run -i %s" % self.fname)
+            assert _ip.user_ns["yy"] == 23
         finally:
             _ip.magic('reset -f')
             
@@ -329,7 +327,7 b' tclass.py: deleting object: C-third'
         mydir = os.path.dirname(__file__)
         na = os.path.join(mydir, 'nonascii.py')
         _ip.magic('run "%s"' % na)
-        nt.assert_equal(_ip.user_ns['u'], u'Ўт№Ф')
+        assert _ip.user_ns["u"] == "Ўт№Ф"
 
     def test_run_py_file_attribute(self):
         """Test handling of `__file__` attribute in `%run <file>.py`."""
@@ -342,10 +340,10 b' tclass.py: deleting object: C-third'
 
         # Check that __file__ was equal to the filename in the script's
         # namespace.
-        nt.assert_equal(_ip.user_ns['t'], self.fname)
+        assert _ip.user_ns["t"] == self.fname
 
         # Check that __file__ was not leaked back into user_ns.
-        nt.assert_equal(file1, file2)
+        assert file1 == file2
 
     def test_run_ipy_file_attribute(self):
         """Test handling of `__file__` attribute in `%run <file.ipy>`."""
@@ -358,10 +356,10 b' tclass.py: deleting object: C-third'
 
         # Check that __file__ was equal to the filename in the script's
         # namespace.
-        nt.assert_equal(_ip.user_ns['t'], self.fname)
+        assert _ip.user_ns["t"] == self.fname
 
         # Check that __file__ was not leaked back into user_ns.
-        nt.assert_equal(file1, file2)
+        assert file1 == file2
 
     def test_run_formatting(self):
         """ Test that %run -t -N<N> does not raise a TypeError for N > 1."""
@@ -394,16 +392,16 b' tclass.py: deleting object: C-third'
         
         _ip.magic("run %s" % self.fname)
         
-        nt.assert_equal(_ip.user_ns['answer'], 42)
+        assert _ip.user_ns["answer"] == 42
 
     def test_run_nb_error(self):
         """Test %run notebook.ipynb error"""
         from nbformat import v4, writes
         # %run when a file name isn't provided
-        nt.assert_raises(Exception, _ip.magic, "run")
+        pytest.raises(Exception, _ip.magic, "run")
 
         # %run when a file doesn't exist
-        nt.assert_raises(Exception, _ip.magic, "run foobar.ipynb")
+        pytest.raises(Exception, _ip.magic, "run foobar.ipynb")
 
         # %run on a notebook with an error
         nb = v4.new_notebook(
@@ -413,15 +411,15 b' tclass.py: deleting object: C-third'
         )
         src = writes(nb, version=4)
         self.mktmp(src, ext='.ipynb')
-        nt.assert_raises(Exception, _ip.magic, "run %s" % self.fname)
+        pytest.raises(Exception, _ip.magic, "run %s" % self.fname)
 
     def test_file_options(self):
         src = ('import sys\n'
                'a = " ".join(sys.argv[1:])\n')
         self.mktmp(src)
-        test_opts = '-x 3 --verbose'
-        _ip.run_line_magic("run", '{0} {1}'.format(self.fname, test_opts))
-        nt.assert_equal(_ip.user_ns['a'], test_opts)
+        test_opts = "-x 3 --verbose"
+        _ip.run_line_magic("run", "{0} {1}".format(self.fname, test_opts))
+        assert _ip.user_ns["a"] == test_opts
 
 
 class TestMagicRunWithPackage(unittest.TestCase):
@@ -500,16 +498,17 b' class TestMagicRunWithPackage(unittest.TestCase):'
         self.check_run_submodule('relative', '-d')
 
     def test_module_options(self):
-        _ip.user_ns.pop('a', None)
-        test_opts = '-x abc -m test'
-        _ip.run_line_magic('run', '-m {0}.args {1}'.format(self.package, test_opts))
-        nt.assert_equal(_ip.user_ns['a'], test_opts)
+        _ip.user_ns.pop("a", None)
+        test_opts = "-x abc -m test"
+        _ip.run_line_magic("run", "-m {0}.args {1}".format(self.package, test_opts))
+        assert _ip.user_ns["a"] == test_opts
 
     def test_module_options_with_separator(self):
-        _ip.user_ns.pop('a', None)
-        test_opts = '-x abc -m test'
-        _ip.run_line_magic('run', '-m {0}.args -- {1}'.format(self.package, test_opts))
-        nt.assert_equal(_ip.user_ns['a'], test_opts)
+        _ip.user_ns.pop("a", None)
+        test_opts = "-x abc -m test"
+        _ip.run_line_magic("run", "-m {0}.args -- {1}".format(self.package, test_opts))
+        assert _ip.user_ns["a"] == test_opts
+
 
 def test_run__name__():
     with TemporaryDirectory() as td:
@@ -517,16 +516,16 b' def test_run__name__():'
         with open(path, 'w') as f:
             f.write("q = __name__")
         
-        _ip.user_ns.pop('q', None)
-        _ip.magic('run {}'.format(path))
-        nt.assert_equal(_ip.user_ns.pop('q'), '__main__')
+        _ip.user_ns.pop("q", None)
+        _ip.magic("run {}".format(path))
+        assert _ip.user_ns.pop("q") == "__main__"
         
-        _ip.magic('run -n {}'.format(path))
-        nt.assert_equal(_ip.user_ns.pop('q'), 'foo')
+        _ip.magic("run -n {}".format(path))
+        assert _ip.user_ns.pop("q") == "foo"
 
         try:
-            _ip.magic('run -i -n {}'.format(path))
-            nt.assert_equal(_ip.user_ns.pop('q'), 'foo')
+            _ip.magic("run -i -n {}".format(path))
+            assert _ip.user_ns.pop("q") == "foo"
         finally:
             _ip.magic('reset -f')
 
@@ -546,9 +545,9 b' def test_run_tb():'
         with capture_output() as io:
             _ip.magic('run {}'.format(path))
         out = io.stdout
-        nt.assert_not_in("execfile", out)
-        nt.assert_in("RuntimeError", out)
-        nt.assert_equal(out.count("---->"), 3)
+        assert "execfile" not in out
+        assert "RuntimeError" in out
+        assert out.count("---->") == 3
         del ip.user_ns['bar']
         del ip.user_ns['foo']
 
@@ -572,10 +571,10 b' def test_multiprocessing_run():'
                 _ip.run_line_magic('run', path)
                 _ip.run_cell("i_m_undefined")
             out = io.stdout
-            nt.assert_in("hoy", out)
-            nt.assert_not_in("AttributeError", out)
-            nt.assert_in("NameError", out)
-            nt.assert_equal(out.count("---->"), 1)
+            assert "hoy" in out
+            assert "AttributeError" not in out
+            assert "NameError" in out
+            assert out.count("---->") == 1
         except:
             raise
         finally:
@@ -595,7 +594,6 b' def test_script_tb():'
                 "foo()",
             ]))
         out, err = tt.ipexec(path)
-        nt.assert_not_in("execfile", out)
-        nt.assert_in("RuntimeError", out)
-        nt.assert_equal(out.count("---->"), 3)
-
+        assert "execfile" not in out
+        assert "RuntimeError" in out
+        assert out.count("---->") == 3

IPython/core/tests/test_splitinput.py

@@ -1,38 +1,38 b''
 # coding: utf-8
-import nose.tools as nt
 
 from IPython.core.splitinput import split_user_input, LineInfo
 from IPython.testing import tools as tt
 
 tests = [
-    ('x=1', ('', '', 'x', '=1')),
-    ('?', ('', '?', '', '')),
-    ('??', ('', '??', '', '')),
-    (' ?', (' ', '?', '', '')),
-    (' ??', (' ', '??', '', '')),
-    ('??x', ('', '??', 'x', '')),
-    ('?x=1', ('', '?', 'x', '=1')),
-    ('!ls', ('', '!', 'ls', '')),
-    ('  !ls', ('  ', '!', 'ls', '')),
-    ('!!ls', ('', '!!', 'ls', '')),
-    ('  !!ls', ('  ', '!!', 'ls', '')),
-    (',ls', ('', ',', 'ls', '')),
-    (';ls', ('', ';', 'ls', '')),
-    ('  ;ls', ('  ', ';', 'ls', '')),
-    ('f.g(x)',  ('', '', 'f.g', '(x)')),
-    ('f.g (x)', ('', '', 'f.g', '(x)')),
-    ('?%hist1', ('', '?', '%hist1', '')),
-    ('?%%hist2', ('', '?', '%%hist2', '')),
-    ('??%hist3', ('', '??', '%hist3', '')),
-    ('??%%hist4', ('', '??', '%%hist4', '')),
-    ('?x*', ('', '?', 'x*', '')),
+    ("x=1", ("", "", "x", "=1")),
+    ("?", ("", "?", "", "")),
+    ("??", ("", "??", "", "")),
+    (" ?", (" ", "?", "", "")),
+    (" ??", (" ", "??", "", "")),
+    ("??x", ("", "??", "x", "")),
+    ("?x=1", ("", "?", "x", "=1")),
+    ("!ls", ("", "!", "ls", "")),
+    ("  !ls", ("  ", "!", "ls", "")),
+    ("!!ls", ("", "!!", "ls", "")),
+    ("  !!ls", ("  ", "!!", "ls", "")),
+    (",ls", ("", ",", "ls", "")),
+    (";ls", ("", ";", "ls", "")),
+    ("  ;ls", ("  ", ";", "ls", "")),
+    ("f.g(x)", ("", "", "f.g", "(x)")),
+    ("f.g (x)", ("", "", "f.g", "(x)")),
+    ("?%hist1", ("", "?", "%hist1", "")),
+    ("?%%hist2", ("", "?", "%%hist2", "")),
+    ("??%hist3", ("", "??", "%hist3", "")),
+    ("??%%hist4", ("", "??", "%%hist4", "")),
+    ("?x*", ("", "?", "x*", "")),
     ]
-tests.append((u"Pérez Fernando", (u'', u'', u'Pérez', u'Fernando')))
+tests.append(("Pérez Fernando", ("", "", "Pérez", "Fernando")))
+
 
 def test_split_user_input():
     return tt.check_pairs(split_user_input, tests)
 
 def test_LineInfo():
     """Simple test for LineInfo construction and str()"""
-    linfo = LineInfo('  %cd /home')
-    nt.assert_equal(str(linfo), 'LineInfo [  |%|cd|/home]')
+    linfo = LineInfo("  %cd /home")
+    assert str(linfo) == "LineInfo [  |%|cd|/home]"

IPython/extensions/tests/test_autoreload.py

@@ -21,7 +21,6 b' import random'
 import time
 from io import StringIO
 
-import nose.tools as nt
 import IPython.testing.tools as tt
 
 from unittest import TestCase
@@ -227,12 +226,12 b' class TestAutoreload(Fixture):'
         self.shell.run_code("from %s import MyClass" % mod_name)
         self.shell.run_code("first = MyClass(5)")
         self.shell.run_code("first.square()")
-        with nt.assert_raises(AttributeError):
+        with self.assertRaises(AttributeError):
             self.shell.run_code("first.cube()")
-        with nt.assert_raises(AttributeError):
+        with self.assertRaises(AttributeError):
             self.shell.run_code("first.power(5)")
         self.shell.run_code("first.b")
-        with nt.assert_raises(AttributeError):
+        with self.assertRaises(AttributeError):
             self.shell.run_code("first.toto")
 
         # remove square, add power
@@ -258,13 +257,13 b' class TestAutoreload(Fixture):'
 
         for object_name in {"first", "second"}:
             self.shell.run_code(f"{object_name}.power(5)")
-            with nt.assert_raises(AttributeError):
+            with self.assertRaises(AttributeError):
                 self.shell.run_code(f"{object_name}.cube()")
-            with nt.assert_raises(AttributeError):
+            with self.assertRaises(AttributeError):
                 self.shell.run_code(f"{object_name}.square()")
             self.shell.run_code(f"{object_name}.b")
             self.shell.run_code(f"{object_name}.a")
-            with nt.assert_raises(AttributeError):
+            with self.assertRaises(AttributeError):
                 self.shell.run_code(f"{object_name}.toto")
 
     def test_autoload_newly_added_objects(self):
@@ -275,11 +274,11 b' class TestAutoreload(Fixture):'
         mod_name, mod_fn = self.new_module(textwrap.dedent(mod_code))
         self.shell.run_code(f"from {mod_name} import *")
         self.shell.run_code("func1()")
-        with nt.assert_raises(NameError):
+        with self.assertRaises(NameError):
             self.shell.run_code("func2()")
-        with nt.assert_raises(NameError):
+        with self.assertRaises(NameError):
             self.shell.run_code("t = Test()")
-        with nt.assert_raises(NameError):
+        with self.assertRaises(NameError):
             self.shell.run_code("number")
 
         # ----------- TEST NEW OBJ LOADED --------------------------
@@ -391,19 +390,19 b" class Bar: # old-style class: weakref doesn't work for it on Python < 2.7"
             self.shell.magic_aimport(mod_name)
             stream = StringIO()
             self.shell.magic_aimport("", stream=stream)
-            nt.assert_in(("Modules to reload:\n%s" % mod_name), stream.getvalue())
+            self.assertIn(("Modules to reload:\n%s" % mod_name), stream.getvalue())
 
-            with nt.assert_raises(ImportError):
+            with self.assertRaises(ImportError):
                 self.shell.magic_aimport("tmpmod_as318989e89ds")
         else:
             self.shell.magic_autoreload("2")
             self.shell.run_code("import %s" % mod_name)
             stream = StringIO()
             self.shell.magic_aimport("", stream=stream)
-            nt.assert_true(
+            self.assertTrue(
                 "Modules to reload:\nall-except-skipped" in stream.getvalue()
             )
-        nt.assert_in(mod_name, self.shell.ns)
+        self.assertIn(mod_name, self.shell.ns)
 
         mod = sys.modules[mod_name]
 
@@ -415,21 +414,21 b" class Bar: # old-style class: weakref doesn't work for it on Python < 2.7"
         old_obj2 = mod.Bar()
 
         def check_module_contents():
-            nt.assert_equal(mod.x, 9)
-            nt.assert_equal(mod.z, 123)
+            self.assertEqual(mod.x, 9)
+            self.assertEqual(mod.z, 123)
 
-            nt.assert_equal(old_foo(0), 3)
-            nt.assert_equal(mod.foo(0), 3)
+            self.assertEqual(old_foo(0), 3)
+            self.assertEqual(mod.foo(0), 3)
 
             obj = mod.Baz(9)
-            nt.assert_equal(old_obj.bar(1), 10)
-            nt.assert_equal(obj.bar(1), 10)
-            nt.assert_equal(obj.quux, 42)
-            nt.assert_equal(obj.zzz(), 99)
+            self.assertEqual(old_obj.bar(1), 10)
+            self.assertEqual(obj.bar(1), 10)
+            self.assertEqual(obj.quux, 42)
+            self.assertEqual(obj.zzz(), 99)
 
             obj2 = mod.Bar()
-            nt.assert_equal(old_obj2.foo(), 1)
-            nt.assert_equal(obj2.foo(), 1)
+            self.assertEqual(old_obj2.foo(), 1)
+            self.assertEqual(obj2.foo(), 1)
 
         check_module_contents()
 
@@ -481,25 +480,25 b' class Bar: # old-style class'
         )
 
         def check_module_contents():
-            nt.assert_equal(mod.x, 10)
-            nt.assert_false(hasattr(mod, "z"))
+            self.assertEqual(mod.x, 10)
+            self.assertFalse(hasattr(mod, "z"))
 
-            nt.assert_equal(old_foo(0), 4)  # superreload magic!
-            nt.assert_equal(mod.foo(0), 4)
+            self.assertEqual(old_foo(0), 4)  # superreload magic!
+            self.assertEqual(mod.foo(0), 4)
 
             obj = mod.Baz(9)
-            nt.assert_equal(old_obj.bar(1), 11)  # superreload magic!
-            nt.assert_equal(obj.bar(1), 11)
+            self.assertEqual(old_obj.bar(1), 11)  # superreload magic!
+            self.assertEqual(obj.bar(1), 11)
 
-            nt.assert_equal(old_obj.quux, 43)
-            nt.assert_equal(obj.quux, 43)
+            self.assertEqual(old_obj.quux, 43)
+            self.assertEqual(obj.quux, 43)
 
-            nt.assert_false(hasattr(old_obj, "zzz"))
-            nt.assert_false(hasattr(obj, "zzz"))
+            self.assertFalse(hasattr(old_obj, "zzz"))
+            self.assertFalse(hasattr(obj, "zzz"))
 
             obj2 = mod.Bar()
-            nt.assert_equal(old_obj2.foo(), 2)
-            nt.assert_equal(obj2.foo(), 2)
+            self.assertEqual(old_obj2.foo(), 2)
+            self.assertEqual(obj2.foo(), 2)
 
         self.shell.run_code("pass")  # trigger reload
         check_module_contents()
@@ -519,7 +518,7 b' class Bar: # old-style class'
             self.shell.magic_aimport("-" + mod_name)
             stream = StringIO()
             self.shell.magic_aimport("", stream=stream)
-            nt.assert_true(("Modules to skip:\n%s" % mod_name) in stream.getvalue())
+            self.assertTrue(("Modules to skip:\n%s" % mod_name) in stream.getvalue())
 
             # This should succeed, although no such module exists
             self.shell.magic_aimport("-tmpmod_as318989e89ds")
@@ -546,7 +545,7 b' x = -99'
             self.shell.magic_autoreload("")
 
         self.shell.run_code("pass")  # trigger reload
-        nt.assert_equal(mod.x, -99)
+        self.assertEqual(mod.x, -99)
 
     def test_smoketest_aimport(self):
         self._check_smoketest(use_aimport=True)

IPython/extensions/tests/test_storemagic.py

@@ -1,7 +1,6 b''
 import tempfile, os
 
 from traitlets.config.loader import Config
-import nose.tools as nt
 
 
 def setup_module():
@@ -23,10 +22,10 b' def test_store_restore():'
     ip.magic('store foobar foobaz')
 
     # Check storing
-    nt.assert_equal(ip.db['autorestore/foo'], 78)
-    nt.assert_in('bar', ip.db['stored_aliases'])
-    nt.assert_equal(ip.db['autorestore/foobar'], 79)
-    nt.assert_equal(ip.db['autorestore/foobaz'], '80')
+    assert ip.db["autorestore/foo"] == 78
+    assert "bar" in ip.db["stored_aliases"]
+    assert ip.db["autorestore/foobar"] == 79
+    assert ip.db["autorestore/foobaz"] == "80"
 
     # Remove those items
     ip.user_ns.pop('foo', None)
@@ -37,14 +36,14 b' def test_store_restore():'
     ip.user_ns['_dh'][:] = []
 
     # Check restoring
-    ip.magic('store -r foo bar foobar foobaz')
-    nt.assert_equal(ip.user_ns['foo'], 78)
-    assert ip.alias_manager.is_alias('bar')
-    nt.assert_equal(ip.user_ns['foobar'], 79)
-    nt.assert_equal(ip.user_ns['foobaz'], '80')
+    ip.magic("store -r foo bar foobar foobaz")
+    assert ip.user_ns["foo"] == 78
+    assert ip.alias_manager.is_alias("bar")
+    assert ip.user_ns["foobar"] == 79
+    assert ip.user_ns["foobaz"] == "80"
 
-    ip.magic('store -r') # restores _dh too
-    nt.assert_in(os.path.realpath(tmpd), ip.user_ns['_dh'])
+    ip.magic("store -r")  # restores _dh too
+    assert os.path.realpath(tmpd) in ip.user_ns["_dh"]
 
     os.rmdir(tmpd)
 
@@ -57,10 +56,10 b' def test_autorestore():'
     orig_config = ip.config
     try:
         ip.config = c
-        ip.extension_manager.reload_extension('storemagic')
-        nt.assert_not_in('foo', ip.user_ns)
+        ip.extension_manager.reload_extension("storemagic")
+        assert "foo" not in ip.user_ns
         c.StoreMagics.autorestore = True
-        ip.extension_manager.reload_extension('storemagic')
-        nt.assert_equal(ip.user_ns['foo'], 95)
+        ip.extension_manager.reload_extension("storemagic")
+        assert ip.user_ns["foo"] == 95
     finally:
         ip.config = orig_config

IPython/lib/tests/test_clipboard.py

@@ -1,5 +1,3 b''
-import nose.tools as nt
-
 from IPython.core.error import TryNext
 from IPython.lib.clipboard import ClipboardEmpty
 from IPython.testing.decorators import skip_if_no_x11
@@ -18,4 +16,4 b' def test_clipboard_get():'
         # No clipboard access API available
         pass
     else:
-        nt.assert_is_instance(a, str)
+        assert isinstance(a, str)

IPython/lib/tests/test_deepreload.py

@@ -6,8 +6,6 b''
 
 from pathlib import Path
 
-import nose.tools as nt
-
 from IPython.utils.syspathcontext import prepended_to_syspath
 from IPython.utils.tempdir import TemporaryDirectory
 from IPython.lib.deepreload import reload as dreload
@@ -28,9 +26,9 b' def test_deepreload():'
             # Test that A is not reloaded.
             obj = A.Object()
             dreload(B, exclude=["A"])
-            nt.assert_true(isinstance(obj, A.Object))
+            assert isinstance(obj, A.Object) is True
 
             # Test that A is reloaded.
             obj = A.Object()
             dreload(B)
-            nt.assert_false(isinstance(obj, A.Object))
+            assert isinstance(obj, A.Object) is False

IPython/lib/tests/test_display.py

@@ -21,7 +21,7 b' import wave'
 from io import BytesIO
 
 # Third-party imports
-import nose.tools as nt
+import pytest
 
 try:
     import numpy
@@ -48,10 +48,10 b' def test_instantiation_FileLink():'
     fl = display.FileLink(pathlib.PurePath('example.txt'))
 
 def test_warning_on_non_existent_path_FileLink():
-    """FileLink: Calling _repr_html_ on non-existent files returns a warning
-    """
-    fl = display.FileLink('example.txt')
-    nt.assert_true(fl._repr_html_().startswith('Path (<tt>example.txt</tt>)'))
+    """FileLink: Calling _repr_html_ on non-existent files returns a warning"""
+    fl = display.FileLink("example.txt")
+    assert fl._repr_html_().startswith("Path (<tt>example.txt</tt>)")
+
 
 def test_existing_path_FileLink():
     """FileLink: Calling _repr_html_ functions as expected on existing filepath
@@ -77,7 +77,7 b' def test_error_on_directory_to_FileLink():'
     """FileLink: Raises error when passed directory
     """
     td = mkdtemp()
-    nt.assert_raises(ValueError,display.FileLink,td)
+    pytest.raises(ValueError, display.FileLink, td)
 
 #--------------------------
 # FileLinks tests
@@ -89,10 +89,10 b' def test_instantiation_FileLinks():'
     fls = display.FileLinks('example')
 
 def test_warning_on_non_existent_path_FileLinks():
-    """FileLinks: Calling _repr_html_ on non-existent files returns a warning
-    """
-    fls = display.FileLinks('example')
-    nt.assert_true(fls._repr_html_().startswith('Path (<tt>example</tt>)'))
+    """FileLinks: Calling _repr_html_ on non-existent files returns a warning"""
+    fls = display.FileLinks("example")
+    assert fls._repr_html_().startswith("Path (<tt>example</tt>)")
+
 
 def test_existing_path_FileLinks():
     """FileLinks: Calling _repr_html_ functions as expected on existing dir
@@ -172,7 +172,8 b' def test_error_on_file_to_FileLinks():'
     """
     td = mkdtemp()
     tf1 = NamedTemporaryFile(dir=td)
-    nt.assert_raises(ValueError,display.FileLinks,tf1.name)
+    pytest.raises(ValueError, display.FileLinks, tf1.name)
+
 
 def test_recursive_FileLinks():
     """FileLinks: Does not recurse when recursive=False
@@ -210,7 +211,7 b' class TestAudioDataWithNumpy(TestCase):'
 
     @skipif_not_numpy
     def test_audio_from_numpy_array_without_rate_raises(self):
-        nt.assert_raises(ValueError, display.Audio, get_test_tone())
+        self.assertRaises(ValueError, display.Audio, get_test_tone())
 
     @skipif_not_numpy
     def test_audio_data_normalization(self):
@@ -232,10 +233,10 b' class TestAudioDataWithNumpy(TestCase):'
             assert actual_max_value == expected_max_value
 
     def test_audio_data_without_normalization_raises_for_invalid_data(self):
-        nt.assert_raises(
+        self.assertRaises(
             ValueError,
             lambda: display.Audio([1.001], rate=44100, normalize=False))
-        nt.assert_raises(
+        self.assertRaises(
             ValueError,
             lambda: display.Audio([-1.001], rate=44100, normalize=False))
 
@@ -253,9 +254,8 b' class TestAudioDataWithoutNumpy(TestAudioDataWithNumpy):'
     @skipif_not_numpy
     def test_audio_raises_for_nested_list(self):
         stereo_signal = [list(get_test_tone())] * 2
-        nt.assert_raises(
-            TypeError,
-            lambda: display.Audio(stereo_signal, rate=44100))
+        self.assertRaises(TypeError, lambda: display.Audio(stereo_signal, rate=44100))
+
 
 @skipif_not_numpy
 def get_test_tone(scale=1):

IPython/lib/tests/test_latextools.py

@@ -5,7 +5,6 b''
 from contextlib import contextmanager
 from unittest.mock import patch
 
-import nose.tools as nt
 import pytest
 
 from IPython.lib import latextools
@@ -185,7 +184,13 b' def test_latex_to_png_invalid_hex_colors():'
     Test that invalid hex colors provided to dvipng gives an exception.
     """
     latex_string = "$x^2$"
-    nt.assert_raises(ValueError, lambda: latextools.latex_to_png(latex_string,
-                                        backend='dvipng', color="#f00bar"))
-    nt.assert_raises(ValueError, lambda: latextools.latex_to_png(latex_string,
-                                        backend='dvipng', color="#f00"))
+    pytest.raises(
+        ValueError,
+        lambda: latextools.latex_to_png(
+            latex_string, backend="dvipng", color="#f00bar"
+        ),
+    )
+    pytest.raises(
+        ValueError,
+        lambda: latextools.latex_to_png(latex_string, backend="dvipng", color="#f00"),
+    )

IPython/lib/tests/test_pretty.py

@@ -11,7 +11,6 b' import types'
 import string
 import unittest
 
-import nose.tools as nt
 import pytest
 
 from IPython.lib import pretty
@@ -70,7 +69,6 b' class BreakingRepr(object):'
         return "Breaking(\n)"
 
 class BadRepr(object):
-    
     def __repr__(self):
         return 1/0
 
@@ -178,7 +176,7 b' def test_pprint_break_repr():'
 
 def test_bad_repr():
     """Don't catch bad repr errors"""
-    with nt.assert_raises(ZeroDivisionError):
+    with pytest.raises(ZeroDivisionError):
         pretty.pretty(BadRepr())
 
 class BadException(Exception):
@@ -195,7 +193,7 b' class ReallyBadRepr(object):'
         raise BadException()
 
 def test_really_bad_repr():
-    with nt.assert_raises(BadException):
+    with pytest.raises(BadException):
         pretty.pretty(ReallyBadRepr())
 
 
@@ -293,7 +291,7 b' def test_basic_class():'
     output = stream.getvalue()
 
     assert output == "%s.MyObj" % __name__
-    nt.assert_true(type_pprint_wrapper.called)
+    assert type_pprint_wrapper.called is True
 
 
 # TODO : pytest.mark.parametrise once nose is gone.
@@ -478,7 +476,7 b' def test_function_pretty():'
             return 42
         return "Don't panic"
 
-    nt.assert_in('meaning_of_life(question=None)', pretty.pretty(meaning_of_life))
+    assert "meaning_of_life(question=None)" in pretty.pretty(meaning_of_life)
 
 
 class OrderedCounter(Counter, OrderedDict):
@@ -497,6 +495,6 b' class MySet(set): # Override repr of a basic type'
 def test_custom_repr():
     """A custom repr should override a pretty printer for a parent type"""
     oc = OrderedCounter("abracadabra")
-    nt.assert_in("OrderedCounter(OrderedDict", pretty.pretty(oc))
+    assert "OrderedCounter(OrderedDict" in pretty.pretty(oc)
 
     assert pretty.pretty(MySet()) == "mine"

IPython/terminal/tests/test_embed.py

@@ -14,7 +14,7 b''
 import os
 import subprocess
 import sys
-import nose.tools as nt
+
 from IPython.utils.tempdir import NamedFileInTemporaryDirectory
 from IPython.testing.decorators import skip_win32
 from IPython.testing import IPYTHON_TESTING_TIMEOUT_SCALE
@@ -55,12 +55,13 b' def test_ipython_embed():'
         out, err = p.communicate(_exit)
         std = out.decode('UTF-8')
 
-        nt.assert_equal(p.returncode, 0)
-        nt.assert_in('3 . 14', std)
-        if os.name != 'nt':
+        assert p.returncode == 0
+        assert "3 . 14" in std
+        if os.name != "nt":
             # TODO: Fix up our different stdout references, see issue gh-14
-            nt.assert_in('IPython', std)
-        nt.assert_in('bye!', std)
+            assert "IPython" in std
+        assert "bye!" in std
+
 
 @skip_win32
 def test_nest_embed():

IPython/terminal/tests/test_interactivshell.py

@@ -12,29 +12,42 b' from IPython.testing import tools as tt'
 from IPython.utils.capture import capture_output
 
 from IPython.terminal.ptutils import _elide, _adjust_completion_text_based_on_context
-import nose.tools as nt
 
-class TestElide(unittest.TestCase):
 
+class TestElide(unittest.TestCase):
     def test_elide(self):
-        _elide('concatenate((a1, a2, ...), axis', '') # do not raise
-        _elide('concatenate((a1, a2, ..), . axis', '') # do not raise
-        nt.assert_equal(_elide('aaaa.bbbb.ccccc.dddddd.eeeee.fffff.gggggg.hhhhhh',''), 'aaaa.b…g.hhhhhh')
-
-        test_string = os.sep.join(['', 10*'a', 10*'b', 10*'c', ''])
-        expect_stirng = os.sep + 'a' + '\N{HORIZONTAL ELLIPSIS}' + 'b' + os.sep + 10*'c'
-        nt.assert_equal(_elide(test_string, ''), expect_stirng)
+        _elide("concatenate((a1, a2, ...), axis", "")  # do not raise
+        _elide("concatenate((a1, a2, ..), . axis", "")  # do not raise
+        self.assertEqual(
+            _elide("aaaa.bbbb.ccccc.dddddd.eeeee.fffff.gggggg.hhhhhh", ""),
+            "aaaa.b…g.hhhhhh",
+        )
+
+        test_string = os.sep.join(["", 10 * "a", 10 * "b", 10 * "c", ""])
+        expect_stirng = (
+            os.sep + "a" + "\N{HORIZONTAL ELLIPSIS}" + "b" + os.sep + 10 * "c"
+        )
+        self.assertEqual(_elide(test_string, ""), expect_stirng)
 
     def test_elide_typed_normal(self):
-        nt.assert_equal(_elide('the quick brown fox jumped over the lazy dog', 'the quick brown fox', min_elide=10), 'the…fox jumped over the lazy dog')
-
+        self.assertEqual(
+            _elide(
+                "the quick brown fox jumped over the lazy dog",
+                "the quick brown fox",
+                min_elide=10,
+            ),
+            "the…fox jumped over the lazy dog",
+        )
 
     def test_elide_typed_short_match(self):
         """
         if the match is too short we don't elide.
         avoid the "the...the"
         """
-        nt.assert_equal(_elide('the quick brown fox jumped over the lazy dog', 'the', min_elide=10), 'the quick brown fox jumped over the lazy dog')
+        self.assertEqual(
+            _elide("the quick brown fox jumped over the lazy dog", "the", min_elide=10),
+            "the quick brown fox jumped over the lazy dog",
+        )
 
     def test_elide_typed_no_match(self):
         """
@@ -42,22 +55,41 b' class TestElide(unittest.TestCase):'
         avoid the "the...the"
         """
         # here we typed red instead of brown
-        nt.assert_equal(_elide('the quick brown fox jumped over the lazy dog', 'the quick red fox', min_elide=10), 'the quick brown fox jumped over the lazy dog')
+        self.assertEqual(
+            _elide(
+                "the quick brown fox jumped over the lazy dog",
+                "the quick red fox",
+                min_elide=10,
+            ),
+            "the quick brown fox jumped over the lazy dog",
+        )
 
-class TestContextAwareCompletion(unittest.TestCase):
 
+class TestContextAwareCompletion(unittest.TestCase):
     def test_adjust_completion_text_based_on_context(self):
         # Adjusted case
-        nt.assert_equal(_adjust_completion_text_based_on_context('arg1=', 'func1(a=)', 7), 'arg1')
+        self.assertEqual(
+            _adjust_completion_text_based_on_context("arg1=", "func1(a=)", 7), "arg1"
+        )
 
         # Untouched cases
-        nt.assert_equal(_adjust_completion_text_based_on_context('arg1=', 'func1(a)', 7), 'arg1=')
-        nt.assert_equal(_adjust_completion_text_based_on_context('arg1=', 'func1(a', 7), 'arg1=')
-        nt.assert_equal(_adjust_completion_text_based_on_context('%magic', 'func1(a=)', 7), '%magic')
-        nt.assert_equal(_adjust_completion_text_based_on_context('func2', 'func1(a=)', 7), 'func2')
+        self.assertEqual(
+            _adjust_completion_text_based_on_context("arg1=", "func1(a)", 7), "arg1="
+        )
+        self.assertEqual(
+            _adjust_completion_text_based_on_context("arg1=", "func1(a", 7), "arg1="
+        )
+        self.assertEqual(
+            _adjust_completion_text_based_on_context("%magic", "func1(a=)", 7), "%magic"
+        )
+        self.assertEqual(
+            _adjust_completion_text_based_on_context("func2", "func1(a=)", 7), "func2"
+        )
+
 
 # Decorator for interaction loop tests -----------------------------------------
 
+
 class mock_input_helper(object):
     """Machinery for tests of the main interact loop.
 

IPython/testing/tests/test_decorators.py

@@ -6,9 +6,6 b''
 import inspect
 import sys
 
-# Third party
-import nose.tools as nt
-
 # Our own
 from IPython.testing import decorators as dec
 from IPython.testing.skipdoctest import skip_doctest
@@ -95,7 +92,7 b' def test_skip_dt_decorator():'
     # Fetch the docstring from doctest_bad after decoration.
     val = doctest_bad.__doc__
     
-    nt.assert_equal(check,val,"doctest_bad docstrings don't match")
+    assert check == val, "doctest_bad docstrings don't match"
 
 
 # Doctest skipping should work for class methods too
@@ -156,13 +153,14 b' def test_skip_dt_decorator2():'
 
 @dec.skip_linux
 def test_linux():
-    nt.assert_false(sys.platform.startswith('linux'),"This test can't run under linux")
+    assert sys.platform.startswith("linux") is False, "This test can't run under linux"
+
 
 @dec.skip_win32
 def test_win32():
-    nt.assert_not_equal(sys.platform,'win32',"This test can't run under windows")
+    assert sys.platform != "win32", "This test can't run under windows"
+
 
 @dec.skip_osx
 def test_osx():
-    nt.assert_not_equal(sys.platform,'darwin',"This test can't run under osx")
-
+    assert sys.platform != "darwin", "This test can't run under osx"

IPython/testing/tests/test_tools.py

@@ -17,8 +17,6 b' Tests for testing.tools'
 import os
 import unittest
 
-import nose.tools as nt
-
 from IPython.testing import decorators as dec
 from IPython.testing import tools as tt
 
@@ -28,26 +26,26 b' from IPython.testing import tools as tt'
 
 @dec.skip_win32
 def test_full_path_posix():
-    spath = '/foo/bar.py'
-    result = tt.full_path(spath,['a.txt','b.txt'])
-    nt.assert_equal(result, ['/foo/a.txt', '/foo/b.txt'])
-    spath = '/foo'
-    result = tt.full_path(spath,['a.txt','b.txt'])
-    nt.assert_equal(result, ['/a.txt', '/b.txt'])
-    result = tt.full_path(spath,'a.txt')
-    nt.assert_equal(result, ['/a.txt'])
+    spath = "/foo/bar.py"
+    result = tt.full_path(spath, ["a.txt", "b.txt"])
+    assert result, ["/foo/a.txt" == "/foo/b.txt"]
+    spath = "/foo"
+    result = tt.full_path(spath, ["a.txt", "b.txt"])
+    assert result, ["/a.txt" == "/b.txt"]
+    result = tt.full_path(spath, "a.txt")
+    assert result == ["/a.txt"]
 
 
 @dec.skip_if_not_win32
 def test_full_path_win32():
-    spath = 'c:\\foo\\bar.py'
-    result = tt.full_path(spath,['a.txt','b.txt'])
-    nt.assert_equal(result, ['c:\\foo\\a.txt', 'c:\\foo\\b.txt'])
-    spath = 'c:\\foo'
-    result = tt.full_path(spath,['a.txt','b.txt'])
-    nt.assert_equal(result, ['c:\\a.txt', 'c:\\b.txt'])
-    result = tt.full_path(spath,'a.txt')
-    nt.assert_equal(result, ['c:\\a.txt'])
+    spath = "c:\\foo\\bar.py"
+    result = tt.full_path(spath, ["a.txt", "b.txt"])
+    assert result, ["c:\\foo\\a.txt" == "c:\\foo\\b.txt"]
+    spath = "c:\\foo"
+    result = tt.full_path(spath, ["a.txt", "b.txt"])
+    assert result, ["c:\\a.txt" == "c:\\b.txt"]
+    result = tt.full_path(spath, "a.txt")
+    assert result == ["c:\\a.txt"]
 
     
 def test_parser():
@@ -56,8 +54,8 b' def test_parser():'
     both = ("FAILED (errors=1, failures=1)", 1, 1)
     for txt, nerr, nfail in [err, fail, both]:
         nerr1, nfail1 = tt.parse_test_output(txt)
-        nt.assert_equal(nerr, nerr1)
-        nt.assert_equal(nfail, nfail1)
+        assert nerr == nerr1
+        assert nfail == nfail1
 
 
 def test_temp_pyfile():
@@ -66,7 +64,7 b' def test_temp_pyfile():'
     assert os.path.isfile(fname)
     with open(fname) as fh2:
         src2 = fh2.read()
-    nt.assert_equal(src2, src)
+    assert src2 == src
 
 class TestAssertPrints(unittest.TestCase):
     def test_passing(self):

IPython/utils/tests/test_dir2.py

@@ -1,6 +1,7 b''
-import nose.tools as nt
 from IPython.utils.dir2 import dir2
 
+import pytest
+
 
 class Base(object):
     x = 1
@@ -9,12 +10,13 b' class Base(object):'
 
 def test_base():
     res = dir2(Base())
-    assert ('x' in res)
-    assert ('z' in res)
-    assert ('y' not in res)
-    assert ('__class__' in res)
-    nt.assert_equal(res.count('x'), 1)
-    nt.assert_equal(res.count('__class__'), 1)
+    assert "x" in res
+    assert "z" in res
+    assert "y" not in res
+    assert "__class__" in res
+    assert res.count("x") == 1
+    assert res.count("__class__") == 1
+
 
 def test_SubClass():
 
@@ -22,9 +24,9 b' def test_SubClass():'
         y = 2
 
     res = dir2(SubClass())
-    assert ('y' in res)
-    nt.assert_equal(res.count('y'), 1)
-    nt.assert_equal(res.count('x'), 1)
+    assert "y" in res
+    assert res.count("y") == 1
+    assert res.count("x") == 1
 
 
 def test_SubClass_with_trait_names_attr():
@@ -35,24 +37,31 b' def test_SubClass_with_trait_names_attr():'
         trait_names = 44
 
     res = dir2(SubClass())
-    assert('trait_names' in res)
+    assert "trait_names" in res
 
 
 def test_misbehaving_object_without_trait_names():
     # dir2 shouldn't raise even when objects are dumb and raise
     # something other than AttribteErrors on bad getattr.
 
-    class MisbehavingGetattr(object):
-        def __getattr__(self):
+    class MisbehavingGetattr:
+        def __getattr__(self, attr):
             raise KeyError("I should be caught")
 
         def some_method(self):
-            pass
+            return True
 
     class SillierWithDir(MisbehavingGetattr):
         def __dir__(self):
             return ['some_method']
 
     for bad_klass in (MisbehavingGetattr, SillierWithDir):
-        res = dir2(bad_klass())
-        assert('some_method' in res)
+        obj = bad_klass()
+
+        assert obj.some_method()
+
+        with pytest.raises(KeyError):
+            obj.other_method()
+
+        res = dir2(obj)
+        assert "some_method" in res

IPython/utils/tests/test_importstring.py

@@ -11,7 +11,7 b''
 # Imports
 #-----------------------------------------------------------------------------
 
-import nose.tools as nt
+import pytest
 
 from IPython.utils.importstring import import_item
 
@@ -22,18 +22,19 b' from IPython.utils.importstring import import_item'
 def test_import_plain():
     "Test simple imports"
     import os
-    os2 = import_item('os')
-    nt.assert_true(os is os2)
+
+    os2 = import_item("os")
+    assert os is os2
 
 
 def test_import_nested():
     "Test nested imports from the stdlib"
     from os import path
-    path2 = import_item('os.path')
-    nt.assert_true(path is path2)
+
+    path2 = import_item("os.path")
+    assert path is path2
 
 
 def test_import_raises():
     "Test that failing imports raise the right exception"
-    nt.assert_raises(ImportError, import_item, 'IPython.foobar')
-    
+    pytest.raises(ImportError, import_item, "IPython.foobar")

IPython/utils/tests/test_io.py

@@ -11,8 +11,6 b' from io import StringIO'
 from subprocess import Popen, PIPE
 import unittest
 
-import nose.tools as nt
-
 from IPython.utils.io import IOStream, Tee, capture_output
 
 
@@ -22,7 +20,7 b' def test_tee_simple():'
     text = 'Hello'
     tee = Tee(chan, channel='stdout')
     print(text, file=chan)
-    nt.assert_equal(chan.getvalue(), text+"\n")
+    assert chan.getvalue() == text + "\n"
 
 
 class TeeTestCase(unittest.TestCase):
@@ -39,7 +37,7 b' class TeeTestCase(unittest.TestCase):'
 
         print(text, end='', file=chan)
         trap_val = trap.getvalue()
-        nt.assert_equal(chan.getvalue(), text)
+        self.assertEqual(chan.getvalue(), text)
 
         tee.close()
 
@@ -82,8 +80,8 b' class TestIOStream(unittest.TestCase):'
         """capture_output() context works"""
         
         with capture_output() as io:
-            print('hi, stdout')
-            print('hi, stderr', file=sys.stderr)
+            print("hi, stdout")
+            print("hi, stderr", file=sys.stderr)
         
-        nt.assert_equal(io.stdout, 'hi, stdout\n')
-        nt.assert_equal(io.stderr, 'hi, stderr\n')
+        self.assertEqual(io.stdout, "hi, stdout\n")
+        self.assertEqual(io.stderr, "hi, stderr\n")

IPython/utils/tests/test_module_paths.py

@@ -22,8 +22,6 b' from IPython.testing.tools import make_tempfile'
 
 import IPython.utils.module_paths as mp
 
-import nose.tools as nt
-
 TEST_FILE_PATH = Path(__file__).resolve().parent
 
 TMP_TEST_DIR = Path(tempfile.mkdtemp(suffix="with.dot"))
@@ -67,7 +65,7 b' def test_tempdir():'
     """
     Ensure the test are done with a temporary file that have a dot somewhere.
     """
-    nt.assert_in(".", str(TMP_TEST_DIR))
+    assert "." in str(TMP_TEST_DIR)
 
 
 def test_find_mod_1():
@@ -76,7 +74,7 b' def test_find_mod_1():'
     Expected output: a path to that directory's __init__.py file.
     """
     modpath = TMP_TEST_DIR / "xmod" / "__init__.py"
-    nt.assert_equal(Path(mp.find_mod("xmod")), modpath)
+    assert Path(mp.find_mod("xmod")) == modpath
 
 def test_find_mod_2():
     """
@@ -85,7 +83,7 b' def test_find_mod_2():'
     TODO: Confirm why this is a duplicate test.
     """
     modpath = TMP_TEST_DIR / "xmod" / "__init__.py"
-    nt.assert_equal(Path(mp.find_mod("xmod")), modpath)
+    assert Path(mp.find_mod("xmod")) == modpath
 
 def test_find_mod_3():
     """
@@ -93,7 +91,7 b' def test_find_mod_3():'
     Expected output: full path with .py extension.
     """
     modpath = TMP_TEST_DIR / "xmod" / "sub.py"
-    nt.assert_equal(Path(mp.find_mod("xmod.sub")), modpath)
+    assert Path(mp.find_mod("xmod.sub")) == modpath
 
 def test_find_mod_4():
     """
@@ -101,11 +99,11 b' def test_find_mod_4():'
     Expected output: full path with .py extension
     """
     modpath = TMP_TEST_DIR / "pack.py"
-    nt.assert_equal(Path(mp.find_mod("pack")), modpath)
+    assert Path(mp.find_mod("pack")) == modpath
 
 def test_find_mod_5():
     """
     Search for a filename with a .pyc extension
     Expected output: TODO: do we exclude or include .pyc files?
     """
-    nt.assert_equal(mp.find_mod("packpyc"), None)
+    assert mp.find_mod("packpyc") == None

IPython/utils/tests/test_openpy.py

@@ -1,6 +1,5 b''
 import io
 import os.path
-import nose.tools as nt
 
 from IPython.utils import openpy
 
@@ -11,14 +10,14 b' nonascii_path = os.path.join(mydir, "../../core/tests/nonascii.py")'
 def test_detect_encoding():
     with open(nonascii_path, "rb") as f:
         enc, lines = openpy.detect_encoding(f.readline)
-    nt.assert_equal(enc, "iso-8859-5")
+    assert enc == "iso-8859-5"
 
 
 def test_read_file():
     with io.open(nonascii_path, encoding="iso-8859-5") as f:
         read_specified_enc = f.read()
     read_detected_enc = openpy.read_py_file(nonascii_path, skip_encoding_cookie=False)
-    nt.assert_equal(read_detected_enc, read_specified_enc)
+    assert read_detected_enc == read_specified_enc
     assert "coding: iso-8859-5" in read_detected_enc
 
     read_strip_enc_cookie = openpy.read_py_file(
@@ -30,10 +29,10 b' def test_read_file():'
 def test_source_to_unicode():
     with io.open(nonascii_path, "rb") as f:
         source_bytes = f.read()
-    nt.assert_equal(
-        openpy.source_to_unicode(source_bytes, skip_encoding_cookie=False).splitlines(),
-        source_bytes.decode("iso-8859-5").splitlines(),
+    assert (
+        openpy.source_to_unicode(source_bytes, skip_encoding_cookie=False).splitlines()
+        == source_bytes.decode("iso-8859-5").splitlines()
     )
 
     source_no_cookie = openpy.source_to_unicode(source_bytes, skip_encoding_cookie=True)
-    nt.assert_not_in("coding: iso-8859-5", source_no_cookie)
+    assert "coding: iso-8859-5" not in source_no_cookie

IPython/utils/tests/test_path.py

@@ -15,7 +15,7 b' from os.path import join, abspath'
 from imp import reload
 
 from nose import SkipTest, with_setup
-import nose.tools as nt
+import pytest
 
 import IPython
 from IPython import paths
@@ -155,7 +155,7 b' def test_get_home_dir_5():'
     env['HOME'] = abspath(HOME_TEST_DIR+'garbage')
     # set os.name = posix, to prevent My Documents fallback on Windows
     os.name = 'posix'
-    nt.assert_raises(path.HomeDirError, path.get_home_dir, True)
+    pytest.raises(path.HomeDirError, path.get_home_dir, True)
 
 # Should we stub wreg fully so we can run the test on all platforms?
 @skip_if_not_win32
@@ -237,8 +237,7 b' def test_get_xdg_dir_3():'
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
     cfgdir=os.path.join(path.get_home_dir(), '.config')
-    if not os.path.exists(cfgdir):
-        os.makedirs(cfgdir)
+    os.makedirs(cfgdir, exist_ok=True)
 
     assert path.get_xdg_dir() is None
 
@@ -305,15 +304,15 b' def test_get_py_filename():'
         assert path.get_py_filename("foo") == "foo.py"
     with make_tempfile("foo"):
         assert path.get_py_filename("foo") == "foo"
-        nt.assert_raises(IOError, path.get_py_filename, "foo.py")
-    nt.assert_raises(IOError, path.get_py_filename, "foo")
-    nt.assert_raises(IOError, path.get_py_filename, "foo.py")
+        pytest.raises(IOError, path.get_py_filename, "foo.py")
+    pytest.raises(IOError, path.get_py_filename, "foo")
+    pytest.raises(IOError, path.get_py_filename, "foo.py")
     true_fn = "foo with spaces.py"
     with make_tempfile(true_fn):
         assert path.get_py_filename("foo with spaces") == true_fn
         assert path.get_py_filename("foo with spaces.py") == true_fn
-        nt.assert_raises(IOError, path.get_py_filename, '"foo with spaces.py"')
-        nt.assert_raises(IOError, path.get_py_filename, "'foo with spaces.py'")
+        pytest.raises(IOError, path.get_py_filename, '"foo with spaces.py"')
+        pytest.raises(IOError, path.get_py_filename, "'foo with spaces.py'")
 
 @onlyif_unicode_paths
 def test_unicode_in_filename():
@@ -414,7 +413,7 b' def test_ensure_dir_exists():'
         path.ensure_dir_exists(d) # no-op
         f = os.path.join(td, 'ƒile')
         open(f, 'w').close() # touch
-        with nt.assert_raises(IOError):
+        with pytest.raises(IOError):
             path.ensure_dir_exists(f)
 
 class TestLinkOrCopy(unittest.TestCase):

IPython/utils/tests/test_process.py

@@ -20,9 +20,8 b' import os'
 import time
 from _thread import interrupt_main  # Py 3
 import threading
-from unittest import SkipTest
 
-import nose.tools as nt
+import pytest
 
 from IPython.utils.process import (find_cmd, FindCmdError, arg_split,
                                    system, getoutput, getoutputerror,
@@ -41,8 +40,8 b' python = os.path.basename(sys.executable)'
 @dec.skip_win32
 def test_find_cmd_ls():
     """Make sure we can find the full path to ls."""
-    path = find_cmd('ls')
-    nt.assert_true(path.endswith('ls'))
+    path = find_cmd("ls")
+    assert path.endswith("ls")
 
     
 def has_pywin32():
@@ -64,7 +63,7 b' def test_find_cmd_pythonw():'
             "This test runs on posix or in win32 with win32api installed")
 def test_find_cmd_fail():
     """Make sure that FindCmdError is raised if we can't find the cmd."""
-    nt.assert_raises(FindCmdError,find_cmd,'asdfasdf')
+    pytest.raises(FindCmdError, find_cmd, "asdfasdf")
 
 
 # TODO: move to pytest.mark.parametrize once nose gone
@@ -121,7 +120,7 b' class SubProcessTestCase(tt.TempFileMixin):'
         Interrupt a subprocess after a second.
         """
         if threading.main_thread() != threading.current_thread():
-            raise nt.SkipTest("Can't run this test if not in main thread.")
+            raise pytest.skip("Can't run this test if not in main thread.")
 
         # Some tests can overwrite SIGINT handler (by using pdb for example),
         # which then breaks this test, so just make sure it's operating

IPython/utils/tests/test_pycolorize.py

@@ -17,9 +17,6 b' Authors'
 # Imports
 #-----------------------------------------------------------------------------
 
-# third party
-import nose.tools as nt
-
 from IPython.testing.decorators import skip_iptest_but_not_pytest
 
 # our own
@@ -65,7 +62,7 b' def test_parse_sample(style):'
     buf.seek(0)
     f1 = buf.read()
 
-    nt.assert_not_in("ERROR", f1)
+    assert "ERROR" not in f1
 
 
 @skip_iptest_but_not_pytest
@@ -73,4 +70,4 b' def test_parse_error(style):'
     p = Parser(style=style)
     f1 = p.format(")", "str")
     if style != "NoColor":
-        nt.assert_in("ERROR", f1)
+        assert "ERROR" in f1

IPython/utils/tests/test_sysinfo.py

@@ -5,7 +5,6 b''
 # Distributed under the terms of the Modified BSD License.
 
 import json
-import nose.tools as nt
 
 from IPython.utils import sysinfo
 

IPython/utils/tests/test_text.py

@@ -17,9 +17,10 b' import math'
 import random
 import sys
 
-import nose.tools as nt
 from pathlib import Path
 
+import pytest
+
 from IPython.utils import text
 
 #-----------------------------------------------------------------------------
@@ -117,7 +118,8 b' def eval_formatter_check(f):'
     # This decodes in a platform dependent manner, but it shouldn't error out
     s = f.format("{b}", **ns)
         
-    nt.assert_raises(NameError, f.format, '{dne}', **ns)
+    pytest.raises(NameError, f.format, "{dne}", **ns)
+
 
 def eval_formatter_slicing_check(f):
     ns = dict(n=12, pi=math.pi, stuff='hello there', os=os)
@@ -128,7 +130,7 b' def eval_formatter_slicing_check(f):'
     s = f.format("{stuff[::2]}", **ns)
     assert s == ns["stuff"][::2]
 
-    nt.assert_raises(SyntaxError, f.format, "{n:x}", **ns)
+    pytest.raises(SyntaxError, f.format, "{n:x}", **ns)
 
 def eval_formatter_no_slicing_check(f):
     ns = dict(n=12, pi=math.pi, stuff='hello there', os=os)
@@ -194,7 +196,7 b' def test_LSString():'
     assert lss.l == ["abc", "def"]
     assert lss.s == "abc def"
     lss = text.LSString(os.getcwd())
-    nt.assert_is_instance(lss.p[0], Path)
+    assert isinstance(lss.p[0], Path)
 
 def test_SList():
     sl = text.SList(["a 11", "b 1", "a 2"])

IPython/utils/tests/test_tokenutil.py

@@ -2,7 +2,6 b''
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-import nose.tools as nt
 import pytest
 from IPython.testing.decorators import skip_iptest_but_not_pytest
 
@@ -17,12 +16,15 b' def expect_token(expected, cell, cursor_pos):'
         else:
             offset += len(line)+1
     column = cursor_pos - offset
-    line_with_cursor = '%s|%s' % (line[:column], line[column:])
-    nt.assert_equal(token, expected,
-        "Expected %r, got %r in: %r (pos %i)" % (
-        expected, token, line_with_cursor, cursor_pos)
+    line_with_cursor = "%s|%s" % (line[:column], line[column:])
+    assert token == expected, "Expected %r, got %r in: %r (pos %i)" % (
+        expected,
+        token,
+        line_with_cursor,
+        cursor_pos,
     )
 
+
 def test_simple(): 
     cell = "foo"
     for i in range(len(cell)):
@@ -107,20 +109,20 b' def test_attrs():'
 def test_line_at_cursor():
     cell = ""
     (line, offset) = line_at_cursor(cell, cursor_pos=11)
-    nt.assert_equal(line, "")
-    nt.assert_equal(offset, 0)
+    assert line == ""
+    assert offset == 0
 
     # The position after a newline should be the start of the following line.
     cell = "One\nTwo\n"
     (line, offset) = line_at_cursor(cell, cursor_pos=4)
-    nt.assert_equal(line, "Two\n")
-    nt.assert_equal(offset, 4)
+    assert line == "Two\n"
+    assert offset == 4
 
     # The end of a cell should be on the last line
     cell = "pri\npri"
     (line, offset) = line_at_cursor(cell, cursor_pos=7)
-    nt.assert_equal(line, "pri")
-    nt.assert_equal(offset, 4)
+    assert line == "pri"
+    assert offset == 4
 
 
 @pytest.mark.parametrize(

MANIFEST.in

@@ -8,6 +8,7 b' include pytest.ini'
 include mypy.ini
 include .mailmap
 include .flake8
+include .pre-commit-config.yaml
 
 recursive-exclude tools *
 exclude tools

setup.py

@@ -176,6 +176,7 b' extras_require = dict('
     doc=["Sphinx>=1.3"],
     test=[
         "nose>=0.10.1",
+        "pytest",
         "requests",
         "testpath",
         "pygments",