这样做的方式在mock 0.7.0中已经改变，它最终支持模拟python协议方法(magic方法)，特别是使用MagicMock:

http://www.voidspace.org.uk/python/mock/magicmock.html < a href = " http://www.voidspace.org.uk/python/mock/magicmock.html " > < / >

一个作为上下文管理器打开的mock示例(来自mock文档中的示例页面):

>>> open_name = '%s.open' % __name__
>>> with patch(open_name, create=True) as mock_open:
...     mock_open.return_value = MagicMock(spec=file)
...
...     with open('/some/path', 'w') as f:
...         f.write('something')
...
<mock.Mock object at 0x...>
>>> file_handle = mock_open.return_value.__enter__.return_value
>>> file_handle.write.assert_called_with('something')

在mock的最新版本中，你可以使用真正有用的mock_open帮助器:

mock_open(模拟= None, read_data =没有)

一个helper函数 用Mock代替open。它适用于open call direct或 用作上下文管理器

mock参数是要配置的模拟对象。若无( 默认)，然后将为您创建一个MagicMock，使用API 仅限于标准文件句柄上可用的方法或属性

read_data是文件句柄的读取方法的字符串 回报。

.默认为空字符串

>>> from mock import mock_open, patch
>>> m = mock_open()
>>> with patch('{}.open'.format(__name__), m, create=True):
...    with open('foo', 'w') as h:
...        h.write('some stuff')


>>> m.assert_called_once_with('foo', 'w')
>>> handle = m()
>>> handle.write.assert_called_once_with('some stuff')

要对一个简单的文件read()使用mock_open(原始的mock_open代码段本页已经给出了更适合写入):

my_text = "some text to return when read() is called on the file object"
mocked_open_function = mock.mock_open(read_data=my_text)


with mock.patch("__builtin__.open", mocked_open_function):
with open("any_string") as f:
print f.read()

注意，根据mock_open的文档，这是专门针对read()的，所以不能用于常见的模式，例如for line in f。

使用python 2.6.6 / mock 1.0.1

我可能有点晚了，但当我在另一个模块中调用open而无需创建新文件时，这对我来说是有效的。

test.py

import unittest
from mock import Mock, patch, mock_open
from MyObj import MyObj


class TestObj(unittest.TestCase):
open_ = mock_open()
with patch.object(__builtin__, "open", open_):
ref = MyObj()
ref.save("myfile.txt")
assert open_.call_args_list == [call("myfile.txt", "wb")]

MyObj.py

class MyObj(object):
def save(self, filename):
with open(filename, "wb") as f:
f.write("sample text")

通过将__builtin__模块内的open函数修补到我的mock_open()，我可以模拟写入文件而不创建一个文件。

注意:如果你正在使用一个使用cython的模块，或者你的程序以任何方式依赖于cython，你将需要通过在你的文件顶部包含import __builtin__来导入cython的__builtin__模块。如果你正在使用cython，你将不能模拟通用__builtin__。

Python 3

修补builtins.open并使用mock_open，它是mock框架的一部分。patch用作上下文管理器返回用于替换修补的对象:

from unittest.mock import patch, mock_open
with patch("builtins.open", mock_open(read_data="data")) as mock_file:
assert open("path/to/open").read() == "data"
mock_file.assert_called_with("path/to/open")

如果你想使用patch作为装饰器，使用mock_open()的结果作为new=参数到patch可能会有点奇怪。相反，使用patch的new_callable=实参，并记住patch不使用的每个额外实参将被传递给new_callable函数，如patch文档中所述:

patch()接受任意关键字参数。它们将在构造时传递给Mock(或new_callable)。

@patch("builtins.open", new_callable=mock_open, read_data="data")
def test_patch(mock_file):
assert open("path/to/open").read() == "data"
mock_file.assert_called_with("path/to/open")

记住，在这种情况下，patch将模拟对象作为参数传递给测试函数。

Python 2

你需要修补__builtin__.open而不是builtins.open，并且mock不是unittest的一部分，你需要pip install并单独导入它:

from mock import patch, mock_open
with patch("__builtin__.open", mock_open(read_data="data")) as mock_file:
assert open("path/to/open").read() == "data"
mock_file.assert_called_with("path/to/open")

上面的答案很有用，但我对它进行了一些扩展。

如果你想基于传递给open()的参数来设置文件对象的值(as f中的f)，这里有一种方法:

def save_arg_return_data(*args, **kwargs):
mm = MagicMock(spec=file)
mm.__enter__.return_value = do_something_with_data(*args, **kwargs)
return mm
m = MagicMock()
m.side_effect = save_arg_return_array_of_data


# if your open() call is in the file mymodule.animals
# use mymodule.animals as name_of_called_file
open_name = '%s.open' % name_of_called_file


