Fixes to frontend tests.

Mostly robustness and isolation improvements.

IPython/frontend/prefilterfrontend.py

@@ -1,280 +1,285 b''
 """
 Frontend class that uses IPython0 to prefilter the inputs.
 
 Using the IPython0 mechanism gives us access to the magics.
 
 This is a transitory class, used here to do the transition between
 ipython0 and ipython1. This class is meant to be short-lived as more
 functionnality is abstracted out of ipython0 in reusable functions and
 is added on the interpreter. This class can be a used to guide this
 refactoring.
 """
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  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 sys
 import pydoc
 import os
 import re
 import __builtin__
 
 from IPython.ipmaker import make_IPython
 from IPython.ipapi import IPApi
 from IPython.kernel.core.redirector_output_trap import RedirectorOutputTrap
 
 from IPython.kernel.core.sync_traceback_trap import SyncTracebackTrap
 
 from IPython.genutils import Term
 
 from linefrontendbase import LineFrontEndBase, common_prefix
 
 
 def mk_system_call(system_call_function, command):
     """ given a os.system replacement, and a leading string command,
         returns a function that will execute the command with the given
         argument string.
     """
     def my_system_call(args):
         system_call_function("%s %s" % (command, args))
 
     my_system_call.__doc__ = "Calls %s" % command
     return my_system_call
 
 #-------------------------------------------------------------------------------
 # Frontend class using ipython0 to do the prefiltering. 
 #-------------------------------------------------------------------------------
 class PrefilterFrontEnd(LineFrontEndBase):
     """ Class that uses ipython0 to do prefilter the input, do the
     completion and the magics.
 
     The core trick is to use an ipython0 instance to prefilter the
     input, and share the namespace between the interpreter instance used
     to execute the statements and the ipython0 used for code
     completion...
     """
 
     debug = False
     
-    def __init__(self, ipython0=None, *args, **kwargs):
+    def __init__(self, ipython0=None, argv=None, *args, **kwargs):
         """ Parameters:
             -----------
 
             ipython0: an optional ipython0 instance to use for command
             prefiltering and completion.
+
+            argv : list, optional
+              Used as the instance's argv value.  If not given, [] is used.
         """
+        if argv is None:
+            argv = []
         # This is a hack to avoid the IPython exception hook to trigger
         # on exceptions (https://bugs.launchpad.net/bugs/337105)
         # XXX: This is horrible: module-leve monkey patching -> side
         # effects.
         from IPython import iplib
         iplib.InteractiveShell.isthreaded = True
 
         LineFrontEndBase.__init__(self, *args, **kwargs)
         self.shell.output_trap = RedirectorOutputTrap(
                             out_callback=self.write,
                             err_callback=self.write,
                                             )
         self.shell.traceback_trap = SyncTracebackTrap(
                         formatters=self.shell.traceback_trap.formatters,
                             )
 
         # Start the ipython0 instance:
         self.save_output_hooks()
         if ipython0 is None:
             # Instanciate an IPython0 interpreter to be able to use the
             # prefiltering.
             # Suppress all key input, to avoid waiting
             def my_rawinput(x=None):
                 return '\n'
             old_rawinput = __builtin__.raw_input
             __builtin__.raw_input = my_rawinput
             # XXX: argv=[] is a bit bold.
