Python: Creating a mock or fake directory with files for unittesting

Question

I am trying to create a unit test for the following function:

def my_function(path):
    #Search files at the given path
    for file in os.listdir(path):
        if file.endswith(".json"):
            #Search for file i'm looking for
            if file == "file_im_looking_for.json":
                #Open file
                os.chdir(path)
                json_file=json.load(open(file))
                print json_file["name"]

However I am having trouble successfully creating a fake directory with files in order for the function to work correctly and not through errors.

Below is what I have so far but it is not working for me, and I'm not sure how to incorporate "file_im_looking_for" as the file in the fake directory.

tmpfilepath = os.path.join(tempfile.gettempdir(), "tmp-testfile")
@mock.patch('my_module.os')

def test_my_function(self):

    # make the file 'exist'
    mock_path.endswith.return_value = True

    file_im_looking_for=[{
      "name": "test_json_file",
      "type": "General"
    }]

    my_module.my_function("tmpfilepath")

Any advice where I'm going wrong or other ideas to approach this problem are appreciated!

Answer 1

I would suggest to use Python's tempfile library, specifically TemporaryDirectory.

The issue with your and Mauro Baraldi's solution is that you have to patch multiple functions. This is a very error prone way, since with mock.patch you have to know exactly what you are doing! Otherwise, this may cause unexpected errors and eventually frustration.

Personally, I prefer pytest, since it has IMO nicer syntax and better fixtures, but since the creator used unittest I will stick with it.

I would rewrite your test code like this:

import json
import pathlib
import tempfile
import unittest

wrong_data = {
      "name": "wrong_json_file",
      "type": "Fake"
    }

correct_data = {
      "name": "test_json_file",
      "type": "General"
    }

class TestMyFunction(unittest.TestCase):
    def setUp(self):
        """ Called before every test. """
        self._temp_dir = tempfile.TemporaryDirectory()
        temp_path = pathlib.Path(self._temp_dir.name)
        self._create_temporary_file_with_json_data(temp_path / 'wrong_json_file.json', wrong_data)
        self._create_temporary_file_with_json_data(temp_path / 'file_im_looking_for.json', correct_data)
        
    def tearDown(self):
        """ Called after every test. """
        self._temp_dir.cleanup()

    def _create_temporary_file_with_json_data(self, file_path, json_data):
        with open(file_path, 'w') as ifile:
            ifile.write(json.dumps(content))

    def test_my_function(self):
        my_module.my_function(str(self._temp_dir))

You see that your actual test is compressed down to a single line! Admittedly, there is no assert, but if your function would return something, the result would behave as expected.

No mocking, because everything exists and will be cleaned up afterwards. And the best thing is that you now can add more tests with a lower barrier of entry.