cpython: ac13f0390866 (original) (raw)

--- a/Lib/unittest/case.py +++ b/Lib/unittest/case.py @@ -129,37 +129,42 @@ class _BaseTestCaseContext: msg = self.test_case._formatMessage(self.msg, standardMsg) raise self.test_case.failureException(msg) -def _sentinel(*args, **kwargs):

• raise AssertionError('Should never be called')

- class _AssertRaisesBaseContext(_BaseTestCaseContext):

• def init(self, expected, test_case, callable_obj=_sentinel,

•             expected_regex=None):[](#l1.13)

• def init(self, expected, test_case, expected_regex=None): _BaseTestCaseContext.init(self, test_case) self.expected = expected self.test_case = test_case

•    if callable_obj is not _sentinel:[](#l1.18)

•        try:[](#l1.19)

•            self.obj_name = callable_obj.__name__[](#l1.20)

•        except AttributeError:[](#l1.21)

•            self.obj_name = str(callable_obj)[](#l1.22)

•    else:[](#l1.23)

•        self.obj_name = None[](#l1.24)
     if expected_regex is not None:[](#l1.25)
         expected_regex = re.compile(expected_regex)[](#l1.26)
     self.expected_regex = expected_regex[](#l1.27)

•    self.obj_name = None[](#l1.28)
     self.msg = None[](#l1.29)

• def handle(self, name, callable_obj, args, kwargs):

• def handle(self, name, args, kwargs): """

•    If callable_obj is _sentinel, assertRaises/Warns is being used as a[](#l1.34)

•    If args is empty, assertRaises/Warns is being used as a[](#l1.35)
     context manager, so check for a 'msg' kwarg and return self.[](#l1.36)

•    If callable_obj is not _sentinel, call it passing args and kwargs.[](#l1.37)

•    If args is not empty, call a callable passing positional and keyword[](#l1.38)

•    arguments.[](#l1.39)
     """[](#l1.40)

•    if callable_obj is _sentinel:[](#l1.41)

•    if args and args[0] is None:[](#l1.42)

•        warnings.warn("callable is None",[](#l1.43)

•                      DeprecationWarning, 3)[](#l1.44)

•        args = ()[](#l1.45)

•    if not args:[](#l1.46)
         self.msg = kwargs.pop('msg', None)[](#l1.47)

•        if kwargs:[](#l1.48)

•            warnings.warn('%r is an invalid keyword argument for '[](#l1.49)

•                          'this function' % next(iter(kwargs)),[](#l1.50)

•                          DeprecationWarning, 3)[](#l1.51)
         return self[](#l1.52)

+

•    callable_obj, *args = args[](#l1.54)

•    try:[](#l1.55)

•        self.obj_name = callable_obj.__name__[](#l1.56)

•    except AttributeError:[](#l1.57)

•        self.obj_name = str(callable_obj)[](#l1.58)
     with self:[](#l1.59)
         callable_obj(*args, **kwargs)[](#l1.60)

@@ -676,15 +681,15 @@ class TestCase(object): except UnicodeDecodeError: return '%s : %s' % (safe_repr(standardMsg), safe_repr(msg))

• def assertRaises(self, excClass, callableObj=_sentinel, *args, **kwargs):

•    """Fail unless an exception of class excClass is raised[](#l1.67)

•       by callableObj when invoked with arguments args and keyword[](#l1.68)

•       arguments kwargs. If a different type of exception is[](#l1.69)

• def assertRaises(self, expected_exception, *args, **kwargs):

•    """Fail unless an exception of class expected_exception is raised[](#l1.71)

•       by the callable when invoked with specified positional and[](#l1.72)

•       keyword arguments. If a different type of exception is[](#l1.73)
        raised, it will not be caught, and the test case will be[](#l1.74)
        deemed to have suffered an error, exactly as for an[](#l1.75)
        unexpected exception.[](#l1.76)

•       If called with callableObj omitted, will return a[](#l1.78)

•       If called with the callable and arguments omitted, will return a[](#l1.79)
        context object used like this::[](#l1.80)

with self.assertRaises(SomeException): @@ -702,18 +707,18 @@ class TestCase(object): the_exception = cm.exception self.assertEqual(the_exception.error_code, 3) """

•    context = _AssertRaisesContext(excClass, self, callableObj)[](#l1.87)

•    return context.handle('assertRaises', callableObj, args, kwargs)[](#l1.88)

•    context = _AssertRaisesContext(expected_exception, self)[](#l1.89)

•    return context.handle('assertRaises', args, kwargs)[](#l1.90)

• def assertWarns(self, expected_warning, callable_obj=_sentinel, *args, **kwargs):

• def assertWarns(self, expected_warning, *args, **kwargs): """Fail unless a warning of class warnClass is triggered

•       by callable_obj when invoked with arguments args and keyword[](#l1.95)

•       arguments kwargs.  If a different type of warning is[](#l1.96)

•       by the callable when invoked with specified positional and[](#l1.97)

•       keyword arguments.  If a different type of warning is[](#l1.98)
        triggered, it will not be handled: depending on the other[](#l1.99)
        warning filtering rules in effect, it might be silenced, printed[](#l1.100)
        out, or raised as an exception.[](#l1.101)

•       If called with callable_obj omitted, will return a[](#l1.103)

•       If called with the callable and arguments omitted, will return a[](#l1.104)
        context object used like this::[](#l1.105)

with self.assertWarns(SomeWarning): @@ -733,8 +738,8 @@ class TestCase(object): the_warning = cm.warning self.assertEqual(the_warning.some_attribute, 147) """

•    context = _AssertWarnsContext(expected_warning, self, callable_obj)[](#l1.112)

•    return context.handle('assertWarns', callable_obj, args, kwargs)[](#l1.113)

•    context = _AssertWarnsContext(expected_warning, self)[](#l1.114)

•    return context.handle('assertWarns', args, kwargs)[](#l1.115)

def assertLogs(self, logger=None, level=None): """Fail unless a log message of level level or higher is emitted @@ -1221,26 +1226,23 @@ class TestCase(object): self.fail(self._formatMessage(msg, standardMsg)) def assertRaisesRegex(self, expected_exception, expected_regex,

•                      callable_obj=_sentinel, *args, **kwargs):[](#l1.123)

•                      *args, **kwargs):[](#l1.124)
     """Asserts that the message in a raised exception matches a regex.[](#l1.125)

Args: expected_exception: Exception class expected to be raised. expected_regex: Regex (re pattern object or string) expected to be found in error message.

•        callable_obj: Function to be called.[](#l1.131)

•        args: Function to be called and extra positional args.[](#l1.132)

•        kwargs: Extra kwargs.[](#l1.133)
         msg: Optional message used in case of failure. Can only be used[](#l1.134)
                 when assertRaisesRegex is used as a context manager.[](#l1.135)

•        args: Extra args.[](#l1.136)

•        kwargs: Extra kwargs.[](#l1.137)
     """[](#l1.138)

•    context = _AssertRaisesContext(expected_exception, self, callable_obj,[](#l1.139)

•                                   expected_regex)[](#l1.140)

-

•    return context.handle('assertRaisesRegex', callable_obj, args, kwargs)[](#l1.142)

•    context = _AssertRaisesContext(expected_exception, self, expected_regex)[](#l1.143)

•    return context.handle('assertRaisesRegex', args, kwargs)[](#l1.144)

def assertWarnsRegex(self, expected_warning, expected_regex,

•                     callable_obj=_sentinel, *args, **kwargs):[](#l1.147)

•                     *args, **kwargs):[](#l1.148)
     """Asserts that the message in a triggered warning matches a regexp.[](#l1.149)
     Basic functioning is similar to assertWarns() with the addition[](#l1.150)
     that only warnings whose messages also match the regular expression[](#l1.151)

@@ -1250,15 +1252,13 @@ class TestCase(object): expected_warning: Warning class expected to be triggered. expected_regex: Regex (re pattern object or string) expected to be found in error message.

•        callable_obj: Function to be called.[](#l1.156)

•        args: Function to be called and extra positional args.[](#l1.157)

•        kwargs: Extra kwargs.[](#l1.158)
         msg: Optional message used in case of failure. Can only be used[](#l1.159)
                 when assertWarnsRegex is used as a context manager.[](#l1.160)

•        args: Extra args.[](#l1.161)

•        kwargs: Extra kwargs.[](#l1.162)
     """[](#l1.163)

•    context = _AssertWarnsContext(expected_warning, self, callable_obj,[](#l1.164)

•                                  expected_regex)[](#l1.165)

•    return context.handle('assertWarnsRegex', callable_obj, args, kwargs)[](#l1.166)

•    context = _AssertWarnsContext(expected_warning, self, expected_regex)[](#l1.167)

•    return context.handle('assertWarnsRegex', args, kwargs)[](#l1.168)

def assertRegex(self, text, expected_regex, msg=None): """Fail the test unless the text matches the regular expression."""

--- a/Lib/unittest/test/test_case.py +++ b/Lib/unittest/test/test_case.py @@ -1146,7 +1146,7 @@ test case with self.assertRaises(self.failureException): self.assertRaises(ExceptionMock, lambda: 0) # Failure when the function is None

•    with self.assertRaises(TypeError):[](#l2.7)

•    with self.assertWarns(DeprecationWarning):[](#l2.8)
         self.assertRaises(ExceptionMock, None)[](#l2.9)
     # Failure when another exception is raised[](#l2.10)
     with self.assertRaises(ExceptionMock):[](#l2.11)

@@ -1172,6 +1172,15 @@ test case with self.assertRaises(self.failureException): with self.assertRaises(ExceptionMock): pass

•    # Custom message[](#l2.16)

•    with self.assertRaisesRegex(self.failureException, 'foobar'):[](#l2.17)

•        with self.assertRaises(ExceptionMock, msg='foobar'):[](#l2.18)

•            pass[](#l2.19)

•    # Invalid keyword argument[](#l2.20)

•    with self.assertWarnsRegex(DeprecationWarning, 'foobar'), \[](#l2.21)

•         self.assertRaises(AssertionError):[](#l2.22)

•        with self.assertRaises(ExceptionMock, foobar=42):[](#l2.23)

•            pass[](#l2.24)
     # Failure when another exception is raised[](#l2.25)
     with self.assertRaises(ExceptionMock):[](#l2.26)
         self.assertRaises(ValueError, Stub)[](#l2.27)

@@ -1185,7 +1194,7 @@ test case self.assertRaisesRegex(ExceptionMock, re.compile('expect$'), Stub) self.assertRaisesRegex(ExceptionMock, 'expect$', Stub)

•    with self.assertRaises(TypeError):[](#l2.32)

•    with self.assertWarns(DeprecationWarning):[](#l2.33)
         self.assertRaisesRegex(ExceptionMock, 'expect$', None)[](#l2.34)

def testAssertNotRaisesRegex(self): @@ -1197,6 +1206,15 @@ test case self.failureException, '^Exception not raised by $', self.assertRaisesRegex, Exception, 'x', lambda: None)

•    # Custom message[](#l2.41)

•    with self.assertRaisesRegex(self.failureException, 'foobar'):[](#l2.42)

•        with self.assertRaisesRegex(Exception, 'expect', msg='foobar'):[](#l2.43)

•            pass[](#l2.44)

•    # Invalid keyword argument[](#l2.45)

•    with self.assertWarnsRegex(DeprecationWarning, 'foobar'), \[](#l2.46)

•         self.assertRaises(AssertionError):[](#l2.47)

•        with self.assertRaisesRegex(Exception, 'expect', foobar=42):[](#l2.48)

•            pass[](#l2.49)

def testAssertRaisesRegexInvalidRegex(self): # Issue 20145. @@ -1255,7 +1273,7 @@ test case with self.assertRaises(self.failureException): self.assertWarns(RuntimeWarning, lambda: 0) # Failure when the function is None

•    with self.assertRaises(TypeError):[](#l2.57)

•    with self.assertWarns(DeprecationWarning):[](#l2.58)
         self.assertWarns(RuntimeWarning, None)[](#l2.59)
     # Failure when another warning is triggered[](#l2.60)
     with warnings.catch_warnings():[](#l2.61)

@@ -1295,6 +1313,15 @@ test case with self.assertRaises(self.failureException): with self.assertWarns(RuntimeWarning): pass

•    # Custom message[](#l2.66)

•    with self.assertRaisesRegex(self.failureException, 'foobar'):[](#l2.67)

•        with self.assertWarns(RuntimeWarning, msg='foobar'):[](#l2.68)

•            pass[](#l2.69)

•    # Invalid keyword argument[](#l2.70)

•    with self.assertWarnsRegex(DeprecationWarning, 'foobar'), \[](#l2.71)

•         self.assertRaises(AssertionError):[](#l2.72)

•        with self.assertWarns(RuntimeWarning, foobar=42):[](#l2.73)

•            pass[](#l2.74)
     # Failure when another warning is triggered[](#l2.75)
     with warnings.catch_warnings():[](#l2.76)
         # Force default filter (in case tests are run with -We)[](#l2.77)

@@ -1319,7 +1346,7 @@ test case self.assertWarnsRegex(RuntimeWarning, "o+", lambda: 0) # Failure when the function is None

•    with self.assertRaises(TypeError):[](#l2.82)

•    with self.assertWarns(DeprecationWarning):[](#l2.83)
         self.assertWarnsRegex(RuntimeWarning, "o+", None)[](#l2.84)
     # Failure when another warning is triggered[](#l2.85)
     with warnings.catch_warnings():[](#l2.86)

@@ -1357,6 +1384,15 @@ test case with self.assertRaises(self.failureException): with self.assertWarnsRegex(RuntimeWarning, "o+"): pass

•    # Custom message[](#l2.91)

•    with self.assertRaisesRegex(self.failureException, 'foobar'):[](#l2.92)

•        with self.assertWarnsRegex(RuntimeWarning, 'o+', msg='foobar'):[](#l2.93)

•            pass[](#l2.94)

•    # Invalid keyword argument[](#l2.95)

•    with self.assertWarnsRegex(DeprecationWarning, 'foobar'), \[](#l2.96)

•         self.assertRaises(AssertionError):[](#l2.97)

•        with self.assertWarnsRegex(RuntimeWarning, 'o+', foobar=42):[](#l2.98)

•            pass[](#l2.99)
     # Failure when another warning is triggered[](#l2.100)
     with warnings.catch_warnings():[](#l2.101)
         # Force default filter (in case tests are run with -We)[](#l2.102)

--- a/Misc/NEWS +++ b/Misc/NEWS @@ -76,7 +76,8 @@ Library usernames and passwords to UTF8.

• Issue #24134: assertRaises(), assertRaisesRegex(), assertWarns() and
• assertWarnsRegex() checks are not longer successful if the callable is None.

• assertWarnsRegex() checks now emits a deprecation warning when callable is
• None or keyword arguments except msg is passed in the context manager mode.

• Issue #24018: Add a collections.abc.Generator abstract base class. Contributed by Stefan Behnel.