mirror of
https://github.com/janeczku/calibre-web
synced 2024-08-31 13:32:49 +00:00
![OzzieIsaacs](/assets/img/avatar_default.png)
Bugfix for feeds - removed categories related and up - load new books now working - category random now working login page is free of non accessible elements boolean custom column is vivible in UI books with only with certain languages can be shown book shelfs can be deleted from UI Anonymous user view is more resticted Added browse of series in sidebar Dependencys in vendor folder are updated to newer versions (licencs files are now present) Bugfix editing Authors names Made upload on windows working
180 lines
6.0 KiB
Python
180 lines
6.0 KiB
Python
# -*- coding: utf-8 -*-
|
|
import gc
|
|
import sys
|
|
import unittest
|
|
from markupsafe import Markup, escape, escape_silent
|
|
from markupsafe._compat import text_type
|
|
|
|
|
|
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 and unescaping
|
|
assert escape('"<>&\'') == '"<>&''
|
|
assert Markup("<em>Foo & Bar</em>").striptags() == "Foo & Bar"
|
|
assert Markup("<test>").unescape() == "<test>"
|
|
|
|
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_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'))
|
|
|
|
|
|
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>")
|
|
counts.add(len(gc.get_objects()))
|
|
assert len(counts) == 1, 'ouch, c extension seems to leak objects'
|
|
|
|
|
|
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))
|
|
|
|
return suite
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main(defaultTest='suite')
|
|
|
|
# vim:sts=4:sw=4:et:
|