Merge branch 'master' into rm-3.4

Author: hugovk

.github/workflows/main.yml

@@ -10,7 +10,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python: ["2.7", "3.5", "3.6", "3.7"]
+        python: ["2.7", "3.5", "3.6", "3.7", "3.8"]
         os: [ubuntu-latest, windows-latest]
         include:
           - python: "2.7"
@@ -21,6 +21,8 @@ jobs:
             tox_env: "py36"
           - python: "3.7"
             tox_env: "py37"
+          - python: "3.8"
+            tox_env: "py38"
 
     steps:
     - uses: actions/checkout@v1

CHANGELOG.rst

@@ -1,11 +1,39 @@
-1.11.2 (unreleased)
+1.13.0 (2019-12-05)
+-------------------
+
+* The object returned by ``mocker.spy`` now also tracks any side effect
+  of the spied method/function.
+
+1.12.1 (2019-11-20)
+-------------------
+
+* Fix error if ``mocker.patch`` is used in code where the source file
+  is not available, for example stale ``.pyc`` files (`#169`_).
+
+.. _#169: https://github.com/pytest-dev/pytest-mock/issues/169#issuecomment-555729265
+
+1.12.0 (2019-11-19)
+-------------------
+
+* Now all patch functions also raise a ``ValueError`` when used
+  as a context-manager. Thanks `@AlexGascon`_ for the PR (`#168`_).
+
+.. _@AlexGascon: https://github.com/AlexGascon
+.. _#168: https://github.com/pytest-dev/pytest-mock/pull/168
+
+1.11.2 (2019-10-19)
 -------------------
 
 * The *pytest introspection follows* message is no longer shown
   if there is no pytest introspection (`#154`_).
   Thanks `@The-Compiler`_ for the report.
 
+* ``mocker`` now raises a ``ValueError`` when used as a context-manager.
+  Thanks `@binarymason`_ for the PR (`#165`_).
+
 .. _#154: https://github.com/pytest-dev/pytest-mock/issues/154
+.. _#165: https://github.com/pytest-dev/pytest-mock/pull/165
+.. _@binarymason: https://github.com/binarymason
 
 1.11.1 (2019-10-04)
 -------------------

README.rst

@@ -35,8 +35,8 @@ of a test:
 .. |ci| image:: https://github.com/pytest-dev/pytest-mock/workflows/build/badge.svg
   :target: https://github.com/pytest-dev/pytest-mock/actions
 
-.. |coverage| image:: http://img.shields.io/coveralls/pytest-dev/pytest-mock.svg
-  :target: https://coveralls.io/r/pytest-dev/pytest-mock
+.. |coverage| image:: https://coveralls.io/repos/github/pytest-dev/pytest-mock/badge.svg?branch=master
+  :target: https://coveralls.io/github/pytest-dev/pytest-mock?branch=master
 
 .. |python| image:: https://img.shields.io/pypi/pyversions/pytest-mock.svg
   :target: https://pypi.python.org/pypi/pytest-mock/
@@ -103,6 +103,9 @@ features with it, like retrieving call count. It also works for class and static
 Since version ``1.11``, it is also possible to query the ``return_value`` attribute
 to observe what the spied function/method returned.
 
+Since version ``1.13``, it is also possible to query the ``side_effect`` attribute
+to observe any exception thrown by the spied function/method.
+
 Stub
 ----
 

src/pytest_mock/plugin.py

@@ -113,8 +113,13 @@ def spy(self, obj, name):
 
         @w
         def wrapper(*args, **kwargs):
-            r = method(*args, **kwargs)
-            result.return_value = r
+            try:
+                r = method(*args, **kwargs)
+            except Exception as e:
+                result.side_effect = e
+                raise
+            else:
+                result.return_value = r
             return r
 
         result = self.patch.object(obj, name, side_effect=wrapper, autospec=autospec)
