only test `--help-all`

help-all is a superset of `-h`, so no need to do both,
since these tests are slow.

IPython/html/tests/test_notebookapp.py

@@ -1,29 +1,25 b''
 """Test NotebookApp"""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2013 The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import nose.tools as nt
 
 import IPython.testing.tools as tt
 
 #-----------------------------------------------------------------------------
 # Test functions
 #-----------------------------------------------------------------------------
 
 def test_help_output():
-    """ipython notebook -h works"""
-    tt.help_output_test('notebook')
-
-def test_help_all_output():
     """ipython notebook --help-all works"""
     tt.help_all_output_test('notebook')
 

IPython/kernel/tests/test_kernel.py

@@ -1,252 +1,256 b''
 """test the IPython Kernel"""
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2013  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 import os
 import shutil
 import sys
 import tempfile
 
 from contextlib import contextmanager
 from subprocess import PIPE
 
 import nose.tools as nt
 
 from IPython.kernel import KernelManager
 from IPython.kernel.tests.test_message_spec import execute, flush_channels
-from IPython.testing import decorators as dec
+from IPython.testing import decorators as dec, tools as tt
 from IPython.utils import path, py3compat
 
 #-------------------------------------------------------------------------------
 # Tests
 #-------------------------------------------------------------------------------
 IPYTHONDIR = None
 save_env = None
 save_get_ipython_dir = None
 
 STARTUP_TIMEOUT = 60
 TIMEOUT = 15
 
 def setup():
     """setup temporary IPYTHONDIR for tests"""
     global IPYTHONDIR
     global save_env
     global save_get_ipython_dir
     
     IPYTHONDIR = tempfile.mkdtemp()
 
     save_env = os.environ.copy()
     os.environ["IPYTHONDIR"] = IPYTHONDIR
 
     save_get_ipython_dir = path.get_ipython_dir
     path.get_ipython_dir = lambda : IPYTHONDIR
 
 
 def teardown():
     path.get_ipython_dir = save_get_ipython_dir
     os.environ = save_env
     
     try:
         shutil.rmtree(IPYTHONDIR)
     except (OSError, IOError):
         # no such file
         pass
 
 
 @contextmanager
 def new_kernel():
     """start a kernel in a subprocess, and wait for it to be ready
     
     Returns
     -------
     kernel_manager: connected KernelManager instance
     """
     KM = KernelManager()
 
     KM.start_kernel(stdout=PIPE, stderr=PIPE)
     KC = KM.client()
     KC.start_channels()
     
     # wait for kernel to be ready
     KC.shell_channel.execute("import sys")
     KC.shell_channel.get_msg(block=True, timeout=STARTUP_TIMEOUT)
     flush_channels(KC)
     try:
         yield KC
     finally:
         KC.stop_channels()
         KM.shutdown_kernel()
 
 
 def assemble_output(iopub):
     """assemble stdout/err from an execution"""
     stdout = ''
     stderr = ''
     while True:
         msg = iopub.get_msg(block=True, timeout=1)
         msg_type = msg['msg_type']
         content = msg['content']
         if msg_type == 'status' and content['execution_state'] == 'idle':
             # idle message signals end of output
             break
         elif msg['msg_type'] == 'stream':
             if content['name'] == 'stdout':
                 stdout = stdout + content['data']
             elif content['name'] == 'stderr':
                 stderr = stderr + content['data']
             else:
                 raise KeyError("bad stream: %r" % content['name'])
         else:
             # other output, ignored
             pass
     return stdout, stderr
 
 
 def _check_mp_mode(kc, expected=False, stream="stdout"):
     execute(kc=kc, code="import sys")
     flush_channels(kc)
     msg_id, content = execute(kc=kc, code="print (sys.%s._check_mp_mode())" % stream)
     stdout, stderr = assemble_output(kc.iopub_channel)
     nt.assert_equal(eval(stdout.strip()), expected)
 
 
 # printing tests
 
 def test_simple_print():
     """simple print statement in kernel"""
     with new_kernel() as kc:
         iopub = kc.iopub_channel
         msg_id, content = execute(kc=kc, code="print ('hi')")
         stdout, stderr = assemble_output(iopub)
         nt.assert_equal(stdout, 'hi\n')
         nt.assert_equal(stderr, '')
         _check_mp_mode(kc, expected=False)
 
 
 @dec.knownfailureif(sys.platform == 'win32', "subprocess prints fail on Windows")
 def test_subprocess_print():
     """printing from forked mp.Process"""
     with new_kernel() as kc:
         iopub = kc.iopub_channel
         
         _check_mp_mode(kc, expected=False)
         flush_channels(kc)
         np = 5
         code = '\n'.join([
             "from __future__ import print_function",
             "import multiprocessing as mp",
             "pool = [mp.Process(target=print, args=('hello', i,)) for i in range(%i)]" % np,
             "for p in pool: p.start()",
             "for p in pool: p.join()"
         ])
         
         expected = '\n'.join([
             "hello %s" % i for i in range(np)
         ]) + '\n'
         
         msg_id, content = execute(kc=kc, code=code)
         stdout, stderr = assemble_output(iopub)
         nt.assert_equal(stdout.count("hello"), np, stdout)
         for n in range(np):
             nt.assert_equal(stdout.count(str(n)), 1, stdout)
         nt.assert_equal(stderr, '')
         _check_mp_mode(kc, expected=False)
         _check_mp_mode(kc, expected=False, stream="stderr")
 
 
 def test_subprocess_noprint():
     """mp.Process without print doesn't trigger iostream mp_mode"""
     with new_kernel() as kc:
         iopub = kc.iopub_channel
         
         np = 5
         code = '\n'.join([
             "import multiprocessing as mp",
             "pool = [mp.Process(target=range, args=(i,)) for i in range(%i)]" % np,
             "for p in pool: p.start()",
             "for p in pool: p.join()"
         ])
         
         msg_id, content = execute(kc=kc, code=code)
         stdout, stderr = assemble_output(iopub)
         nt.assert_equal(stdout, '')
         nt.assert_equal(stderr, '')
 
         _check_mp_mode(kc, expected=False)
         _check_mp_mode(kc, expected=False, stream="stderr")
 
 
 @dec.knownfailureif(sys.platform == 'win32', "subprocess prints fail on Windows")
 def test_subprocess_error():
     """error in mp.Process doesn't crash"""
     with new_kernel() as kc:
         iopub = kc.iopub_channel
         
         code = '\n'.join([
             "import multiprocessing as mp",
             "p = mp.Process(target=int, args=('hi',))",
             "p.start()",
             "p.join()",
         ])
         
         msg_id, content = execute(kc=kc, code=code)
         stdout, stderr = assemble_output(iopub)
         nt.assert_equal(stdout, '')
         nt.assert_true("ValueError" in stderr, stderr)
 
         _check_mp_mode(kc, expected=False)
         _check_mp_mode(kc, expected=False, stream="stderr")
 
