Use IPython parameterized testing

IPython/nbconvert/filters/tests/test_ansi.py

@@ -1,88 +1,84 b''
 """
 Module with tests for ansi filters
 """
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
-from IPython.testing import decorators as dec
 from IPython.utils.coloransi import TermColors
 
 from ...tests.base import TestsBase
 from ..ansi import strip_ansi, ansi2html, ansi2latex
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class TestAnsi(TestsBase):
     """Contains test functions for ansi.py"""
 
-    @dec.parametric
     def test_strip_ansi(self):
         """strip_ansi test"""
         correct_outputs = {
             '%s%s%s' % (TermColors.Green, TermColors.White, TermColors.Red)  : '',
             'hello%s' % TermColors.Blue: 'hello',
             'he%s%sllo' % (TermColors.Yellow, TermColors.Cyan) : 'hello',
             '%shello' % TermColors.Blue : 'hello',
             '{0}h{0}e{0}l{0}l{0}o{0}'.format(TermColors.Red) : 'hello',
             'hel%slo' % TermColors.Green : 'hello',
             'hello' : 'hello'}
 
         for inval, outval in correct_outputs.items():
-            yield self._try_strip_ansi, inval, outval
+            yield self._try_strip_ansi(inval, outval)
 
 
     def _try_strip_ansi(self, inval, outval):
-        self.assert_equal(outval, strip_ansi(inval))
+        self.assertEqual(outval, strip_ansi(inval))
 
 
-    @dec.parametric
     def test_ansi2html(self):
         """ansi2html test"""
         correct_outputs = {
             '%s' % (TermColors.Red)  : '<span class="ansired"></span>',
             'hello%s' % TermColors.Blue: 'hello<span class="ansiblue"></span>',
             'he%s%sllo' % (TermColors.Green, TermColors.Cyan) : 'he<span class="ansigreen"></span><span class="ansicyan">llo</span>',
             '%shello' % TermColors.Yellow : '<span class="ansiyellow">hello</span>',
             '{0}h{0}e{0}l{0}l{0}o{0}'.format(TermColors.White) : '<span class="ansigrey">h</span><span class="ansigrey">e</span><span class="ansigrey">l</span><span class="ansigrey">l</span><span class="ansigrey">o</span><span class="ansigrey"></span>',
             'hel%slo' % TermColors.Green : 'hel<span class="ansigreen">lo</span>',
             'hello' : 'hello'}
 
         for inval, outval in correct_outputs.items():
-            yield self._try_ansi2html, inval, outval
+            yield self._try_ansi2html(inval, outval)
 
 
     def _try_ansi2html(self, inval, outval):
         self.fuzzy_compare(outval, ansi2html(inval))
 
 
-    @dec.parametric
     def test_ansi2latex(self):
         """ansi2latex test"""
         correct_outputs = {
             '%s' % (TermColors.Red)  : r'\red{}',
             'hello%s' % TermColors.Blue: r'hello\blue{}',
             'he%s%sllo' % (TermColors.Green, TermColors.Cyan) : r'he\green{}\cyan{llo}',
             '%shello' % TermColors.Yellow : r'\yellow{hello}',
             '{0}h{0}e{0}l{0}l{0}o{0}'.format(TermColors.White) : r'\white{h}\white{e}\white{l}\white{l}\white{o}\white{}',
             'hel%slo' % TermColors.Green : r'hel\green{lo}',
             'hello' : 'hello'}
 
         for inval, outval in correct_outputs.items():
-            yield self._try_ansi2latex, inval, outval
+            yield self._try_ansi2latex(inval, outval)
 
 
     def _try_ansi2latex(self, inval, outval):
         self.fuzzy_compare(outval, ansi2latex(inval), case_sensitive=True)

IPython/nbconvert/filters/tests/test_datatypefilter.py

