Deprecate raises(..., 'code(as_a_string)') / warns(..., 'code(as_a_string)').

changelog/4435.deprecation.rst

@@ -0,0 +1 @@
+Deprecate ``raises(..., 'code(as_a_string)')`` and ``warns(..., 'code(as_a_string)')``.  See https://docs.pytest.org/en/latest/deprecations.html#raises-warns-exec

doc/en/assert.rst

@@ -100,10 +100,9 @@ If you want to write test code that works on Python 2.4 as well,
 you may also use two other ways to test for an expected exception::
 
     pytest.raises(ExpectedException, func, *args, **kwargs)
-    pytest.raises(ExpectedException, "func(*args, **kwargs)")
 
-both of which execute the specified function with args and kwargs and
-asserts that the given ``ExpectedException`` is raised.  The reporter will
+which will execute the specified function with args and kwargs and
+assert that the given ``ExpectedException`` is raised.  The reporter will
 provide you with helpful output in case of failures such as *no
 exception* or *wrong exception*.
 

doc/en/deprecations.rst

@@ -14,6 +14,41 @@ Below is a complete list of all pytest features which are considered deprecated.
 :class:`_pytest.warning_types.PytestWarning` or subclasses, which can be filtered using
 :ref:`standard warning filters <warnings>`.
 
+.. _raises-warns-exec:
+
+``raises`` / ``warns`` with a string as the second argument
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. deprecated:: 4.1
+
+Use the context manager form of these instead.  When necessary, invoke ``exec``
+directly.
+
+Example:
+
+.. code-block:: python
+
+    pytest.raises(ZeroDivisionError, "1 / 0")
+    pytest.raises(SyntaxError, "a $ b")
+
+    pytest.warns(DeprecationWarning, "my_function()")
+    pytest.warns(SyntaxWarning, "assert(1, 2)")
+
+Becomes:
+
+.. code-block:: python
+
+    with pytest.raises(ZeroDivisionError):
+        1 / 0
+    with pytest.raises(SyntaxError):
+        exec("a $ b")  # exec is required for invalid syntax
+
+    with pytest.warns(DeprecationWarning):
+        my_function()
+    with pytest.warns(SyntaxWarning):
+        exec("assert(1, 2)")  # exec is used to avoid a top-level warning
+
+
 Internal classes accessed through ``Node``
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

doc/en/example/assertion/failure_demo.py

@@ -165,11 +165,11 @@ def globf(x):
 
 class TestRaises(object):
     def test_raises(self):
-        s = "qwe"  # NOQA
-        raises(TypeError, "int(s)")
+        s = "qwe"
+        raises(TypeError, int, s)
 
     def test_raises_doesnt(self):
-        raises(IOError, "int('3')")
+        raises(IOError, int, "3")
 
     def test_raise(self):
         raise ValueError("demo error")

doc/en/example/parametrize.rst