-
 # raw_input tests
 
 def test_raw_input():
     """test [raw_]input"""
     with new_kernel() as kc:
         iopub = kc.iopub_channel
         
         input_f = "input" if py3compat.PY3 else "raw_input"
         theprompt = "prompt> "
         code = 'print({input_f}("{theprompt}"))'.format(**locals())
         msg_id = kc.execute(code, allow_stdin=True)
         msg = kc.get_stdin_msg(block=True, timeout=TIMEOUT)
         nt.assert_equal(msg['header']['msg_type'], u'input_request')
         content = msg['content']
         nt.assert_equal(content['prompt'], theprompt)
         text = "some text"
         kc.input(text)
         reply = kc.get_shell_msg(block=True, timeout=TIMEOUT)
         nt.assert_equal(reply['content']['status'], 'ok')
         stdout, stderr = assemble_output(iopub)
         nt.assert_equal(stdout, text + "\n")
 
 
 @dec.skipif(py3compat.PY3)
 def test_eval_input():
     """test input() on Python 2"""
     with new_kernel() as kc:
         iopub = kc.iopub_channel
         
         input_f = "input" if py3compat.PY3 else "raw_input"
         theprompt = "prompt> "
         code = 'print(input("{theprompt}"))'.format(**locals())
         msg_id = kc.execute(code, allow_stdin=True)
         msg = kc.get_stdin_msg(block=True, timeout=TIMEOUT)
         nt.assert_equal(msg['header']['msg_type'], u'input_request')
         content = msg['content']
         nt.assert_equal(content['prompt'], theprompt)
         kc.input("1+1")
         reply = kc.get_shell_msg(block=True, timeout=TIMEOUT)
         nt.assert_equal(reply['content']['status'], 'ok')
         stdout, stderr = assemble_output(iopub)
         nt.assert_equal(stdout, "2\n")
 
