irunner.py => lib/irunner.py and imports updated.

IPython/lib/tests/test_imports.py

@@ -1,11 +1,14 b''
 #!/usr/bin/env python
 # encoding: utf-8
 
 def test_import_backgroundjobs():
     from IPython.lib import backgroundjobs
 
 def test_import_deepreload():
     from IPython.lib import deepreload
 
 def test_import_demo():
-    from IPython.lib import demo
  No newline at end of file
+    from IPython.lib import demo
+
+def test_import_irunner():
+    from IPython.lib import demo

IPython/testing/attic/ipdoctest.py

@@ -1,800 +1,800 b''
 #!/usr/bin/env python
 """IPython-enhanced doctest module with unittest integration.
 
 This module is heavily based on the standard library's doctest module, but
 enhances it with IPython support.  This enables docstrings to contain
 unmodified IPython input and output pasted from real IPython sessions.
 
 It should be possible to use this module as a drop-in replacement for doctest
 whenever you wish to use IPython input.
 
 Since the module absorbs all normal doctest functionality, you can use a mix of
 both plain Python and IPython examples in any given module, though not in the
 same docstring.
 
 See a simple example at the bottom of this code which serves as self-test and
 demonstration code.  Simply run this file (use -v for details) to run the
 tests.
 
 This module also contains routines to ease the integration of doctests with
 regular unittest-based testing.  In particular, see the DocTestLoader class and
 the makeTestSuite utility function.
 
 
 Limitations:
 
  - When generating examples for use as doctests, make sure that you have
    pretty-printing OFF.  This can be done either by starting ipython with the
    flag '--nopprint', by setting pprint to 0 in your ipythonrc file, or by
    interactively disabling it with %Pprint.  This is required so that IPython
    output matches that of normal Python, which is used by doctest for internal
    execution.
 
  - Do not rely on specific prompt numbers for results (such as using
    '_34==True', for example).  For IPython tests run via an external process
    the prompt numbers may be different, and IPython tests run as normal python
    code won't even have these special _NN variables set at all.
 
  - IPython functions that produce output as a side-effect of calling a system
    process (e.g. 'ls') can be doc-tested, but they must be handled in an
    external IPython process.  Such doctests must be tagged with:
 
         # ipdoctest: EXTERNAL
 
    so that the testing machinery handles them differently.  Since these are run
    via pexpect in an external process, they can't deal with exceptions or other
    fancy featurs of regular doctests.  You must limit such tests to simple
    matching of the output.  For this reason, I recommend you limit these kinds
    of doctests to features that truly require a separate process, and use the
    normal IPython ones (which have all the features of normal doctests) for
    everything else.  See the examples at the bottom of this file for a
    comparison of what can be done with both types.
 """
 
 # Standard library imports
 import __builtin__
 import doctest
 import inspect
 import os
 import re
 import sys
 import unittest
 
 from doctest import *
 
 from IPython.tools import utils
 from IPython.core import ipapi
 
 ###########################################################################
 #
 # We must start our own ipython object and heavily muck with it so that all the
 # modifications IPython makes to system behavior don't send the doctest
 # machinery into a fit.  This code should be considered a gross hack, but it
 # gets the job done.
 
 import IPython
 
 # Hack to restore __main__, which ipython modifies upon startup
 _main = sys.modules.get('__main__')
 ipython = IPython.Shell.IPShell(['--classic','--noterm_title']).IP
 sys.modules['__main__'] = _main
 
 # Deactivate the various python system hooks added by ipython for
 # interactive convenience so we don't confuse the doctest system
 sys.displayhook = sys.__displayhook__
 sys.excepthook = sys.__excepthook__
 
 # So that ipython magics and aliases can be doctested
 __builtin__._ip = ipapi.get()
 
 # for debugging only!!!
 #from IPython.Shell import IPShellEmbed;ipshell=IPShellEmbed(['--noterm_title']) # dbg
 
 
 # runner
