1
0
mirror of https://github.com/janeczku/calibre-web synced 2024-12-11 18:50:31 +00:00
calibre-web/lib/werkzeug/testsuite/__init__.py

268 lines
7.6 KiB
Python
Raw Normal View History

# -*- coding: utf-8 -*-
"""
werkzeug.testsuite
~~~~~~~~~~~~~~~~~~
Contains all test Werkzeug tests.
:copyright: (c) 2013 by Armin Ronacher.
:license: BSD, see LICENSE for more details.
"""
from __future__ import with_statement
import re
import sys
import unittest
import shutil
import tempfile
import atexit
from werkzeug.utils import find_modules
from werkzeug._compat import text_type, integer_types, reraise
def get_temporary_directory():
directory = tempfile.mkdtemp()
@atexit.register
def remove_directory():
try:
shutil.rmtree(directory)
except EnvironmentError:
pass
return directory
def iter_suites(package):
"""Yields all testsuites."""
for module in find_modules(package, include_packages=True):
mod = __import__(module, fromlist=['*'])
if hasattr(mod, 'suite'):
yield mod.suite()
def find_all_tests(suite):
"""Yields all the tests and their names from a given suite."""
suites = [suite]
while suites:
s = suites.pop()
try:
suites.extend(s)
except TypeError:
yield s, '%s.%s.%s' % (
s.__class__.__module__,
s.__class__.__name__,
s._testMethodName
)
class WerkzeugTestCase(unittest.TestCase):
"""Baseclass for all the tests that Werkzeug uses. Use these
methods for testing instead of the camelcased ones in the
baseclass for consistency.
"""
def setup(self):
pass
def teardown(self):
pass
def setUp(self):
self.setup()
def tearDown(self):
unittest.TestCase.tearDown(self)
self.teardown()
def assert_line_equal(self, x, y):
assert x == y, "lines not equal\n a = %r\n b = %r" % (x, y)
def assert_equal(self, x, y, msg=None):
return self.assertEqual(x, y, msg)
def assert_not_equal(self, x, y):
return self.assertNotEqual(x, y)
def assert_raises(self, exc_type, callable=None, *args, **kwargs):
catcher = _ExceptionCatcher(self, exc_type)
if callable is None:
return catcher
with catcher:
callable(*args, **kwargs)
if sys.version_info[:2] == (2, 6):
def assertIsNone(self, x):
assert x is None, "%r is not None" % (x,)
def assertIsNotNone(self, x):
assert x is not None, "%r is None" % (x, )
def assertIn(self, x, y):
assert x in y, "%r not in %r" % (x, y)
def assertNotIn(self, x, y):
assert x not in y, "%r in %r" % (x, y)
def assertIsInstance(self, x, y):
assert isinstance(x, y), "not isinstance(%r, %r)" % (x, y)
def assertIs(self, x, y):
assert x is y, "%r is not %r" % (x, y)
def assertIsNot(self, x, y):
assert x is not y, "%r is %r" % (x, y)
def assertSequenceEqual(self, x, y):
self.assertEqual(x, y)
def assertRaisesRegex(self, exc_type, regex, *args, **kwargs):
catcher = _ExceptionCatcher(self, exc_type)
if not args:
return catcher
elif callable(args[0]):
with catcher:
args[0](*args[1:], **kwargs)
if args[0] is not None:
assert re.search(args[0], catcher.exc_value[0])
else:
raise NotImplementedError()
elif sys.version_info[0] == 2:
def assertRaisesRegex(self, *args, **kwargs):
return self.assertRaisesRegexp(*args, **kwargs)
def assert_is_none(self, x):
self.assertIsNone(x)
def assert_is_not_none(self, x):
self.assertIsNotNone(x)
def assert_in(self, x, y):
self.assertIn(x, y)
def assert_is_instance(self, x, y):
self.assertIsInstance(x, y)
def assert_not_in(self, x, y):
self.assertNotIn(x, y)
def assert_is(self, x, y):
self.assertIs(x, y)
def assert_is_not(self, x, y):
self.assertIsNot(x, y)
def assert_true(self, x):
self.assertTrue(x)
def assert_false(self, x):
self.assertFalse(x)
def assert_raises_regex(self, *args, **kwargs):
return self.assertRaisesRegex(*args, **kwargs)
def assert_sequence_equal(self, x, y):
self.assertSequenceEqual(x, y)
def assert_strict_equal(self, x, y):
'''Stricter version of assert_equal that doesn't do implicit conversion
between unicode and strings'''
self.assert_equal(x, y)
assert issubclass(type(x), type(y)) or issubclass(type(y), type(x)), \
'%s != %s' % (type(x), type(y))
if isinstance(x, (bytes, text_type, integer_types)) or x is None:
return
elif isinstance(x, dict) or isinstance(y, dict):
x = sorted(x.items())
y = sorted(y.items())
elif isinstance(x, set) or isinstance(y, set):
x = sorted(x)
y = sorted(y)
rx, ry = repr(x), repr(y)
if rx != ry:
rx = rx[:200] + (rx[200:] and '...')
ry = ry[:200] + (ry[200:] and '...')
raise AssertionError(rx, ry)
assert repr(x) == repr(y), repr((x, y))[:200]
class _ExceptionCatcher(object):
def __init__(self, test_case, exc_type):
self.test_case = test_case
self.exc_type = exc_type
self.exc_value = None
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, tb):
exception_name = self.exc_type.__name__
if exc_type is None:
self.test_case.fail('Expected exception of type %r' %
exception_name)
elif not issubclass(exc_type, self.exc_type):
reraise(exc_type, exc_value, tb)
self.exc_value = exc_value
return True
class BetterLoader(unittest.TestLoader):
"""A nicer loader that solves two problems. First of all we are setting
up tests from different sources and we're doing this programmatically
which breaks the default loading logic so this is required anyways.
Secondly this loader has a nicer interpolation for test names than the
default one so you can just do ``run-tests.py ViewTestCase`` and it
will work.
"""
def getRootSuite(self):
return suite()
def loadTestsFromName(self, name, module=None):
root = self.getRootSuite()
if name == 'suite':
return root
all_tests = []
for testcase, testname in find_all_tests(root):
if testname == name or \
testname.endswith('.' + name) or \
('.' + name + '.') in testname or \
testname.startswith(name + '.'):
all_tests.append(testcase)
if not all_tests:
raise LookupError('could not find test case for "%s"' % name)
if len(all_tests) == 1:
return all_tests[0]
rv = unittest.TestSuite()
for test in all_tests:
rv.addTest(test)
return rv
def suite():
"""A testsuite that has all the Flask tests. You can use this
function to integrate the Flask tests into your own testsuite
in case you want to test that monkeypatches to Flask do not
break it.
"""
suite = unittest.TestSuite()
for other_suite in iter_suites(__name__):
suite.addTest(other_suite)
return suite
def main():
"""Runs the testsuite as command line application."""
try:
unittest.main(testLoader=BetterLoader(), defaultTest='suite')
except Exception:
import sys
import traceback
traceback.print_exc()
sys.exit(1)