+
+def test_help_output():
+    """ipython kernel --help-all works"""
+    tt.help_all_output_test('kernel')
+

IPython/nbconvert/tests/test_nbconvertapp.py

@@ -1,164 +1,160 b''
 """Test NbConvertApp"""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2013 The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import os
 import glob
 
 from .base import TestsBase
 
 import IPython.testing.tools as tt
 from IPython.testing import decorators as dec
 
 
 #-----------------------------------------------------------------------------
 # Constants
 #-----------------------------------------------------------------------------
 
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 class TestNbConvertApp(TestsBase):
     """Collection of NbConvertApp tests"""
 
 
     def test_notebook_help(self):
         """Will help show if no notebooks are specified?"""
         with self.create_temp_cwd():
             out, err = self.call('nbconvert --log-level 0', ignore_return_code=True)
             self.assertIn("see '--help-all'", out)
     
     def test_help_output(self):
-        """ipython nbconvert -h works"""
-        tt.help_output_test('nbconvert')
-
-    def test_help_all_output(self):
         """ipython nbconvert --help-all works"""
         tt.help_all_output_test('nbconvert')
 
     def test_glob(self):
         """
         Do search patterns work for notebook names?
         """
         with self.create_temp_cwd(['notebook*.ipynb']):
             self.call('nbconvert --to python *.ipynb --log-level 0')
             assert os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')
 
 
     def test_glob_subdir(self):
         """
         Do search patterns work for subdirectory notebook names?
         """
         with self.create_temp_cwd():
             self.copy_files_to(['notebook*.ipynb'], 'subdir/')
             self.call('nbconvert --to python --log-level 0 ' + 
                       os.path.join('subdir', '*.ipynb'))
             assert os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')
 
 
     def test_explicit(self):
         """
         Do explicit notebook names work?
         """
         with self.create_temp_cwd(['notebook*.ipynb']):
             self.call('nbconvert --log-level 0 --to python notebook2')
             assert not os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')
 
 
     @dec.onlyif_cmds_exist('pdflatex')
     @dec.onlyif_cmds_exist('pandoc')
     def test_filename_spaces(self):
         """
         Generate PDFs with graphics if notebooks have spaces in the name?
         """
         with self.create_temp_cwd(['notebook2.ipynb']):
             os.rename('notebook2.ipynb', 'notebook with spaces.ipynb')
             o,e = self.call('nbconvert --log-level 0 --to latex '
                             '"notebook with spaces" --post PDF '
                             '--PDFPostProcessor.verbose=True')
             assert os.path.isfile('notebook with spaces.tex')
             assert os.path.isdir('notebook with spaces_files')
             assert os.path.isfile('notebook with spaces.pdf')
 
     @dec.onlyif_cmds_exist('pdflatex')
     @dec.onlyif_cmds_exist('pandoc')
     def test_post_processor(self):
         """
         Do post processors work?
         """
         with self.create_temp_cwd(['notebook1.ipynb']):
             self.call('nbconvert --log-level 0 --to latex notebook1 '
                       '--post PDF --PDFPostProcessor.verbose=True')
             assert os.path.isfile('notebook1.tex')
             assert os.path.isfile('notebook1.pdf')
 
 
     @dec.onlyif_cmds_exist('pandoc')
     def test_template(self):
         """
         Do export templates work?
         """
         with self.create_temp_cwd(['notebook2.ipynb']):
             self.call('nbconvert --log-level 0 --to slides '  
                       'notebook2.ipynb --template reveal')
             assert os.path.isfile('notebook2.slides.html')
             with open('notebook2.slides.html') as f:
                 assert '/reveal.css' in f.read()
 
 
     def test_glob_explicit(self):
         """
         Can a search pattern be used along with matching explicit notebook names?
         """
         with self.create_temp_cwd(['notebook*.ipynb']):
             self.call('nbconvert --log-level 0 --to python '
                       '*.ipynb notebook1.ipynb notebook2.ipynb')
             assert os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')
 
 
     def test_explicit_glob(self):
         """
         Can explicit notebook names be used and then a matching search pattern?
         """
         with self.create_temp_cwd(['notebook*.ipynb']):
             self.call('nbconvert --log-level 0 --to=python '
                       'notebook1.ipynb notebook2.ipynb *.ipynb')
             assert os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')
 
 
     def test_default_config(self):
         """
         Does the default config work?
         """
         with self.create_temp_cwd(['notebook*.ipynb', 'ipython_nbconvert_config.py']):
             self.call('nbconvert --log-level 0')
             assert os.path.isfile('notebook1.py')
             assert not os.path.isfile('notebook2.py')
 
 
     def test_override_config(self):
         """
         Can the default config be overriden?
         """
         with self.create_temp_cwd(['notebook*.ipynb',
                                    'ipython_nbconvert_config.py',
                                    'override.py']):
             self.call('nbconvert --log-level 0 --config="override.py"')
             assert not os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')