-from IPython.irunner import IPythonRunner
+from IPython.lib.irunner import IPythonRunner
 iprunner = IPythonRunner(echo=False)
 
 ###########################################################################
 
 # 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
 
 class IPExternalExample(doctest.Example):
     """Doctest examples to be run in an external process."""
     
     def __init__(self, source, want, exc_msg=None, lineno=0, indent=0,
                  options=None):
         # Parent constructor
         doctest.Example.__init__(self,source,want,exc_msg,lineno,indent,options)
 
         # An EXTRA newline is needed to prevent pexpect hangs
         self.source += '\n'
 
 class IPDocTestParser(doctest.DocTestParser):
     """
     A class used to parse strings containing doctest examples.
 
     Note: This is a version modified to properly recognize IPython input and
     convert any IPython examples into valid Python ones.
     """
     # This regular expression is used to find doctest examples in a
     # string.  It defines three groups: `source` is the source code
     # (including leading indentation and prompts); `indent` is the
     # indentation of the first (PS1) line of the source code; and
     # `want` is the expected output (including leading indentation).
 
     # Classic Python prompts or default IPython ones
     _PS1_PY = r'>>>'
     _PS2_PY = r'\.\.\.'
 
     _PS1_IP = r'In\ \[\d+\]:'
     _PS2_IP = r'\ \ \ \.\.\.+:'
 
     _RE_TPL = r'''
         # Source consists of a PS1 line followed by zero or more PS2 lines.
         (?P<source>
             (?:^(?P<indent> [ ]*) (?P<ps1> %s) .*)    # PS1 line
             (?:\n           [ ]*  (?P<ps2> %s) .*)*)  # PS2 lines
         \n? # a newline
         # Want consists of any non-blank lines that do not start with PS1.
         (?P<want> (?:(?![ ]*$)    # Not a blank line
                      (?![ ]*%s)   # Not a line starting with PS1
                      (?![ ]*%s)   # Not a line starting with PS2
                      .*$\n?       # But any other line
                   )*)
                   '''
 
     _EXAMPLE_RE_PY = re.compile( _RE_TPL % (_PS1_PY,_PS2_PY,_PS1_PY,_PS2_PY),
                                  re.MULTILINE | re.VERBOSE)
 
     _EXAMPLE_RE_IP = re.compile( _RE_TPL % (_PS1_IP,_PS2_IP,_PS1_IP,_PS2_IP),
                                  re.MULTILINE | re.VERBOSE)
 
     def ip2py(self,source):
         """Convert input IPython source into valid Python."""
         out = []
         newline = out.append
         for line in source.splitlines():
             newline(ipython.prefilter(line,True))
         newline('')  # ensure a closing newline, needed by doctest
         return '\n'.join(out)
 
     def parse(self, string, name='<string>'):
         """
         Divide the given string into examples and intervening text,
         and return them as a list of alternating Examples and strings.
         Line numbers for the Examples are 0-based.  The optional
         argument `name` is a name identifying this string, and is only
         used for error messages.
         """
         string = string.expandtabs()
         # If all lines begin with the same indentation, then strip it.
         min_indent = self._min_indent(string)
         if min_indent > 0:
             string = '\n'.join([l[min_indent:] for l in string.split('\n')])
 
         output = []
         charno, lineno = 0, 0
 
         # Whether to convert the input from ipython to python syntax
         ip2py = False
         # Find all doctest examples in the string.  First, try them as Python
         # examples, then as IPython ones
         terms = list(self._EXAMPLE_RE_PY.finditer(string))
         if terms:
             # Normal Python example
             Example = doctest.Example
         else:
             # It's an ipython example.  Note that IPExamples are run
             # in-process, so their syntax must be turned into valid python.
             # IPExternalExamples are run out-of-process (via pexpect) so they
             # don't need any filtering (a real ipython will be executing them).
             terms = list(self._EXAMPLE_RE_IP.finditer(string))
             if re.search(r'#\s*ipdoctest:\s*EXTERNAL',string):
                 #print '-'*70  # dbg
                 #print 'IPExternalExample, Source:\n',string  # dbg
                 #print '-'*70  # dbg
                 Example = IPExternalExample
             else:
                 #print '-'*70  # dbg
                 #print 'IPExample, Source:\n',string  # dbg
                 #print '-'*70  # dbg
                 Example = IPExample
                 ip2py = True
         
         for m in terms:
             # Add the pre-example text to `output`.
             output.append(string[charno:m.start()])
             # Update lineno (lines before this example)
             lineno += string.count('\n', charno, m.start())
             # Extract info from the regexp match.
             (source, options, want, exc_msg) = \
                      self._parse_example(m, name, lineno,ip2py)
             if Example is IPExternalExample:
                 options[doctest.NORMALIZE_WHITESPACE] = True
             # Create an Example, and add it to the list.
             if not self._IS_BLANK_OR_COMMENT(source):
                 output.append(Example(source, want, exc_msg,
                                       lineno=lineno,
                                       indent=min_indent+len(m.group('indent')),
                                       options=options))
             # Update lineno (lines inside this example)
             lineno += string.count('\n', m.start(), m.end())
             # Update charno.
             charno = m.end()
         # Add any remaining post-example text to `output`.
         output.append(string[charno:])
 
         return output
 
     def _parse_example(self, m, name, lineno,ip2py=False):
         """
         Given a regular expression match from `_EXAMPLE_RE` (`m`),
         return a pair `(source, want)`, where `source` is the matched
         example's source code (with prompts and indentation stripped);
         and `want` is the example's expected output (with indentation
         stripped).
 
         `name` is the string's name, and `lineno` is the line number
         where the example starts; both are used for error messages.
 
         Optional:
         `ip2py`: if true, filter the input via IPython to convert the syntax
         into valid python.
         """
         
         # Get the example's indentation level.
         indent = len(m.group('indent'))
 
         # Divide source into lines; check that they're properly
         # indented; and then strip their indentation & prompts.
         source_lines = m.group('source').split('\n')
 
         # We're using variable-length input prompts
         ps1 = m.group('ps1')
         ps2 = m.group('ps2')
         ps1_len = len(ps1)
 
         self._check_prompt_blank(source_lines, indent, name, lineno,ps1_len)
         if ps2:
             self._check_prefix(source_lines[1:], ' '*indent + ps2, name, lineno)
 
         source = '\n'.join([sl[indent+ps1_len+1:] for sl in source_lines])
 
         if ip2py:
             # Convert source input from IPython into valid Python syntax
             source = self.ip2py(source)
 
         # Divide want into lines; check that it's properly indented; and
         # then strip the indentation.  Spaces before the last newline should
         # be preserved, so plain rstrip() isn't good enough.
         want = m.group('want')
         want_lines = want.split('\n')
         if len(want_lines) > 1 and re.match(r' *$', want_lines[-1]):
             del want_lines[-1]  # forget final newline & spaces after it
         self._check_prefix(want_lines, ' '*indent, name,
                            lineno + len(source_lines))
 
         # Remove ipython output prompt that might be present in the first line
         want_lines[0] = re.sub(r'Out\[\d+\]: \s*?\n?','',want_lines[0])
 
         want = '\n'.join([wl[indent:] for wl in want_lines])
 
         # If `want` contains a traceback message, then extract it.
         m = self._EXCEPTION_RE.match(want)
         if m:
             exc_msg = m.group('msg')
         else:
             exc_msg = None
 
         # Extract options from the source.
         options = self._find_options(source, name, lineno)
 
         return source, options, want, exc_msg
 
     def _check_prompt_blank(self, lines, indent, name, lineno, ps1_len):
         """
         Given the lines of a source string (including prompts and
         leading indentation), check to make sure that every prompt is
         followed by a space character.  If any line is not followed by
         a space character, then raise ValueError.
 
         Note: IPython-modified version which takes the input prompt length as a
         parameter, so that prompts of variable length can be dealt with.
         """
         space_idx = indent+ps1_len
         min_len = space_idx+1
         for i, line in enumerate(lines):
             if len(line) >=  min_len and line[space_idx] != ' ':
                 raise ValueError('line %r of the docstring for %s '
                                  'lacks blank after %s: %r' %
                                  (lineno+i+1, name,
                                   line[indent:space_idx], line))
 
 
 SKIP = register_optionflag('SKIP')
 
 class IPDocTestRunner(doctest.DocTestRunner):
     """Modified DocTestRunner which can also run IPython tests.
 
     This runner is capable of handling IPython doctests that require
     out-of-process output capture (such as system calls via !cmd or aliases).
     Note however that because these tests are run in a separate process, many
     of doctest's fancier capabilities (such as detailed exception analysis) are
     not available.  So try to limit such tests to simple cases of matching
     actual output.
     """
     
     #/////////////////////////////////////////////////////////////////
     # DocTest Running
     #/////////////////////////////////////////////////////////////////
 
     def _run_iptest(self, test, out):
         """
         Run the examples in `test`.  Write the outcome of each example with one
         of the `DocTestRunner.report_*` methods, using the writer function
         `out`.  Return a tuple `(f, t)`, where `t` is the number of examples
         tried, and `f` is the number of examples that failed.  The examples are
         run in the namespace `test.globs`.
 
         IPython note: this is a modified version of the original __run()
         private method to handle out-of-process examples.
         """
 
         if out is None:
             out = sys.stdout.write
 
         # Keep track of the number of failures and tries.
         failures = tries = 0
 
         # Save the option flags (since option directives can be used
         # to modify them).
         original_optionflags = self.optionflags
 
         SUCCESS, FAILURE, BOOM = range(3) # `outcome` state
 
         check = self._checker.check_output
 
         # Process each example.
         for examplenum, example in enumerate(test.examples):
 
             # If REPORT_ONLY_FIRST_FAILURE is set, then supress
             # reporting after the first failure.
             quiet = (self.optionflags & REPORT_ONLY_FIRST_FAILURE and
                      failures > 0)
 
             # Merge in the example's options.
             self.optionflags = original_optionflags
             if example.options:
                 for (optionflag, val) in example.options.items():
                     if val:
                         self.optionflags |= optionflag
                     else:
                         self.optionflags &= ~optionflag
 
             # If 'SKIP' is set, then skip this example.
             if self.optionflags & SKIP:
                 continue
 
             # Record that we started this example.
             tries += 1
             if not quiet:
                 self.report_start(out, test, example)
 
             # Run the example in the given context (globs), and record
             # any exception that gets raised.  (But don't intercept
             # keyboard interrupts.)
             try:
                 # Don't blink!  This is where the user's code gets run.
                 got = ''
                 # The code is run in an external process
                 got = iprunner.run_source(example.source,get_output=True)
             except KeyboardInterrupt:
                 raise
             except:
                 self.debugger.set_continue() # ==== Example Finished ====
 
             outcome = FAILURE   # guilty until proved innocent or insane
 
             if check(example.want, got, self.optionflags):
                 outcome = SUCCESS
 
             # Report the outcome.
             if outcome is SUCCESS:
                 if not quiet:
                     self.report_success(out, test, example, got)
             elif outcome is FAILURE:
                 if not quiet:
                     self.report_failure(out, test, example, got)
                 failures += 1
             elif outcome is BOOM:
                 if not quiet:
                     self.report_unexpected_exception(out, test, example,
                                                      exc_info)
                 failures += 1
             else:
                 assert False, ("unknown outcome", outcome)
 
         # Restore the option flags (in case they were modified)
         self.optionflags = original_optionflags
 
         # Record and return the number of failures and tries.
 
         # Hack to access a parent private method by working around Python's
         # name mangling (which is fortunately simple).
         doctest.DocTestRunner._DocTestRunner__record_outcome(self,test,
                                                              failures, tries)
         return failures, tries
 
     def run(self, test, compileflags=None, out=None, clear_globs=True):
         """Run examples in `test`.
 
         This method will defer to the parent for normal Python examples, but it
         will run IPython ones via pexpect.
         """
         if not test.examples:
             return
         
         if isinstance(test.examples[0],IPExternalExample):
             self._run_iptest(test,out)
         else:
             DocTestRunner.run(self,test,compileflags,out,clear_globs)
 
 
 class IPDebugRunner(IPDocTestRunner,doctest.DebugRunner):
     """IPython-modified DebugRunner, see the original class for details."""
     
     def run(self, test, compileflags=None, out=None, clear_globs=True):
         r = IPDocTestRunner.run(self, test, compileflags, out, False)
         if clear_globs:
             test.globs.clear()
         return r
 
 
 class IPDocTestLoader(unittest.TestLoader):
     """A test loader with IPython-enhanced doctest support.
 
     Instances of this loader will automatically add doctests found in a module
     to the test suite returned by the loadTestsFromModule method.  In
     addition, at initialization time a string of doctests can be given to the
     loader, enabling it to add doctests to a module which didn't have them in
     its docstring, coming from an external source."""
 
     
     def __init__(self,dt_files=None,dt_modules=None,test_finder=None):
         """Initialize the test loader.
 
         :Keywords:
 
           dt_files : list (None)
             List of names of files to be executed as doctests.
             
           dt_modules : list (None)
             List of module names to be scanned for doctests in their
             docstrings. 
 
           test_finder : instance (None)
             Instance of a testfinder (see doctest for details).
         """
 
         if dt_files is None: dt_files = []
         if dt_modules is None: dt_modules = []
         self.dt_files = utils.list_strings(dt_files)
         self.dt_modules = utils.list_strings(dt_modules)
         if test_finder is None:
             test_finder = doctest.DocTestFinder(parser=IPDocTestParser())
         self.test_finder = test_finder
 
     def loadTestsFromModule(self, module):
         """Return a suite of all tests cases contained in the given module.
 
         If the loader was initialized with a doctests argument, then this
         string is assigned as the module's docstring."""
 
         # Start by loading any tests in the called module itself
         suite = super(self.__class__,self).loadTestsFromModule(module)
 
         # Now, load also tests referenced at construction time as companion
         # doctests that reside in standalone files
         for fname in self.dt_files:
             #print 'mod:',module  # dbg
             #print 'fname:',fname  # dbg
             #suite.addTest(doctest.DocFileSuite(fname))
             suite.addTest(doctest.DocFileSuite(fname,module_relative=False))
         # Add docstring tests from module, if given at construction time
         for mod in self.dt_modules:
             suite.addTest(doctest.DocTestSuite(mod,
                                                test_finder=self.test_finder))
 
         #ipshell()  # dbg
         return suite
 
 def my_import(name):
     """Module importer - taken from the python documentation.
 
     This function allows importing names with dots in them."""
     
     mod = __import__(name)
     components = name.split('.')
     for comp in components[1:]:
         mod = getattr(mod, comp)
     return mod
 
 def makeTestSuite(module_name,dt_files=None,dt_modules=None,idt=True):
     """Make a TestSuite object for a given module, specified by name.
 
     This extracts all the doctests associated with a module using a
     DocTestLoader object.
 
     :Parameters:
 
       - module_name: a string containing the name of a module with unittests.
 
     :Keywords:
 
       dt_files : list of strings
         List of names of plain text files to be treated as doctests.
 
       dt_modules : list of strings
         List of names of modules to be scanned for doctests in docstrings.
 
       idt : bool (True)
         If True, return integrated doctests.  This means that each filename
         listed in dt_files is turned into a *single* unittest, suitable for
         running via unittest's runner or Twisted's Trial runner.  If false, the
         dt_files parameter is returned unmodified, so that other test runners
         (such as oilrun) can run the doctests with finer granularity.
     """
 
     mod = my_import(module_name)
     if idt:
         suite = IPDocTestLoader(dt_files,dt_modules).loadTestsFromModule(mod)
     else:
         suite = IPDocTestLoader(None,dt_modules).loadTestsFromModule(mod)
         
     if idt:
         return suite
     else:
         return suite,dt_files
 
 # Copied from doctest in py2.5 and modified for our purposes (since they don't
 # parametrize what we need)
 
 # For backward compatibility, a global instance of a DocTestRunner
 # class, updated by testmod.
 master = None
 
 def testmod(m=None, name=None, globs=None, verbose=None,
             report=True, optionflags=0, extraglobs=None,
             raise_on_error=False, exclude_empty=False):
     """m=None, name=None, globs=None, verbose=None, report=True,
        optionflags=0, extraglobs=None, raise_on_error=False,
        exclude_empty=False
 
     Note: IPython-modified version which loads test finder and runners that
     recognize IPython syntax in doctests.
 
     Test examples in docstrings in functions and classes reachable
     from module m (or the current module if m is not supplied), starting
     with m.__doc__.
 
     Also test examples reachable from dict m.__test__ if it exists and is
     not None.  m.__test__ maps names to functions, classes and strings;
     function and class docstrings are tested even if the name is private;
     strings are tested directly, as if they were docstrings.
 
     Return (#failures, #tests).
 
     See doctest.__doc__ for an overview.
 
     Optional keyword arg "name" gives the name of the module; by default
     use m.__name__.
 
     Optional keyword arg "globs" gives a dict to be used as the globals
     when executing examples; by default, use m.__dict__.  A copy of this
     dict is actually used for each docstring, so that each docstring's
     examples start with a clean slate.
 
     Optional keyword arg "extraglobs" gives a dictionary that should be
     merged into the globals that are used to execute examples.  By
     default, no extra globals are used.  This is new in 2.4.
 
     Optional keyword arg "verbose" prints lots of stuff if true, prints
     only failures if false; by default, it's true iff "-v" is in sys.argv.
 
     Optional keyword arg "report" prints a summary at the end when true,
     else prints nothing at the end.  In verbose mode, the summary is
     detailed, else very brief (in fact, empty if all tests passed).
 
     Optional keyword arg "optionflags" or's together module constants,
     and defaults to 0.  This is new in 2.3.  Possible values (see the
     docs for details):
 
         DONT_ACCEPT_TRUE_FOR_1
         DONT_ACCEPT_BLANKLINE
         NORMALIZE_WHITESPACE
         ELLIPSIS
         SKIP
         IGNORE_EXCEPTION_DETAIL
         REPORT_UDIFF
         REPORT_CDIFF
         REPORT_NDIFF
         REPORT_ONLY_FIRST_FAILURE
 
     Optional keyword arg "raise_on_error" raises an exception on the
     first unexpected exception or failure. This allows failures to be
     post-mortem debugged.
 
     Advanced tomfoolery:  testmod runs methods of a local instance of
     class doctest.Tester, then merges the results into (or creates)
     global Tester instance doctest.master.  Methods of doctest.master
     can be called directly too, if you want to do something unusual.
     Passing report=0 to testmod is especially useful then, to delay
     displaying a summary.  Invoke doctest.master.summarize(verbose)
     when you're done fiddling.
     """
     global master
 
     # If no module was given, then use __main__.
     if m is None:
         # DWA - m will still be None if this wasn't invoked from the command
         # line, in which case the following TypeError is about as good an error
         # as we should expect
         m = sys.modules.get('__main__')
 
     # Check that we were actually given a module.
     if not inspect.ismodule(m):
         raise TypeError("testmod: module required; %r" % (m,))
 
     # If no name was given, then use the module's name.
     if name is None:
         name = m.__name__
 
     #----------------------------------------------------------------------
     # fperez - make IPython finder and runner:
     # Find, parse, and run all tests in the given module.
     finder = DocTestFinder(exclude_empty=exclude_empty,
                            parser=IPDocTestParser())
 
     if raise_on_error:
         runner = IPDebugRunner(verbose=verbose, optionflags=optionflags)
     else:
         runner = IPDocTestRunner(verbose=verbose, optionflags=optionflags,
                                  #checker=IPOutputChecker()  # dbg
                                  )
 
     # /fperez - end of ipython changes
     #----------------------------------------------------------------------
 
     for test in finder.find(m, name, globs=globs, extraglobs=extraglobs):
         runner.run(test)
 
     if report:
         runner.summarize()
 
     if master is None:
         master = runner
     else:
         master.merge(runner)
 
     return runner.failures, runner.tries
 
 
 # Simple testing and example code
 if __name__ == "__main__":
     
     def ipfunc():
         """
         Some ipython tests...
 
         In [1]: import os
 
         In [2]: cd /
         /
 
         In [3]: 2+3
         Out[3]: 5
 
         In [26]: for i in range(3):
            ....:     print i,
            ....:     print i+1,
            ....:
         0 1 1 2 2 3
 
 
         Examples that access the operating system work:
         
         In [19]: cd /tmp
         /tmp
 
         In [20]: mkdir foo_ipython
 
         In [21]: cd foo_ipython
         /tmp/foo_ipython
 
         In [23]: !touch bar baz
 
         # We unfortunately can't just call 'ls' because its output is not
         # seen by doctest, since it happens in a separate process
         
         In [24]: os.listdir('.')
         Out[24]: ['bar', 'baz']
 
         In [25]: cd /tmp
         /tmp
 
         In [26]: rm -rf foo_ipython
 
 
         It's OK to use '_' for the last result, but do NOT try to use IPython's
         numbered history of _NN outputs, since those won't exist under the
         doctest environment:
         
         In [7]: 3+4
         Out[7]: 7
 
         In [8]: _+3
         Out[8]: 10
         """
 
     def ipfunc_external():
         """
         Tests that must be run in an external process
 
 
         # ipdoctest: EXTERNAL
 
         In [11]: for i in range(10):
            ....:     print i,
            ....:     print i+1,
            ....:
         0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10
 
 
         In [1]: import os
 
         In [1]: print "hello"
         hello
         
         In [19]: cd /tmp
         /tmp
 
         In [20]: mkdir foo_ipython2
 
         In [21]: cd foo_ipython2
         /tmp/foo_ipython2
 
         In [23]: !touch bar baz
 
         In [24]: ls
         bar  baz
 
         In [24]: !ls
         bar  baz
 
         In [25]: cd /tmp
         /tmp
 
         In [26]: rm -rf foo_ipython2
         """
 
     def pyfunc():
         """
         Some pure python tests...
 
         >>> import os
 
         >>> 2+3
         5
 
         >>> for i in range(3):
         ...     print i,
         ...     print i+1,
         ...
         0 1 1 2 2 3
         """
 
     # Call the global testmod() just like you would with normal doctest
     testmod()

