Merge branch 'bug-tests' of https://github.com/ivanov/ipython into ivanov-bug-tests

IPython/external/decorators/_numpy_testing_noseclasses.py

@@ -0,0 +1,41 b''
+# IPython: modified copy of numpy.testing.noseclasses, so
+# IPython.external._decorators works without numpy being installed.
+
+# These classes implement a "known failure" error class.
+
+import os
+
+from nose.plugins.errorclass import ErrorClass, ErrorClassPlugin
+
+class KnownFailureTest(Exception):
+    '''Raise this exception to mark a test as a known failing test.'''
+    pass
+
+
+class KnownFailure(ErrorClassPlugin):
+    '''Plugin that installs a KNOWNFAIL error class for the
+    KnownFailureClass exception.  When KnownFailureTest is raised,
+    the exception will be logged in the knownfail attribute of the
+    result, 'K' or 'KNOWNFAIL' (verbose) will be output, and the
+    exception will not be counted as an error or failure.'''
+    enabled = True
+    knownfail = ErrorClass(KnownFailureTest,
+                           label='KNOWNFAIL',
+                           isfailure=False)
+
+    def options(self, parser, env=os.environ):
+        env_opt = 'NOSE_WITHOUT_KNOWNFAIL'
+        parser.add_option('--no-knownfail', action='store_true',
+                          dest='noKnownFail', default=env.get(env_opt, False),
+                          help='Disable special handling of KnownFailureTest '
+                               'exceptions')
+
+    def configure(self, options, conf):
+        if not self.can_configure:
+            return
+        self.conf = conf
+        disable = getattr(options, 'noKnownFail', False)
+        if disable:
+            self.enabled = False
+
+

IPython/core/tests/test_interactiveshell.py

@@ -20,6 +20,7 b' Authors'
 #-----------------------------------------------------------------------------
 # stdlib
 import unittest
+from IPython.testing import decorators as dec
 
 #-----------------------------------------------------------------------------
 # Tests
@@ -35,14 +36,14 b' class InteractiveShellTestCase(unittest.TestCase):'
         # And also multi-line cells
         ip.run_cell('"""a\nb"""\n')
         self.assertEquals(ip.user_ns['_'], 'a\nb')
-        
+
     def test_run_empty_cell(self):
         """Just make sure we don't get a horrible error with a blank
         cell of input. Yes, I did overlook that."""
         ip = get_ipython()
         ip.run_cell('')
 
-    def test_run_cell_multilne(self):
+    def test_run_cell_multiline(self):
         """Multi-block, multi-line cells must execute correctly.
         """
         ip = get_ipython()
@@ -54,4 +55,34 b' class InteractiveShellTestCase(unittest.TestCase):'
         ip.run_cell(src)
         self.assertEquals(ip.user_ns['x'], 2)
         self.assertEquals(ip.user_ns['y'], 3)
-        
+
+    @dec.skip_known_failure
+    def test_multiline_string_cells(self):
+        "Code sprinkled with multiline strings should execute (GH-306)"
+        ip = get_ipython()
+        ip.run_cell('tmp=0')
+        self.assertEquals(ip.user_ns['tmp'], 0)
+        ip.run_cell('tmp=1;"""a\nb"""\n')
+        self.assertEquals(ip.user_ns['tmp'], 1)
+
+    @dec.skip_known_failure
+    def test_dont_cache_with_semicolon(self):
+        "Ending a line with semicolon should not cache the returned object (GH-307)"
+        ip = get_ipython()
+        oldlen = len(ip.user_ns['Out'])
+        a = ip.run_cell('1;')
+        newlen = len(ip.user_ns['Out'])
+        self.assertEquals(oldlen, newlen)
+        #also test the default caching behavior
+        ip.run_cell('1')
+        newlen = len(ip.user_ns['Out'])
+        self.assertEquals(oldlen+1, newlen)
+
+    def test_In_variable(self):
+        "Verify that In variable grows with user input (GH-284)"
+        ip = get_ipython()
+        oldlen = len(ip.user_ns['In'])
+        ip.run_cell('1;')
+        newlen = len(ip.user_ns['In'])
+        self.assertEquals(oldlen+1, newlen)
+        self.assertEquals(ip.user_ns['In'][-1],'1;')