@@ -147,13 +152,30 @@ def _start_patch(self, mock_func, *args, **kwargs):
             module, registering the patch to stop it later and returns the
             mock object resulting from the mock call.
             """
+            self._enforce_no_with_context(inspect.stack())
             p = mock_func(*args, **kwargs)
             mocked = p.start()
             self._patches.append(p)
             if hasattr(mocked, "reset_mock"):
                 self._mocks.append(mocked)
             return mocked
 
+        def _enforce_no_with_context(self, stack):
+            """raises a ValueError if mocker is used in a with context"""
+            caller = stack[2]
+            frame = caller[0]
+            info = inspect.getframeinfo(frame)
+            if info.code_context is None:
+                # no source code available (#169)
+                return
+            code_context = " ".join(info.code_context).strip()
+
+            if code_context.startswith("with mocker."):
+                raise ValueError(
+                    "Using mocker in a with context is not supported. "
+                    "https://github.com/pytest-dev/pytest-mock#note-about-usage-as-context-manager"
+                )
+
         def object(self, *args, **kwargs):
             """API to mock.patch.object"""
             return self._start_patch(self.mock_module.patch.object, *args, **kwargs)

tests/test_pytest_mock.py

@@ -243,6 +243,25 @@ def bar(self, arg):
     assert spy.return_value == 20
 
 
+def test_instance_method_spy_exception(mocker):
+    excepted_message = "foo"
+
+    class Foo(object):
+        def bar(self, arg):
+            raise Exception(excepted_message)
+
+    foo = Foo()
+    other = Foo()
+    spy = mocker.spy(foo, "bar")
+
+    with pytest.raises(Exception) as exc_info:
+        foo.bar(10)
+    assert str(exc_info.value) == excepted_message
+
+    foo.bar.assert_called_once_with(arg=10)
+    assert spy.side_effect == exc_info.value
+
+
 @skip_pypy
 def test_instance_method_by_class_spy(mocker):
     class Foo(object):
@@ -717,3 +736,73 @@ def test_get_random_number(mocker):
     result = testdir.runpytest_subprocess()
     result.stdout.fnmatch_lines("* 1 passed in *")
     assert "RuntimeError" not in result.stderr.str()
+
+
+def test_abort_patch_object_context_manager(mocker):
+    class A(object):
+        def doIt(self):
+            return False
+
+    a = A()
+
+    with pytest.raises(ValueError) as excinfo:
+        with mocker.patch.object(a, "doIt", return_value=True):
+            assert a.doIt() == True
+
+    expected_error_msg = (
+        "Using mocker in a with context is not supported. "
+        "https://github.com/pytest-dev/pytest-mock#note-about-usage-as-context-manager"
+    )
+
+    assert str(excinfo.value) == expected_error_msg
+
+
+def test_abort_patch_context_manager(mocker):
+    with pytest.raises(ValueError) as excinfo:
+        with mocker.patch("some_package"):
+            pass
+
+    expected_error_msg = (
+        "Using mocker in a with context is not supported. "
+        "https://github.com/pytest-dev/pytest-mock#note-about-usage-as-context-manager"
+    )
+
+    assert str(excinfo.value) == expected_error_msg
+
+
+def test_abort_patch_context_manager_with_stale_pyc(testdir):
+    """Ensure we don't trigger an error in case the frame where mocker.patch is being
+    used doesn't have a 'context' (#169)"""
+    import compileall
+
+    py_fn = testdir.makepyfile(
+        c="""
+        class C:
+            x = 1
+
+        def check(mocker):
+            mocker.patch.object(C, "x", 2)
+            assert C.x == 2
+    """
+    )
+    testdir.syspathinsert()
+
+    testdir.makepyfile(
+        """
+        from c import check
+        def test_foo(mocker):
+            check(mocker)
+    """
+    )
+    result = testdir.runpytest()
+    result.stdout.fnmatch_lines("* 1 passed *")
+
+    kwargs = {"legacy": True} if sys.version_info[0] >= 3 else {}
+    assert compileall.compile_file(str(py_fn), **kwargs)
+
+    pyc_fn = str(py_fn) + "c"
+    assert os.path.isfile(pyc_fn)
+
+    py_fn.remove()
+    result = testdir.runpytest()
+    result.stdout.fnmatch_lines("* 1 passed *")