如何模拟with语句中使用的open（使用Python中的模拟框架）？

如何测试以下代码：

---

mock 0.7.0最终支持模拟python协议方法（magic方法），特别是使用MagicMock：

模拟作为上下文管理器打开的示例（来自模拟文档中的示例页面）：

>>open\u name='%s.open'%\u name__
>>>将补丁（open_name，create=True）设置为mock_open：
...     mock_open.return_value=MagicMock（spec=file）
...
...     将open（'/some/path'，w'）作为f：
...         f、 写（‘某物’）
...
>>>文件\句柄=模拟\打开。返回\值。\输入\返回\值
>>>文件\u handle.write.assert\u用（'something'）调用

在mock 0.7.0中，实现这一点的方法已经改变，它最终支持模拟python协议方法（魔术方法），特别是使用MagicMock：

模拟作为上下文管理器打开的示例（来自模拟文档中的示例页面）：

>>open\u name='%s.open'%\u name__
>>>将补丁（open_name，create=True）设置为mock_open：
...     mock_open.return_value=MagicMock（spec=file）
...
...     将open（'/some/path'，w'）作为f：
...         f、 写（‘某物’）
...
>>>文件\句柄=模拟\打开。返回\值。\输入\返回\值
>>>文件\u handle.write.assert\u用（'something'）调用

使用最新版本的mock，您可以使用真正有用的帮助工具：

mock\u open（mock=None，read\u data=None）

一个帮助器函数，用于创建 mock取代open的使用。它适用于直接或间接调用的open 用作上下文管理器

mock参数是要配置的mock对象。如无(修订), 默认设置）然后将使用API为您创建MagicMock 仅限于标准文件句柄上可用的方法或属性

read_data是一个字符串，用于文件句柄的read方法 返回。默认情况下，这是一个空字符串

---

使用最新版本的mock，您可以使用真正有用的帮助程序：

mock\u open（mock=None，read\u data=None）

一个帮助器函数，用于创建 mock取代open的使用。它适用于直接或间接调用的open 用作上下文管理器

mock参数是要配置的mock对象。如无(修订), 默认设置）然后将使用API为您创建MagicMock 仅限于标准文件句柄上可用的方法或属性

read_data是一个字符串，用于文件句柄的read方法 返回。默认情况下，这是一个空字符串

用于简单文件

read（）

（原始的mock\u open代码段更适合于编写）：

注意：根据mock_open的文档，这是专门针对

read（）

，因此不适用于常见的模式，例如f中的行的

使用Python2.6.6/mock 1.0.1
用于简单的文件
read（）
（原始mock_open代码段更适合于编写）：

注意：根据mock_open的文档，这是专门针对
read（）
，因此不适用于常见的模式，例如f

中的行的

使用Python2.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")

通过将
内置模块中的
打开
函数修补到我的
mock\u open（）
，我可以模拟写入文件，而无需创建文件

注意：如果您使用的是使用cython的模块，或者您的程序以任何方式依赖cython，则需要通过在文件顶部包含
import\uuuuuuu builtin\uuuu
来导入。如果您使用cython，您将无法模拟universal
\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu。
我可能会在游戏中迟到一点，但在另一个模块中调用
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")

通过将
内置模块中的
打开
函数修补到我的
mock\u open（）
，我可以模拟写入文件，而无需创建文件

注意：如果您使用的是使用cython的模块，或者您的程序以任何方式依赖cython，则需要通过在文件顶部包含
import\uuuuuuu builtin\uuuu
来导入。如果您使用的是cython，您将无法模拟universal
\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu
补丁和使用，这是框架的一部分。用作返回用于替换已修补对象的对象：

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（）
的结果作为
patch
的
new=
参数可能有点奇怪。相反，请使用
patch
的
new\u callable=
参数，并记住
patch
不使用的每个额外参数都将传递给
new\u callable
函数，如下所述：

patch（）
接受任意关键字参数。这些将在构造时传递给
模拟
（或新的可调用）

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

Python 2
您需要修补
\uuu内置\uuu。打开
而不是
内置。打开
和
模拟
不是
单元测试的一部分，您需要
安装
并单独导入：

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")

Python 3
补丁和使用，这是框架的一部分。用作返回用于替换已修补对象的对象：

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（）
的结果作为
patch
的
new=
参数可能有点奇怪。相反，使用
patch
的
new\u 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")

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")

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

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

for line in file:
    #do action

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

@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"

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

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