IPython/core/tests/test_run.py

@@ -170,6 +170,26 b' class TestMagicRunSimple(tt.TempFileMixin):'
                "a = A()\n")
         self.mktmp(src)
         tt.ipexec_validate(self.fname, 'object A deleted')
+    
+    @dec.skip_known_failure 
+    def test_aggressive_namespace_cleanup(self):
+        """Test that namespace cleanup is not too aggressive GH-238
+
+        Returning from another run magic deletes the namespace"""
+        # see ticket https://github.com/ipython/ipython/issues/238
+        class secondtmp(tt.TempFileMixin): pass
+        empty = secondtmp()
+        empty.mktmp('')
+        src = ("ip = get_ipython()\n"
+               "for i in range(5):\n"
+               "   try:\n"
+               "       ip.magic('run %s')\n"
+               "   except NameError, e:\n"
+               "       print i;break\n" % empty.fname)
+        self.mktmp(src)
+        _ip.magic('run %s' % self.fname)
+        _ip.runlines('ip == get_ipython()')
+        tt.assert_equals(_ip.user_ns['i'], 5)
 
     @dec.skip_win32
     def test_tclass(self):

IPython/extensions/sympy_printing.py

@@ -15,8 +15,14 b' Authors:'
 #-----------------------------------------------------------------------------
 
 from IPython.lib.latextools import latex_to_png
+from IPython.testing import decorators as dec
+# use @dec.skipif_not_sympy to skip tests requiring sympy
+
+try:
+    from sympy import pretty, latex
+except ImportError:
+    pass
 
-from sympy import pretty, latex
 
 #-----------------------------------------------------------------------------
 # Definitions of magic functions for use with IPython
@@ -44,7 +50,6 b' def print_png(o):'
 
 _loaded = False
 
-
 def load_ipython_extension(ip):
     """Load the extension in IPython."""
     global _loaded

IPython/external/decorators/__init__.py

@@ -1,4 +1,6 b''
 try:
     from numpy.testing.decorators import *
+    from numpy.testing.noseclasses import KnownFailure
 except ImportError:
     from _decorators import *
+    from _numpy_testing_noseclasses import KnownFailure

IPython/external/decorators/_decorators.py

@@ -14,18 +14,15 b' function name, setup and teardown functions and so on - see'
 
 """
 import warnings
-import sys
 
 # IPython changes: make this work if numpy not available
 # Original code:
 #from numpy.testing.utils import \
 #        WarningManager, WarningMessage
 # Our version:
-try:
-    from numpy.testing.utils import WarningManager, WarningMessage
-except ImportError:
-    from _numpy_testing_utils import WarningManager, WarningMessage
-    
+from _numpy_testing_utils import WarningManager
+from _numpy_testing_noseclasses import KnownFailureTest
+
 # End IPython changes
 
 def slow(t):
@@ -34,7 +31,7 b' def slow(t):'
 
     The exact definition of a slow test is obviously both subjective and
     hardware-dependent, but in general any individual test that requires more
-    than a second or two should be labeled as slow (the whole suite consits of
+    than a second or two should be labeled as slow (the whole suite consists of
     thousands of tests, so even a second is significant).
 
     Parameters
@@ -172,7 +169,6 b' def skipif(skip_condition, msg=None):'
 
     return skip_decorator
 
-
 def knownfailureif(fail_condition, msg=None):
     """
     Make function raise KnownFailureTest exception if given condition is true.
