diff options
author | David Lord <davidism@gmail.com> | 2018-05-04 13:28:40 -0700 |
---|---|---|
committer | David Lord <davidism@gmail.com> | 2018-05-04 13:28:40 -0700 |
commit | 3fe4a11f139eba8711c7194a4a05e5bbd9a36786 (patch) | |
tree | 68a34fb0ccc3ac579dafa8de35d6cc237e72f200 | |
parent | 2f931bd8b101c572a431255d35efcf2c177e1630 (diff) | |
download | markupsafe-3fe4a11f139eba8711c7194a4a05e5bbd9a36786.tar.gz |
convert to pytest
-rwxr-xr-x | tests.py | 271 | ||||
-rw-r--r-- | tests/test_escape.py | 35 |
2 files changed, 35 insertions, 271 deletions
diff --git a/tests.py b/tests.py deleted file mode 100755 index da4b486..0000000 --- a/tests.py +++ /dev/null @@ -1,271 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- -import gc -import sys -import unittest -from markupsafe import Markup, escape, escape_silent -from markupsafe._compat import text_type, PY2 -from markupsafe import _native -try: - from markupsafe import _speedups - have_speedups = True -except ImportError: - have_speedups = False - - -class MarkupTestCase(unittest.TestCase): - - def test_adding(self): - # adding two strings should escape the unsafe one - unsafe = '<script type="application/x-some-script">alert("foo");</script>' - safe = Markup('<em>username</em>') - assert unsafe + safe == text_type(escape(unsafe)) + text_type(safe) - - def test_string_interpolation(self): - # string interpolations are safe to use too - assert Markup('<em>%s</em>') % '<bad user>' == \ - '<em><bad user></em>' - assert Markup('<em>%(username)s</em>') % { - 'username': '<bad user>' - } == '<em><bad user></em>' - - assert Markup('%i') % 3.14 == '3' - assert Markup('%.2f') % 3.14 == '3.14' - - def test_type_behavior(self): - # an escaped object is markup too - assert type(Markup('foo') + 'bar') is Markup - - # and it implements __html__ by returning itself - x = Markup("foo") - assert x.__html__() is x - - def test_html_interop(self): - # it also knows how to treat __html__ objects - class Foo(object): - def __html__(self): - return '<em>awesome</em>' - def __unicode__(self): - return 'awesome' - __str__ = __unicode__ - assert Markup(Foo()) == '<em>awesome</em>' - assert Markup('<strong>%s</strong>') % Foo() == \ - '<strong><em>awesome</em></strong>' - - def test_tuple_interpol(self): - self.assertEqual(Markup('<em>%s:%s</em>') % ( - '<foo>', - '<bar>', - ), Markup(u'<em><foo>:<bar></em>')) - - def test_dict_interpol(self): - self.assertEqual(Markup('<em>%(foo)s</em>') % { - 'foo': '<foo>', - }, Markup(u'<em><foo></em>')) - self.assertEqual(Markup('<em>%(foo)s:%(bar)s</em>') % { - 'foo': '<foo>', - 'bar': '<bar>', - }, Markup(u'<em><foo>:<bar></em>')) - - def test_escaping(self): - # escaping - assert escape('"<>&\'') == '"<>&'' - assert Markup("<em>Foo & Bar</em>").striptags() == "Foo & Bar" - - def test_unescape(self): - assert Markup("<test>").unescape() == "<test>" - assert "jack & tavi are cooler than mike & russ" == \ - Markup("jack & tavi are cooler than mike & russ").unescape(), \ - Markup("jack & tavi are cooler than mike & russ").unescape() - - # Test that unescape is idempotent - original = '&foo;' - once = Markup(original).unescape() - twice = Markup(once).unescape() - expected = "&foo;" - assert expected == once == twice, (once, twice) - - def test_formatting(self): - for actual, expected in ( - (Markup('%i') % 3.14, '3'), - (Markup('%.2f') % 3.14159, '3.14'), - (Markup('%s %s %s') % ('<', 123, '>'), '< 123 >'), - (Markup('<em>{awesome}</em>').format(awesome='<awesome>'), - '<em><awesome></em>'), - (Markup('{0[1][bar]}').format([0, {'bar': '<bar/>'}]), - '<bar/>'), - (Markup('{0[1][bar]}').format([0, {'bar': Markup('<bar/>')}]), - '<bar/>')): - assert actual == expected, "%r should be %r!" % (actual, expected) - - # This is new in 2.7 - if sys.version_info >= (2, 7): - def test_formatting_empty(self): - formatted = Markup('{}').format(0) - assert formatted == Markup('0') - - def test_custom_formatting(self): - class HasHTMLOnly(object): - def __html__(self): - return Markup('<foo>') - - class HasHTMLAndFormat(object): - def __html__(self): - return Markup('<foo>') - def __html_format__(self, spec): - return Markup('<FORMAT>') - - assert Markup('{0}').format(HasHTMLOnly()) == Markup('<foo>') - assert Markup('{0}').format(HasHTMLAndFormat()) == Markup('<FORMAT>') - - def test_complex_custom_formatting(self): - class User(object): - def __init__(self, id, username): - self.id = id - self.username = username - def __html_format__(self, format_spec): - if format_spec == 'link': - return Markup('<a href="/user/{0}">{1}</a>').format( - self.id, - self.__html__(), - ) - elif format_spec: - raise ValueError('Invalid format spec') - return self.__html__() - def __html__(self): - return Markup('<span class=user>{0}</span>').format(self.username) - - user = User(1, 'foo') - assert Markup('<p>User: {0:link}').format(user) == \ - Markup('<p>User: <a href="/user/1"><span class=user>foo</span></a>') - - def test_formatting_with_objects(self): - class Stringable(object): - def __unicode__(self): - return u'строка' - if PY2: - def __str__(self): - return 'some other value' - else: - __str__ = __unicode__ - - assert Markup('{s}').format(s=Stringable()) == \ - Markup(u'строка') - - def test_all_set(self): - import markupsafe as markup - for item in markup.__all__: - getattr(markup, item) - - def test_escape_silent(self): - assert escape_silent(None) == Markup() - assert escape(None) == Markup(None) - assert escape_silent('<foo>') == Markup(u'<foo>') - - def test_splitting(self): - self.assertEqual(Markup('a b').split(), [ - Markup('a'), - Markup('b') - ]) - self.assertEqual(Markup('a b').rsplit(), [ - Markup('a'), - Markup('b') - ]) - self.assertEqual(Markup('a\nb').splitlines(), [ - Markup('a'), - Markup('b') - ]) - - def test_mul(self): - self.assertEqual(Markup('a') * 3, Markup('aaa')) - - def test_escape_return_type(self): - self.assertTrue(isinstance(escape('a'), Markup)) - self.assertTrue(isinstance(escape(Markup('a')), Markup)) - class Foo: - def __html__(self): - return '<strong>Foo</strong>' - self.assertTrue(isinstance(escape(Foo()), Markup)) - - -class MarkupLeakTestCase(unittest.TestCase): - - def test_markup_leaks(self): - counts = set() - for count in range(20): - for item in range(1000): - escape("foo") - escape("<foo>") - escape(u"foo") - escape(u"<foo>") - if hasattr(sys, 'pypy_version_info'): - gc.collect() - counts.add(len(gc.get_objects())) - assert len(counts) == 1, 'ouch, c extension seems to ' \ - 'leak objects, got: ' + str(len(counts)) - - -class NativeEscapeTestCase(unittest.TestCase): - - escape = staticmethod(_native.escape) - - def test_empty(self): - self.assertEqual(Markup(u''), self.escape(u'')) - - def test_ascii(self): - self.assertEqual( - Markup(u'abcd&><'"efgh'), - self.escape(u'abcd&><\'"efgh')) - self.assertEqual( - Markup(u'&><'"efgh'), - self.escape(u'&><\'"efgh')) - self.assertEqual( - Markup(u'abcd&><'"'), - self.escape(u'abcd&><\'"')) - - def test_2byte(self): - self.assertEqual( - Markup(u'こんにちは&><'"こんばんは'), - self.escape(u'こんにちは&><\'"こんばんは')) - self.assertEqual( - Markup(u'&><'"こんばんは'), - self.escape(u'&><\'"こんばんは')) - self.assertEqual( - Markup(u'こんにちは&><'"'), - self.escape(u'こんにちは&><\'"')) - - def test_4byte(self): - self.assertEqual( - Markup(u'\U0001F363\U0001F362&><'"\U0001F37A xyz'), - self.escape(u'\U0001F363\U0001F362&><\'"\U0001F37A xyz')) - self.assertEqual( - Markup(u'&><'"\U0001F37A xyz'), - self.escape(u'&><\'"\U0001F37A xyz')) - self.assertEqual( - Markup(u'\U0001F363\U0001F362&><'"'), - self.escape(u'\U0001F363\U0001F362&><\'"')) - -if have_speedups: - class SpeedupEscapeTestCase(NativeEscapeTestCase): - escape = _speedups.escape - - -def suite(): - suite = unittest.TestSuite() - suite.addTest(unittest.makeSuite(MarkupTestCase)) - - # this test only tests the c extension - if not hasattr(escape, 'func_code'): - suite.addTest(unittest.makeSuite(MarkupLeakTestCase)) - - suite.addTest(unittest.makeSuite(NativeEscapeTestCase)) - if have_speedups: - suite.addTest(unittest.makeSuite(SpeedupEscapeTestCase)) - - return suite - - -if __name__ == '__main__': - unittest.main(defaultTest='suite') - -# vim:sts=4:sw=4:et: diff --git a/tests/test_escape.py b/tests/test_escape.py new file mode 100644 index 0000000..cf09d6a --- /dev/null +++ b/tests/test_escape.py @@ -0,0 +1,35 @@ +# -*- coding: utf-8 -*- +import pytest + +from markupsafe import Markup, _native + +try: + from markupsafe import _speedups +except ImportError: + _speedups = None + + +@pytest.mark.parametrize('mod', ( + _native, + pytest.param(_speedups, marks=pytest.mark.skipif( + _speedups is None, reason='speedups unavailable')), +)) +@pytest.mark.parametrize(('value', 'expect'), ( + # empty + (u'', u''), + # ascii + (u'abcd&><\'"efgh', u'abcd&><'"efgh'), + (u'&><\'"efgh', u'&><'"efgh'), + (u'abcd&><\'"', u'abcd&><'"'), + # 2 byte + (u'こんにちは&><\'"こんばんは', + u'こんにちは&><'"こんばんは'), + (u'&><\'"こんばんは', u'&><'"こんばんは'), + (u'こんにちは&><\'"', u'こんにちは&><'"'), + # 4 byte + (u'\U0001F363\U0001F362&><\'"\U0001F37A xyz', u'\U0001F363\U0001F362&><'"\U0001F37A xyz'), + (u'&><\'"\U0001F37A xyz', u'&><'"\U0001F37A xyz'), + (u'\U0001F363\U0001F362&><\'"', u'\U0001F363\U0001F362&><'"'), +)) +def test_escape(mod, value, expect): + assert mod.escape(value) == Markup(expect) |