IPython/testing/iptest.py

@@ -1,300 +1,300 b''
 # -*- coding: utf-8 -*-
 """IPython Test Suite Runner.
 
 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
    calling this script (with different arguments) or trial recursively.  This
    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.
 
 For now, this script requires that both nose and twisted are installed.  This
 will change in the future.
 """
 
 #-----------------------------------------------------------------------------
 # Module imports
 #-----------------------------------------------------------------------------
 
 import os
 import os.path as path
 import sys
 import subprocess
 import time
 import warnings
 
 import nose.plugins.builtin
 from nose.core import TestProgram
 
 from IPython.platutils import find_cmd
 from IPython.testing.plugin.ipdoctest import IPythonDoctest
 
 pjoin = path.join
 
 #-----------------------------------------------------------------------------
 # Logic for skipping doctests
 #-----------------------------------------------------------------------------
 
 def test_for(mod):
     """Test to see if mod is importable."""
     try:
         __import__(mod)
     except ImportError:
         return False
     else:
         return True
 
 have_curses = test_for('_curses')
 have_wx = test_for('wx')
 have_zi = test_for('zope.interface')
 have_twisted = test_for('twisted')
 have_foolscap = test_for('foolscap')
 have_objc = test_for('objc')
 have_pexpect = test_for('pexpect')
 
 # For the IPythonDoctest plugin, we need to exclude certain patterns that cause
 # testing problems.  We should strive to minimize the number of skipped
 # modules, since this means untested code.  As the testing machinery
 # solidifies, this list should eventually become empty.
 EXCLUDE = [pjoin('IPython', 'external'),
            pjoin('IPython', 'frontend', 'process', 'winprocess.py'),
            pjoin('IPython_doctest_plugin'),
            pjoin('IPython', 'Gnuplot'),
            pjoin('IPython', 'Extensions', 'ipy_'),
            pjoin('IPython', 'Extensions', 'clearcmd'),
            pjoin('IPython', 'Extensions', 'PhysicalQInteractive'),
            pjoin('IPython', 'Extensions', 'scitedirector'),
            pjoin('IPython', 'Extensions', 'numeric_formats'),
            pjoin('IPython', 'testing', 'attic'),
            pjoin('IPython', 'testing', 'tutils'),
            pjoin('IPython', 'testing', 'tools'),
            pjoin('IPython', 'testing', 'mkdoctests')
            ]
 
 if not have_wx:
     EXCLUDE.append(pjoin('IPython', 'Extensions', 'igrid'))
     EXCLUDE.append(pjoin('IPython', 'gui'))
     EXCLUDE.append(pjoin('IPython', 'frontend', 'wx'))
 
 if not have_objc:
     EXCLUDE.append(pjoin('IPython', 'frontend', 'cocoa'))
 
 if not have_curses:
     EXCLUDE.append(pjoin('IPython', 'Extensions', 'ibrowse'))
 
 if not sys.platform == 'win32':
     EXCLUDE.append(pjoin('IPython', 'platutils_win32'))
 
 # These have to be skipped on win32 because the use echo, rm, cd, etc.
 # See ticket https://bugs.launchpad.net/bugs/366982
 if sys.platform == 'win32':
     EXCLUDE.append(pjoin('IPython', 'testing', 'plugin', 'test_exampleip'))
     EXCLUDE.append(pjoin('IPython', 'testing', 'plugin', 'dtexample'))
 
 if not os.name == 'posix':
     EXCLUDE.append(pjoin('IPython', 'platutils_posix'))
 
 if not have_pexpect:
