third_party/web_platform_tests/tools/pytest/testing/test_recwarn.py

import warnings
import py
import pytest
from _pytest.recwarn import WarningsRecorder


def test_recwarn_functional(testdir):
    reprec = testdir.inline_runsource("""
        import warnings
        oldwarn = warnings.showwarning
        def test_method(recwarn):
            assert warnings.showwarning != oldwarn
            warnings.warn("hello")
            warn = recwarn.pop()
            assert isinstance(warn.message, UserWarning)
        def test_finalized():
            assert warnings.showwarning == oldwarn
    """)
    res = reprec.countoutcomes()
    assert tuple(res) == (2, 0, 0), res


class TestWarningsRecorderChecker(object):
    def test_recording(self, recwarn):
        showwarning = py.std.warnings.showwarning
        rec = WarningsRecorder()
        with rec:
            assert py.std.warnings.showwarning != showwarning
            assert not rec.list
            py.std.warnings.warn_explicit("hello", UserWarning, "xyz", 13)
            assert len(rec.list) == 1
            py.std.warnings.warn(DeprecationWarning("hello"))
            assert len(rec.list) == 2
            warn = rec.pop()
            assert str(warn.message) == "hello"
            l = rec.list
            rec.clear()
            assert len(rec.list) == 0
            assert l is rec.list
            pytest.raises(AssertionError, "rec.pop()")

        assert showwarning == py.std.warnings.showwarning

    def test_typechecking(self):
        from _pytest.recwarn import WarningsChecker
        with pytest.raises(TypeError):
            WarningsChecker(5)
        with pytest.raises(TypeError):
            WarningsChecker(('hi', RuntimeWarning))
        with pytest.raises(TypeError):
            WarningsChecker([DeprecationWarning, RuntimeWarning])

    def test_invalid_enter_exit(self):
        # wrap this test in WarningsRecorder to ensure warning state gets reset
        with WarningsRecorder():
            with pytest.raises(RuntimeError):
                rec = WarningsRecorder()
                rec.__exit__(None, None, None)  # can't exit before entering

            with pytest.raises(RuntimeError):
                rec = WarningsRecorder()
                with rec:
                    with rec:
                        pass  # can't enter twice


class TestDeprecatedCall(object):
    """test pytest.deprecated_call()"""

    def dep(self, i, j=None):
        if i == 0:
            py.std.warnings.warn("is deprecated", DeprecationWarning,
                                 stacklevel=1)
        return 42

    def dep_explicit(self, i):
        if i == 0:
            py.std.warnings.warn_explicit("dep_explicit", category=DeprecationWarning,
                                          filename="hello", lineno=3)

    def test_deprecated_call_raises(self):
        with pytest.raises(AssertionError) as excinfo:
            pytest.deprecated_call(self.dep, 3, 5)
        assert str(excinfo).find("did not produce") != -1

    def test_deprecated_call(self):
        pytest.deprecated_call(self.dep, 0, 5)

    def test_deprecated_call_ret(self):
        ret = pytest.deprecated_call(self.dep, 0)
        assert ret == 42

    def test_deprecated_call_preserves(self):
        onceregistry = py.std.warnings.onceregistry.copy()
        filters = py.std.warnings.filters[:]
        warn = py.std.warnings.warn
        warn_explicit = py.std.warnings.warn_explicit
        self.test_deprecated_call_raises()
        self.test_deprecated_call()
        assert onceregistry == py.std.warnings.onceregistry
        assert filters == py.std.warnings.filters
        assert warn is py.std.warnings.warn
        assert warn_explicit is py.std.warnings.warn_explicit

    def test_deprecated_explicit_call_raises(self):
        with pytest.raises(AssertionError):
            pytest.deprecated_call(self.dep_explicit, 3)

    def test_deprecated_explicit_call(self):
        pytest.deprecated_call(self.dep_explicit, 0)
        pytest.deprecated_call(self.dep_explicit, 0)

    def test_deprecated_call_as_context_manager_no_warning(self):
        with pytest.raises(pytest.fail.Exception) as ex:
            with pytest.deprecated_call():
                self.dep(1)
        assert str(ex.value) == "DID NOT WARN"

    def test_deprecated_call_as_context_manager(self):
        with pytest.deprecated_call():
            self.dep(0)

    def test_deprecated_call_pending(self):
        def f():
            py.std.warnings.warn(PendingDeprecationWarning("hi"))
        pytest.deprecated_call(f)

    def test_deprecated_call_specificity(self):
        other_warnings = [Warning, UserWarning, SyntaxWarning, RuntimeWarning,
                          FutureWarning, ImportWarning, UnicodeWarning]
        for warning in other_warnings:
            def f():
                py.std.warnings.warn(warning("hi"))
            with pytest.raises(AssertionError):
                pytest.deprecated_call(f)

    def test_deprecated_function_already_called(self, testdir):
        """deprecated_call should be able to catch a call to a deprecated
        function even if that function has already been called in the same
        module. See #1190.
        """
        testdir.makepyfile("""
            import warnings
            import pytest

            def deprecated_function():
                warnings.warn("deprecated", DeprecationWarning)

            def test_one():
                deprecated_function()

            def test_two():
                pytest.deprecated_call(deprecated_function)
        """)
        result = testdir.runpytest()
        result.stdout.fnmatch_lines('*=== 2 passed in *===')


