Remove iptest and other Nose-dependent code

.github/workflows/test.yml

@@ -38,11 +38,6 b' jobs:'
         python -m pip install --upgrade check-manifest pytest-cov anyio
     - name: Check manifest
       run: check-manifest
-    - name: iptest
-      run: |
-        cd /tmp && iptest --coverage xml && cd -
-        cp /tmp/ipy_coverage.xml ./
-        cp /tmp/.coverage ./
     - name: pytest
       env:
         COLUMNS: 120

CONTRIBUTING.md

@@ -76,20 +76,15 b' For more detailed information, see our [GitHub Workflow](https://github.com/ipyt'
 
 All the tests can be run by using
 ```shell
-iptest
+pytest
 ```
 
 All the tests for a single module (for example **test_alias**) can be run by using the fully qualified path to the module.
 ```shell
-iptest IPython.core.tests.test_alias
+pytest IPython/core/tests/test_alias.py
 ```
 
-Only a single test (for example **test_alias_lifecycle**) within a single file can be run by adding the specific test after a `:` at the end:
+Only a single test (for example **test_alias_lifecycle**) within a single file can be run by adding the specific test after a `::` at the end:
 ```shell
-iptest IPython.core.tests.test_alias:test_alias_lifecycle
-```
-
-For convenience, the full path to a file can often be used instead of the module path on unix systems. For example we can run all the tests by using
-```shell
-iptest IPython/core/tests/test_alias.py
+pytest IPython/core/tests/test_alias.py::test_alias_lifecycle
 ```

IPython/__init__.py

@@ -51,7 +51,6 b' from .core.application import Application'
 from .terminal.embed import embed
 
 from .core.interactiveshell import InteractiveShell
-from .testing import test
 from .utils.sysinfo import sys_info
 from .utils.frame import extract_module_locals
 

IPython/core/tests/test_completer.py

@@ -5,6 +5,7 b''
 # Distributed under the terms of the Modified BSD License.
 
 import os
+import pytest
 import sys
 import textwrap
 import unittest
@@ -14,7 +15,6 b' from contextlib import contextmanager'
 from traitlets.config.loader import Config
 from IPython import get_ipython
 from IPython.core import completer
-from IPython.external import decorators
 from IPython.utils.tempdir import TemporaryDirectory, TemporaryWorkingDirectory
 from IPython.utils.generics import complete_object
 from IPython.testing import decorators as dec
@@ -317,8 +317,8 b' class TestCompleter(unittest.TestCase):'
         self.assertEqual(matches, ["\u2164"])  # same as above but explicit.
 
     @unittest.skip("now we have a completion for \jmath")
