Merge branch 'feature/assert-warns'

Author: srittau

NEWS.rst

@@ -1,13 +1,17 @@
 News in asserts 0.7.2
 =====================
 
+API Additions
+-------------
+
+* Add assert_warns() and assert_warns_regex().
+
 News in asserts 0.7.1
 =====================
 
 * Distribute as wheel.
 * asserts is now a package, instead of a module.
 
-
 News in asserts 0.7.0
 =====================
 

asserts/__init__.py

@@ -20,8 +20,9 @@
 
 """
 
-from datetime import datetime, timedelta
 import re
+from datetime import datetime, timedelta
+from warnings import catch_warnings
 
 
 def fail(msg=None):
@@ -660,3 +661,118 @@ def __exit__(self, exc_type, exc_val, exc_tb):
                 fail(msg or exception.__name__ + " was unexpectedly raised")
 
     return _AssertSucceeds()
+
+
+class AssertWarnsContext(object):
+
+    """A context manager to test for warning with certain properties.
+
+    When the context is left and the expected warning has not been raised, an
+    AssertionError will be raised:
+
+        >>> context = AssertWarnsContext(DeprecationWarning)
+        >>> with context:
+        ...    pass
+        Traceback (most recent call last):
+            ...
+        AssertionError: DeprecationWarning not issued
+
+    If the warning has the right class, any additional tests that have been
+    configured on the context, will be called:
+
+        >>> from warnings import warn
+        >>> def test(warning):
+        ...     return False
+        >>> context.add_test(test)
+        >>> with context:
+        ...     warn("Wrong Message", DeprecationWarning)
+        Traceback (most recent call last):
+            ...
+        AssertionError: DeprecationWarning not issued
+
+    """
+
+    def __init__(self, warning_class, msg=None):
+        self._warning_class = warning_class
+        self._msg = msg or "{} not issued".format(warning_class.__name__)
+        self._warning_context = None
+        self._warnings = []
+        self._tests = []
+
+    def __enter__(self):
+        self._warning_context = catch_warnings(record=True)
+        self._warnings = self._warning_context.__enter__()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._warning_context.__exit__(exc_type, exc_val, exc_tb)
+        if not any(self._is_expected_warning(w) for w in self._warnings):
+            raise AssertionError(self._msg)
+
+    def _is_expected_warning(self, warning):
+        if not issubclass(warning.category, self._warning_class):
+            return False
+        return all(test(warning) for test in self._tests)
+
+    def add_test(self, cb):
+        """Add a test callback.
+
+        This callback is called after determining that the right warning
+        class was issued. The callback will get the issued warning as only
+        argument and must return a boolean value.
+
+        """
+        self._tests.append(cb)
+
+
+def assert_warns(warning_type, msg=None):
+    """Fail unless a specific warning is issued inside the context.
+
+    If a different type of warning is issued, it will not be caught.
+
+    >>> from warnings import warn
+    >>> with assert_warns(UserWarning):
+    ...     warn("warning message", UserWarning)
+    ...
+    >>> with assert_warns(UserWarning):
+    ...     pass
+    ...
+    Traceback (most recent call last):
+        ...
+    AssertionError: UserWarning not issued
+    >>> with assert_warns(UserWarning):
+    ...     warn("warning message", UnicodeWarning)
+    ...
+    Traceback (most recent call last):
+        ...
+    AssertionError: UserWarning not issued
+
+    """
+    return AssertWarnsContext(warning_type, msg)
+
+
+def assert_warns_regex(warning_type, regex, msg=None):
+    """Fail unless a warning with a message is issued inside the context.
+
+    The message can be a regular expression string or object.
+
+    >>> from warnings import warn
+    >>> with assert_warns_regex(UserWarning, r"#\d+"):
+    ...     warn("Error #42", UserWarning)
+    ...
+    >>> with assert_warns_regex(UserWarning, r"Expected Error"):
+    ...     warn("Generic Error", UserWarning)
+    ...
+    Traceback (most recent call last):
+        ...
+    AssertionError: no UserWarning matching 'Expected Error' issued
+    """
+
+    def test(warning):
+        return re.search(regex, str(warning.message)) is not None
+
+    if msg is None:
+        msg = "no {} matching {} issued".format(
+            warning_type.__name__, repr(regex))
+    context = AssertWarnsContext(warning_type, msg)
+    context.add_test(test)
+    return context

asserts/__init__.pyi

@@ -12,6 +12,12 @@ class AssertRaisesContext:
     def __exit__(self, exc_type: Type[BaseException], exc_val: BaseException, exc_tb: Any) -> None: ...
     def add_test(self, cb: Callable[[BaseException], None]) -> None: ...
 
+class AssertWarnsContext:
+    def __init__(self, warning_class: Type[Warning], msg: Optional[str] = ...) -> None: ...
+    def __enter__(self) -> None: ...
+    def __exit__(self, exc_type: Type[BaseException], exc_val: BaseException, exc_tb: Any) -> None: ...
+    def add_test(self, cb: Callable[[Warning], None]) -> None: ...
+
 def fail(msg: Optional[str] = ...) -> None: ...
 def assert_true(expr: Any, msg: Optional[str] = ...) -> None: ...
 def assert_false(expr: Any, msg: Optional[str] = ...) -> None: ...
@@ -39,6 +45,8 @@ def assert_has_attr(obj: Any, attribute: str, msg: Optional[str] = ...) -> None:
 def assert_datetime_about_now(actual: Optional[datetime.datetime], msg: Optional[str] = ...) -> None: ...
 def assert_datetime_about_now_utc(actual: Optional[datetime.datetime], msg: Optional[str] = ...) -> None: ...
 def assert_raises(exception: Type[BaseException], msg: Optional[str] = ...) -> AssertRaisesContext: ...
-def assert_raises_regex(exception: Type[BaseException], regex:  str, msg: Optional[str] = ...) -> AssertRaisesContext: ...
+def assert_raises_regex(exception: Type[BaseException], regex: str, msg: Optional[str] = ...) -> AssertRaisesContext: ...
 def assert_raises_errno(exception: Type[BaseException], errno: int, msg: Optional[str] = ...) -> AssertRaisesContext: ...
 def assert_succeeds(exception: Type[BaseException], msg: Optional[str] = ...) -> ContextManager: ...
+def assert_warns(warning_type: Type[Warning], msg: Optional[str] = ...) -> AssertWarnsContext: ...
+def assert_warns_regex(warning_type: Type[Warning], regex: str, msg: Optional[str] = ...) -> AssertWarnsContext: ...

test_asserts.py

@@ -1,7 +1,8 @@
-from datetime import datetime, timedelta
 import re
-from unittest import TestCase
 import sys
+from datetime import datetime, timedelta
+from unittest import TestCase
+from warnings import warn, catch_warnings
 
 from asserts import (
     fail,
@@ -34,7 +35,8 @@
     assert_raises_regex,
     assert_raises_errno,
     assert_succeeds,
-)
+    assert_warns,
+    assert_warns_regex)
 
 
 class _DummyObject(object):
@@ -562,6 +564,8 @@ def test_assert_raises_errno__wrong_errno__custom_message(self):
             with assert_raises_errno(OSError, 20, msg="test message"):
                 raise OSError(1, "Test error")
 
+    # assert_succeeds()
+
     def test_assert_succeeds__no_exception_raised(self):
         with assert_succeeds(KeyError):
             pass
@@ -584,3 +588,132 @@ def test_assert_succeeds__unexpected_exception(self):
             pass
         else:
             raise AssertionError("KeyError was not raised")
+
+    # assert_warns()
+
+    def test_assert_warns__warned(self):
+        with assert_succeeds(AssertionError):
+            with assert_warns(FutureWarning):
+                warn("foo", FutureWarning)
+
+    def test_assert_warns__not_warned(self):
+        with assert_raises(AssertionError):
+            with assert_warns(ImportWarning):
+                pass
+
+    def test_assert_warns__wrong_type(self):
+        with assert_raises(AssertionError):
+            with assert_warns(ImportWarning):
+                warn("foo", UnicodeWarning)
+
+    def test_assert_warns__multiple_warnings(self):
+        with assert_succeeds(AssertionError):
+            with assert_warns(UserWarning):
+                warn("foo", UnicodeWarning)
+                warn("bar", UserWarning)
+                warn("baz", FutureWarning)
+
+    def test_assert_warns__warning_handler_deinstalled_on_success(self):
+        with catch_warnings(record=1) as warnings:
+            with assert_warns(UserWarning):
+                warn("foo", UserWarning)
+            assert_equal(0, len(warnings))
+            warn("bar", UserWarning)
+            assert_equal(1, len(warnings))
+
+    def test_assert_warns__warning_handler_deinstalled_on_failure(self):
+        with catch_warnings(record=1) as warnings:
+            try:
+                with assert_warns(UserWarning):
+                    pass
+            except AssertionError:
+                pass
+            assert_equal(0, len(warnings))
+            warn("bar", UserWarning)
+            assert_equal(1, len(warnings))
+
+    def test_assert_warns__default_message(self):
+        with assert_raises_regex(AssertionError,
+                                 r"^ImportWarning not issued"):
+            with assert_warns(ImportWarning):
+                pass
+
+    def test_assert_warns__custom_message(self):
+        with assert_raises_regex(AssertionError, r"^Custom Test Message$"):
+            with assert_warns(ImportWarning, msg="Custom Test Message"):
+                pass
+
+    # assert_warns_regex()
+
+    def test_assert_warns_regex__warned(self):
+        with assert_succeeds(AssertionError):
+            with assert_warns_regex(FutureWarning, r"fo+"):
+                warn("foo", FutureWarning)
+
+    def test_assert_warns_regex__warning_text_matches_in_the_middle(self):
+        with assert_succeeds(AssertionError):
+            with assert_warns_regex(FutureWarning, r"o"):
+                warn("foo", FutureWarning)
+
+    def test_assert_warns_regex__not_warned(self):
+        with assert_raises(AssertionError):
+            with assert_warns_regex(UserWarning, r"foo"):
+                pass
+
+    def test_assert_warns_regex__wrong_type(self):
+        with assert_raises(AssertionError):
+            with assert_warns_regex(ImportWarning, r"foo"):
+                warn("foo", UnicodeWarning)
+
+    def test_assert_warns_regex__wrong_message(self):
+        with assert_raises(AssertionError):
+            with assert_warns_regex(UnicodeWarning, r"foo"):
+                warn("bar", UnicodeWarning)
+
+    def test_assert_warns_regex__multiple_warnings(self):
+        with assert_succeeds(AssertionError):
+            with assert_warns_regex(UserWarning, r"bar2"):
+                warn("foo", UnicodeWarning)
+                warn("bar1", UserWarning)
+                warn("bar2", UserWarning)
+                warn("bar3", UserWarning)
+                warn("baz", FutureWarning)
+
+    def test_assert_warns_regex__warning_handler_deinstalled_on_success(self):
+        with catch_warnings(record=1) as warnings:
+            with assert_warns_regex(UserWarning, r"foo"):
+                warn("foo", UserWarning)
+            assert_equal(0, len(warnings))
+            warn("bar", UserWarning)
+            assert_equal(1, len(warnings))
+
+    def test_assert_warns_regex__warning_handler_deinstalled_on_failure(self):
+        with catch_warnings(record=1) as warnings:
+            try:
+                with assert_warns_regex(UserWarning, r""):
+                    pass
+            except AssertionError:
+                pass
+            assert_equal(0, len(warnings))
+            warn("bar", UserWarning)
+            assert_equal(1, len(warnings))
+
+    def test_assert_warns_regex__default_message_not_issued(self):
+        with assert_raises_regex(
+                AssertionError,
+                r"^no UserWarning matching 'foo.*bar' issued$"):
+            with assert_warns_regex(UserWarning, r"foo.*bar"):
+                pass
+
+    def test_assert_warns_regex__default_message_wrong_message(self):
+        with assert_raises_regex(
+                AssertionError,
+                r"^no UserWarning matching 'foo.*bar' issued$"):
+            with assert_warns_regex(UserWarning, r"foo.*bar"):
+                pass
+
+    def test_assert_warns_regex__custom_message(self):
+        with assert_raises_regex(AssertionError, r"^Custom Test Message$"):
+            with assert_warns_regex(
+                    ImportWarning, r"", msg="Custom Test Message"):
+                pass