@@ -1,46 +1,46 b''
 """
 Module with tests for DataTypeFilter
 """
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 
 from ...tests.base import TestsBase
 from ..datatypefilter import DataTypeFilter
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class TestDataTypeFilter(TestsBase):
     """Contains test functions for datatypefilter.py"""
 
 
     def test_constructor(self):
         """Can an instance of a DataTypeFilter be created?"""
         DataTypeFilter()
 
 
     def test_junk_types(self):
         """Can the DataTypeFilter pickout a useful type from a list of junk types?"""
         filter = DataTypeFilter()
         assert "png" in filter(["hair", "water", "png", "rock"])
         assert "pdf" in filter(["pdf", "hair", "water", "png", "rock"])
-        self.assert_equals(filter(["hair", "water", "rock"]), [])
+        self.assertEqual(filter(["hair", "water", "rock"]), [])
 
 
     def test_null(self):
         """Will the DataTypeFilter fail if no types are passed in?"""
         filter = DataTypeFilter()
-        self.assert_equals(filter([]), [])
+        self.assertEqual(filter([]), [])

IPython/nbconvert/filters/tests/test_highlight.py

@@ -1,69 +1,65 b''
 """
 Module with tests for Highlight
 """
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
-from IPython.testing import decorators as dec
-
 from ...tests.base import TestsBase
 from ..highlight import highlight2html, highlight2latex
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class TestHighlight(TestsBase):
     """Contains test functions for highlight.py"""
 
     #Hello world test, magics test, blank string test
     tests = [
         """
         #Hello World Example
 
         def say(text):
             print(text)
 
         say('Hello World!')
         """,
         """
         %%pylab
         plot(x,y, 'r')
         """
         ]   
 
     tokens = [
         ['Hello World Example', 'say', 'text', 'print', 'def'],
         ['pylab', 'plot']]
 
 
-    @dec.parametric
     def test_highlight2html(self):
         """highlight2html test"""
         for index, test in enumerate(self.tests):
-            yield self._try_highlight, highlight2html, test, self.tokens[index]
+            yield self._try_highlight(highlight2html, test, self.tokens[index])
 
 
-    @dec.parametric
     def test_highlight2latex(self):
         """highlight2latex test"""
         for index, test in enumerate(self.tests):
-            yield self._try_highlight, highlight2latex, test, self.tokens[index]
+            yield self._try_highlight(highlight2latex, test, self.tokens[index])
 
 
     def _try_highlight(self, method, test, tokens):
         """Try highlighting source, look for key tokens"""
         results = method(test)
         for token in tokens:
             assert token in results

IPython/nbconvert/filters/tests/test_latex.py

@@ -1,69 +1,65 b''
 """
 Module with tests for Latex
 """
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
-from IPython.testing import decorators as dec
-
 from ...tests.base import TestsBase
 from ..latex import escape_latex, strip_math_space
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class TestLatex(TestsBase):
 
 
-    @dec.parametric
     def test_escape_latex(self):
         """escape_latex test"""
         tests = [
             (r'How are \you doing today?', r'How are \textbackslashyou doing today?'),
             (r'\escapechar=`\A\catcode`\|=0 |string|foo', r'\textbackslashescapechar=`\textbackslashA\textbackslashcatcode`\textbackslash|=0 |string|foo'),
             (r'# $ % & ~ _ ^ \ { }',r'\# \$ \% \& \~{} \_ \^{} \textbackslash \{ \}'),
             ('','')]
 
         for test in tests:
-            yield self._try_escape_latex, test[0], test[1]
+            yield self._try_escape_latex(test[0], test[1])
 
 
     def _try_escape_latex(self, test, result):
         """Try to remove latex from string"""
