iptest.py
638 lines
| 23.4 KiB
| text/x-python
|
PythonLexer
|
r1574 | # -*- coding: utf-8 -*- | ||
"""IPython Test Suite Runner. | ||||
|
r1851 | |||
|
r1972 | This module provides a main entry point to a user script to test IPython | ||
itself from the command line. There are two ways of running this script: | ||||
1. With the syntax `iptest all`. This runs our entire test suite by | ||||
|
r3486 | calling this script (with different arguments) recursively. This | ||
|
r1972 | causes modules and package to be tested in different processes, using nose | ||
or trial where appropriate. | ||||
2. With the regular nose syntax, like `iptest -vvs IPython`. In this form | ||||
the script simply calls nose, but with special command line flags and | ||||
plugins loaded. | ||||
|
r1574 | """ | ||
|
r1851 | #----------------------------------------------------------------------------- | ||
|
r5390 | # Copyright (C) 2009-2011 The IPython Development Team | ||
|
r2498 | # | ||
# Distributed under the terms of the BSD License. The full license is in | ||||
# the file COPYING, distributed as part of this software. | ||||
#----------------------------------------------------------------------------- | ||||
#----------------------------------------------------------------------------- | ||||
# Imports | ||||
|
r1851 | #----------------------------------------------------------------------------- | ||
|
r7817 | from __future__ import print_function | ||
|
r1851 | |||
|
r2442 | # Stdlib | ||
|
r7412 | import glob | ||
|
r1972 | import os | ||
import os.path as path | ||||
|
r2399 | import signal | ||
|
r1574 | import sys | ||
|
r1972 | import subprocess | ||
|
r2111 | import tempfile | ||
|
r1972 | import time | ||
|
r1574 | import warnings | ||
|
r2442 | # Note: monkeypatch! | ||
# We need to monkeypatch a small problem in nose itself first, before importing | ||||
# it for actual use. This should get into nose upstream, but its release cycle | ||||
# is slow and we need it for our parametric tests to work correctly. | ||||
|
r2480 | from IPython.testing import nosepatch | ||
|
r7213 | |||
# Monkeypatch extra assert methods into nose.tools if they're not already there. | ||||
# This can be dropped once we no longer test on Python 2.6 | ||||
from IPython.testing import nose_assert_methods | ||||
|
r2442 | # Now, proceed to import nose itself | ||
|
r1574 | import nose.plugins.builtin | ||
|
r6101 | from nose.plugins.xunit import Xunit | ||
from nose import SkipTest | ||||
|
r1851 | from nose.core import TestProgram | ||
|
r1574 | |||
|
r2442 | # Our own imports | ||
|
r7732 | from IPython.utils import py3compat | ||
|
r4857 | from IPython.utils.importstring import import_item | ||
|
r7126 | from IPython.utils.path import get_ipython_module_path, get_ipython_package_dir | ||
|
r11133 | from IPython.utils.process import pycmd2argv | ||
|
r2498 | from IPython.utils.sysinfo import sys_info | ||
|
r8038 | from IPython.utils.tempdir import TemporaryDirectory | ||
|
r7121 | from IPython.utils.warn import warn | ||
|
r2498 | |||
|
r2480 | from IPython.testing import globalipapp | ||
from IPython.testing.plugin.ipdoctest import IPythonDoctest | ||||
|
r6101 | from IPython.external.decorators import KnownFailure, knownfailureif | ||
|
r1574 | |||
|
r1979 | pjoin = path.join | ||
|
r2494 | |||
#----------------------------------------------------------------------------- | ||||
# Globals | ||||
#----------------------------------------------------------------------------- | ||||
|
r1851 | #----------------------------------------------------------------------------- | ||
|
r2398 | # Warnings control | ||
#----------------------------------------------------------------------------- | ||||
|
r2512 | |||
|
r2398 | # Twisted generates annoying warnings with Python 2.6, as will do other code | ||
# that imports 'sets' as of today | ||||
warnings.filterwarnings('ignore', 'the sets module is deprecated', | ||||
DeprecationWarning ) | ||||
|
r2461 | # This one also comes from Twisted | ||
warnings.filterwarnings('ignore', 'the sha module is deprecated', | ||||
DeprecationWarning) | ||||
|
r2483 | # Wx on Fedora11 spits these out | ||
warnings.filterwarnings('ignore', 'wxPython/wxWidgets release number mismatch', | ||||
UserWarning) | ||||
|
r6101 | # ------------------------------------------------------------------------------ | ||
# Monkeypatch Xunit to count known failures as skipped. | ||||
# ------------------------------------------------------------------------------ | ||||
|
r6102 | def monkeypatch_xunit(): | ||
|
r6101 | try: | ||
knownfailureif(True)(lambda: None)() | ||||
except Exception as e: | ||||
KnownFailureTest = type(e) | ||||
def addError(self, test, err, capt=None): | ||||
if issubclass(err[0], KnownFailureTest): | ||||
err = (SkipTest,) + err[1:] | ||||
return self.orig_addError(test, err, capt) | ||||
Xunit.orig_addError = Xunit.addError | ||||
Xunit.addError = addError | ||||
|
r2398 | #----------------------------------------------------------------------------- | ||
|
r1981 | # Logic for skipping doctests | ||
|
r1851 | #----------------------------------------------------------------------------- | ||
|
r4857 | def extract_version(mod): | ||
return mod.__version__ | ||||
|
r1851 | |||
|
r4857 | def test_for(item, min_version=None, callback=extract_version): | ||
"""Test to see if item is importable, and optionally check against a minimum | ||||
version. | ||||
|
r4872 | |||
|
r4857 | If min_version is given, the default behavior is to check against the | ||
`__version__` attribute of the item, but specifying `callback` allows you to | ||||
extract the value you are interested in. e.g:: | ||||
|
r4872 | |||
|
r4857 | In [1]: import sys | ||
|
r4872 | |||
|
r4857 | In [2]: from IPython.testing.iptest import test_for | ||
|
r4872 | |||
|
r4857 | In [3]: test_for('sys', (2,6), callback=lambda sys: sys.version_info) | ||
Out[3]: True | ||||
|
r4872 | |||
|
r4857 | """ | ||
|
r1981 | try: | ||
|
r4857 | check = import_item(item) | ||
|
r2488 | except (ImportError, RuntimeError): | ||
|
r4857 | # GTK reports Runtime error if it can't be initialized even if it's | ||
|
r2488 | # importable. | ||
|
r1981 | return False | ||
else: | ||||
|
r3640 | if min_version: | ||
|
r4857 | if callback: | ||
# extra processing step to get version to compare | ||||
check = callback(check) | ||||
|
r4872 | |||
|
r4857 | return check >= min_version | ||
|
r3640 | else: | ||
return True | ||||
|
r1981 | |||
|
r2496 | # Global dict where we can store information on what we have and what we don't | ||
# have available at test run time | ||||
have = {} | ||||
have['curses'] = test_for('_curses') | ||||
|
r3731 | have['matplotlib'] = test_for('matplotlib') | ||
|
r7224 | have['numpy'] = test_for('numpy') | ||
|
r4857 | have['pexpect'] = test_for('IPython.external.pexpect') | ||
|
r3731 | have['pymongo'] = test_for('pymongo') | ||
|
r6874 | have['pygments'] = test_for('pygments') | ||
|
r3761 | have['qt'] = test_for('IPython.external.qt') | ||
|
r7224 | have['rpy2'] = test_for('rpy2') | ||
|
r5147 | have['sqlite3'] = test_for('sqlite3') | ||
|
r7102 | have['cython'] = test_for('Cython') | ||
|
r7385 | have['oct2py'] = test_for('oct2py') | ||
|
r4857 | have['tornado'] = test_for('tornado.version_info', (2,1,0), callback=None) | ||
|
r8908 | have['jinja2'] = test_for('jinja2') | ||
|
r7224 | have['wx'] = test_for('wx') | ||
have['wx.aui'] = test_for('wx.aui') | ||||
|
r8184 | have['azure'] = test_for('azure') | ||
|
r11095 | have['sphinx'] = test_for('sphinx') | ||
have['markdown'] = test_for('markdown') | ||||
|
r4857 | |||
|
r9336 | min_zmq = (2,1,11) | ||
|
r9339 | have['zmq'] = test_for('zmq.pyzmq_version_info', min_zmq, callback=lambda x: x()) | ||
|
r1981 | |||
|
r2494 | #----------------------------------------------------------------------------- | ||
# Functions and classes | ||||
#----------------------------------------------------------------------------- | ||||
|
r1980 | |||
|
r2496 | def report(): | ||
"""Return a string with a summary report of test-related variables.""" | ||||
|
r3204 | out = [ sys_info(), '\n'] | ||
|
r2496 | |||
avail = [] | ||||
not_avail = [] | ||||
|
r4872 | |||
|
r2496 | for k, is_avail in have.items(): | ||
if is_avail: | ||||
avail.append(k) | ||||
else: | ||||
not_avail.append(k) | ||||
if avail: | ||||
out.append('\nTools and libraries available at test time:\n') | ||||
avail.sort() | ||||
out.append(' ' + ' '.join(avail)+'\n') | ||||
if not_avail: | ||||
out.append('\nTools and libraries NOT available at test time:\n') | ||||
not_avail.sort() | ||||
out.append(' ' + ' '.join(not_avail)+'\n') | ||||
|
r4872 | |||
|
r2496 | return ''.join(out) | ||
|
r2079 | def make_exclude(): | ||
|
r2454 | """Make patterns of modules and packages to exclude from testing. | ||
|
r2512 | |||
|
r2454 | For the IPythonDoctest plugin, we need to exclude certain patterns that | ||
cause testing problems. We should strive to minimize the number of | ||||
|
r2512 | skipped modules, since this means untested code. | ||
|
r2454 | These modules and packages will NOT get scanned by nose at all for tests. | ||
""" | ||||
# Simple utility to make IPython paths more readably, we need a lot of | ||||
# these below | ||||
ipjoin = lambda *paths: pjoin('IPython', *paths) | ||||
|
r4872 | |||
|
r2454 | exclusions = [ipjoin('external'), | ||
ipjoin('quarantine'), | ||||
ipjoin('deathrow'), | ||||
|
r2461 | # This guy is probably attic material | ||
|
r2454 | ipjoin('testing', 'mkdoctests'), | ||
|
r2461 | # Testing inputhook will need a lot of thought, to figure out | ||
# how to have tests that don't lock up with the gui event | ||||
# loops in the picture | ||||
|
r2454 | ipjoin('lib', 'inputhook'), | ||
|
r2417 | # Config files aren't really importable stand-alone | ||
|
r2454 | ipjoin('config', 'profile'), | ||
|
r7801 | # The notebook 'static' directory contains JS, css and other | ||
# files for web serving. Occasionally projects may put a .py | ||||
# file in there (MathJax ships a conf.py), so we might as | ||||
# well play it safe and skip the whole thing. | ||||
|
r11035 | ipjoin('html', 'static'), | ||
ipjoin('html', 'fabfile'), | ||||
|
r2417 | ] | ||
|
r5147 | if not have['sqlite3']: | ||
exclusions.append(ipjoin('core', 'tests', 'test_history')) | ||||
exclusions.append(ipjoin('core', 'history')) | ||||
|
r2496 | if not have['wx']: | ||
|
r2454 | exclusions.append(ipjoin('lib', 'inputhookwx')) | ||
|
r7455 | |||
|
r9375 | if 'IPython.kernel.inprocess' not in sys.argv: | ||
exclusions.append(ipjoin('kernel', 'inprocess')) | ||||
|
r7455 | # FIXME: temporarily disable autoreload tests, as they can produce | ||
# spurious failures in subsequent tests (cythonmagic). | ||||
exclusions.append(ipjoin('extensions', 'autoreload')) | ||||
exclusions.append(ipjoin('extensions', 'tests', 'test_autoreload')) | ||||
|
r4872 | |||
|
r3458 | # We do this unconditionally, so that the test suite doesn't import | ||
# gtk, changing the default encoding and masking some unicode bugs. | ||||
exclusions.append(ipjoin('lib', 'inputhookgtk')) | ||||
|
r9375 | exclusions.append(ipjoin('kernel', 'zmq', 'gui', 'gtkembed')) | ||
|
r2083 | |||
|
r11507 | #Also done unconditionally, exclude nbconvert directories containing | ||
#config files used to test. Executing the config files with iptest would | ||||
#cause an exception. | ||||
exclusions.append(ipjoin('nbconvert', 'tests', 'files')) | ||||
exclusions.append(ipjoin('nbconvert', 'exporters', 'tests', 'files')) | ||||
|
r11497 | |||
|
r2079 | # These have to be skipped on win32 because the use echo, rm, cd, etc. | ||
|
r3917 | # See ticket https://github.com/ipython/ipython/issues/87 | ||
|
r2079 | if sys.platform == 'win32': | ||
|
r2454 | exclusions.append(ipjoin('testing', 'plugin', 'test_exampleip')) | ||
exclusions.append(ipjoin('testing', 'plugin', 'dtexample')) | ||||
|
r2079 | |||
|
r2496 | if not have['pexpect']: | ||
|
r7775 | exclusions.extend([ipjoin('lib', 'irunner'), | ||
|
r5694 | ipjoin('lib', 'tests', 'test_irunner'), | ||
|
r11026 | ipjoin('terminal', 'console'), | ||
|
r5694 | ]) | ||
|
r2079 | |||
|
r3640 | if not have['zmq']: | ||
|
r9375 | exclusions.append(ipjoin('kernel')) | ||
|
r11026 | exclusions.append(ipjoin('qt')) | ||
exclusions.append(ipjoin('html')) | ||||
exclusions.append(ipjoin('consoleapp.py')) | ||||
exclusions.append(ipjoin('terminal', 'console')) | ||||
|
r3672 | exclusions.append(ipjoin('parallel')) | ||
|
r6874 | elif not have['qt'] or not have['pygments']: | ||
|
r11026 | exclusions.append(ipjoin('qt')) | ||
|
r4872 | |||
|
r3674 | if not have['pymongo']: | ||
exclusions.append(ipjoin('parallel', 'controller', 'mongodb')) | ||||
|
r3875 | exclusions.append(ipjoin('parallel', 'tests', 'test_mongodb')) | ||
|
r3640 | |||
|
r3731 | if not have['matplotlib']: | ||
|
r5474 | exclusions.extend([ipjoin('core', 'pylabtools'), | ||
|
r6566 | ipjoin('core', 'tests', 'test_pylabtools'), | ||
|
r9375 | ipjoin('kernel', 'zmq', 'pylab'), | ||
|
r6566 | ]) | ||
|
r3731 | |||
|
r7102 | if not have['cython']: | ||
exclusions.extend([ipjoin('extensions', 'cythonmagic')]) | ||||
|
r7117 | exclusions.extend([ipjoin('extensions', 'tests', 'test_cythonmagic')]) | ||
|
r7102 | |||
|
r7385 | if not have['oct2py']: | ||
exclusions.extend([ipjoin('extensions', 'octavemagic')]) | ||||
exclusions.extend([ipjoin('extensions', 'tests', 'test_octavemagic')]) | ||||
|
r4703 | if not have['tornado']: | ||
|
r11026 | exclusions.append(ipjoin('html')) | ||
|
r4703 | |||
|
r8908 | if not have['jinja2']: | ||
|
r11035 | exclusions.append(ipjoin('html', 'notebookapp')) | ||
|
r8908 | |||
|
r7224 | if not have['rpy2'] or not have['numpy']: | ||
exclusions.append(ipjoin('extensions', 'rmagic')) | ||||
exclusions.append(ipjoin('extensions', 'tests', 'test_rmagic')) | ||||
|
r8184 | if not have['azure']: | ||
|
r11035 | exclusions.append(ipjoin('html', 'services', 'notebooks', 'azurenbmanager')) | ||
|
r8184 | |||
|
r11095 | if not all((have['pygments'], have['jinja2'], have['markdown'], have['sphinx'])): | ||
exclusions.append(ipjoin('nbconvert')) | ||||
|
r2079 | # This is needed for the reg-exp to match on win32 in the ipdoctest plugin. | ||
if sys.platform == 'win32': | ||||
|
r2414 | exclusions = [s.replace('\\','\\\\') for s in exclusions] | ||
|
r7121 | |||
# check for any exclusions that don't seem to exist: | ||||
|
r7126 | parent, _ = os.path.split(get_ipython_package_dir()) | ||
|
r7121 | for exclusion in exclusions: | ||
|
r7463 | if exclusion.endswith(('deathrow', 'quarantine')): | ||
# ignore deathrow/quarantine, which exist in dev, but not install | ||||
continue | ||||
|
r7126 | fullpath = pjoin(parent, exclusion) | ||
|
r7412 | if not os.path.exists(fullpath) and not glob.glob(fullpath + '.*'): | ||
|
r8223 | warn("Excluding nonexistent file: %r" % exclusion) | ||
|
r2079 | |||
|
r2414 | return exclusions | ||
|
r1980 | |||
|
r2398 | class IPTester(object): | ||
"""Call that calls iptest or trial in a subprocess. | ||||
""" | ||||
|
r2399 | #: string, name of test runner that will be called | ||
runner = None | ||||
#: list, parameters for test runner | ||||
params = None | ||||
#: list, arguments of system call to be made to call test runner | ||||
call_args = None | ||||
|
r8035 | #: list, subprocesses we start (for cleanup) | ||
processes = None | ||||
|
r5983 | #: str, coverage xml output file | ||
coverage_xml = None | ||||
|
r4872 | |||
|
r2480 | def __init__(self, runner='iptest', params=None): | ||
|
r2399 | """Create new test runner.""" | ||
|
r2494 | p = os.path | ||
|
r2398 | if runner == 'iptest': | ||
|
r11055 | iptest_app = os.path.abspath(get_ipython_module_path('IPython.testing.iptest')) | ||
|
r2507 | self.runner = pycmd2argv(iptest_app) + sys.argv[1:] | ||
|
r2512 | else: | ||
raise Exception('Not a valid test runner: %s' % repr(runner)) | ||||
|
r2398 | if params is None: | ||
params = [] | ||||
|
r2480 | if isinstance(params, str): | ||
|
r2398 | params = [params] | ||
self.params = params | ||||
# Assemble call | ||||
self.call_args = self.runner+self.params | ||||
|
r5962 | |||
|
r5987 | # Find the section we're testing (IPython.foo) | ||
for sect in self.params: | ||||
|
r11073 | if sect.startswith('IPython') or sect in special_test_suites: break | ||
|
r5987 | else: | ||
raise ValueError("Section not found", self.params) | ||||
|
r5962 | if '--with-xunit' in self.call_args: | ||
|
r7744 | |||
self.call_args.append('--xunit-file') | ||||
# FIXME: when Windows uses subprocess.call, these extra quotes are unnecessary: | ||||
xunit_file = path.abspath(sect+'.xunit.xml') | ||||
if sys.platform == 'win32': | ||||
xunit_file = '"%s"' % xunit_file | ||||
self.call_args.append(xunit_file) | ||||
|
r5983 | |||
|
r5985 | if '--with-xml-coverage' in self.call_args: | ||
|
r5983 | self.coverage_xml = path.abspath(sect+".coverage.xml") | ||
|
r5985 | self.call_args.remove('--with-xml-coverage') | ||
|
r5984 | self.call_args = ["coverage", "run", "--source="+sect] + self.call_args[1:] | ||
|
r2398 | |||
|
r8035 | # Store anything we start to clean up on deletion | ||
self.processes = [] | ||||
|
r2399 | |||
|
r7870 | def _run_cmd(self): | ||
|
r8038 | with TemporaryDirectory() as IPYTHONDIR: | ||
env = os.environ.copy() | ||||
env['IPYTHONDIR'] = IPYTHONDIR | ||||
# print >> sys.stderr, '*** CMD:', ' '.join(self.call_args) # dbg | ||||
subp = subprocess.Popen(self.call_args, env=env) | ||||
self.processes.append(subp) | ||||
# If this fails, the process will be left in self.processes and | ||||
# cleaned up later, but if the wait call succeeds, then we can | ||||
# clear the stored process. | ||||
retcode = subp.wait() | ||||
self.processes.pop() | ||||
return retcode | ||||
|
r4872 | |||
|
r2398 | def run(self): | ||
"""Run the stored commands""" | ||||
try: | ||||
|
r5983 | retcode = self._run_cmd() | ||
|
r8495 | except KeyboardInterrupt: | ||
return -signal.SIGINT | ||||
|
r2398 | except: | ||
import traceback | ||||
traceback.print_exc() | ||||
return 1 # signal failure | ||||
|
r5983 | |||
if self.coverage_xml: | ||||
|
r5986 | subprocess.call(["coverage", "xml", "-o", self.coverage_xml]) | ||
|
r5983 | return retcode | ||
|
r2398 | |||
|
r2399 | def __del__(self): | ||
"""Cleanup on exit by killing any leftover processes.""" | ||||
|
r8035 | for subp in self.processes: | ||
|
r8036 | if subp.poll() is not None: | ||
continue # process is already dead | ||||
|
r2399 | try: | ||
|
r8495 | print('Cleaning up stale PID: %d' % subp.pid) | ||
|
r8035 | subp.kill() | ||
except: # (OSError, WindowsError) ? | ||||
|
r2399 | # This is just a best effort, if we fail or the process was | ||
# really gone, ignore it. | ||||
|
r4872 | pass | ||
|
r8495 | else: | ||
for i in range(10): | ||||
if subp.poll() is None: | ||||
time.sleep(0.1) | ||||
else: | ||||
break | ||||
|
r2400 | |||
|
r8036 | if subp.poll() is None: | ||
# The process did not die... | ||||
|
r8495 | print('... failed. Manual cleanup may be required.') | ||
|
r2398 | |||
|
r11073 | |||
special_test_suites = { | ||||
'autoreload': ['IPython.extensions.autoreload', 'IPython.extensions.tests.test_autoreload'], | ||||
} | ||||
|
r11026 | |||
|
r8124 | def make_runners(inc_slow=False): | ||
|
r2398 | """Define the top-level packages that need to be tested. | ||
""" | ||||
|
r2483 | # Packages to be tested via nose, that only depend on the stdlib | ||
|
r11026 | nose_pkg_names = ['config', 'core', 'extensions', 'lib', 'terminal', | ||
|
r11095 | 'testing', 'utils', 'nbformat'] | ||
|
r4872 | |||
|
r11026 | if have['qt']: | ||
nose_pkg_names.append('qt') | ||||
if have['tornado']: | ||||
nose_pkg_names.append('html') | ||||
|
r3673 | if have['zmq']: | ||
|
r9375 | nose_pkg_names.append('kernel') | ||
nose_pkg_names.append('kernel.inprocess') | ||||
|
r8124 | if inc_slow: | ||
nose_pkg_names.append('parallel') | ||||
|
r4872 | |||
|
r11095 | if all((have['pygments'], have['jinja2'], have['markdown'], have['sphinx'])): | ||
nose_pkg_names.append('nbconvert') | ||||
|
r2483 | # For debugging this code, only load quick stuff | ||
|
r2494 | #nose_pkg_names = ['core', 'extensions'] # dbg | ||
|
r2483 | |||
# Make fully qualified package names prepending 'IPython.' to our name lists | ||||
nose_packages = ['IPython.%s' % m for m in nose_pkg_names ] | ||||
# Make runners | ||||
runners = [ (v, IPTester('iptest', params=v)) for v in nose_packages ] | ||||
|
r11073 | |||
for name in special_test_suites: | ||||
runners.append((name, IPTester('iptest', params=name))) | ||||
|
r4872 | |||
|
r2398 | return runners | ||
|
r1972 | def run_iptest(): | ||
"""Run the IPython test suite using nose. | ||||
|
r4872 | |||
|
r1972 | This function is called when this script is **not** called with the form | ||
`iptest all`. It simply calls nose with appropriate command line flags | ||||
and accepts all of the standard nose arguments. | ||||
|
r1574 | """ | ||
|
r6102 | # Apply our monkeypatch to Xunit | ||
|
r6113 | if '--with-xunit' in sys.argv and not hasattr(Xunit, 'orig_addError'): | ||
|
r6102 | monkeypatch_xunit() | ||
|
r1574 | |||
|
r4872 | warnings.filterwarnings('ignore', | ||
|
r1574 | 'This will be removed soon. Use IPython.testing.util instead') | ||
|
r11073 | |||
if sys.argv[1] in special_test_suites: | ||||
sys.argv[1:2] = special_test_suites[sys.argv[1]] | ||||
special_suite = True | ||||
else: | ||||
special_suite = False | ||||
|
r1574 | |||
|
r2487 | argv = sys.argv + [ '--detailed-errors', # extra info in tracebacks | ||
|
r4872 | |||
|
r2414 | '--with-ipdoctest', | ||
'--ipdoctest-tests','--ipdoctest-extension=txt', | ||||
|
r4872 | |||
|
r1761 | # We add --exe because of setuptools' imbecility (it | ||
# blindly does chmod +x on ALL files). Nose does the | ||||
# right thing and it tries to avoid executables, | ||||
# setuptools unfortunately forces our hand here. This | ||||
# has been discussed on the distutils list and the | ||||
# setuptools devs refuse to fix this problem! | ||||
'--exe', | ||||
] | ||||
|
r8201 | if '-a' not in argv and '-A' not in argv: | ||
argv = argv + ['-a', '!crash'] | ||||
|
r1574 | |||
|
r2494 | if nose.__version__ >= '0.11': | ||
# I don't fully understand why we need this one, but depending on what | ||||
# directory the test suite is run from, if we don't give it, 0 tests | ||||
# get run. Specifically, if the test suite is run from the source dir | ||||
# with an argument (like 'iptest.py IPython.core', 0 tests are run, | ||||
# even if the same call done in this directory works fine). It appears | ||||
# that if the requested package is in the current dir, nose bails early | ||||
# by default. Since it's otherwise harmless, leave it in by default | ||||
# for nose >= 0.11, though unfortunately nose 0.10 doesn't support it. | ||||
argv.append('--traverse-namespace') | ||||
|
r1574 | |||
|
r4567 | # use our plugin for doctesting. It will remove the standard doctest plugin | ||
# if it finds it enabled | ||||
|
r11073 | ipdt = IPythonDoctest() if special_suite else IPythonDoctest(make_exclude()) | ||
plugins = [ipdt, KnownFailure()] | ||||
|
r8489 | |||
# We need a global ipython running in this process, but the special | ||||
# in-process group spawns its own IPython kernels, so for *that* group we | ||||
# must avoid also opening the global one (otherwise there's a conflict of | ||||
# singletons). Ultimately the solution to this problem is to refactor our | ||||
# assumptions about what needs to be a singleton and what doesn't (app | ||||
# objects should, individual shells shouldn't). But for now, this | ||||
# workaround allows the test suite for the inprocess module to complete. | ||||
|
r9375 | if not 'IPython.kernel.inprocess' in sys.argv: | ||
|
r8489 | globalipapp.start_ipython() | ||
|
r2414 | # Now nose can run | ||
|
r4567 | TestProgram(argv=argv, addplugins=plugins) | ||
|
r1972 | |||
|
r8124 | def run_iptestall(inc_slow=False): | ||
|
r1972 | """Run the entire IPython test suite by calling nose and trial. | ||
|
r4872 | |||
|
r1972 | This function constructs :class:`IPTester` instances for all IPython | ||
modules and package and then runs each of them. This causes the modules | ||||
and packages of IPython to be tested each in their own subprocess using | ||||
|
r6421 | nose. | ||
|
r8124 | |||
Parameters | ||||
---------- | ||||
inc_slow : bool, optional | ||||
Include slow tests, like IPython.parallel. By default, these tests aren't | ||||
run. | ||||
|
r1972 | """ | ||
|
r2079 | |||
|
r8124 | runners = make_runners(inc_slow=inc_slow) | ||
|
r2079 | |||
|
r2398 | # Run the test runners in a temporary dir so we can nuke it when finished | ||
# to clean up any junk files left over by accident. This also makes it | ||||
# robust against being run in non-writeable directories by mistake, as the | ||||
# temp dir will always be user-writeable. | ||||
|
r4208 | curdir = os.getcwdu() | ||
|
r2398 | testdir = tempfile.gettempdir() | ||
os.chdir(testdir) | ||||
|
r1972 | # Run all test runners, tracking execution time | ||
|
r2480 | failed = [] | ||
|
r1972 | t_start = time.time() | ||
|
r2398 | try: | ||
|
r2480 | for (name, runner) in runners: | ||
|
r7817 | print('*'*70) | ||
print('IPython test group:',name) | ||||
|
r2398 | res = runner.run() | ||
if res: | ||||
|
r2480 | failed.append( (name, runner) ) | ||
|
r8495 | if res == -signal.SIGINT: | ||
print("Interrupted") | ||||
break | ||||
|
r2398 | finally: | ||
os.chdir(curdir) | ||||
|
r1972 | t_end = time.time() | ||
t_tests = t_end - t_start | ||||
nrunners = len(runners) | ||||
nfail = len(failed) | ||||
# summarize results | ||||
|
r7817 | print() | ||
print('*'*70) | ||||
print('Test suite completed for system with the following information:') | ||||
print(report()) | ||||
print('Ran %s test groups in %.3fs' % (nrunners, t_tests)) | ||||
print() | ||||
print('Status:') | ||||
|
r1972 | if not failed: | ||
|
r7817 | print('OK') | ||
|
r1972 | else: | ||
# If anything went wrong, point out what command to rerun manually to | ||||
# see the actual errors and individual summary | ||||
|
r7817 | print('ERROR - %s out of %s test groups failed.' % (nfail, nrunners)) | ||
|
r2480 | for name, failed_runner in failed: | ||
|
r7817 | print('-'*40) | ||
print('Runner failed:',name) | ||||
print('You may wish to rerun this one individually, with:') | ||||
|
r7732 | failed_call_args = [py3compat.cast_unicode(x) for x in failed_runner.call_args] | ||
|
r7817 | print(u' '.join(failed_call_args)) | ||
print() | ||||
|
r3895 | # Ensure that our exit code indicates failure | ||
sys.exit(1) | ||||
|
r1972 | |||
def main(): | ||||
|
r2480 | for arg in sys.argv[1:]: | ||
|
r11073 | if arg.startswith('IPython') or arg in special_test_suites: | ||
|
r2481 | # This is in-process | ||
|
r1990 | run_iptest() | ||
|
r2480 | else: | ||
|
r8124 | if "--all" in sys.argv: | ||
sys.argv.remove("--all") | ||||
inc_slow = True | ||||
else: | ||||
inc_slow = False | ||||
|
r2481 | # This starts subprocesses | ||
|
r8124 | run_iptestall(inc_slow=inc_slow) | ||
|
r1972 | |||
if __name__ == '__main__': | ||||
|
r2091 | main() | ||