IPython/qt/console/tests/test_app.py

@@ -1,29 +1,25 b''
 """Test QtConsoleApp"""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2013 The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import nose.tools as nt
 
 import IPython.testing.tools as tt
 
 #-----------------------------------------------------------------------------
 # Test functions
 #-----------------------------------------------------------------------------
 
 def test_help_output():
-    """ipython qtconsole -h works"""
-    tt.help_output_test('qtconsole')
-
-def test_help_all_output():
     """ipython qtconsole --help-all works"""
     tt.help_all_output_test('qtconsole')
 

IPython/terminal/console/tests/test_console.py

@@ -1,67 +1,63 b''
 """Tests for two-process terminal frontend
 
 Currently only has the most simple test possible, starting a console and running
 a single command.
 
 Authors:
 
 * Min RK
 """
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import sys
 import time
 
 import nose.tools as nt
 from nose import SkipTest
 
 import IPython.testing.tools as tt
 from IPython.testing import decorators as dec
 from IPython.utils import py3compat
 
 #-----------------------------------------------------------------------------
 # Tests
 #-----------------------------------------------------------------------------
 
 @dec.skip_win32
 def test_console_starts():
     """test that `ipython console` starts a terminal"""
     from IPython.external import pexpect
     
     args = ['console', '--colors=NoColor']
     # FIXME: remove workaround for 2.6 support
     if sys.version_info[:2] > (2,6):
         args = ['-m', 'IPython'] + args
         cmd = sys.executable
     else:
         cmd = 'ipython'
     
     try:
         p = pexpect.spawn(cmd, args=args)
     except IOError:
         raise SkipTest("Couldn't find command %s" % cmd)
     
     # timeout after one minute
     t = 60
     idx = p.expect([r'In \[\d+\]', pexpect.EOF], timeout=t)
     p.sendline('5')
     idx = p.expect([r'Out\[\d+\]: 5', pexpect.EOF], timeout=t)
     idx = p.expect([r'In \[\d+\]', pexpect.EOF], timeout=t)
     # send ctrl-D;ctrl-D to exit
     p.sendeof()
     p.sendeof()
     p.expect([pexpect.EOF, pexpect.TIMEOUT], timeout=t)
     if p.isalive():
         p.terminate()
 
 def test_help_output():
-    """ipython console -h works"""
-    tt.help_output_test('console')
-    
-def test_help_all_output():
     """ipython console --help-all works"""
     tt.help_all_output_test('console')
 

IPython/terminal/tests/test_help.py

@@ -1,55 +1,37 b''
 """Test help output of various IPython entry points"""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2013 The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import IPython.testing.tools as tt
 
 #-----------------------------------------------------------------------------
 # Tests
 #-----------------------------------------------------------------------------
 
 
 def test_ipython_help():
-    tt.help_output_test()
-
-def test_ipython_help_all():
     tt.help_all_output_test()
 
 def test_profile_help():
-    tt.help_output_test("profile")
-
-def test_profile_help_all():
     tt.help_all_output_test("profile")
 
 def test_profile_list_help():
-    tt.help_output_test("profile list")
-
-def test_profile_list_help_all():
     tt.help_all_output_test("profile list")
 
 def test_profile_create_help():
-    tt.help_output_test("profile create")
-
-def test_profile_create_help_all():
     tt.help_all_output_test("profile create")
 
 def test_locate_help():
-    tt.help_output_test("locate")
-
-def test_locate_help_all():
     tt.help_all_output_test("locate")
 
 def test_locate_profile_help():
-    tt.help_output_test("locate profile")
-
-def test_locate_profile_all():
     tt.help_all_output_test("locate profile")