-        self.assert_equal(escape_latex(test), result)
+        self.assertEqual(escape_latex(test), result)
 
 
-    @dec.parametric
     def test_strip_math_space(self):
         """strip_math_space test"""
         tests = [
             ('$e$','$e$'),
             ('$ e $','$e$'),
             ('xxx$e^i$yyy','xxx$e^i$yyy'),
             ('xxx$ e^i $yyy','xxx$e^i$yyy'),
             ('xxx$e^i $yyy','xxx$e^i$yyy'),
             ('xxx$ e^i$yyy','xxx$e^i$yyy'),
             ('\$ e $ e $','\$ e $e$'),
             ('','')]
 
         for test in tests:
-            yield self._try_strip_math_space, test[0], test[1]
+            yield self._try_strip_math_space(test[0], test[1])
 
 
     def _try_strip_math_space(self, test, result):
         """
         Try to remove spaces between dollar symbols and contents correctly
         """
-        self.assert_equal(strip_math_space(test), result)
+        self.assertEqual(strip_math_space(test), result)

IPython/nbconvert/filters/tests/test_markdown.py

@@ -1,96 +1,93 b''
 
 """
 Module with tests for Markdown
 """
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from copy import copy
 
 from IPython.utils.py3compat import string_types
 from IPython.testing import decorators as dec
 
 from ...tests.base import TestsBase
 from ..markdown import markdown2latex, markdown2html, markdown2rst
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class TestMarkdown(TestsBase):
 
     tests = [
         '*test',
         '**test',
         '*test*',
         '_test_',
         '__test__',
         '__*test*__',
         '**test**',
         '#test',
         '##test',
         'test\n----',
         'test [link](https://google.com/)']
 
     tokens = [
         '*test',
         '**test',
         'test',
         'test',
         'test',
         'test',
         'test',
         'test',
         'test',
         'test',
         ('test', 'https://google.com/')]
 
 
     @dec.onlyif_cmds_exist('pandoc')
-    @dec.parametric
     def test_markdown2latex(self):
         """markdown2latex test"""
         for index, test in enumerate(self.tests):
-            yield self._try_markdown, markdown2latex, test, self.tokens[index]
+            yield self._try_markdown(markdown2latex, test, self.tokens[index])
 
 
     @dec.onlyif_cmds_exist('pandoc')
-    @dec.parametric
     def test_markdown2html(self):
         """markdown2html test"""
         for index, test in enumerate(self.tests):
-            yield self._try_markdown, markdown2html, test, self.tokens[index]
+            yield self._try_markdown(markdown2html, test, self.tokens[index])
 
 
     @dec.onlyif_cmds_exist('pandoc')
-    @dec.parametric
     def test_markdown2rst(self):
         """markdown2rst test"""
 
         #Modify token array for rst, escape asterik
         tokens = copy(self.tokens)
         tokens[0] = r'\*test'
         tokens[1] = r'\*\*test'
 
         for index, test in enumerate(self.tests):
-            yield self._try_markdown, markdown2rst, test, tokens[index]
+            yield self._try_markdown(markdown2rst, test, tokens[index])
 
 
     def _try_markdown(self, method, test, tokens):
         results = method(test)
         if isinstance(tokens, string_types):
             assert tokens in results
         else:
             for token in tokens:
                 assert token in results

IPython/nbconvert/filters/tests/test_strings.py

@@ -1,122 +1,119 b''
 """
 Module with tests for Strings
 """
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from IPython.testing import decorators as dec
 from ...tests.base import TestsBase
 from ..strings import (wrap_text, html2text, add_anchor, strip_dollars, 
     strip_files_prefix, get_lines, comment_lines, ipython2python)
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class TestStrings(TestsBase):
 
-    @dec.parametric
     def test_wrap_text(self):
         """wrap_text test"""
         test_text = """
         Tush! never tell me; I take it much unkindly
         That thou, Iago, who hast had my purse
         As if the strings were thine, shouldst know of this.
         """
         for length in [30,5,1]:
-            yield self._confirm_wrap_text, test_text, length
+            yield self._confirm_wrap_text(test_text, length)
     
 
     def _confirm_wrap_text(self, text, length):
         for line in wrap_text(text, length).split('\n'):
             assert len(line) <= length
 
 
     def test_html2text(self):
         """html2text test"""
         #TODO: More tests
