You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
235 lines
8.5 KiB
235 lines
8.5 KiB
#!/usr/bin/python
|
|
"""
|
|
Python-Markdown Regression Tests
|
|
================================
|
|
|
|
Tests of the various APIs with the python markdown lib.
|
|
|
|
"""
|
|
|
|
import unittest
|
|
from doctest import DocTestSuite
|
|
import os
|
|
import markdown
|
|
|
|
class TestMarkdown(unittest.TestCase):
|
|
""" Tests basics of the Markdown class. """
|
|
|
|
def setUp(self):
|
|
""" Create instance of Markdown. """
|
|
self.md = markdown.Markdown()
|
|
|
|
def testBlankInput(self):
|
|
""" Test blank input. """
|
|
self.assertEqual(self.md.convert(''), '')
|
|
|
|
def testWhitespaceOnly(self):
|
|
""" Test input of only whitespace. """
|
|
self.assertEqual(self.md.convert(' '), '')
|
|
|
|
def testSimpleInput(self):
|
|
""" Test simple input. """
|
|
self.assertEqual(self.md.convert('foo'), '<p>foo</p>')
|
|
|
|
class TestBlockParser(unittest.TestCase):
|
|
""" Tests of the BlockParser class. """
|
|
|
|
def setUp(self):
|
|
""" Create instance of BlockParser. """
|
|
self.parser = markdown.Markdown().parser
|
|
|
|
def testParseChunk(self):
|
|
""" Test BlockParser.parseChunk. """
|
|
root = markdown.etree.Element("div")
|
|
text = 'foo'
|
|
self.parser.parseChunk(root, text)
|
|
self.assertEqual(markdown.etree.tostring(root), "<div><p>foo</p></div>")
|
|
|
|
def testParseDocument(self):
|
|
""" Test BlockParser.parseDocument. """
|
|
lines = ['#foo', '', 'bar', '', ' baz']
|
|
tree = self.parser.parseDocument(lines)
|
|
self.assert_(isinstance(tree, markdown.etree.ElementTree))
|
|
self.assert_(markdown.etree.iselement(tree.getroot()))
|
|
self.assertEqual(markdown.etree.tostring(tree.getroot()),
|
|
"<div><h1>foo</h1><p>bar</p><pre><code>baz\n</code></pre></div>")
|
|
|
|
|
|
class TestBlockParserState(unittest.TestCase):
|
|
""" Tests of the State class for BlockParser. """
|
|
|
|
def setUp(self):
|
|
self.state = markdown.blockparser.State()
|
|
|
|
def testBlankState(self):
|
|
""" Test State when empty. """
|
|
self.assertEqual(self.state, [])
|
|
|
|
def testSetSate(self):
|
|
""" Test State.set(). """
|
|
self.state.set('a_state')
|
|
self.assertEqual(self.state, ['a_state'])
|
|
self.state.set('state2')
|
|
self.assertEqual(self.state, ['a_state', 'state2'])
|
|
|
|
def testIsSate(self):
|
|
""" Test State.isstate(). """
|
|
self.assertEqual(self.state.isstate('anything'), False)
|
|
self.state.set('a_state')
|
|
self.assertEqual(self.state.isstate('a_state'), True)
|
|
self.state.set('state2')
|
|
self.assertEqual(self.state.isstate('state2'), True)
|
|
self.assertEqual(self.state.isstate('a_state'), False)
|
|
self.assertEqual(self.state.isstate('missing'), False)
|
|
|
|
def testReset(self):
|
|
""" Test State.reset(). """
|
|
self.state.set('a_state')
|
|
self.state.reset()
|
|
self.assertEqual(self.state, [])
|
|
self.state.set('state1')
|
|
self.state.set('state2')
|
|
self.state.reset()
|
|
self.assertEqual(self.state, ['state1'])
|
|
|
|
class TestHtmlStash(unittest.TestCase):
|
|
""" Test Markdown's HtmlStash. """
|
|
|
|
def setUp(self):
|
|
self.stash = markdown.preprocessors.HtmlStash()
|
|
self.placeholder = self.stash.store('foo')
|
|
|
|
def testSimpleStore(self):
|
|
""" Test HtmlStash.store. """
|
|
self.assertEqual(self.placeholder,
|
|
markdown.preprocessors.HTML_PLACEHOLDER % 0)
|
|
self.assertEqual(self.stash.html_counter, 1)
|
|
self.assertEqual(self.stash.rawHtmlBlocks, [('foo', False)])
|
|
|
|
def testStoreMore(self):
|
|
""" Test HtmlStash.store with additional blocks. """
|
|
placeholder = self.stash.store('bar')
|
|
self.assertEqual(placeholder,
|
|
markdown.preprocessors.HTML_PLACEHOLDER % 1)
|
|
self.assertEqual(self.stash.html_counter, 2)
|
|
self.assertEqual(self.stash.rawHtmlBlocks,
|
|
[('foo', False), ('bar', False)])
|
|
|
|
def testSafeStore(self):
|
|
""" Test HtmlStash.store with 'safe' html. """
|
|
self.stash.store('bar', True)
|
|
self.assertEqual(self.stash.rawHtmlBlocks,
|
|
[('foo', False), ('bar', True)])
|
|
|
|
def testReset(self):
|
|
""" Test HtmlStash.reset. """
|
|
self.stash.reset()
|
|
self.assertEqual(self.stash.html_counter, 0)
|
|
self.assertEqual(self.stash.rawHtmlBlocks, [])
|
|
|
|
class TestOrderedDict(unittest.TestCase):
|
|
""" Test OrderedDict storage class. """
|
|
|
|
def setUp(self):
|
|
self.odict = markdown.odict.OrderedDict()
|
|
self.odict['first'] = 'This'
|
|
self.odict['third'] = 'a'
|
|
self.odict['fourth'] = 'self'
|
|
self.odict['fifth'] = 'test'
|
|
|
|
def testValues(self):
|
|
""" Test output of OrderedDict.values(). """
|
|
self.assertEqual(self.odict.values(), ['This', 'a', 'self', 'test'])
|
|
|
|
def testKeys(self):
|
|
""" Test output of OrderedDict.keys(). """
|
|
self.assertEqual(self.odict.keys(),
|
|
['first', 'third', 'fourth', 'fifth'])
|
|
|
|
def testItems(self):
|
|
""" Test output of OrderedDict.items(). """
|
|
self.assertEqual(self.odict.items(),
|
|
[('first', 'This'), ('third', 'a'),
|
|
('fourth', 'self'), ('fifth', 'test')])
|
|
|
|
def testAddBefore(self):
|
|
""" Test adding an OrderedDict item before a given key. """
|
|
self.odict.add('second', 'is', '<third')
|
|
self.assertEqual(self.odict.items(),
|
|
[('first', 'This'), ('second', 'is'), ('third', 'a'),
|
|
('fourth', 'self'), ('fifth', 'test')])
|
|
|
|
def testAddAfter(self):
|
|
""" Test adding an OrderDict item after a given key. """
|
|
self.odict.add('second', 'is', '>first')
|
|
self.assertEqual(self.odict.items(),
|
|
[('first', 'This'), ('second', 'is'), ('third', 'a'),
|
|
('fourth', 'self'), ('fifth', 'test')])
|
|
|
|
def testAddAfterEnd(self):
|
|
""" Test adding an OrderedDict item after the last key. """
|
|
self.odict.add('sixth', '.', '>fifth')
|
|
self.assertEqual(self.odict.items(),
|
|
[('first', 'This'), ('third', 'a'),
|
|
('fourth', 'self'), ('fifth', 'test'), ('sixth', '.')])
|
|
|
|
def testAdd_begin(self):
|
|
""" Test adding an OrderedDict item using "_begin". """
|
|
self.odict.add('zero', 'CRAZY', '_begin')
|
|
self.assertEqual(self.odict.items(),
|
|
[('zero', 'CRAZY'), ('first', 'This'), ('third', 'a'),
|
|
('fourth', 'self'), ('fifth', 'test')])
|
|
|
|
def testAdd_end(self):
|
|
""" Test adding an OrderedDict item using "_end". """
|
|
self.odict.add('sixth', '.', '_end')
|
|
self.assertEqual(self.odict.items(),
|
|
[('first', 'This'), ('third', 'a'),
|
|
('fourth', 'self'), ('fifth', 'test'), ('sixth', '.')])
|
|
|
|
def testAddBadLocation(self):
|
|
""" Test Error on bad location in OrderedDict.add(). """
|
|
self.assertRaises(ValueError, self.odict.add, 'sixth', '.', '<seventh')
|
|
self.assertRaises(ValueError, self.odict.add, 'second', 'is', 'third')
|
|
|
|
def testDeleteItem(self):
|
|
""" Test deletion of an OrderedDict item. """
|
|
del self.odict['fourth']
|
|
self.assertEqual(self.odict.items(),
|
|
[('first', 'This'), ('third', 'a'), ('fifth', 'test')])
|
|
|
|
def testChangeValue(self):
|
|
""" Test OrderedDict change value. """
|
|
self.odict['fourth'] = 'CRAZY'
|
|
self.assertEqual(self.odict.items(),
|
|
[('first', 'This'), ('third', 'a'),
|
|
('fourth', 'CRAZY'), ('fifth', 'test')])
|
|
|
|
def testChangeOrder(self):
|
|
""" Test OrderedDict change order. """
|
|
self.odict.link('fourth', '<third')
|
|
self.assertEqual(self.odict.items(),
|
|
[('first', 'This'), ('fourth', 'self'),
|
|
('third', 'a'), ('fifth', 'test')])
|
|
|
|
def suite():
|
|
""" Build a test suite of the above tests and extension doctests. """
|
|
suite = unittest.TestSuite()
|
|
suite.addTest(unittest.makeSuite(TestMarkdown))
|
|
suite.addTest(unittest.makeSuite(TestBlockParser))
|
|
suite.addTest(unittest.makeSuite(TestBlockParserState))
|
|
suite.addTest(unittest.makeSuite(TestHtmlStash))
|
|
suite.addTest(unittest.makeSuite(TestOrderedDict))
|
|
|
|
for filename in os.listdir('markdown/extensions'):
|
|
if filename.endswith('.py'):
|
|
module = 'markdown.extensions.%s' % filename[:-3]
|
|
try:
|
|
suite.addTest(DocTestSuite(module))
|
|
except: ValueError
|
|
# No tests
|
|
return suite
|
|
|
|
if __name__ == '__main__':
|
|
unittest.TextTestRunner(verbosity=2).run(suite())
|