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.
148 lines
4.7 KiB
148 lines
4.7 KiB
# coding: utf-8
|
|
from __future__ import unicode_literals, division, absolute_import, print_function
|
|
|
|
import sys
|
|
import unittest
|
|
import re
|
|
|
|
|
|
if sys.version_info < (3,):
|
|
str_cls = unicode # noqa
|
|
else:
|
|
str_cls = str
|
|
|
|
|
|
_non_local = {'patched': False}
|
|
|
|
|
|
def patch():
|
|
if sys.version_info >= (3, 0):
|
|
return
|
|
|
|
if _non_local['patched']:
|
|
return
|
|
|
|
if sys.version_info < (2, 7):
|
|
unittest.TestCase.assertIsInstance = _assert_is_instance
|
|
unittest.TestCase.assertRegex = _assert_regex
|
|
unittest.TestCase.assertRaises = _assert_raises
|
|
unittest.TestCase.assertRaisesRegex = _assert_raises_regex
|
|
unittest.TestCase.assertGreaterEqual = _assert_greater_equal
|
|
unittest.TestCase.assertLess = _assert_less
|
|
unittest.TestCase.assertLessEqual = _assert_less_equal
|
|
unittest.TestCase.assertIn = _assert_in
|
|
unittest.TestCase.assertNotIn = _assert_not_in
|
|
else:
|
|
unittest.TestCase.assertRegex = unittest.TestCase.assertRegexpMatches
|
|
unittest.TestCase.assertRaisesRegex = unittest.TestCase.assertRaisesRegexp
|
|
_non_local['patched'] = True
|
|
|
|
|
|
def _safe_repr(obj):
|
|
try:
|
|
return repr(obj)
|
|
except Exception:
|
|
return object.__repr__(obj)
|
|
|
|
|
|
def _format_message(msg, standard_msg):
|
|
return msg or standard_msg
|
|
|
|
|
|
def _assert_greater_equal(self, a, b, msg=None):
|
|
if not a >= b:
|
|
standard_msg = '%s not greater than or equal to %s' % (_safe_repr(a), _safe_repr(b))
|
|
self.fail(_format_message(msg, standard_msg))
|
|
|
|
|
|
def _assert_less(self, a, b, msg=None):
|
|
if not a < b:
|
|
standard_msg = '%s not less than %s' % (_safe_repr(a), _safe_repr(b))
|
|
self.fail(_format_message(msg, standard_msg))
|
|
|
|
|
|
def _assert_less_equal(self, a, b, msg=None):
|
|
if not a <= b:
|
|
standard_msg = '%s not less than or equal to %s' % (_safe_repr(a), _safe_repr(b))
|
|
self.fail(_format_message(msg, standard_msg))
|
|
|
|
|
|
def _assert_is_instance(self, obj, cls, msg=None):
|
|
if not isinstance(obj, cls):
|
|
if not msg:
|
|
msg = '%s is not an instance of %r' % (obj, cls)
|
|
self.fail(msg)
|
|
|
|
|
|
def _assert_in(self, member, container, msg=None):
|
|
if member not in container:
|
|
standard_msg = '%s not found in %s' % (_safe_repr(member), _safe_repr(container))
|
|
self.fail(_format_message(msg, standard_msg))
|
|
|
|
|
|
def _assert_not_in(self, member, container, msg=None):
|
|
if member in container:
|
|
standard_msg = '%s found in %s' % (_safe_repr(member), _safe_repr(container))
|
|
self.fail(_format_message(msg, standard_msg))
|
|
|
|
|
|
def _assert_regex(self, text, expected_regexp, msg=None):
|
|
"""Fail the test unless the text matches the regular expression."""
|
|
if isinstance(expected_regexp, str_cls):
|
|
expected_regexp = re.compile(expected_regexp)
|
|
if not expected_regexp.search(text):
|
|
msg = msg or "Regexp didn't match"
|
|
msg = '%s: %r not found in %r' % (msg, expected_regexp.pattern, text)
|
|
self.fail(msg)
|
|
|
|
|
|
def _assert_raises(self, excClass, callableObj=None, *args, **kwargs): # noqa
|
|
context = _AssertRaisesContext(excClass, self)
|
|
if callableObj is None:
|
|
return context
|
|
with context:
|
|
callableObj(*args, **kwargs)
|
|
|
|
|
|
def _assert_raises_regex(self, expected_exception, expected_regexp, callable_obj=None, *args, **kwargs):
|
|
if expected_regexp is not None:
|
|
expected_regexp = re.compile(expected_regexp)
|
|
context = _AssertRaisesContext(expected_exception, self, expected_regexp)
|
|
if callable_obj is None:
|
|
return context
|
|
with context:
|
|
callable_obj(*args, **kwargs)
|
|
|
|
|
|
class _AssertRaisesContext(object):
|
|
def __init__(self, expected, test_case, expected_regexp=None):
|
|
self.expected = expected
|
|
self.failureException = test_case.failureException
|
|
self.expected_regexp = expected_regexp
|
|
|
|
def __enter__(self):
|
|
return self
|
|
|
|
def __exit__(self, exc_type, exc_value, tb):
|
|
if exc_type is None:
|
|
try:
|
|
exc_name = self.expected.__name__
|
|
except AttributeError:
|
|
exc_name = str(self.expected)
|
|
raise self.failureException(
|
|
"{0} not raised".format(exc_name))
|
|
if not issubclass(exc_type, self.expected):
|
|
# let unexpected exceptions pass through
|
|
return False
|
|
self.exception = exc_value # store for later retrieval
|
|
if self.expected_regexp is None:
|
|
return True
|
|
|
|
expected_regexp = self.expected_regexp
|
|
if not expected_regexp.search(str(exc_value)):
|
|
raise self.failureException(
|
|
'"%s" does not match "%s"' %
|
|
(expected_regexp.pattern, str(exc_value))
|
|
)
|
|
return True
|