Update decorators and test scripts.

IPython/testing/decorators.py

@@ -1,160 +1,244 b''
 """Decorators for labeling test objects.
 
-Decorators that merely return a modified version of the original
-function object are straightforward.  Decorators that return a new
-function object need to use
-nose.tools.make_decorator(original_function)(decorator) in returning
-the decorator, in order to preserve metadata such as function name,
-setup and teardown functions and so on - see nose.tools for more
-information.
+Decorators that merely return a modified version of the original function
+object are straightforward.  Decorators that return a new function object need
+to use nose.tools.make_decorator(original_function)(decorator) in returning the
+decorator, in order to preserve metadata such as function name, setup and
+teardown functions and so on - see nose.tools for more information.
 
 This module provides a set of useful decorators meant to be ready to use in
 your own tests.  See the bottom of the file for the ready-made ones, and if you
 find yourself writing a new one that may be of generic use, add it here.
 
 NOTE: This file contains IPython-specific decorators and imports the
 numpy.testing.decorators file, which we've copied verbatim.  Any of our own
 code will be added at the bottom if we end up extending this.
 """
 
 # Stdlib imports
 import inspect
 import sys
 
 # Third-party imports
 
 # This is Michele Simionato's decorator module, also kept verbatim.
 from decorator_msim import decorator, update_wrapper
 
 # Grab the numpy-specific decorators which we keep in a file that we
 # occasionally update from upstream: decorators_numpy.py is an IDENTICAL copy
 # of numpy.testing.decorators.
 from decorators_numpy import *
 
 ##############################################################################
 # Local code begins
 
 # Utility functions
 
 def apply_wrapper(wrapper,func):
     """Apply a wrapper to a function for decoration.
 
     This mixes Michele Simionato's decorator tool with nose's make_decorator,
     to apply a wrapper in a decorator so that all nose attributes, as well as
     function signature and other properties, survive the decoration cleanly.
     This will ensure that wrapped functions can still be well introspected via
     IPython, for example.
     """
     import nose.tools
 
     return decorator(wrapper,nose.tools.make_decorator(func)(wrapper))
 
 
 def make_label_dec(label,ds=None):
     """Factory function to create a decorator that applies one or more labels.
 
     :Parameters:
       label : string or sequence
       One or more labels that will be applied by the decorator to the functions
     it decorates.  Labels are attributes of the decorated function with their
     value set to True.
 
     :Keywords:
       ds : string
       An optional docstring for the resulting decorator.  If not given, a
       default docstring is auto-generated.
 
     :Returns:
       A decorator.
 
     :Examples:
 
     A simple labeling decorator:
     >>> slow = make_label_dec('slow')
     >>> print slow.__doc__
     Labels a test as 'slow'.
 
     And one that uses multiple labels and a custom docstring:
     >>> rare = make_label_dec(['slow','hard'],
     ... "Mix labels 'slow' and 'hard' for rare tests.")
     >>> print rare.__doc__
     Mix labels 'slow' and 'hard' for rare tests.
 
     Now, let's test using this one:
     >>> @rare
     ... def f(): pass
     ...
     >>>
     >>> f.slow
     True
     >>> f.hard
     True
     """
 
     if isinstance(label,basestring):
         labels = [label]
     else:
         labels = label
         
     # Validate that the given label(s) are OK for use in setattr() by doing a
     # dry run on a dummy function.
     tmp = lambda : None
     for label in labels:
         setattr(tmp,label,True)
 
     # This is the actual decorator we'll return
     def decor(f):
         for label in labels:
             setattr(f,label,True)
         return f
     
     # Apply the user's docstring, or autogenerate a basic one
     if ds is None:
         ds = "Labels a test as %r." % label
     decor.__doc__ = ds
     
     return decor
 