-    EXCLUDE.append(pjoin('IPython', 'irunner'))
+    EXCLUDE.append(pjoin('IPython', 'lib', 'irunner'))
 
 # This is needed for the reg-exp to match on win32 in the ipdoctest plugin.
 if sys.platform == 'win32':
     EXCLUDE = [s.replace('\\','\\\\') for s in EXCLUDE]
 
 
 #-----------------------------------------------------------------------------
 # Functions and classes
 #-----------------------------------------------------------------------------
 
 def run_iptest():
     """Run the IPython test suite using nose.
     
     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.
     """
 
     warnings.filterwarnings('ignore', 
         'This will be removed soon.  Use IPython.testing.util instead')
 
     argv = sys.argv + [ 
                         # Loading ipdoctest causes problems with Twisted.
                         # I am removing this as a temporary fix to get the 
                         # test suite back into working shape.  Our nose
                         # plugin needs to be gone through with a fine
                         # toothed comb to find what is causing the problem.
                         '--with-ipdoctest',
                         '--ipdoctest-tests','--ipdoctest-extension=txt',
                         '--detailed-errors',
                        
                         # 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',
                         ]
 
     # Detect if any tests were required by explicitly calling an IPython
     # submodule or giving a specific path
     has_tests = False
     for arg in sys.argv:
         if 'IPython' in arg or arg.endswith('.py') or \
            (':' in arg and  '.py' in arg):
             has_tests = True
             break
         
     # If nothing was specifically requested, test full IPython
     if not has_tests:
         argv.append('IPython')
 
     # Construct list of plugins, omitting the existing doctest plugin, which
     # ours replaces (and extends).
     plugins = [IPythonDoctest(EXCLUDE)]
     for p in nose.plugins.builtin.plugins:
         plug = p()
         if plug.name == 'doctest':
             continue
 
         #print '*** adding plugin:',plug.name  # dbg
         plugins.append(plug)
 
     TestProgram(argv=argv,plugins=plugins)
 
 
 class IPTester(object):
     """Call that calls iptest or trial in a subprocess.
     """
     def __init__(self,runner='iptest',params=None):
         """ """
         if runner == 'iptest':
             self.runner = ['iptest','-v']
         else:
             self.runner = [find_cmd('trial')]
         if params is None:
             params = []
         if isinstance(params,str):
             params = [params]
         self.params = params
 
         # Assemble call
         self.call_args = self.runner+self.params
 
     def run(self):
         """Run the stored commands"""
         return subprocess.call(self.call_args)
 
 
 def make_runners():
     """Define the modules and packages that need to be tested.
     """
     
     # This omits additional top-level modules that should not be doctested.
     # XXX: Shell.py is also ommited because of a bug in the skip_doctest
     # decorator.  See ticket https://bugs.launchpad.net/bugs/366209
     top_mod = \
       ['backgroundjobs.py', 'coloransi.py', 'completer.py', 'configloader.py',
        'crashhandler.py', 'debugger.py', 'deepreload.py', 'demo.py',
        'DPyGetOpt.py', 'dtutils.py', 'excolors.py', 'fakemodule.py',
        'generics.py', 'genutils.py', 'history.py', 'hooks.py', 'ipapi.py',
        'iplib.py', 'ipmaker.py', 'ipstruct.py', 'Itpl.py',
        'logger.py', 'macro.py', 'Magic.py', 'OInspect.py',
        'OutputTrap.py', 'platutils.py', 'prefilter.py', 'Prompts.py',
        'PyColorize.py', 'Release.py', 'rlineimpl.py', 'shadowns.py',
        'shellglobals.py', 'strdispatch.py', 'twshell.py',
        'ultraTB.py', 'upgrade_dir.py', 'usage.py', 'wildcard.py',
        # See note above for why this is skipped
        # 'Shell.py',
        'winconsole.py']
 
     if have_pexpect:
         top_mod.append('irunner.py')
 
     if sys.platform == 'win32':
         top_mod.append('platutils_win32.py')
     elif os.name == 'posix':
         top_mod.append('platutils_posix.py')
     else:
         top_mod.append('platutils_dummy.py')
 
     # These are tested by nose, so skip IPython.kernel
     top_pack = ['config','Extensions','frontend',
                 'testing','tests','tools','UserConfig']
 
     if have_wx:
         top_pack.append('gui')
 
     modules  = ['IPython.%s' % m[:-3] for m in top_mod ]
     packages = ['IPython.%s' % m for m in top_pack ]
 
     # Make runners
     runners = dict(zip(top_pack, [IPTester(params=v) for v in packages]))
     
     # Test IPython.kernel using trial if twisted is installed
     if have_zi and have_twisted and have_foolscap:
         runners['trial'] = IPTester('trial',['IPython'])
 
     runners['modules'] = IPTester(params=modules)
 
     return runners
 
 
 def run_iptestall():
     """Run the entire IPython test suite by calling nose and trial.
     
     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
     nose or twisted.trial appropriately.
     """
     runners = make_runners()
     # Run all test runners, tracking execution time
     failed = {}
     t_start = time.time()
     for name,runner in runners.iteritems():
         print '*'*77
         print 'IPython test set:',name
         res = runner.run()
         if res:
             failed[name] = res
     t_end = time.time()
     t_tests = t_end - t_start
     nrunners = len(runners)
     nfail = len(failed)
     # summarize results
     print
     print '*'*77
     print 'Ran %s test sets in %.3fs' % (nrunners, t_tests)
     print
     if not failed:
         print 'OK'
     else:
         # If anything went wrong, point out what command to rerun manually to
         # see the actual errors and individual summary
         print 'ERROR - %s out of %s test sets failed.' % (nfail, nrunners)
         for name in failed:
             failed_runner = runners[name]
             print '-'*40
             print 'Runner failed:',name
             print 'You may wish to rerun this one individually, with:'
             print ' '.join(failed_runner.call_args)
             print
 
 
 def main():
     if len(sys.argv) == 1:
         run_iptestall()
     else:
         if sys.argv[1] == 'all':
             run_iptestall()
         else:
             run_iptest()
 
 
 if __name__ == '__main__':
     main()
  No newline at end of file

