模拟类方法使用的 open() 函数

TL;DR

您的问题的核心是您应该还模拟 json.dump 以便能够正确测试将要写入文件的数据.在对您的测试方法进行一些重要调整之前，我实际上很难运行您的代码.

TL;DR

The heart of your problem is that you should be also mocking json.dump to be able to properly test the data that is going to be written to your file. I actually had a hard time running your code until a few important adjustments were made to your test method.

• 使用 builtins.open 而不是 mymmodule.open
进行模拟
• 你在一个上下文管理器中，所以你应该检查 m.return_value.__enter__.write，但是你实际上是从 json.dump 调用 write 的，这是调用 write 的地方.(以下有关建议解决方案的详细信息)
• 您还应该模拟 json.dump 以简单地验证它是用您的数据调用的

• Mock with builtins.open and not mymmodule.open
• You are in a context manager, so you should be checking m.return_value.__enter__.write, however you are actually calling the write from json.dump which is where the write will be called. (Details below on a suggested solution)
• You should also mock json.dump to simply validate it is called with your data

简而言之，有了上面提到的问题，方法可以重写为:

In short, with the issues mentioned above, the method can be re-written as:

以下所有内容的详细信息

def test_save_data_to_file(self):
    with patch('builtins.open', new_callable=mock_open()) as m:
        with patch('json.dump') as m_json:
            self.mc.save_data_to_file(self.data)

            # simple assertion that your open was called 
            m.assert_called_with('/tmp/data.json', 'w')

            # assert that you called m_json with your data
            m_json.assert_called_with(self.data, m.return_value)

详细说明

要专注于我在您的代码中看到的问题，我强烈建议您做的第一件事，因为 open 是内置的，是从内置模拟，此外，您可以为自己节省一行通过使用 new_callable 和 as 来编写代码，所以你可以简单地这样做:

Detailed Explanation

To focus on the problems I see in your code, the first thing I strongly suggest doing, since open is a builtin, is to mock from builtins, furthermore, you can save yourself a line of code by making use of new_callable and as, so you can simply do this:

with patch('builtins.open', new_callable=mock_open()) as m:

我在您的代码中看到的下一个问题是我在运行此代码时遇到了问题，直到您开始循环调用时我实际进行了以下调整:

The next problem that I see with your code as I had trouble running this until I actually made the following adjustment when you started looping over your calls:

m.return_value.__enter__.return_value.write.mock_calls

要剖析它，您必须记住的是您的方法使用的是上下文管理器.在使用上下文管理器时，您的写入工作实际上将在您的 __enter__ 方法中完成.所以，从你的m的return_value中，你想得到__enter__的return_value.

To dissect that, what you have to keep in mind is that your method is using a context manager. In using a context manager, the work of your write will actually be done inside your __enter__ method. So, from the return_value of your m, you want to then get the return_value of __enter__.

但是，这将我们带到了您要测试的问题的核心.由于 json.dump 在写入文件时的工作方式，您在检查代码后写入的 mock_calls 实际上如下所示:

However, this brings us to the heart of the problem with what you are trying to test. Because of how the json.dump works when writing to the file, your mock_calls for your write after inspecting the code, will actually look like this:

<MagicMock name='open().write' id='4348414496'>
call('[')
call('{')
call('"name"')
call(': ')
call('"peter"')
call(', ')
call('"id"')
call(': ')
call('5414470')
call('}')
call(', ')
call('{')
call('"name"')
call(': ')
call('"tom"')
call(', ')
call('"id"')
call(': ')
call('5414472')
call('}')
call(', ')
call('{')
call('"name"')
call(': ')
call('"pit"')
call(', ')
call('"id"')
call(': ')
call('5414232')
call('}')
call(']')
call.__str__()

测试起来不会很有趣.因此，这将我们带到您可以尝试的下一个解决方案；模拟 json.dump.

That is not going to be fun to test. So, this brings us to the next solution you can try out; Mock json.dump.

你不应该测试 json.dump，你应该测试用正确的参数调用它.话虽如此，您可以按照类似的方式进行模拟并执行以下操作:

You shouldn't be testing json.dump, you should be testing calling it with the right parameters. With that being said, you can follow similar fashion with your mocking and do something like this:

with patch('json.dump') as m_json:

现在，有了它，您可以显着简化您的测试代码，以简单地验证该方法是否被您正在测试的数据调用.所以，有了它，当你把它们放在一起时，你会得到这样的东西:

Now, with that, you can significantly simplify your test code, to simply validate that the method gets called with your data that you are testing with. So, with that, when you put it all together, you will have something like this:

def test_save_data_to_file(self):
    with patch('builtins.open', new_callable=mock_open()) as m:
        with patch('json.dump') as m_json:
            self.mc.save_data_to_file(self.data)

            # simple assertion that your open was called 
            m.assert_called_with('/tmp/data.json', 'w')

            # assert that you called m_json with your data
            m_json.assert_called_with(self.data, m.return_value.__enter__.return_value)

如果您有兴趣进一步重构以使您的测试方法更简洁，您还可以将补丁设置为装饰器，让您的代码更简洁:

If you're interested in further refactoring to make your test method a bit cleaner, you could also set up your patching as a decorator, leaving your code cleaner inside the method:

@patch('json.dump')
@patch('builtins.open', new_callable=mock_open())
def test_save_data_to_file(self, m, m_json):
    self.mc.save_data_to_file(self.data)

    # simple assertion that your open was called
    m.assert_called_with('/tmp/data.json', 'w')

    # assert that you called m_json with your data
    m_json.assert_called_with(self.data, m.return_value.__enter__.return_value)

检查是您最好的朋友，查看在哪些步骤调用了哪些方法，以进一步帮助测试.祝你好运.

Inspecting is your best friend here, to see what methods are being called at what steps, to further help with the testing. Good luck.

这篇好文章是转载于：学新通技术网