-    @decorators.knownfailureif(
-        sys.platform == "win32", "Fails if there is a C:\\j... path"
+    @pytest.mark.xfail(
+        sys.platform == "win32", reason="Fails if there is a C:\\j... path"
     )
     def test_no_ascii_back_completion(self):
         ip = get_ipython()
@@ -357,8 +357,8 b' class TestCompleter(unittest.TestCase):'
         for s in ['""', '""" """', '"hi" "ipython"']:
             self.assertFalse(completer.has_open_quotes(s))
 
-    @decorators.knownfailureif(
-        sys.platform == "win32", "abspath completions fail on Windows"
+    @pytest.mark.xfail(
+        sys.platform == "win32", reason="abspath completions fail on Windows"
     )
     def test_abspath_file_completions(self):
         ip = get_ipython()

IPython/core/tests/test_magic.py

@@ -1,8 +1,5 b''
 # -*- coding: utf-8 -*-
-"""Tests for various magic functions.
-
-Needs to be run by nose (to make ipython session available).
-"""
+"""Tests for various magic functions."""
 
 import asyncio
 import io

IPython/core/tests/test_magic_terminal.py

@@ -1,7 +1,4 b''
-"""Tests for various magic functions specific to the terminal frontend.
-
-Needs to be run by nose (to make ipython session available).
-"""
+"""Tests for various magic functions specific to the terminal frontend."""
 
 #-----------------------------------------------------------------------------
 # Imports

IPython/core/tests/test_run.py

@@ -125,6 +125,9 b' def doctest_run_option_parser_for_posix():'
     """
 
 
+doctest_run_option_parser_for_posix.__skip_doctest__ = sys.platform == "win32"
+
+
 @dec.skip_if_not_win32
 def doctest_run_option_parser_for_windows():
     r"""Test option parser in %run (Windows specific).
@@ -132,16 +135,19 b' def doctest_run_option_parser_for_windows():'
     In Windows, you can't escape ``*` `by backslash:
 
     In [1]: %run print_argv.py print\\*.py
-    ['print\\*.py']
+    ['print\\\\*.py']
 
     You can use quote to escape glob:
 
     In [2]: %run print_argv.py 'print*.py'
-    ['print*.py']
+    ["'print*.py'"]
 
     """
 
 
+doctest_run_option_parser_for_windows.__skip_doctest__ = sys.platform != "win32"
+
+
 def doctest_reset_del():
     """Test that resetting doesn't cause errors in __del__ methods.
 
@@ -556,7 +562,6 b' def test_multiprocessing_run():'
     """
     with TemporaryDirectory() as td:
         mpm = sys.modules.get('__mp_main__')
-        assert mpm is not None
         sys.modules['__mp_main__'] = None
         try:
             path = pjoin(td, 'test.py')
@@ -575,7 +580,7 b' def test_multiprocessing_run():'
         finally:
             sys.modules['__mp_main__'] = mpm
 
[e-mail](sys.platform == 'win32', "writes to io.stdout aren't captured on Windows")
+
 def test_script_tb():
     """Test traceback offset in `ipython script.py`"""
     with TemporaryDirectory() as td:

IPython/testing/__init__.py

@@ -12,38 +12,9 b''
 import os
 
 #-----------------------------------------------------------------------------
-# Functions
-#-----------------------------------------------------------------------------
-
-# User-level entry point for testing
-def test(**kwargs):
-    """Run the entire IPython test suite.
-
-    Any of the options for run_iptestall() may be passed as keyword arguments.
-
-    For example::
-    
-        IPython.test(testgroups=['lib', 'config', 'utils'], fast=2)
-    
-    will run those three sections of the test suite, using two processes.
-    """
-
-    # Do the import internally, so that this function doesn't increase total
-    # import time
-    from .iptestcontroller import run_iptestall, default_options
-    options = default_options()
-    for name, val in kwargs.items():
-        setattr(options, name, val)
-    run_iptestall(options)
-
-#-----------------------------------------------------------------------------
 # Constants
 #-----------------------------------------------------------------------------
 
 # We scale all timeouts via this factor, slow machines can increase it
 IPYTHON_TESTING_TIMEOUT_SCALE = float(os.getenv(
                                     'IPYTHON_TESTING_TIMEOUT_SCALE', 1))
-
-# So nose doesn't try to run this as a test itself and we end up with an
-# infinite test loop
-test.__test__ = False

IPython/testing/decorators.py

@@ -44,11 +44,6 b' from decorator import decorator'
 # Expose the unittest-driven decorators
 from .ipunittest import ipdoctest, ipdocstring
 
-# Grab the numpy-specific decorators which we keep in a file that we
-# occasionally update from upstream: decorators.py is a copy of
-# numpy.testing.decorators, we expose all of it here.
-from IPython.external.decorators import knownfailureif
-
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
@@ -165,11 +160,8 b' def skip_iptest_but_not_pytest(f):'
     return f
 
 
-# Inspired by numpy's skipif, but uses the full apply_wrapper utility to
-# preserve function metadata better and allows the skip condition to be a
-# callable.
 def skipif(skip_condition, msg=None):
-    ''' Make function raise SkipTest exception if skip_condition is true
+    """Make function raise SkipTest exception if skip_condition is true
 
     Parameters
     ----------
@@ -188,57 +180,15 b' def skipif(skip_condition, msg=None):'
       Decorator, which, when applied to a function, causes SkipTest
       to be raised when the skip_condition was True, and the function
       to be called normally otherwise.
+    """
+    if msg is None:
+        msg = "Test skipped due to test condition."
 
-    Notes
-    -----
-    You will see from the code that we had to further decorate the
-    decorator with the nose.tools.make_decorator function in order to
-    transmit function name, and various other metadata.
-    '''
-
-    def skip_decorator(f):
-        # Local import to avoid a hard nose dependency and only incur the
-        # import time overhead at actual test-time.
-        import nose
-
-        # Allow for both boolean or callable skip conditions.
-        if callable(skip_condition):
-            skip_val = skip_condition
-        else:
-            skip_val = lambda : skip_condition
-
-        def get_msg(func,msg=None):
-            """Skip message with information about function being skipped."""
-            if msg is None: out = 'Test skipped due to test condition.'
-            else: out = msg
-            return "Skipping test: %s. %s" % (func.__name__,out)
-
-        # We need to define *two* skippers because Python doesn't allow both
-        # return with value and yield inside the same function.
-        def skipper_func(*args, **kwargs):
-            """Skipper for normal test functions."""
-            if skip_val():
-                raise nose.SkipTest(get_msg(f,msg))
-            else:
-                return f(*args, **kwargs)
-
-        def skipper_gen(*args, **kwargs):
-            """Skipper for test generators."""
-            if skip_val():
-                raise nose.SkipTest(get_msg(f,msg))
-            else:
-                for x in f(*args, **kwargs):
-                    yield x
-
-        # Choose the right skipper to use when building the actual generator.
-        if nose.util.isgenerator(f):
-            skipper = skipper_gen
-        else:
-            skipper = skipper_func
+    import pytest
 
-        return nose.tools.make_decorator(f)(skipper)
+    assert isinstance(skip_condition, bool)
+    return pytest.mark.skipif(skip_condition, reason=msg)
 
-    return skip_decorator
 
 # A version with the condition set to true, common case just to attach a message
 # to a skip decorator
@@ -265,12 +215,7 b' def skip(msg=None):'
 def onlyif(condition, msg):
     """The reverse from skipif, see skipif for details."""
 
-    if callable(condition):
-        skip_condition = lambda : not condition()
-    else:
-        skip_condition = lambda : not condition
-
-    return skipif(skip_condition, msg)
+    return skipif(not condition, msg)
 
 #-----------------------------------------------------------------------------
 # Utility functions for decorators
@@ -351,8 +296,6 b" skipif_not_matplotlib = skip_without('matplotlib')"
 
 skipif_not_sympy = skip_without('sympy')
 
-skip_known_failure = knownfailureif(True,'This test is known to fail')
-
 # A null 'decorator', useful to make more readable code that needs to pick
 # between different decorators based on OS or other conditions
 null_deco = lambda f: f

IPython/testing/plugin/ipdoctest.py

@@ -19,35 +19,14 b' Limitations:'
 # Module imports
 
 # From the standard library
-import builtins as builtin_mod
 import doctest
 import inspect
 import logging
 import os
 import re
-import sys
-from importlib import import_module
-from io import StringIO
 
 from testpath import modified_env
 
-from inspect import getmodule
-
-from pathlib import Path, PurePath
-
-# We are overriding the default doctest runner, so we need to import a few
-# things from doctest directly
-from doctest import (REPORTING_FLAGS, REPORT_ONLY_FIRST_FAILURE,
-                     _unittest_reportflags, DocTestRunner,
-                     _extract_future_flags, pdb, _OutputRedirectingPdb,
-                     _exception_traceback,
-                     linecache)
-
-# Third-party modules
-
-from nose.plugins import doctests, Plugin
-from nose.util import anyp, tolist
-
 #-----------------------------------------------------------------------------
 # Module globals and other constants
 #-----------------------------------------------------------------------------
@@ -195,129 +174,6 b' class IPDoctestOutputChecker(doctest.OutputChecker):'
         return ret
 
 
-class DocTestCase(doctests.DocTestCase):
-    """Proxy for DocTestCase: provides an address() method that
-    returns the correct address for the doctest case. Otherwise
-    acts as a proxy to the test case. To provide hints for address(),
-    an obj may also be passed -- this will be used as the test object
-    for purposes of determining the test address, if it is provided.
-    """
-
-    # Note: this method was taken from numpy's nosetester module.
-
-    # Subclass nose.plugins.doctests.DocTestCase to work around a bug in
-    # its constructor that blocks non-default arguments from being passed
-    # down into doctest.DocTestCase
-
-    def __init__(self, test, optionflags=0, setUp=None, tearDown=None,
-                 checker=None, obj=None, result_var='_'):
-        self._result_var = result_var
-        doctests.DocTestCase.__init__(self, test,
-                                      optionflags=optionflags,
-                                      setUp=setUp, tearDown=tearDown,
-                                      checker=checker)
-        # Now we must actually copy the original constructor from the stdlib
-        # doctest class, because we can't call it directly and a bug in nose
-        # means it never gets passed the right arguments.
-
-        self._dt_optionflags = optionflags
-        self._dt_checker = checker
-        self._dt_test = test
-        self._dt_test_globs_ori = test.globs
-        self._dt_setUp = setUp
-        self._dt_tearDown = tearDown
-
-        # XXX - store this runner once in the object!
-        runner = IPDocTestRunner(optionflags=optionflags,
-                                 checker=checker, verbose=False)
-        self._dt_runner = runner
-
-
-        # Each doctest should remember the directory it was loaded from, so
-        # things like %run work without too many contortions
-        self._ori_dir = os.path.dirname(test.filename)
-
-    # Modified runTest from the default stdlib
-    def runTest(self):
-        test = self._dt_test
-        runner = self._dt_runner
-
-        old = sys.stdout
-        new = StringIO()
-        optionflags = self._dt_optionflags
-
-        if not (optionflags & REPORTING_FLAGS):
-            # The option flags don't include any reporting flags,
-            # so add the default reporting flags
-            optionflags |= _unittest_reportflags
-
-        try:
-            # Save our current directory and switch out to the one where the
-            # test was originally created, in case another doctest did a
-            # directory change.  We'll restore this in the finally clause.
-            curdir = os.getcwd()
-            #print 'runTest in dir:', self._ori_dir  # dbg
-            os.chdir(self._ori_dir)
-
-            runner.DIVIDER = "-"*70
-            failures, tries = runner.run(test,out=new.write,
-                                         clear_globs=False)
-        finally:
-            sys.stdout = old
-            os.chdir(curdir)
-
-        if failures:
-            raise self.failureException(self.format_failure(new.getvalue()))
-
-    def setUp(self):
-        """Modified test setup that syncs with ipython namespace"""
-        #print "setUp test", self._dt_test.examples # dbg
-        if isinstance(self._dt_test.examples[0], IPExample):
-            # for IPython examples *only*, we swap the globals with the ipython
-            # namespace, after updating it with the globals (which doctest
-            # fills with the necessary info from the module being tested).
-            self.user_ns_orig = {}
-            self.user_ns_orig.update(_ip.user_ns)
-            _ip.user_ns.update(self._dt_test.globs)
-            # We must remove the _ key in the namespace, so that Python's
-            # doctest code sets it naturally
-            _ip.user_ns.pop('_', None)
-            _ip.user_ns['__builtins__'] = builtin_mod
-            self._dt_test.globs = _ip.user_ns
-
-        super(DocTestCase, self).setUp()
-
-    def tearDown(self):
-
-        # Undo the test.globs reassignment we made, so that the parent class
-        # teardown doesn't destroy the ipython namespace
-        if isinstance(self._dt_test.examples[0], IPExample):
-            self._dt_test.globs = self._dt_test_globs_ori
-            _ip.user_ns.clear()
-            _ip.user_ns.update(self.user_ns_orig)
-
-        # XXX - fperez: I am not sure if this is truly a bug in nose 0.11, but
-        # it does look like one to me: its tearDown method tries to run
-        #
-        # delattr(builtin_mod, self._result_var)
-        #
-        # without checking that the attribute really is there; it implicitly
-        # assumes it should have been set via displayhook.  But if the
-        # displayhook was never called, this doesn't necessarily happen.  I
-        # haven't been able to find a little self-contained example outside of
-        # ipython that would show the problem so I can report it to the nose
-        # team, but it does happen a lot in our code.
-        #
-        # So here, we just protect as narrowly as possible by trapping an
-        # attribute error whose message would be the name of self._result_var,
-        # and letting any other error propagate.
-        try:
-            super(DocTestCase, self).tearDown()
-        except AttributeError as exc:
-            if exc.args[0] != self._result_var:
-                raise
-
-
 # A simple subclassing of the original with a different class name, so we can
 # distinguish and treat differently IPython examples from pure python ones.
 class IPExample(doctest.Example): pass
@@ -594,169 +450,3 b' class DocFileCase(doctest.DocFileCase):'
     """
     def address(self):
         return (self._dt_test.filename, None, None)
-
-
-class ExtensionDoctest(doctests.Doctest):
-    """Nose Plugin that supports doctests in extension modules.
-    """
-    name = 'extdoctest'   # call nosetests with --with-extdoctest
-    enabled = True
-
-    def options(self, parser, env=os.environ):
-        Plugin.options(self, parser, env)
-        parser.add_option('--doctest-tests', action='store_true',
-                          dest='doctest_tests',
-                          default=env.get('NOSE_DOCTEST_TESTS',True),
-                          help="Also look for doctests in test modules. "
-                          "Note that classes, methods and functions should "
-                          "have either doctests or non-doctest tests, "
-                          "not both. [NOSE_DOCTEST_TESTS]")
-        parser.add_option('--doctest-extension', action="append",
-                          dest="doctestExtension",
-                          help="Also look for doctests in files with "
-                          "this extension [NOSE_DOCTEST_EXTENSION]")
-        # Set the default as a list, if given in env; otherwise
-        # an additional value set on the command line will cause
-        # an error.
-        env_setting = env.get('NOSE_DOCTEST_EXTENSION')
-        if env_setting is not None:
-            parser.set_defaults(doctestExtension=tolist(env_setting))
-
-
-    def configure(self, options, config):
-        Plugin.configure(self, options, config)
-        # Pull standard doctest plugin out of config; we will do doctesting
-        config.plugins.plugins = [p for p in config.plugins.plugins
-                                  if p.name != 'doctest']
-        self.doctest_tests = options.doctest_tests
-        self.extension = tolist(options.doctestExtension)
-
-        self.parser = doctest.DocTestParser()
-        self.finder = DocTestFinder()
-        self.checker = IPDoctestOutputChecker()
-        self.globs = None
-        self.extraglobs = None
-
-
-    def loadTestsFromExtensionModule(self,filename):
-        bpath,mod = os.path.split(filename)
-        modname = os.path.splitext(mod)[0]
-        try:
-            sys.path.append(bpath)
-            module = import_module(modname)
-            tests = list(self.loadTestsFromModule(module))
-        finally:
-            sys.path.pop()
-        return tests
-
-    # NOTE: the method below is almost a copy of the original one in nose, with
-    # a  few modifications to control output checking.
-
-    def loadTestsFromModule(self, module):
-        #print '*** ipdoctest - lTM',module  # dbg
-
-        if not self.matches(module.__name__):
-            log.debug("Doctest doesn't want module %s", module)
-            return
-
-        tests = self.finder.find(module,globs=self.globs,
-                                 extraglobs=self.extraglobs)
-        if not tests:
-            return
-
-        # always use whitespace and ellipsis options
-        optionflags = doctest.NORMALIZE_WHITESPACE | doctest.ELLIPSIS
-
-        tests.sort()
-        module_file = module.__file__
-        if module_file[-4:] in ('.pyc', '.pyo'):
-            module_file = module_file[:-1]
-        for test in tests:
-            if not test.examples:
-                continue
-            if not test.filename:
-                test.filename = module_file
-
-            yield DocTestCase(test,
-                              optionflags=optionflags,
-                              checker=self.checker)
-
-
-    def loadTestsFromFile(self, filename):
-        #print "ipdoctest - from file", filename # dbg
-        if is_extension_module(filename):
-            for t in self.loadTestsFromExtensionModule(filename):
-                yield t
-        else:
-            if self.extension and anyp(filename.endswith, self.extension):
-                name = PurePath(filename).name
-                doc = Path(filename).read_text()
-                test = self.parser.get_doctest(
-                    doc, globs={'__file__': filename}, name=name,
-                    filename=filename, lineno=0)
-                if test.examples:
-                    #print 'FileCase:',test.examples  # dbg
-                    yield DocFileCase(test)
-                else:
-                    yield False # no tests to load
-
-
-class IPythonDoctest(ExtensionDoctest):
-    """Nose Plugin that supports doctests in extension modules.
-    """
-    name = 'ipdoctest'   # call nosetests with --with-ipdoctest
-    enabled = True
-
-    def makeTest(self, obj, parent):
-        """Look for doctests in the given object, which will be a
-        function, method or class.
-        """
-        #print 'Plugin analyzing:', obj, parent  # dbg
-        # always use whitespace and ellipsis options
-        optionflags = doctest.NORMALIZE_WHITESPACE | doctest.ELLIPSIS
-
-        doctests = self.finder.find(obj, module=getmodule(parent))
-        if doctests:
-            for test in doctests:
-                if len(test.examples) == 0:
-                    continue
-
-                yield DocTestCase(test, obj=obj,
-                                  optionflags=optionflags,
-                                  checker=self.checker)
-
-    def options(self, parser, env=os.environ):
-        #print "Options for nose plugin:", self.name # dbg
-        Plugin.options(self, parser, env)
-        parser.add_option('--ipdoctest-tests', action='store_true',
-                          dest='ipdoctest_tests',
-                          default=env.get('NOSE_IPDOCTEST_TESTS',True),
-                          help="Also look for doctests in test modules. "
-                          "Note that classes, methods and functions should "
-                          "have either doctests or non-doctest tests, "
-                          "not both. [NOSE_IPDOCTEST_TESTS]")
-        parser.add_option('--ipdoctest-extension', action="append",
-                          dest="ipdoctest_extension",
-                          help="Also look for doctests in files with "
-                          "this extension [NOSE_IPDOCTEST_EXTENSION]")
-        # Set the default as a list, if given in env; otherwise
-        # an additional value set on the command line will cause
-        # an error.
-        env_setting = env.get('NOSE_IPDOCTEST_EXTENSION')
-        if env_setting is not None:
-            parser.set_defaults(ipdoctest_extension=tolist(env_setting))
-
-    def configure(self, options, config):
-        #print "Configuring nose plugin:", self.name # dbg
-        Plugin.configure(self, options, config)
-        # Pull standard doctest plugin out of config; we will do doctesting
-        config.plugins.plugins = [p for p in config.plugins.plugins
-                                  if p.name != 'doctest']
-        self.doctest_tests = options.ipdoctest_tests
-        self.extension = tolist(options.ipdoctest_extension)
-
-        self.parser = IPDocTestParser()
-        self.finder = DocTestFinder(parser=self.parser)
-        self.checker = IPDoctestOutputChecker()
-        self.globs = None
-        self.extraglobs = None

IPython/utils/tests/test_path.py

@@ -14,7 +14,6 b' from unittest.mock import patch'
 from os.path import join, abspath
 from imp import reload
 
-from nose import SkipTest, with_setup
 import pytest
 
 import IPython
@@ -98,8 +97,17 b' def teardown_environment():'
     if hasattr(sys, 'frozen'):
         del sys.frozen
 
+
 # Build decorator that uses the setup_environment/setup_environment
-with_environment = with_setup(setup_environment, teardown_environment)
[e-mail]
+def environment():
+    setup_environment()
+    yield
+    teardown_environment()
+
+
+with_environment = pytest.mark.usefixtures("environment")
+
 
 @skip_if_not_win32
 @with_environment
@@ -291,7 +299,8 b' class TestRaiseDeprecation(unittest.TestCase):'
         else:
             # I can still write to an unwritable dir,
             # assume I'm root and skip the test
-            raise SkipTest("I can't create directories that I can't write to")
+            pytest.skip("I can't create directories that I can't write to")
+
         with self.assertWarnsRegex(UserWarning, 'is not a writable location'):
             ipdir = paths.get_ipython_dir()
         env.pop('IPYTHON_DIR', None)

appveyor.yml

@@ -26,13 +26,9 b' init:'
 install:
   - "SET PATH=%PYTHON%;%PYTHON%\\Scripts;%PATH%"
   - python -m pip install --upgrade setuptools pip
-  - pip install nose coverage pytest pytest-cov pytest-trio matplotlib pandas
+  - pip install pytest pytest-cov pytest-trio matplotlib pandas
   - pip install -e .[test]
-  - mkdir results
-  - cd results
 test_script:
-  - iptest --coverage xml
-  - cd ..
   - pytest --color=yes -ra --cov --cov-report=xml
 on_finish:
   - curl -Os https://uploader.codecov.io/latest/windows/codecov.exe

docs/environment.yml

@@ -5,7 +5,6 b' dependencies:'
 - sphinx>=1.8
 - sphinx_rtd_theme
 - numpy
-- nose
 - testpath
 - matplotlib
 - pip:

docs/source/install/install.rst

@@ -100,12 +100,11 b' permissions, you may need to run the last command with :command:`sudo`. You can'
 also install in user specific location by using the ``--user`` flag in
 conjunction with pip.
 
-To run IPython's test suite, use the :command:`iptest` command from outside of
-the IPython source tree:
+To run IPython's test suite, use the :command:`pytest` command:
 
 .. code-block:: bash
 
-    $ iptest
+    $ pytest
 
 .. _devinstall:
 

setup.py

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

setupbase.py

@@ -234,7 +234,6 b' def find_entry_points():'
     """
     ep = [
             'ipython%s = IPython:start_ipython',
-            'iptest%s = IPython.testing.iptestcontroller:main',
         ]
     suffix = str(sys.version_info[0])
     return [e % '' for e in ep] + [e % suffix for e in ep]

tools/release_helper.sh

@@ -7,7 +7,7 b" python -c 'import keyring'"
 python -c 'import twine'
 python -c 'import sphinx'
 python -c 'import sphinx_rtd_theme'
-python -c 'import nose'
+python -c 'import pytest'
 
 
 BLACK=$(tput setaf 1)