-#-----------------------------------------------------------------------------
-# Decorators for public use
-
-skip_doctest = make_label_dec('skip_doctest',
-    """Decorator - mark a function or method for skipping its doctest.
 
-    This decorator allows you to mark a function whose docstring you wish to
-    omit from testing, while preserving the docstring for introspection, help,
-    etc.""")                              
-
-def skip(msg=''):
-    """Decorator - mark a test function for skipping from test suite.
-
-    This function *is* already a decorator, it is not a factory like
-    make_label_dec or some of those in decorators_numpy.
+# Inspired by numpy's skipif, but uses the full apply_wrapper utility to
+# preserve function metadata better and allows the skip condition to be a
+# callable.
+def skipif(skip_condition, msg=None):
+    ''' Make function raise SkipTest exception if skip_condition is true
+
+    Parameters
+    ---------
+    skip_condition : bool or callable. 
+ 	Flag to determine whether to skip test.  If the condition is a 
+ 	callable, it is used at runtime to dynamically make the decision.  This 
+ 	is useful for tests that may require costly imports, to delay the cost 
+ 	until the test suite is actually executed.        
+    msg : string
+        Message to give on raising a SkipTest exception
+
+   Returns
+   -------
+   decorator : function
+       Decorator, which, when applied to a function, causes SkipTest
+       to be raised when the skip_condition was True, and the function
+       to be called normally otherwise.
+
+    Notes
+    -----
+    You will see from the code that we had to further decorate the
+    decorator with the nose.tools.make_decorator function in order to
+    transmit function name, and various other metadata.
+    '''
+
+    def skip_decorator(f):
+        # Local import to avoid a hard nose dependency and only incur the 
+        # import time overhead at actual test-time. 
+        import nose
+
+        # Allow for both boolean or callable skip conditions.
+        if callable(skip_condition):
+            skip_val = lambda : skip_condition()
+        else:
+            skip_val = lambda : skip_condition
+
+        def get_msg(func,msg=None):
+            """Skip message with information about function being skipped."""
+            if msg is None: out = 'Test skipped due to test condition.'
+            else: out = msg
+            return "Skipping test: %s. %s" % (func.__name__,out)
+
+        # We need to define *two* skippers because Python doesn't allow both
+        # return with value and yield inside the same function.
+        def skipper_func(*args, **kwargs):
+            """Skipper for normal test functions."""
+            if skip_val():
+                raise nose.SkipTest(get_msg(f,msg))
+            else:
+                return f(*args, **kwargs) 
+
+        def skipper_gen(*args, **kwargs):
+            """Skipper for test generators."""
+            if skip_val():
+                raise nose.SkipTest(get_msg(f,msg))
+            else:
+                for x in f(*args, **kwargs):
+                    yield x
+
+        # Choose the right skipper to use when building the actual generator.
+        if nose.util.isgenerator(f):
+            skipper = skipper_gen
+        else:
+            skipper = skipper_func
+            
+        return nose.tools.make_decorator(f)(skipper)
+
+    return skip_decorator
+
+# A version with the condition set to true, common case just to attacha message
+# to a skip decorator
+def skip(msg=None):
+    """Decorator factory - mark a test function for skipping from test suite.
 
     :Parameters:
-
-      func : function
-        Test function to be skipped
-
       msg : string
         Optional message to be added.
+
+    :Returns:
+       decorator : function
+         Decorator, which, when applied to a function, causes SkipTest
+         to be raised, with the optional message added.
       """
 
-    import nose
+    return skipif(True,msg)
 
-    def inner(func):
 
-        def wrapper(*a,**k):
-            if msg: out = '\n'+msg
-            else: out = ''
-            raise nose.SkipTest("Skipping test for function: %s%s" %
-                                (func.__name__,out))
+#-----------------------------------------------------------------------------
+# Utility functions for decorators
+def numpy_not_available():
+    """Can numpy be imported?  Returns true if numpy does NOT import.
 
-        return apply_wrapper(wrapper,func)
+    This is used to make a decorator to skip tests that require numpy to be
+    available, but delay the 'import numpy' to test execution time.
+    """
+    try:
+        import numpy
+        np_not_avail = False
+    except ImportError:
+        np_not_avail = True
+
+    return np_not_avail
+
+#-----------------------------------------------------------------------------
+# Decorators for public use
+
+skip_doctest = make_label_dec('skip_doctest',
+    """Decorator - mark a function or method for skipping its doctest.
 
