183 lines
6.1 KiB
Python
183 lines
6.1 KiB
Python
"""Base test class for nbconvert"""
|
|
|
|
# Copyright (c) IPython Development Team.
|
|
# Distributed under the terms of the Modified BSD License.
|
|
|
|
import io
|
|
import os
|
|
import glob
|
|
import shlex
|
|
import shutil
|
|
import sys
|
|
import unittest
|
|
import nbconvert
|
|
from subprocess import Popen, PIPE
|
|
|
|
from nbformat import v4, write
|
|
from testpath.tempdir import TemporaryWorkingDirectory
|
|
|
|
from ipython_genutils.py3compat import string_types, bytes_to_str
|
|
|
|
|
|
class TestsBase(unittest.TestCase):
|
|
"""Base tests class. Contains useful fuzzy comparison and nbconvert
|
|
functions."""
|
|
|
|
|
|
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.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 cds "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, dest=temp_dir.name)
|
|
|
|
#Return directory handler
|
|
return temp_dir
|
|
|
|
@classmethod
|
|
def merge_dicts(cls, *dict_args):
|
|
# Because this is annoying to do inline
|
|
outcome = {}
|
|
for d in dict_args:
|
|
outcome.update(d)
|
|
return outcome
|
|
|
|
def create_empty_notebook(self, path):
|
|
nb = v4.new_notebook()
|
|
with io.open(path, 'w', encoding='utf-8') as f:
|
|
write(nb, f, 4)
|
|
|
|
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:
|
|
files = glob.glob(os.path.join(files_path, pattern))
|
|
assert files
|
|
for match in files:
|
|
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 nbconvert directory and the relative path we just
|
|
#found.
|
|
path = os.path.dirname(nbconvert.__file__)
|
|
return os.path.join(path, *names)
|
|
|
|
def nbconvert(self, parameters, ignore_return_code=False, stdin=None):
|
|
"""
|
|
Run nbconvert as a shell command, listening for both Errors and
|
|
non-zero return codes. Returns the tuple (stdout, stderr) of
|
|
output produced during the nbconvert run.
|
|
|
|
Parameters
|
|
----------
|
|
parameters : str, list(str)
|
|
List of parameters to pass to IPython.
|
|
ignore_return_code : optional bool (default False)
|
|
Throw an OSError if the return code
|
|
"""
|
|
cmd = [sys.executable, '-m', 'nbconvert']
|
|
if sys.platform == 'win32':
|
|
if isinstance(parameters, string_types):
|
|
cmd = ' '.join(cmd) + ' ' + parameters
|
|
else:
|
|
cmd = ' '.join(cmd + parameters)
|
|
else:
|
|
if isinstance(parameters, string_types):
|
|
parameters = shlex.split(parameters)
|
|
cmd += parameters
|
|
p = Popen(cmd, stdout=PIPE, stderr=PIPE, stdin=PIPE)
|
|
stdout, stderr = p.communicate(input=stdin)
|
|
if not (p.returncode == 0 or ignore_return_code):
|
|
raise OSError(bytes_to_str(stderr))
|
|
return stdout.decode('utf8', 'replace'), stderr.decode('utf8', 'replace')
|
|
|
|
|
|
def assert_big_text_equal(a, b, chunk_size=80):
|
|
"""assert that large strings are equal
|
|
|
|
Zooms in on first chunk that differs,
|
|
to give better info than vanilla assertEqual for large text blobs.
|
|
"""
|
|
for i in range(0, len(a), chunk_size):
|
|
chunk_a = a[i:i + chunk_size]
|
|
chunk_b = b[i:i + chunk_size]
|
|
assert chunk_a == chunk_b, "[offset: %i]\n%r != \n%r" % (i, chunk_a, chunk_b)
|
|
|
|
if len(a) > len(b):
|
|
raise AssertionError("Length doesn't match (%i > %i). Extra text:\n%r" % (
|
|
len(a), len(b), a[len(b):]))
|
|
elif len(a) < len(b):
|
|
raise AssertionError("Length doesn't match (%i < %i). Extra text:\n%r" % (
|
|
len(a), len(b), a[len(b):]))
|