-            ipython0 = make_IPython(argv=[], 
+            ipython0 = make_IPython(argv=argv, 
                                     user_ns=self.shell.user_ns,
                                     user_global_ns=self.shell.user_global_ns)
             __builtin__.raw_input = old_rawinput
         self.ipython0 = ipython0
         # Set the pager:
         self.ipython0.set_hook('show_in_pager', 
                     lambda s, string: self.write("\n" + string))
         self.ipython0.write = self.write
         self._ip = _ip = IPApi(self.ipython0)
         # Make sure the raw system call doesn't get called, as we don't
         # have a stdin accessible.
         self._ip.system = self.system_call
         # XXX: Muck around with magics so that they work better
         # in our environment
         if not sys.platform.startswith('win'):
             self.ipython0.magic_ls = mk_system_call(self.system_call, 
                                                                 'ls -CF')
         # And now clean up the mess created by ipython0
         self.release_output()
 
 
         if not 'banner' in kwargs and self.banner is None:
             self.banner = self.ipython0.BANNER
 
         # FIXME: __init__ and start should be two different steps
         self.start()
 
     #--------------------------------------------------------------------------
     # FrontEndBase interface 
     #--------------------------------------------------------------------------
 
     def show_traceback(self):
         """ Use ipython0 to capture the last traceback and display it.
         """
         # Don't do the capture; the except_hook has already done some
         # modifications to the IO streams, if we store them, we'll be
         # storing the wrong ones.
         #self.capture_output()
         self.ipython0.showtraceback(tb_offset=-1)
         self.release_output()
 
 
     def execute(self, python_string, raw_string=None):
         if self.debug:
             print 'Executing Python code:', repr(python_string)
         self.capture_output()
         LineFrontEndBase.execute(self, python_string,
                                     raw_string=raw_string)
         self.release_output()
 
 
     def save_output_hooks(self):
         """ Store all the output hooks we can think of, to be able to
         restore them. 
         
         We need to do this early, as starting the ipython0 instance will
         screw ouput hooks.
         """
         self.__old_cout_write = Term.cout.write
         self.__old_cerr_write = Term.cerr.write
         self.__old_stdout = sys.stdout
         self.__old_stderr= sys.stderr
         self.__old_help_output = pydoc.help.output
         self.__old_display_hook = sys.displayhook
 
 
     def capture_output(self):
         """ Capture all the output mechanisms we can think of.
         """
         self.save_output_hooks()
         Term.cout.write = self.write
         Term.cerr.write = self.write
         sys.stdout = Term.cout
         sys.stderr = Term.cerr
         pydoc.help.output = self.shell.output_trap.out
 
 
     def release_output(self):
         """ Release all the different captures we have made.
         """
         Term.cout.write = self.__old_cout_write
         Term.cerr.write = self.__old_cerr_write
         sys.stdout = self.__old_stdout
         sys.stderr = self.__old_stderr
         pydoc.help.output = self.__old_help_output 
         sys.displayhook = self.__old_display_hook 
 
 
     def complete(self, line):
         # FIXME: This should be factored out in the linefrontendbase
         # method.
         word = self._get_completion_text(line)
         completions = self.ipython0.complete(word)
         # FIXME: The proper sort should be done in the complete method.
         key = lambda x: x.replace('_', '')
         completions.sort(key=key)
         if completions:
             prefix = common_prefix(completions) 
             line = line[:-len(word)] + prefix
         return line, completions 
  
     
     #--------------------------------------------------------------------------
     # LineFrontEndBase interface 
     #--------------------------------------------------------------------------
 
     def prefilter_input(self, input_string):
         """ Using IPython0 to prefilter the commands to turn them
         in executable statements that are valid Python strings.
         """
         input_string = LineFrontEndBase.prefilter_input(self, input_string)
         filtered_lines = []
         # The IPython0 prefilters sometime produce output. We need to
         # capture it.
         self.capture_output()
         self.last_result = dict(number=self.prompt_number)
         
         ## try:
         ##     for line in input_string.split('\n'):
         ##         filtered_lines.append(
         ##                 self.ipython0.prefilter(line, False).rstrip())
         ## except:
         ##     # XXX: probably not the right thing to do.
         ##     self.ipython0.showsyntaxerror()
         ##     self.after_execute()
         ## finally:
         ##     self.release_output()
 
 
         try:
             try:
                 for line in input_string.split('\n'):
                     filtered_lines.append(
                             self.ipython0.prefilter(line, False).rstrip())
             except:
                 # XXX: probably not the right thing to do.
                 self.ipython0.showsyntaxerror()
                 self.after_execute()
         finally:
             self.release_output()
 
 
 
         # Clean up the trailing whitespace, to avoid indentation errors
         filtered_string = '\n'.join(filtered_lines)
         return filtered_string
 
 
     #--------------------------------------------------------------------------
     # PrefilterFrontEnd interface 
     #--------------------------------------------------------------------------
  
     def system_call(self, command_string):
         """ Allows for frontend to define their own system call, to be
             able capture output and redirect input.
         """
         return os.system(command_string)
 
 
     def do_exit(self):
         """ Exit the shell, cleanup and save the history.
         """
         self.ipython0.atexit_operations()
 
 
     def _get_completion_text(self, line):
         """ Returns the text to be completed by breaking the line at specified
         delimiters.
         """
         # Break at: spaces, '=', all parentheses (except if balanced).
         # FIXME2: In the future, we need to make the implementation similar to
         # that in the 'pyreadline' module (modes/basemode.py) where we break at
         # each delimiter and try to complete the residual line, until we get a
         # successful list of completions.
         expression = '\s|=|,|:|\((?!.*\))|\[(?!.*\])|\{(?!.*\})' 
         complete_sep = re.compile(expression)
         text = complete_sep.split(line)[-1]
         return text
 

IPython/frontend/tests/test_prefilterfrontend.py

@@ -1,244 +1,252 b''
 # encoding: utf-8
 """
 Test process execution and IO redirection.
 """
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  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.
 #-------------------------------------------------------------------------------
 
+from copy import copy, deepcopy
 from cStringIO import StringIO
 import string
 
 from nose.tools import assert_equal
 
-from IPython.ipapi import get as get_ipython0
 from IPython.frontend.prefilterfrontend import PrefilterFrontEnd
-from copy import copy, deepcopy
+from IPython.ipapi import get as get_ipython0
+from IPython.testing.plugin.ipdoctest import default_argv
+
 
 def safe_deepcopy(d):
     """ Deep copy every key of the given dict, when possible. Elsewhere
         do a copy.
     """
     copied_d = dict()
     for key, value in d.iteritems():
         try:
             copied_d[key] = deepcopy(value)
         except:
             try:
                 copied_d[key] = copy(value)
             except:
                 copied_d[key] = value
     return copied_d
 
 
 class TestPrefilterFrontEnd(PrefilterFrontEnd):
     
     input_prompt_template = string.Template('')
     output_prompt_template = string.Template('')
     banner = ''
 
     def __init__(self):
         self.out = StringIO()
-        PrefilterFrontEnd.__init__(self)
+        PrefilterFrontEnd.__init__(self,argv=default_argv())
         # Some more code for isolation (yeah, crazy)
         self._on_enter()
         self.out.flush()
         self.out.reset()
         self.out.truncate()
 
     def write(self, string, *args, **kwargs):
        self.out.write(string) 
 
     def _on_enter(self):
         self.input_buffer += '\n'
         PrefilterFrontEnd._on_enter(self)
 
 
 def isolate_ipython0(func):
     """ Decorator to isolate execution that involves an iptyhon0.
 
         Notes
-        ------
+        -----
 
         Apply only to functions with no arguments. Nose skips functions
         with arguments.
     """
     def my_func():
         iplib = get_ipython0()
         if iplib is None:
             return func()
         ipython0 = iplib.IP
         global_ns = safe_deepcopy(ipython0.user_global_ns)
         user_ns = safe_deepcopy(ipython0.user_ns)
         try:
             out = func()
         finally:
             ipython0.user_ns = user_ns
             ipython0.user_global_ns = global_ns
         # Undo the hack at creation of PrefilterFrontEnd
         from IPython import iplib
         iplib.InteractiveShell.isthreaded = False
         return out
 
     my_func.__name__ = func.__name__
     return my_func
 
 
 @isolate_ipython0
 def test_execution():
     """ Test execution of a command.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer = 'print 1'
     f._on_enter()
     out_value = f.out.getvalue()
     assert_equal(out_value, '1\n')
 
 
 @isolate_ipython0
 def test_multiline():
     """ Test execution of a multiline command.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer = 'if True:'
     f._on_enter()
     f.input_buffer += 'print 1'
     f._on_enter()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, ''
     f._on_enter()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, '1\n'
     f = TestPrefilterFrontEnd()
     f.input_buffer='(1 +'
     f._on_enter()
     f.input_buffer += '0)'
     f._on_enter()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, ''
     f._on_enter()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, '1\n'
 
 
 @isolate_ipython0
 def test_capture():
     """ Test the capture of output in different channels.
     """
     # Test on the OS-level stdout, stderr.
     f = TestPrefilterFrontEnd()
     f.input_buffer = \
             'import os; out=os.fdopen(1, "w"); out.write("1") ; out.flush()'
     f._on_enter()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, '1'
     f = TestPrefilterFrontEnd()
     f.input_buffer = \
             'import os; out=os.fdopen(2, "w"); out.write("1") ; out.flush()'
     f._on_enter()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, '1'
 
      
 @isolate_ipython0
 def test_magic():
     """ Test the magic expansion and history.
     
         This test is fairly fragile and will break when magics change.
     """
     f = TestPrefilterFrontEnd()
+    # Before checking the interactive namespace, make sure it's clear (it can
+    # otherwise pick up things stored in the user's local db)
+    f.input_buffer += '%reset -f'
+    f._on_enter()
+    f.complete_current_input()
+    # Now, run the %who magic and check output
     f.input_buffer += '%who'
     f._on_enter()
     out_value = f.out.getvalue()
     assert_equal(out_value, 'Interactive namespace is empty.\n')
 
 
 @isolate_ipython0
 def test_help():
     """ Test object inspection.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer += "def f():"
     f._on_enter()
     f.input_buffer += "'foobar'"
     f._on_enter()
     f.input_buffer += "pass"
     f._on_enter()
     f._on_enter()
     f.input_buffer += "f?"
     f._on_enter()
     assert 'traceback' not in f.last_result
     ## XXX: ipython doctest magic breaks this. I have no clue why
     #out_value = f.out.getvalue()
     #assert out_value.split()[-1] == 'foobar' 
 
 
 @isolate_ipython0
 def test_completion_simple():
     """ Test command-line completion on trivial examples.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer = 'zzza = 1'
     f._on_enter()
     f.input_buffer = 'zzzb = 2'
     f._on_enter()
     f.input_buffer = 'zz'
     f.complete_current_input()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, '\nzzza zzzb '
     yield assert_equal, f.input_buffer, 'zzz'
 
 
 @isolate_ipython0
 def test_completion_parenthesis():
     """ Test command-line completion when a parenthesis is open.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer = 'zzza = 1'
     f._on_enter()
     f.input_buffer = 'zzzb = 2'
     f._on_enter()
     f.input_buffer = 'map(zz'
     f.complete_current_input()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, '\nzzza zzzb '
     yield assert_equal, f.input_buffer, 'map(zzz'
 
 
 @isolate_ipython0
 def test_completion_indexing():
     """ Test command-line completion when indexing on objects.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer = 'a = [0]'
     f._on_enter()
     f.input_buffer = 'a[0].'
     f.complete_current_input()
     assert_equal(f.input_buffer, 'a[0].__')
 
 
 @isolate_ipython0
 def test_completion_equal():
     """ Test command-line completion when the delimiter is "=", not " ".
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer = 'a=1.'
     f.complete_current_input()
     assert_equal(f.input_buffer, 'a=1.__')
 
 
 
 if __name__ == '__main__':
     test_magic()
     test_help()
     test_execution()
     test_multiline()
     test_capture()
     test_completion_simple()
     test_completion_complex()