-    return inner
+    This decorator allows you to mark a function whose docstring you wish to
+    omit from testing, while preserving the docstring for introspection, help,
+    etc.""")                              
 
 # Decorators to skip certain tests on specific platforms.
-skip_win32 = skipif(sys.platform=='win32',"This test does not run under Windows")
+skip_win32 = skipif(sys.platform=='win32',
+                    "This test does not run under Windows")
 skip_linux = skipif(sys.platform=='linux2',"This test does not run under Linux")
-skip_osx = skipif(sys.platform=='darwin',"This test does not run under OSX")
+skip_osx = skipif(sys.platform=='darwin',"This test does not run under OS X")
+
+
+skipif_not_numpy = skipif(numpy_not_available,"This test requires numpy")
+
+skipknownfailure = skip('This test is known to fail')

IPython/testing/iptest.py

@@ -1,53 +1,55 b''
 # -*- coding: utf-8 -*-
 """IPython Test Suite Runner.
 """
 
 import sys
 import warnings
 
 from nose.core import TestProgram
 import nose.plugins.builtin
 
 from IPython.testing.plugin.ipdoctest import IPythonDoctest
 
 def main():
     """Run the IPython test suite.
     """
 
     warnings.filterwarnings('ignore', 
         'This will be removed soon.  Use IPython.testing.util instead')
 
     argv = sys.argv + [ '--with-ipdoctest',
                         '--doctest-tests','--doctest-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',
                         ]
 
-    has_ip = False
+    # 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:
-            has_ip = True
+        if 'IPython' in arg or arg.endswith('.py') or \
+           (':' in arg and  '.py' in arg):
+            has_tests = True
             break
-
-    if not has_ip:
+    # If nothing was specifically requested, test full IPython
+    if not has_tests:
         argv.append('IPython')
 
     # construct list of plugins, omitting the existing doctest plugin
     plugins = [IPythonDoctest()]
     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)

IPython/tests/test_magic.py

@@ -1,92 +1,115 b''
-""" Tests for various magic functions
+"""Tests for various magic functions.
 
-Needs to be run by nose (to make ipython session available)
+Needs to be run by nose (to make ipython session available).
 """
 
+# Standard library imports
+import os
+import sys
+
+# Third-party imports
+import nose.tools as nt
+
+# From our own code
 from IPython.testing import decorators as dec
 
+#-----------------------------------------------------------------------------
+# Test functions begin
+
 def test_rehashx():
     # clear up everything
     _ip.IP.alias_table.clear()
     del _ip.db['syscmdlist']
     
     _ip.magic('rehashx')
     # Practically ALL ipython development systems will have more than 10 aliases
 
     assert len(_ip.IP.alias_table) > 10
     for key, val in _ip.IP.alias_table.items():
         # we must strip dots from alias names
         assert '.' not in key
 
     # rehashx must fill up syscmdlist
     scoms = _ip.db['syscmdlist']
     assert len(scoms) > 10
 
 
 def doctest_run_ns():
     """Classes declared %run scripts must be instantiable afterwards.
 
     In [3]: run tclass.py
 
     In [4]: f()
     """
     pass # doctest only
 
 
 def doctest_hist_f():
     """Test %hist -f with temporary filename.
 
     In [9]: import tempfile
 
     In [10]: tfile = tempfile.mktemp('.py','tmp-ipython-')
 
     In [11]: %history -n -f $tfile 3
     """
 
 
 def doctest_hist_r():
     """Test %hist -r
 
     XXX - This test is not recording the output correctly.  Not sure why...
 
     In [6]: x=1
 
     In [7]: hist -n -r 2
     x=1  # random
     hist -n -r 2  # random
     """
 
 
 def test_shist():
-    # Simple tests of ShadowHist class
+    # Simple tests of ShadowHist class - test generator.
     import os, shutil, tempfile
-    import nose.tools as nt
 
     from IPython.Extensions import pickleshare
     from IPython.history import ShadowHist
     
-
     tfile = tempfile.mktemp('','tmp-ipython-')
     
     db = pickleshare.PickleShareDB(tfile)
     s = ShadowHist(db)
     s.add('hello')
     s.add('world')
     s.add('hello')
     s.add('hello')
     s.add('karhu')
 
     yield nt.assert_equals,s.all(),[(1, 'hello'), (2, 'world'), (3, 'karhu')]
     
     yield nt.assert_equal,s.get(2),'world'
     
     shutil.rmtree(tfile)
     
[e-mail]_not_numpy
+def test_numpy_clear_array_undec():
+    _ip.ex('import numpy as np')
+    _ip.ex('a = np.empty(2)')
+    
+    yield nt.assert_true,'a' in _ip.user_ns
+    _ip.magic('clear array')
+    yield nt.assert_false,'a' in _ip.user_ns
+    
 
[e-mail]_numpy_not_avail
-def doctest_clear_array():
-    """Check that array clearing works.
[e-mail]()
+def test_fail_dec(*a,**k):
+    yield nt.assert_true, False
+
[e-mail]('This one shouldn not run')
+def test_fail_dec2(*a,**k):
+    yield nt.assert_true, False
+
[e-mail]
+def test_fail_dec3(*a,**k):
+    yield nt.assert_true, False
 
-    >>> 1/0
-    """
-    pass # doctest only