class TestWarns(object):
    def test_strings(self):
        # different messages, b/c Python suppresses multiple identical warnings
        source1 = "warnings.warn('w1', RuntimeWarning)"
        source2 = "warnings.warn('w2', RuntimeWarning)"
        source3 = "warnings.warn('w3', RuntimeWarning)"
        pytest.warns(RuntimeWarning, source1)
        pytest.raises(pytest.fail.Exception,
                      lambda: pytest.warns(UserWarning, source2))
        pytest.warns(RuntimeWarning, source3)

    def test_function(self):
        pytest.warns(SyntaxWarning,
                     lambda msg: warnings.warn(msg, SyntaxWarning), "syntax")

    def test_warning_tuple(self):
        pytest.warns((RuntimeWarning, SyntaxWarning),
                     lambda: warnings.warn('w1', RuntimeWarning))
        pytest.warns((RuntimeWarning, SyntaxWarning),
                     lambda: warnings.warn('w2', SyntaxWarning))
        pytest.raises(pytest.fail.Exception,
                      lambda: pytest.warns(
                          (RuntimeWarning, SyntaxWarning),
                          lambda: warnings.warn('w3', UserWarning)))

    def test_as_contextmanager(self):
        with pytest.warns(RuntimeWarning):
            warnings.warn("runtime", RuntimeWarning)

        with pytest.raises(pytest.fail.Exception):
            with pytest.warns(RuntimeWarning):
                warnings.warn("user", UserWarning)

        with pytest.raises(pytest.fail.Exception):
            with pytest.warns(UserWarning):
                warnings.warn("runtime", RuntimeWarning)

        with pytest.warns(UserWarning):
            warnings.warn("user", UserWarning)

    def test_record(self):
        with pytest.warns(UserWarning) as record:
            warnings.warn("user", UserWarning)

        assert len(record) == 1
        assert str(record[0].message) == "user"

    def test_record_only(self):
        with pytest.warns(None) as record:
            warnings.warn("user", UserWarning)
            warnings.warn("runtime", RuntimeWarning)

        assert len(record) == 2
        assert str(record[0].message) == "user"
        assert str(record[1].message) == "runtime"

    def test_double_test(self, testdir):
        """If a test is run again, the warning should still be raised"""
        testdir.makepyfile('''
            import pytest
            import warnings

            @pytest.mark.parametrize('run', [1, 2])
            def test(run):
                with pytest.warns(RuntimeWarning):
                    warnings.warn("runtime", RuntimeWarning)
        ''')
        result = testdir.runpytest()
        result.stdout.fnmatch_lines(['*2 passed in*'])