Introduce pytest.not_raises

CHANGELOG.rst

@@ -16,6 +16,10 @@ New Features
 * ``pytest.raises`` now asserts that the error message matches a text or regex
   with the ``match`` keyword argument. Thanks `@Kriechi`_ for the PR.
 
+* ``pytest.not_raises`` helper to use in parametrized tests that expect exceptions or
+  not depending on other parameters (`#1830`_).
+  Thanks `@The-Compiler`_ for the idea and `@nicoddemus`_ for the PR.
+
 * ``pytest.param`` can be used to declare test parameter sets with marks and test ids.
   Thanks `@RonnyPfannschmidt`_ for the PR.
 
@@ -88,6 +92,7 @@ Bug Fixes
 
 .. _#1407: https://github.com/pytest-dev/pytest/issues/1407
 .. _#1512: https://github.com/pytest-dev/pytest/issues/1512
+.. _#1830: https://github.com/pytest-dev/pytest/issues/1830
 .. _#1874: https://github.com/pytest-dev/pytest/pull/1874
 .. _#1952: https://github.com/pytest-dev/pytest/pull/1952
 .. _#2007: https://github.com/pytest-dev/pytest/issues/2007

_pytest/python.py

@@ -131,6 +131,7 @@ def pytest_namespace():
     raises.Exception = pytest.fail.Exception
     return {
         'raises': raises,
+        'not_raises': NotRaisesContext,
         'approx': approx,
         'collect': {
             'Module': Module,
@@ -956,6 +957,8 @@ def _idval(val, argname, idx, idfn, config=None):
         return str(val)
     elif isclass(val) and hasattr(val, '__name__'):
         return val.__name__
+    elif isinstance(val, (RaisesContext, NotRaisesContext)):
+        return str(val)
     return str(argname)+str(idx)
 
 def _idvalset(idx, parameterset, argnames, idfn, ids, config=None):
@@ -1266,6 +1269,27 @@ def __exit__(self, *tp):
             self.excinfo.match(self.match_expr)
         return suppress_exception
 
+    def __str__(self):
+        return 'raises({0})'.format(self.expected_exception.__name__)
+
+
+# builtin pytest.not_raises helper
+
+class NotRaisesContext(object):
+    """
+    Dummy helper class for use in parametrized tests, for non-raising
+    cases.
+    """
+
+    def __enter__(self):
+        pass
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    def __str__(self):
+        return 'not_raises'
+
 
 # builtin pytest.approx helper
 

doc/en/assert.rst

@@ -94,8 +94,7 @@ In the context manager form you may use the keyword argument
      ...    pass
      ... Failed: Expecting ZeroDivisionError
 
-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::
+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)")

doc/en/parametrize.rst

@@ -154,6 +154,75 @@ x=1/y=3.
     comma-separated-string syntax is now advertised first because
     it's easier to write and produces less line noise.
 
+
+``pytest.mark.parametrize`` and exception expectations
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. versionadded:: 3.1
+
+Sometimes you might want to make sure a function raises an exception for
+a set of inputs but should not raise anything for another set of inputs.
+
+For example, consider this function:
+
+.. code-block:: python
+
+    def check_python_identifier(ident):
+        """raise ValueError if ``ident`` is not a valid Python identifier."""
+
+
+This is a natural job for a ``pytest.mark.parametrize``, so you might write
+a test like this:
+
+.. code-block:: python
+
+    @pytest.mark.parametrize('ident, valid', [
+        ('foobar', True),
+        ('Foobar1', True),
+        ('Foobar_', True),
+        ('Foo_bar_', True),
+        ('Foo bar_', False),
+        ('foo bar_', False),
+        ('1foo bar_', False),
+    ])
+    def test_check_python_identifier(ident, valid):
+        if not valid:
+            with pytest.raises(ValueError):
+                check_python_identifier(ident)
+        else:
+            check_python_identifier(ident)  # should not raise
+
+
+But this makes us repeat ourselves on the test function.
+
+For these situations, where you need to ``parametrize`` a test function
+so that sometimes it raises an exception and others do not, you can use
+the convenient ``pytest.not_raises`` helper:
+
+.. code-block:: python
+
+    @pytest.mark.parametrize('ident, valid', [
+        ('foobar', pytest.not_raises()),
+        ('Foobar1', pytest.not_raises()),
+        ('Foobar_', pytest.not_raises()),
+        ('Foo_bar_', pytest.not_raises()),
+        ('Foo bar_', pytest.raises(ValueError)),
+        ('foo bar_', pytest.raises(ValueError)),
+        ('1foo bar_', pytest.raises(ValueError)),
+    ])
+    def test_check_python_identifier(ident, expectation):
+        with pytest.raises(expectation):
+            check_python_identifier(ident)
+
+How does it work? ``pytest.not_raises`` is a context-manager which **does nothing**. It is merely
+a convenience helper to use in conjunction with ``parametrize`` for testing that functions
+raise errors sometimes and other times do not.
+
+.. note::
+    Do not use ``pytest.not_raises()`` in a non-parametrized test just to
+    check if some code does not raise something; just let the original code propagate
+    any exception to make the test fail.
+
 .. _`pytest_generate_tests`:
 
 Basic ``pytest_generate_tests`` example

testing/python/metafunc.py

@@ -263,6 +263,13 @@ def test_idmaker_enum(self):
         result = idmaker(("a", "b"), [pytest.param(e.one, e.two)])
         assert result == ["Foo.one-Foo.two"]
 
+    def test_idmaker_raises(self):
+        from _pytest.python import idmaker
+        result = idmaker(("amount", "exc"), [pytest.param("foo", pytest.raises(TypeError))])
+        assert result == ["foo-raises(TypeError)"]
+        result = idmaker(("amount", "exc"), [pytest.param("foo", pytest.not_raises())])
+        assert result == ["foo-not_raises"]
+
     @pytest.mark.issue351
     def test_idmaker_idfn(self):
         from _pytest.python import idmaker

testing/python/raises.py

@@ -118,7 +118,6 @@ def __call__(self):
         for o in gc.get_objects():
             assert type(o) is not T
 
-
     def test_raises_match(self):
         msg = r"with base \d+"
         with pytest.raises(ValueError, match=msg):
@@ -133,3 +132,13 @@ def test_raises_match(self):
         with pytest.raises(AssertionError, match=expr):
             with pytest.raises(ValueError, match=msg):
                 int('asdf', base=10)
+
+
+def test_not_raises():
+    """pytest.not_raises() does not do anything, just ensure it follows the declared API"""
+    with pytest.not_raises():
+        pass
+    with pytest.raises(ValueError):
+        with pytest.not_raises():
+            raise ValueError
+