Ответ 1

Способ сделать это изменился в mock 0.7.0, который, наконец, поддерживает насмешку методов протокола python (магические методы), особенно с помощью MagicMock:

http://www.voidspace.org.uk/python/mock/magicmock.html

Пример mocking open как менеджер контекста (со страницы примеров в макетной документации):

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

Ответ 2

В этих ответах много шума; почти все правильные, но устаревшие и не опрятные. mock_open является частью mock и является очень проста в использовании. patch, используемый в качестве контекста, возвращает объект, используемый для замены исправленного: вы можете использовать его, чтобы сделать ваш тест более простым.

Python 3.x

Используйте builtins вместо __builtin__.

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

Python 2.7

mock не входит в unittest, и вы должны исправить __builtin__

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

Корпус декоратора

Если вы используете patch в качестве декоратора, используя результат mock_open(), поскольку аргумент new patch может быть немного странным.

В этом случае лучше использовать аргумент new_callable patch и помнить, что все дополнительные аргументы, которые patch не использует, будут переданы функции new_callable, как описано в patch документации.

patch() принимает произвольные аргументы ключевых слов. Они будут переданы в Mock (или new_callable) при построении.

Например, украшенная версия для Python 3.x:

@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 добавит макет-объект в качестве аргумента вашей тестовой функции.

Ответ 3

С последними версиями mock вы можете использовать действительно полезный помощник mock_open:

mock_open (mock = None, read_data = None)

Вспомогательная функция для создания макет, чтобы заменить использование open. Он работает для открытого вызова напрямую или используется как менеджер контекста.

Аргумент mock является макетным объектом для настройки. Если None ( по умолчанию), тогда для вас будет создан 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')

Ответ 4

Обновлен ответ Daryl для исправления изменений в классе Mock.

@patch('__builtin__.open')
def test_testme(self, open_mock):
    #
    # setup
    #
    context_manager_mock = Mock()
    open_mock.return_value = context_manager_mock
    file_mock = Mock()
    file_mock.read.return_value = sentinel.file_contents
    enter_mock = Mock()
    enter_mock.return_value = file_mock
    exit_mock  = Mock()
    setattr( context_manager_mock, '__enter__', enter_mock )
    setattr( context_manager_mock, '__exit__', exit_mock )

    #
    # exercise
    #
    result = cbot.testme(sentinel.filepath)

    #
    # verify
    #
    self.assertEquals(result, sentinel.file_contents)
    self.assertEquals(open_mock.call_args,
                      ((sentinel.filepath, 'r'), {}))
    self.assertEquals(context_manager_mock.method_calls,
                      [('__enter__', (), {}),
                       ('__exit__', (None, None, None), {})])
    self.assertEquals(file_mock.method_calls, [('read', (), {})])

Ответ 5

Чтобы использовать mock_open для простого файла read() (оригинальный фрагмент 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

Ответ 6

Возможно, я немного опоздал на игру, но это работало для меня при вызове 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")

Заменив функцию open внутри модуля __builtin__ на мой mock_open(), я могу издеваться над записью в файл без его создания.

Примечание. Если вы используете модуль, который использует cython, или ваша программа в любом случае зависит от cython, вам нужно будет импортировать модуль cython __builtin__, включив import __builtin__ в начало файла. Вы не сможете издеваться над универсальным __builtin__, если используете cython.

Ответ 7

Самый верный ответ полезен, но я немного расширил его.

Если вы хотите установить значение своего файлового объекта (f in as f) на основе аргументов, переданных в 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

В принципе, open() вернет объект, а with вызовет __enter__() на этом объекте.

Чтобы правильно насмехаться, мы должны издеваться над open(), чтобы вернуть макет объекта. Затем этот издевательский объект должен высмеять вызов __enter__() на нем (MagicMock сделает это для нас), чтобы вернуть нужный нам файл/файл (следовательно mm.__enter__.return_value). Выполнение этого с помощью 2 mocks, как выше, позволяет нам захватывать аргументы, переданные в open(), и передавать их нашему методу do_something_with_data.

Я передал весь mock файл в виде строки в open(), а мой do_something_with_data выглядел следующим образом:

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

Это преобразует строку в список, поэтому вы можете сделать следующее, как в обычном файле:

for line in file:
    #do action