# -*- 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)