@@ -216,7 +212,6 b' def knownfailureif(fail_condition, msg=None):'
         # Local import to avoid a hard nose dependency and only incur the
         # import time overhead at actual test-time.
         import nose
-        from noseclasses import KnownFailureTest
         def knownfailer(*args, **kwargs):
             if fail_val():
                 raise KnownFailureTest, msg
@@ -255,7 +250,6 b' def deprecated(conditional=True):'
         # Local import to avoid a hard nose dependency and only incur the
         # import time overhead at actual test-time.
         import nose
-        from noseclasses import KnownFailureTest
 
         def _deprecated_imp(*args, **kwargs):
             # Poor man's replacement for the with statement

IPython/external/decorators/_numpy_testing_utils.py

@@ -1,14 +1,10 b''
-# IPython: modified copy of numpy.testing.utils, so numpy.testing.decorators
-# works without numpy being installed.
+# IPython: modified copy of numpy.testing.utils, so
+# IPython.external._decorators works without numpy being installed.
 """
 Utility function to facilitate testing.
 """
 
-import os
 import sys
-import re
-import operator
-import types
 import warnings
 
 # The following two classes are copied from python 2.6 warnings module (context

IPython/testing/decorators.py

@@ -24,9 +24,10 b' Lightweight testing that remains unittest-compatible.'
   recognize it as such.  This will make it easier to migrate away from Nose if
   we ever need/want to while maintaining very lightweight tests.
 
-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.
+NOTE: This file contains IPython-specific decorators. Using the machinery in
+IPython.external.decorators, we import either numpy.testing.decorators if numpy is
+available, OR use equivalent code in IPython.external._decorators, which
+we've copied verbatim from numpy.
 
 Authors
 -------
@@ -274,19 +275,19 b' def onlyif(condition, msg):'
 
 #-----------------------------------------------------------------------------
 # Utility functions for decorators
-def numpy_not_available():
-    """Can numpy be imported?  Returns true if numpy does NOT import.
+def module_not_available(module):
+    """Can module be imported?  Returns true if module does NOT import.
 
-    This is used to make a decorator to skip tests that require numpy to be
+    This is used to make a decorator to skip tests that require module to be
     available, but delay the 'import numpy' to test execution time.
     """
     try:
-        import numpy
-        np_not_avail = False
+        mod = __import__(module)
+        mod_not_avail = False
     except ImportError:
-        np_not_avail = True
+        mod_not_avail = True
 
-    return np_not_avail
+    return mod_not_avail
 
 #-----------------------------------------------------------------------------
 # Decorators for public use
@@ -315,9 +316,11 b" skip_if_not_osx = skipif(sys.platform != 'darwin',"
                          "This test only runs under OSX")
 
 # Other skip decorators
-skipif_not_numpy = skipif(numpy_not_available,"This test requires numpy")
+skipif_not_numpy = skipif(module_not_available('numpy'),"This test requires numpy")
 
-skip_known_failure = skip('This test is known to fail')
+skipif_not_sympy = skipif(module_not_available('sympy'),"This test requires sympy")
+
+skip_known_failure = knownfailureif(True,'This test is known to fail')
 
 # A null 'decorator', useful to make more readable code that needs to pick
 # between different decorators based on OS or other conditions

IPython/testing/iptest.py

@@ -53,6 +53,7 b' from IPython.utils.sysinfo import sys_info'
 
 from IPython.testing import globalipapp
 from IPython.testing.plugin.ipdoctest import IPythonDoctest
+from IPython.external.decorators import KnownFailure
 
 pjoin = path.join
 
@@ -357,7 +358,7 b' def run_iptest():'
 
     # Construct list of plugins, omitting the existing doctest plugin, which
     # ours replaces (and extends).
-    plugins = [IPythonDoctest(make_exclude())]
+    plugins = [IPythonDoctest(make_exclude()), KnownFailure()]
     for p in nose.plugins.builtin.plugins:
         plug = p()
         if plug.name == 'doctest':