Make 'raises' and 'warns' args PEP8 compliant

Author: hunse

_pytest/python.py

@@ -1054,8 +1054,8 @@ def getlocation(function, curdir):
 
 # builtin pytest.raises helper
 
-def raises(ExpectedException, *args, **kwargs):
-    """ assert that a code block/function call raises @ExpectedException
+def raises(expected_exception, *args, **kwargs):
+    """ assert that a code block/function call raises @expected_exception
     and raise a failure exception otherwise.
 
     This helper produces a ``py.code.ExceptionInfo()`` object.
@@ -1103,23 +1103,23 @@ def raises(ExpectedException, *args, **kwargs):
 
     """
     __tracebackhide__ = True
-    if ExpectedException is AssertionError:
+    if expected_exception is AssertionError:
         # we want to catch a AssertionError
         # replace our subclass with the builtin one
         # see https://github.com/pytest-dev/pytest/issues/176
         from _pytest.assertion.util import BuiltinAssertionError \
-            as ExpectedException
+            as expected_exception
     msg = ("exceptions must be old-style classes or"
            " derived from BaseException, not %s")
-    if isinstance(ExpectedException, tuple):
-        for exc in ExpectedException:
+    if isinstance(expected_exception, tuple):
+        for exc in expected_exception:
             if not inspect.isclass(exc):
                 raise TypeError(msg % type(exc))
-    elif not inspect.isclass(ExpectedException):
-        raise TypeError(msg % type(ExpectedException))
+    elif not inspect.isclass(expected_exception):
+        raise TypeError(msg % type(expected_exception))
 
     if not args:
-        return RaisesContext(ExpectedException)
+        return RaisesContext(expected_exception)
     elif isinstance(args[0], str):
         code, = args
         assert isinstance(code, str)
@@ -1132,19 +1132,19 @@ def raises(ExpectedException, *args, **kwargs):
             py.builtin.exec_(code, frame.f_globals, loc)
             # XXX didn'T mean f_globals == f_locals something special?
             #     this is destroyed here ...
-        except ExpectedException:
+        except expected_exception:
             return py.code.ExceptionInfo()
     else:
         func = args[0]
         try:
             func(*args[1:], **kwargs)
-        except ExpectedException:
+        except expected_exception:
             return py.code.ExceptionInfo()
     pytest.fail("DID NOT RAISE")
 
 class RaisesContext(object):
-    def __init__(self, ExpectedException):
-        self.ExpectedException = ExpectedException
+    def __init__(self, expected_exception):
+        self.expected_exception = expected_exception
         self.excinfo = None
 
     def __enter__(self):
@@ -1163,14 +1163,14 @@ def __exit__(self, *tp):
                 exc_type, value, traceback = tp
                 tp = exc_type, exc_type(value), traceback
         self.excinfo.__init__(tp)
-        return issubclass(self.excinfo.type, self.ExpectedException)
+        return issubclass(self.excinfo.type, self.expected_exception)
 
 # builtin pytest.warns helper
 
-def warns(ExpectedWarning, *args, **kwargs):
+def warns(expected_warning, *args, **kwargs):
     """Assert that code raises a particular class of warning.
 
-    Specifically, the input ``ExpectedWarning`` can be a warning class or
+    Specifically, the input @expected_warning can be a warning class or
     tuple of warning classes, and the code must return that warning
     (if a single class) or one of those warnings (if a tuple).
 
@@ -1186,14 +1186,14 @@ def warns(ExpectedWarning, *args, **kwargs):
 
     msg = ("exceptions must be old-style classes or"
            " derived from Warning, not %s")
-    if isinstance(ExpectedWarning, tuple):
-        for exc in ExpectedWarning:
+    if isinstance(expected_warning, tuple):
+        for exc in expected_warning:
             if not inspect.isclass(exc):
                 raise TypeError(msg % type(exc))
-    elif not inspect.isclass(ExpectedWarning):
-        raise TypeError(msg % type(ExpectedWarning))
+    elif not inspect.isclass(expected_warning):
+        raise TypeError(msg % type(expected_warning))
 
-    context = WarnsContext(ExpectedWarning)
+    context = WarnsContext(expected_warning)
     if not args:
         return context
     elif isinstance(args[0], str):
@@ -1214,10 +1214,10 @@ def warns(ExpectedWarning, *args, **kwargs):
         context.__exit__(*sys.exc_info())
 
 class WarnsContext(object):
-    def __init__(self, ExpectedWarning):
-        self.ExpectedWarning = (
-            ExpectedWarning if isinstance(ExpectedWarning, tuple) else
-            (ExpectedWarning,))
+    def __init__(self, expected_warning):
+        self.expected_warning = (
+            expected_warning if isinstance(expected_warning, tuple) else
+            (expected_warning,))
         self.catcher = None
         self.record = None
 
@@ -1228,7 +1228,7 @@ def __enter__(self):
 
     def __exit__(self, type, value, traceback):
         self.catcher.__exit__(type, value, traceback)
-        if not any(r.category in self.ExpectedWarning for r in self.record):
+        if not any(r.category in self.expected_warning for r in self.record):
             pytest.fail("DID NOT WARN")
 
 #