|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
""" A collection of tools for testing the Markdown code base and extensions. """ |
|
|
|
|
|
from __future__ import annotations |
|
|
|
|
|
import os |
|
|
import sys |
|
|
import unittest |
|
|
import textwrap |
|
|
from typing import Any |
|
|
from . import markdown, Markdown, util |
|
|
|
|
|
try: |
|
|
import tidylib |
|
|
except ImportError: |
|
|
tidylib = None |
|
|
|
|
|
__all__ = ['TestCase', 'LegacyTestCase', 'Kwargs'] |
|
|
|
|
|
|
|
|
class TestCase(unittest.TestCase): |
|
|
""" |
|
|
A [`unittest.TestCase`][] subclass with helpers for testing Markdown output. |
|
|
|
|
|
Define `default_kwargs` as a `dict` of keywords to pass to Markdown for each |
|
|
test. The defaults can be overridden on individual tests. |
|
|
|
|
|
The `assertMarkdownRenders` method accepts the source text, the expected |
|
|
output, and any keywords to pass to Markdown. The `default_kwargs` are used |
|
|
except where overridden by `kwargs`. The output and expected output are passed |
|
|
to `TestCase.assertMultiLineEqual`. An `AssertionError` is raised with a diff |
|
|
if the actual output does not equal the expected output. |
|
|
|
|
|
The `dedent` method is available to dedent triple-quoted strings if |
|
|
necessary. |
|
|
|
|
|
In all other respects, behaves as `unittest.TestCase`. |
|
|
""" |
|
|
|
|
|
default_kwargs: dict[str, Any] = {} |
|
|
""" Default options to pass to Markdown for each test. """ |
|
|
|
|
|
def assertMarkdownRenders(self, source, expected, expected_attrs=None, **kwargs): |
|
|
""" |
|
|
Test that source Markdown text renders to expected output with given keywords. |
|
|
|
|
|
`expected_attrs` accepts a `dict`. Each key should be the name of an attribute |
|
|
on the `Markdown` instance and the value should be the expected value after |
|
|
the source text is parsed by Markdown. After the expected output is tested, |
|
|
the expected value for each attribute is compared against the actual |
|
|
attribute of the `Markdown` instance using `TestCase.assertEqual`. |
|
|
""" |
|
|
|
|
|
expected_attrs = expected_attrs or {} |
|
|
kws = self.default_kwargs.copy() |
|
|
kws.update(kwargs) |
|
|
md = Markdown(**kws) |
|
|
output = md.convert(source) |
|
|
self.assertMultiLineEqual(output, expected) |
|
|
for key, value in expected_attrs.items(): |
|
|
self.assertEqual(getattr(md, key), value) |
|
|
|
|
|
def dedent(self, text): |
|
|
""" |
|
|
Dedent text. |
|
|
""" |
|
|
|
|
|
|
|
|
|
|
|
return textwrap.dedent(text).strip() |
|
|
|
|
|
|
|
|
class recursionlimit: |
|
|
""" |
|
|
A context manager which temporarily modifies the Python recursion limit. |
|
|
|
|
|
The testing framework, coverage, etc. may add an arbitrary number of levels to the depth. To maintain consistency |
|
|
in the tests, the current stack depth is determined when called, then added to the provided limit. |
|
|
|
|
|
Example usage: |
|
|
|
|
|
``` python |
|
|
with recursionlimit(20): |
|
|
# test code here |
|
|
``` |
|
|
|
|
|
See <https://stackoverflow.com/a/50120316/866026>. |
|
|
""" |
|
|
|
|
|
def __init__(self, limit): |
|
|
self.limit = util._get_stack_depth() + limit |
|
|
self.old_limit = sys.getrecursionlimit() |
|
|
|
|
|
def __enter__(self): |
|
|
sys.setrecursionlimit(self.limit) |
|
|
|
|
|
def __exit__(self, type, value, tb): |
|
|
sys.setrecursionlimit(self.old_limit) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class Kwargs(dict): |
|
|
""" A `dict` like class for holding keyword arguments. """ |
|
|
pass |
|
|
|
|
|
|
|
|
def _normalize_whitespace(text): |
|
|
""" Normalize whitespace for a string of HTML using `tidylib`. """ |
|
|
output, errors = tidylib.tidy_fragment(text, options={ |
|
|
'drop_empty_paras': 0, |
|
|
'fix_backslash': 0, |
|
|
'fix_bad_comments': 0, |
|
|
'fix_uri': 0, |
|
|
'join_styles': 0, |
|
|
'lower_literals': 0, |
|
|
'merge_divs': 0, |
|
|
'output_xhtml': 1, |
|
|
'quote_ampersand': 0, |
|
|
'newline': 'LF' |
|
|
}) |
|
|
return output |
|
|
|
|
|
|
|
|
class LegacyTestMeta(type): |
|
|
def __new__(cls, name, bases, dct): |
|
|
|
|
|
def generate_test(infile, outfile, normalize, kwargs): |
|
|
def test(self): |
|
|
with open(infile, encoding="utf-8") as f: |
|
|
input = f.read() |
|
|
with open(outfile, encoding="utf-8") as f: |
|
|
|
|
|
|
|
|
expected = f.read().replace("\r\n", "\n") |
|
|
output = markdown(input, **kwargs) |
|
|
if tidylib and normalize: |
|
|
try: |
|
|
expected = _normalize_whitespace(expected) |
|
|
output = _normalize_whitespace(output) |
|
|
except OSError: |
|
|
self.skipTest("Tidylib's c library not available.") |
|
|
elif normalize: |
|
|
self.skipTest('Tidylib not available.') |
|
|
self.assertMultiLineEqual(output, expected) |
|
|
return test |
|
|
|
|
|
location = dct.get('location', '') |
|
|
exclude = dct.get('exclude', []) |
|
|
normalize = dct.get('normalize', False) |
|
|
input_ext = dct.get('input_ext', '.txt') |
|
|
output_ext = dct.get('output_ext', '.html') |
|
|
kwargs = dct.get('default_kwargs', Kwargs()) |
|
|
|
|
|
if os.path.isdir(location): |
|
|
for file in os.listdir(location): |
|
|
infile = os.path.join(location, file) |
|
|
if os.path.isfile(infile): |
|
|
tname, ext = os.path.splitext(file) |
|
|
if ext == input_ext: |
|
|
outfile = os.path.join(location, tname + output_ext) |
|
|
tname = tname.replace(' ', '_').replace('-', '_') |
|
|
kws = kwargs.copy() |
|
|
if tname in dct: |
|
|
kws.update(dct[tname]) |
|
|
test_name = 'test_%s' % tname |
|
|
if tname not in exclude: |
|
|
dct[test_name] = generate_test(infile, outfile, normalize, kws) |
|
|
else: |
|
|
dct[test_name] = unittest.skip('Excluded')(lambda: None) |
|
|
|
|
|
return type.__new__(cls, name, bases, dct) |
|
|
|
|
|
|
|
|
class LegacyTestCase(unittest.TestCase, metaclass=LegacyTestMeta): |
|
|
""" |
|
|
A [`unittest.TestCase`][] subclass for running Markdown's legacy file-based tests. |
|
|
|
|
|
A subclass should define various properties which point to a directory of |
|
|
text-based test files and define various behaviors/defaults for those tests. |
|
|
The following properties are supported: |
|
|
|
|
|
Attributes: |
|
|
location (str): A path to the directory of test files. An absolute path is preferred. |
|
|
exclude (list[str]): A list of tests to exclude. Each test name should comprise the filename |
|
|
without an extension. |
|
|
normalize (bool): A boolean value indicating if the HTML should be normalized. Default: `False`. |
|
|
input_ext (str): A string containing the file extension of input files. Default: `.txt`. |
|
|
output_ext (str): A string containing the file extension of expected output files. Default: `html`. |
|
|
default_kwargs (Kwargs[str, Any]): The default set of keyword arguments for all test files in the directory. |
|
|
|
|
|
In addition, properties can be defined for each individual set of test files within |
|
|
the directory. The property should be given the name of the file without the file |
|
|
extension. Any spaces and dashes in the filename should be replaced with |
|
|
underscores. The value of the property should be a `Kwargs` instance which |
|
|
contains the keyword arguments that should be passed to `Markdown` for that |
|
|
test file. The keyword arguments will "update" the `default_kwargs`. |
|
|
|
|
|
When the class instance is created, it will walk the given directory and create |
|
|
a separate `Unitttest` for each set of test files using the naming scheme: |
|
|
`test_filename`. One `Unittest` will be run for each set of input and output files. |
|
|
""" |
|
|
pass |
|
|
|