with patch(open_name, m, create=True):
#do testing here

基本上，open()将返回一个对象，而with将在该对象上调用__enter__()。

要正确地模拟，必须模拟open()以返回模拟对象。然后，该模拟对象应该模拟对其进行的__enter__()调用(MagicMock将为我们完成此操作)，以返回我们想要的模拟数据/文件对象(因此是mm.__enter__.return_value)。用上述方法对2个mock进行此操作，可以捕获传递给open()的参数，并将它们传递给do_something_with_data方法。

我将整个模拟文件作为字符串传递给open()，我的do_something_with_data看起来像这样:

def do_something_with_data(*args, **kwargs):
return args[0].split("\n")

这将字符串转换为一个列表，这样你就可以像处理普通文件一样执行以下操作:

for line in file:
#do action

使用unittest修补内置的open()函数:

这适用于补丁读取json配置。

class ObjectUnderTest:
def __init__(self, filename: str):
with open(filename, 'r') as f:
dict_content = json.load(f)

被模拟的对象是io。由open()函数返回的TextIOWrapper对象

@patch("<src.where.object.is.used>.open",
return_value=io.TextIOWrapper(io.BufferedReader(io.BytesIO(b'{"test_key": "test_value"}'))))
def test_object_function_under_test(self, mocker):

如果你不需要进一步的文件，你可以装饰测试方法:

@patch('builtins.open', mock_open(read_data="data"))
def test_testme():
result = testeme()
assert result == "data"

来自github代码片段，用于修补python中的读写功能。

源链接在在这里上

import configparser
import pytest


simpleconfig = """[section]\nkey = value\n\n"""


def test_monkeypatch_open_read(mockopen):
filename = 'somefile.txt'
mockopen.write(filename, simpleconfig)
 

parser = configparser.ConfigParser()
parser.read(filename)
assert parser.sections() == ['section']
 

def test_monkeypatch_open_write(mockopen):
parser = configparser.ConfigParser()
parser.add_section('section')
parser.set('section', 'key', 'value')
 

filename = 'somefile.txt'
parser.write(open(filename, 'wb'))
assert mockopen.read(filename) == simpleconfig

使用assert简单的@patch

如果你想使用@patch。open()在处理程序内部被调用并被读取。

    @patch("builtins.open", new_callable=mock_open, read_data="data")
def test_lambda_handler(self, mock_open_file):
        

lambda_handler(event, {})

在我的例子中，我使用的是pytest，好消息是在Python 3中，unittest库也可以毫无问题地导入和使用。

以下是我的方法。首先，我用可重用的pytest fixture创建一个conftest.py文件:

from functools import cache
from unittest.mock import MagicMock, mock_open


import pytest
from pytest_mock import MockerFixture




class FileMock(MagicMock):


def __init__(self, mocker: MagicMock = None, **kwargs):
super().__init__(**kwargs)


if mocker:
self.__dict__ = mocker.__dict__
# configure mock object to replace the use of open(...)
# note: this is useful in scenarios where data is written out
_ = mock_open(mock=self)


@property
def read_data(self):
return self.side_effect


@read_data.setter
def read_data(self, mock_data: str):
"""set mock data to be returned when `open(...).read()` is called."""
self.side_effect = mock_open(read_data=mock_data)


@property
@cache
def write_calls(self):
"""a list of calls made to `open().write(...)`"""
handle = self.return_value
write: MagicMock = handle.write
return write.call_args_list


@property
def write_lines(self) -> str:
"""a list of written lines (as a string)"""
return ''.join([c[0][0] for c in self.write_calls])




@pytest.fixture
def mock_file_open(mocker: MockerFixture) -> FileMock:
return FileMock(mocker.patch('builtins.open'))

在这里，我决定将read_data作为一个属性，以便更python化。可以在测试函数中赋值open()需要返回的任何数据。

在我的测试文件中，命名为test_it_works.py，我有以下测试用例来确认预期的功能:

from unittest.mock import call




def test_mock_file_open_and_read(mock_file_open):
mock_file_open.read_data = 'hello\nworld!'


with open('/my/file/here', 'r') as in_file:
assert in_file.readlines() == ['hello\n', 'world!']


mock_file_open.assert_called_with('/my/file/here', 'r')




def test_mock_file_open_and_write(mock_file_open):
with open('/out/file/here', 'w') as f:
f.write('hello\n')
f.write('world!\n')
f.write('--> testing 123 :-)')


mock_file_open.assert_called_with('/out/file/here', 'w')


assert call('world!\n') in mock_file_open.write_calls


assert mock_file_open.write_lines == """\
hello
world!
--> testing 123 :-)
""".rstrip()

看看要点在这里。