-        self.assert_equal(html2text('<name>joe</name>'), 'joe')
+        self.assertEqual(html2text('<name>joe</name>'), 'joe')
         
 
     def test_add_anchor(self):
         """add_anchor test"""
         #TODO: More tests
         results = add_anchor('<b>Hello World!</b>')
         assert 'Hello World!' in results
         assert 'id="' in results
         assert 'class="anchor-link"' in results
         assert '<b' in results
         assert '</b>' in results
 
         
-    @dec.parametric
     def test_strip_dollars(self):
         """strip_dollars test"""
         tests = [
             ('', ''), 
             ('$$', ''), 
             ('$H$', 'H'), 
             ('$He', 'He'), 
             ('H$el', 'H$el'), 
             ('Hell$', 'Hell'),
             ('Hello', 'Hello'),
             ('W$o$rld', 'W$o$rld')]
         for test in tests:
-            yield self._try_strip_dollars, test[0], test[1]
+            yield self._try_strip_dollars(test[0], test[1])
 
 
     def _try_strip_dollars(self, test, result):
-        self.assert_equal(strip_dollars(test), result)
+        self.assertEqual(strip_dollars(test), result)
 
 
-    @dec.parametric
     def test_strip_files_prefix(self):
         """strip_files_prefix test"""
         tests = [
             ('', ''), 
             ('/files', '/files'), 
             ('test="/files"', 'test="/files"'), 
             ('My files are in `files/`', 'My files are in `files/`'),
             ('<a href="files/test.html">files/test.html</a>', '<a href="test.html">files/test.html</a>')]
         for test in tests:
-            yield self._try_files_prefix, test[0], test[1]
+            yield self._try_files_prefix(test[0], test[1])
 
 
     def _try_files_prefix(self, test, result):
-        self.assert_equal(strip_files_prefix(test), result)
+        self.assertEqual(strip_files_prefix(test), result)
         
 
     def test_comment_lines(self):
         """comment_lines test"""
         for line in comment_lines('hello\nworld\n!').split('\n'):
             assert line.startswith('# ')
         for line in comment_lines('hello\nworld\n!', 'beep').split('\n'):
             assert line.startswith('beep')
         
 
     def test_get_lines(self):
         """get_lines test"""
         text = "hello\nworld\n!"
-        self.assert_equal(get_lines(text, start=1), "world\n!")
-        self.assert_equal(get_lines(text, end=2), "hello\nworld")
-        self.assert_equal(get_lines(text, start=2, end=5), "!")
-        self.assert_equal(get_lines(text, start=-2), "world\n!")
+        self.assertEqual(get_lines(text, start=1), "world\n!")
+        self.assertEqual(get_lines(text, end=2), "hello\nworld")
+        self.assertEqual(get_lines(text, start=2, end=5), "!")
+        self.assertEqual(get_lines(text, start=-2), "world\n!")
         
 
     def test_ipython2python(self):
         """ipython2python test"""
         #TODO: More tests
         results = ipython2python(u'%%pylab\nprint("Hello-World")').replace("u'", "'")
         self.fuzzy_compare(results, u"get_ipython().run_cell_magic('pylab', '', 'print(\"Hello-World\")')", 
             ignore_spaces=True, ignore_newlines=True)

IPython/nbconvert/tests/base.py

@@ -1,151 +1,143 b''
 """
 Contains base test class for nbconvert
 """
 #-----------------------------------------------------------------------------
 #Copyright (c) 2013, the IPython Development Team.
 #
 #Distributed under the terms of the Modified BSD License.
 #
 #The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import os
 import glob
 import shutil
 
-from nose.tools import assert_equal
 import IPython
 from IPython.utils.tempdir import TemporaryWorkingDirectory
 from IPython.utils.process import get_output_error_code
 from IPython.testing.tools import get_ipython_cmd
