Python unittest undo patch when exception is raised

This is a difficult one with a complete fake class, but the idea is the same.

Here I need to open a blank file, but if this method returns FileExistsError, I delete that file and call open again. If I want to test the openBlankFile method for situations where the file exists, I need to patch out the 'open' method call and set side-effect to FileNotFound exception. But, when you do this, the second time the 'open' method is called, this one is obviously also patched. How do you go about this type of issue?

File mockPatch.py

from unittest import TestCase
from unittest.mock import patch
from os import remove

class WriteModule(object):
    def openBlankFile(self):
        try:
            with open("Foo.txt", "x"):
            print("created")
        except FileExistsError:
            remove("Foo.txt")
            open("Foo.txt", "x")
            print("removed and created")

class testWriteModule(TestCase):
    @patch("mockPatch.open", side_effect=FileExistsError)
    @patch("mockPatch.remove")
    def testWriteModuleOpen(self, mock_remove, mock_open):
        WriteModule().openBlankFile()

if __name__ == "__main__":
    unittest.main()

# EOF

Run:

python -m unittest mockPatch

Running this does not seem to mock either FileExistsError.

Error output

What is up with this piece of code?

When you mock open, you can set side_effect to a list that contains both the initial exception to raise and the "real" file object for the second call to return. For example,

class testWriteModule(TestCase):
    @patch("mockPatch.open", side_effect=[FileExistsError, io.StringIO()])
    @patch("mockPatch.remove")
    def testWriteModuleOpen(self, mock_remove, mock_open):
        WriteModule().openBlankFile()

The documentation for Mock is fuzzy on this point:

> If side_effect is an iterable then each call to the mock will return the next value from the iterable.

But if an element of the iterable is in fact an exception type or an instance of an exception type, an exception is raised rather than the element being returned. I think the intent of the previous sentence

> Alternatively side_effect can be an exception class or instance. In this case the exception will be raised when the mock is called.

is to imply that an exception is "called" by being raised, whether it is standalone or part of an iterable, but I at least needed to test this to confirm.

You are correct that the second call to the open method in the WriteModule class is also patched due to the way the patch decorators are used. To avoid patching the open method multiple times, we can modify the test case to use a single patch for both FileExistsError and remove side-effects.

Here's how you can achieve that:

from unittest import TestCase
from unittest.mock import patch
from os import remove

class WriteModule(object):
    def openBlankFile(self):
        try:
            with open("Foo.txt", "x"):
                pass
        except FileExistsError:
            remove("Foo.txt")
            with open("Foo.txt", "x"):
                pass

class testWriteModule(TestCase):
    @patch("mockPatch.open", side_effect=[FileExistsError, None])
    @patch("mockPatch.remove")
    def testWriteModuleOpen(self, mock_remove, mock_open):
        WriteModule().openBlankFile()
        mock_remove.assert_called_once_with("Foo.txt")
        mock_open.assert_called_with("Foo.txt", "x")

if __name__ == "__main__":
    unittest.main()

In the provided code, the issue lies in the way the openBlankFile method is handling the exceptions and using the open function. Additionally, the patching of the open function is not being done correctly in the test case. Let's address these issues step by step:

1. Fixing openBlankFile method:
   The openBlankFile method should not use the built-in open function for file handling since it interferes with the patching process in the test case. Instead, it's better to use the os module's functions for file handling, which will allow us to patch those functions independently.

Here's the modified version of openBlankFile:

import os

class WriteModule(object):
    def openBlankFile(self):
        try:
            with open("Foo.txt", "x"):
                pass
        except FileExistsError:
            os.remove("Foo.txt")
            with open("Foo.txt", "x"):
                pass

2. Modifying the test case:

The openBlankFile method needs to be modified to use os module functions, as discussed above.
We need to patch the os.open and os.remove functions in the test case instead of the built-in open function.
Here's the modified test case:

from unittest import TestCase
from unittest.mock import patch
from os import remove

class WriteModule(object):
    def openBlankFile(self):
        try:
            with open("Foo.txt", "x"):
                pass
        except FileExistsError:
            remove("Foo.txt")
            with open("Foo.txt", "x"):
                pass

class testWriteModule(TestCase):
    @patch("mockPatch.os.remove")
    @patch("mockPatch.os.open", side_effect=FileExistsError)
    def testWriteModuleOpen(self, mock_open, mock_remove):
        WriteModule().openBlankFile()

By using os.open and os.remove in both the method and the test case, we can successfully patch the os.open function to raise a FileExistsError exception, and the test case will handle it correctly.

With these modifications, the test case should work as expected, and you should be able to verify the behavior of the openBlankFile method when the file exists.