IPython/testing/mkdoctests.py

@@ -1,244 +1,244 b''
 #!/usr/bin/env python
 """Utility for making a doctest file out of Python or IPython input.
 
   %prog [options] input_file [output_file]
 
 This script is a convenient generator of doctest files that uses IPython's
 irunner script to execute valid Python or IPython input in a separate process,
 capture all of the output, and write it to an output file.
 
 It can be used in one of two ways:
 
 1. With a plain Python or IPython input file (denoted by extensions '.py' or
    '.ipy'.  In this case, the output is an auto-generated reST file with a
    basic header, and the captured Python input and output contained in an
    indented code block.
 
    If no output filename is given, the input name is used, with the extension
    replaced by '.txt'.
 
 2. With an input template file.  Template files are simply plain text files
    with special directives of the form
 
    %run filename
 
    to include the named file at that point.
 
    If no output filename is given and the input filename is of the form
    'base.tpl.txt', the output will be automatically named 'base.txt'.
 """
 
 # Standard library imports
 
 import optparse
 import os
 import re
 import sys
 import tempfile
 
 # IPython-specific libraries
-from IPython import irunner
+from IPython.lib import irunner
 from IPython.utils.genutils import fatal
 
 class IndentOut(object):
     """A simple output stream that indents all output by a fixed amount.
 
     Instances of this class trap output to a given stream and first reformat it
     to indent every input line."""
     
     def __init__(self,out=sys.stdout,indent=4):
         """Create an indented writer.
 
         :Keywords:
 
         - `out` : stream (sys.stdout)
           Output stream to actually write to after indenting.
 
         - `indent` : int
           Number of spaces to indent every input line by.
         """
         
         self.indent_text = ' '*indent
         self.indent = re.compile('^',re.MULTILINE).sub
         self.out = out
         self._write = out.write
         self.buffer = []
         self._closed = False
 
     def write(self,data):
         """Write a string to the output stream."""
 
         if self._closed:
             raise ValueError('I/O operation on closed file')
         self.buffer.append(data)
 
     def flush(self):
         if self.buffer:
             data = ''.join(self.buffer)
             self.buffer[:] = []
             self._write(self.indent(self.indent_text,data))
         
     def close(self):
         self.flush()
         self._closed = True
 
 class RunnerFactory(object):
     """Code runner factory.
 
     This class provides an IPython code runner, but enforces that only one
     runner is every instantiated.  The runner is created based on the extension
     of the first file to run, and it raises an exception if a runner is later
     requested for a different extension type.
 
     This ensures that we don't generate example files for doctest with a mix of
     python and ipython syntax.
     """
 
     def __init__(self,out=sys.stdout):
         """Instantiate a code runner."""
         
         self.out = out
         self.runner = None
         self.runnerClass = None
 
     def _makeRunner(self,runnerClass):
         self.runnerClass = runnerClass
         self.runner = runnerClass(out=self.out)
         return self.runner
           
     def __call__(self,fname):
         """Return a runner for the given filename."""
 
         if fname.endswith('.py'):
             runnerClass = irunner.PythonRunner
         elif fname.endswith('.ipy'):
             runnerClass = irunner.IPythonRunner
         else:
             raise ValueError('Unknown file type for Runner: %r' % fname)
 
         if self.runner is None:
             return self._makeRunner(runnerClass)
         else:
             if runnerClass==self.runnerClass:
                 return self.runner
             else:
                 e='A runner of type %r can not run file %r' % \
                    (self.runnerClass,fname)
                 raise ValueError(e)
 
 TPL = """
 =========================
  Auto-generated doctests
 =========================
 
 This file was auto-generated by IPython in its entirety.  If you need finer
 control over the contents, simply make a manual template.  See the
 mkdoctests.py script for details.
 
 %%run %s
 """
 
 def main():
     """Run as a script."""
 
     # Parse options and arguments.
     parser = optparse.OptionParser(usage=__doc__)
     newopt = parser.add_option
     newopt('-f','--force',action='store_true',dest='force',default=False,
            help='Force overwriting of the output file.')
     newopt('-s','--stdout',action='store_true',dest='stdout',default=False,
            help='Use stdout instead of a file for output.')
 
     opts,args = parser.parse_args()
     if len(args) < 1:
         parser.error("incorrect number of arguments")
 
     # Input filename
     fname = args[0]
 
     # We auto-generate the output file based on a trivial template to make it
     # really easy to create simple doctests.
 
     auto_gen_output = False
     try:
         outfname = args[1]
     except IndexError:
         outfname = None
 
     if fname.endswith('.tpl.txt') and outfname is None:
         outfname = fname.replace('.tpl.txt','.txt')
     else:
         bname, ext = os.path.splitext(fname)
         if ext in ['.py','.ipy']:
             auto_gen_output = True
         if outfname is None:
             outfname = bname+'.txt'
 
     # Open input file
 
     # In auto-gen mode, we actually change the name of the input file to be our
     # auto-generated template
     if auto_gen_output:
         infile = tempfile.TemporaryFile()
         infile.write(TPL % fname)
         infile.flush()
         infile.seek(0)
     else:
         infile = open(fname)
 
     # Now open the output file.  If opts.stdout was given, this overrides any
     # explicit choice of output filename and just directs all output to
     # stdout.
     if opts.stdout:
         outfile = sys.stdout
     else:
         # Argument processing finished, start main code
         if os.path.isfile(outfname) and not opts.force:
             fatal("Output file %r exists, use --force (-f) to overwrite."
                   % outfname)
         outfile = open(outfname,'w')
 
 
     # all output from included files will be indented 
     indentOut = IndentOut(outfile,4)
     getRunner = RunnerFactory(indentOut)
 
     # Marker in reST for transition lines
     rst_transition = '\n'+'-'*76+'\n\n'
 
     # local shorthand for loop
     write = outfile.write
 
     # Process input, simply writing back out all normal lines and executing the
     # files in lines marked as '%run filename'.
     for line in infile:
         if line.startswith('%run '):
             # We don't support files with spaces in their names.
             incfname = line.split()[1]
 
             # We make the output of the included file appear bracketed between
             # clear reST transition marks, and indent it so that if anyone
             # makes an HTML or PDF out of the file, all doctest input and
             # output appears in proper literal blocks.
             write(rst_transition)
             write('Begin included file %s::\n\n' % incfname)
 
             # I deliberately do NOT trap any exceptions here, so that if
             # there's any problem, the user running this at the command line
             # finds out immediately by the code blowing up, rather than ending
             # up silently with an incomplete or incorrect file.
             getRunner(incfname).run_file(incfname)
 
             write('\nEnd included file %s\n' % incfname)
             write(rst_transition)
         else:
             # The rest of the input file is just written out
             write(line)
     infile.close()
 
     # Don't close sys.stdout!!!
     if outfile is not sys.stdout:
         outfile.close()
 
 if __name__ == '__main__':
     main()