+from IPython.testing.ipunittest import ParametricTestCase
 
 # a trailing space allows for simpler concatenation with the other arguments
 ipy_cmd = get_ipython_cmd(as_string=True) + " "
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 
-class TestsBase(object):
+class TestsBase(ParametricTestCase):
     """Base tests class.  Contains useful fuzzy comparison and nbconvert
     functions."""
 
 
-    def __init__(self):
-
-        # We need to manually add assert_equal to the class instead of inheriting
-        # from unittest.TestCase because if we inherit from unittest.TestCase
-        # support for test generators is lost (a known 'feature' of nose).
-        self.assert_equal = assert_equal
-
-
     def fuzzy_compare(self, a, b, newlines_are_spaces=True, tabs_are_spaces=True, 
                       fuzzy_spacing=True, ignore_spaces=False, 
                       ignore_newlines=False, case_sensitive=False, leave_padding=False):
         """
         Performs a fuzzy comparison of two strings.  A fuzzy comparison is a
         comparison that ignores insignificant differences in the two comparands.
         The significance of certain differences can be specified via the keyword
         parameters of this method.
         """
 
         if not leave_padding:
             a = a.strip()
             b = b.strip()
 
         if ignore_newlines:
             a = a.replace('\n', '')
             b = b.replace('\n', '')
 
         if newlines_are_spaces:
             a = a.replace('\n', ' ')
             b = b.replace('\n', ' ')
 
         if tabs_are_spaces:
             a = a.replace('\t', ' ')
             b = b.replace('\t', ' ')
 
         if ignore_spaces:
             a = a.replace(' ', '')
             b = b.replace(' ', '')
 
         if fuzzy_spacing:
             a = self.recursive_replace(a, '  ', ' ')
             b = self.recursive_replace(b, '  ', ' ')
 
         if not case_sensitive:
             a = a.lower()
             b = b.lower()
 
-        self.assert_equal(a, b)
+        self.assertEqual(a, b)
 
 
     def recursive_replace(self, text, search, replacement):
         """
         Performs a recursive replacement operation.  Replaces all instances
         of a search string in a text string with a replacement string until
         the search string no longer exists.  Recursion is needed because the
         replacement string may generate additional search strings.
 
         For example:
            Replace "ii" with "i" in the string "Hiiii" yields "Hii"
            Another replacement yields "Hi" (the desired output)
 
         Parameters:
         -----------
         text : string
             Text to replace in.
         search : string
             String to search for within "text"
         replacement : string
             String to replace "search" with
         """
         while search in text:
             text = text.replace(search, replacement)
         return text
 
     def create_temp_cwd(self, copy_filenames=None):
         temp_dir = TemporaryWorkingDirectory()
 
         #Copy the files if requested.
         if copy_filenames is not None:
             self.copy_files_to(copy_filenames)
 
         #Return directory handler
         return temp_dir
 
 
     def copy_files_to(self, copy_filenames, dest='.'):
         "Copy test files into the destination directory"
         if not os.path.isdir(dest):
             os.makedirs(dest)
         files_path = self._get_files_path()
         for pattern in copy_filenames:
             for match in glob.glob(os.path.join(files_path, pattern)):
                 shutil.copyfile(match, os.path.join(dest, os.path.basename(match)))
 
 
     def _get_files_path(self):
 
         #Get the relative path to this module in the IPython directory.
         names = self.__module__.split('.')[1:-1]
         names.append('files')
         
         #Build a path using the IPython directory and the relative path we just
         #found.
         path = IPython.__path__[0]
         for name in names:
             path = os.path.join(path, name)
         return path
 
 
     def call(self, parameters, raise_on_error=True):
         stdout, stderr, retcode = get_output_error_code(ipy_cmd + parameters)
         if retcode != 0 and raise_on_error:
             raise OSError(stderr)
         return stdout, stderr