@@ -388,7 +388,8 @@ parametrizer`_ but in a lot less code::
             assert a == b
 
         def test_zerodivision(self, a, b):
-            pytest.raises(ZeroDivisionError, "a/b")
+            with pytest.raises(ZeroDivisionError):
+                a / b
 
 Our test generator looks up a class-level definition which specifies which
 argument sets to use for each test function.  Let's run it:

src/_pytest/deprecated.py

@@ -92,6 +92,15 @@
     "Node.warn(code, message) form has been deprecated, use Node.warn(warning_instance) instead."
 )
 
+RAISES_EXEC = PytestDeprecationWarning(
+    "raises(..., 'code(as_a_string)') is deprecated, use the context manager form or use `exec()` directly\n\n"
+    "See https://docs.pytest.org/en/latest/deprecations.html#raises-warns-exec"
+)
+WARNS_EXEC = PytestDeprecationWarning(
+    "warns(..., 'code(as_a_string)') is deprecated, use the context manager form or use `exec()` directly.\n\n"
+    "See https://docs.pytest.org/en/latest/deprecations.html#raises-warns-exec"
+)
+
 RECORD_XML_PROPERTY = RemovedInPytest4Warning(
     'Fixture renamed from "record_xml_property" to "record_property" as user '
     "properties are now available to all reporters.\n"

src/_pytest/python_api.py

@@ -1,6 +1,9 @@
+from __future__ import absolute_import
+
 import math
 import pprint
 import sys
+import warnings
 from decimal import Decimal
 from numbers import Number
 
@@ -14,6 +17,7 @@
 from _pytest.compat import Mapping
 from _pytest.compat import Sequence
 from _pytest.compat import STRING_TYPES
+from _pytest.deprecated import RAISES_EXEC
 from _pytest.outcomes import fail
 
 BASE_TYPE = (type, STRING_TYPES)
@@ -604,9 +608,9 @@ def raises(expected_exception, *args, **kwargs):
         >>> with raises(ValueError, match=r'must be \d+$'):
         ...     raise ValueError("value must be 42")
 
-    **Legacy forms**
+    **Legacy form**
 
-    The forms below are fully supported but are discouraged for new code because the
+    The form below is fully supported but discouraged for new code because the
     context manager form is regarded as more readable and less error-prone.
 
     It is possible to specify a callable by passing a to-be-called lambda::
@@ -623,14 +627,6 @@ def raises(expected_exception, *args, **kwargs):
         >>> raises(ZeroDivisionError, f, x=0)
         <ExceptionInfo ...>
 
-    It is also possible to pass a string to be evaluated at runtime::
-
-        >>> raises(ZeroDivisionError, "f(0)")
-        <ExceptionInfo ...>
-
-    The string will be evaluated using the same ``locals()`` and ``globals()``
-    at the moment of the ``raises`` call.
-
     .. currentmodule:: _pytest._code
 
     Consult the API of ``excinfo`` objects: :class:`ExceptionInfo`.
@@ -672,6 +668,7 @@ def raises(expected_exception, *args, **kwargs):
             raise TypeError(msg)
         return RaisesContext(expected_exception, message, match_expr)
     elif isinstance(args[0], str):
+        warnings.warn(RAISES_EXEC, stacklevel=2)
         code, = args
         assert isinstance(code, str)
         frame = sys._getframe(1)

src/_pytest/recwarn.py

@@ -11,6 +11,7 @@
 import six
 
 import _pytest._code
+from _pytest.deprecated import WARNS_EXEC
 from _pytest.fixtures import yield_fixture
 from _pytest.outcomes import fail
 
@@ -89,6 +90,7 @@ def warns(expected_warning, *args, **kwargs):
             match_expr = kwargs.pop("match")
         return WarningsChecker(expected_warning, match_expr=match_expr)
     elif isinstance(args[0], str):
+        warnings.warn(WARNS_EXEC, stacklevel=2)
         code, = args
         assert isinstance(code, str)
         frame = sys._getframe(1)

testing/code/test_code.py

@@ -37,7 +37,7 @@ def test_code_with_class():
     class A(object):
         pass
 
-    pytest.raises(TypeError, "_pytest._code.Code(A)")
+    pytest.raises(TypeError, _pytest._code.Code, A)
 
 
 def x():

testing/code/test_excinfo.py

@@ -180,7 +180,8 @@ def test_traceback_cut(self):
 
     def test_traceback_cut_excludepath(self, testdir):
         p = testdir.makepyfile("def f(): raise ValueError")
-        excinfo = pytest.raises(ValueError, "p.pyimport().f()")
+        with pytest.raises(ValueError) as excinfo:
+            p.pyimport().f()
         basedir = py.path.local(pytest.__file__).dirpath()
         newtraceback = excinfo.traceback.cut(excludepath=basedir)
         for x in newtraceback:
@@ -336,7 +337,8 @@ def f():
 def test_excinfo_exconly():
     excinfo = pytest.raises(ValueError, h)
     assert excinfo.exconly().startswith("ValueError")
-    excinfo = pytest.raises(ValueError, "raise ValueError('hello\\nworld')")
+    with pytest.raises(ValueError) as excinfo:
+        raise ValueError("hello\nworld")
     msg = excinfo.exconly(tryshort=True)
     assert msg.startswith("ValueError")
     assert msg.endswith("world")

testing/code/test_source.py

@@ -6,6 +6,7 @@
 from __future__ import division
 from __future__ import print_function
 
+import ast
 import inspect
 import sys
 
@@ -14,7 +15,6 @@
 import _pytest._code
 import pytest
 from _pytest._code import Source
-from _pytest._code.source import ast
 
 
 astonly = pytest.mark.nothing
@@ -306,8 +306,6 @@ def test_getstatementrange_with_syntaxerror_issue7(self):
         pytest.raises(SyntaxError, lambda: source.getstatementrange(0))
 
     def test_compile_to_ast(self):
-        import ast
-
         source = Source("x = 4")
         mod = source.compile(flag=ast.PyCF_ONLY_AST)
         assert isinstance(mod, ast.Module)
@@ -317,10 +315,9 @@ def test_compile_and_getsource(self):
         co = self.source.compile()
         six.exec_(co, globals())
         f(7)
-        excinfo = pytest.raises(AssertionError, "f(6)")
+        excinfo = pytest.raises(AssertionError, f, 6)
         frame = excinfo.traceback[-1].frame
         stmt = frame.code.fullsource.getstatement(frame.lineno)
-        # print "block", str(block)
         assert str(stmt).strip().startswith("assert")
 
     @pytest.mark.parametrize("name", ["", None, "my"])
@@ -361,17 +358,13 @@ def test_getline_finally():
     def c():
         pass
 
-    excinfo = pytest.raises(
-        TypeError,
-        """
-           teardown = None
-           try:
-                c(1)
-           finally:
-                if teardown:
-                    teardown()
-    """,
-    )
+    with pytest.raises(TypeError) as excinfo:
+        teardown = None
+        try:
+            c(1)
+        finally:
+            if teardown:
+                teardown()
     source = excinfo.traceback[-1].statement
     assert str(source).strip() == "c(1)"
 

testing/example_scripts/fixtures/fill_fixtures/test_conftest_funcargs_only_available_in_subdir/sub2/conftest.py

@@ -3,4 +3,4 @@
 
 @pytest.fixture
 def arg2(request):
-    pytest.raises(Exception, "request.getfixturevalue('arg1')")
+    pytest.raises(Exception, request.getfixturevalue, "arg1")

testing/python/collect.py

@@ -325,7 +325,7 @@ def test_gen():
         assert len(colitems) == 1
         gencol = colitems[0]
         assert isinstance(gencol, pytest.Generator)
-        pytest.raises(ValueError, "gencol.collect()")
+        pytest.raises(ValueError, gencol.collect)
 
     def test_generative_methods_with_explicit_names(self, testdir):
         modcol = testdir.getmodulecol(
@@ -1103,7 +1103,8 @@ def test_modulecol_roundtrip(testdir):
 
 class TestTracebackCutting(object):
     def test_skip_simple(self):
-        excinfo = pytest.raises(pytest.skip.Exception, 'pytest.skip("xxx")')
+        with pytest.raises(pytest.skip.Exception) as excinfo:
+            pytest.skip("xxx")
         assert excinfo.traceback[-1].frame.code.name == "skip"
         assert excinfo.traceback[-1].ishidden()
 

testing/python/fixture.py

@@ -906,7 +906,8 @@ def test_func2(self, something):
         assert "skipif" not in item1.keywords
         req1.applymarker(pytest.mark.skipif)
         assert "skipif" in item1.keywords
-        pytest.raises(ValueError, "req1.applymarker(42)")
+        with pytest.raises(ValueError):
+            req1.applymarker(42)
 
     def test_accesskeywords(self, testdir):
         testdir.makepyfile(

testing/python/metafunc.py

@@ -70,11 +70,11 @@ def func(arg1):
             pass
 
         metafunc = self.Metafunc(func)
-        pytest.raises(ValueError, "metafunc.addcall(id=None)")
+        pytest.raises(ValueError, metafunc.addcall, id=None)
 
         metafunc.addcall(id=1)
-        pytest.raises(ValueError, "metafunc.addcall(id=1)")
-        pytest.raises(ValueError, "metafunc.addcall(id='1')")
+        pytest.raises(ValueError, metafunc.addcall, id=1)
+        pytest.raises(ValueError, metafunc.addcall, id="1")
         metafunc.addcall(id=2)
         assert len(metafunc._calls) == 2
         assert metafunc._calls[0].id == "1"
@@ -108,7 +108,7 @@ class obj(object):
 
         metafunc.addcall(funcargs={"x": 2})
         metafunc.addcall(funcargs={"x": 3})
-        pytest.raises(pytest.fail.Exception, "metafunc.addcall({'xyz': 0})")
+        pytest.raises(pytest.fail.Exception, metafunc.addcall, {"xyz": 0})
         assert len(metafunc._calls) == 2
         assert metafunc._calls[0].funcargs == {"x": 2}
         assert metafunc._calls[1].funcargs == {"x": 3}

testing/python/raises.py

@@ -4,25 +4,32 @@
 
 import pytest
 from _pytest.outcomes import Failed
+from _pytest.warning_types import PytestDeprecationWarning
 
 
 class TestRaises(object):
     def test_raises(self):
         source = "int('qwe')"
-        excinfo = pytest.raises(ValueError, source)
+        with pytest.warns(PytestDeprecationWarning):
+            excinfo = pytest.raises(ValueError, source)
         code = excinfo.traceback[-1].frame.code
         s = str(code.fullsource)
         assert s == source
 
     def test_raises_exec(self):
-        pytest.raises(ValueError, "a,x = []")
+        with pytest.warns(PytestDeprecationWarning) as warninfo:
+            pytest.raises(ValueError, "a,x = []")
+        assert warninfo[0].filename == __file__
 
     def test_raises_exec_correct_filename(self):
-        excinfo = pytest.raises(ValueError, 'int("s")')
-        assert __file__ in excinfo.traceback[-1].path
+        with pytest.warns(PytestDeprecationWarning):
+            excinfo = pytest.raises(ValueError, 'int("s")')
+            assert __file__ in excinfo.traceback[-1].path
 
     def test_raises_syntax_error(self):
-        pytest.raises(SyntaxError, "qwe qwe qwe")
+        with pytest.warns(PytestDeprecationWarning) as warninfo:
+            pytest.raises(SyntaxError, "qwe qwe qwe")
+        assert warninfo[0].filename == __file__
 
     def test_raises_function(self):
         pytest.raises(ValueError, int, "hello")

testing/test_capture.py

@@ -87,7 +87,7 @@ def test_init_capturing(self):
         try:
             capman = CaptureManager("fd")
             capman.start_global_capturing()
-            pytest.raises(AssertionError, "capman.start_global_capturing()")
+            pytest.raises(AssertionError, capman.start_global_capturing)
             capman.stop_global_capturing()
         finally:
             capouter.stop_capturing()
@@ -798,10 +798,10 @@ def test_unicode_and_str_mixture(self):
         f = capture.CaptureIO()
         if sys.version_info >= (3, 0):
             f.write("\u00f6")
-            pytest.raises(TypeError, "f.write(bytes('hello', 'UTF-8'))")
+            pytest.raises(TypeError, f.write, b"hello")
         else:
-            f.write(text_type("\u00f6", "UTF-8"))
-            f.write("hello")  # bytes
+            f.write(u"\u00f6")
+            f.write(b"hello")
             s = f.getvalue()
             f.close()
             assert isinstance(s, text_type)
@@ -1149,7 +1149,7 @@ def test_stdin_nulled_by_default(self):
         print("XXX which indicates an error in the underlying capturing")
         print("XXX mechanisms")
         with self.getcapture():
-            pytest.raises(IOError, "sys.stdin.read()")
+            pytest.raises(IOError, sys.stdin.read)
 
 
 class TestStdCaptureFD(TestStdCapture):