¿Cómo pruebo el siguiente código con simulacros (utilizando simulacros, el decorador de parches y los centinelas proporcionados por el marco simulado de Michael Foord ):

def testme(filepath):
    with open(filepath, 'r') as f:
        return f.read()

La forma de hacer esto ha cambiado en simulacro 0.7.0 que finalmente admite burlarse de los métodos de protocolo de Python (métodos mágicos), particularmente usando MagicMock:

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

Un ejemplo de simulacro abierto como administrador de contexto (de la página de ejemplos en la documentación simulada):

>>> 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_openes parte del mockframework y es muy simple de usar. patchusado como contexto devuelve el objeto usado para reemplazar el parcheado: puede usarlo para simplificar su prueba.

Python 3.x

Usar en builtinslugar de __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

mockno es parte unittesty debes parchear__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")

Estuche decorador

Si patchusarías como decorador usando mock_open()el resultado como new patchargumento, puede ser un poco extraño.

En este caso, es mejor usar el new_callable patchargumento de 's y recordar que cada argumento adicional que patchno use se pasará a new_callablefuncionar como se describe en la patchdocumentación .

patch () toma argumentos de palabras clave arbitrarios. Estos se pasarán al simulacro (o new_callable) en la construcción.

Por ejemplo, la versión decorada para Python 3.x es:

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

Recuerde que en este caso patchagregará el objeto simulado como argumento de su función de prueba.

Con las últimas versiones de simulacro, puede usar el ayudante realmente útil mock_open :

mock_open (simulacro = Ninguno, read_data = Ninguno)

Una función auxiliar para crear un simulacro para reemplazar el uso de open. Funciona para llamadas abiertas directamente o se usa como administrador de contexto.

El argumento simulado es el objeto simulado a configurar. Si ninguno (el valor predeterminado), se creará un MagicMock para usted, con la API limitada a los métodos o atributos disponibles en los identificadores de archivos estándar.

read_data es una cadena para que el método de lectura del identificador de archivo regrese. Esta es una cadena vacía por defecto.

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

Para usar mock_open para un archivo simple read()(el fragmento original de mock_open ya proporcionado en esta página está más orientado a la escritura):

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

Tenga en cuenta según los documentos para mock_open, esto es específicamente para read(), por lo que no funcionará con patrones comunes como for line in f, por ejemplo.

Utiliza python 2.6.6 / simulacro 1.0.1

La respuesta principal es útil, pero la amplié un poco.

Si desea establecer el valor de su objeto de archivo (la entrada ) fen as ffunción de los argumentos pasados, open()aquí hay una forma de hacerlo:

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

Básicamente, open()devolverá un objeto y withllamará __enter__()a ese objeto.

Para burlarse correctamente, debemos burlarnos open()para devolver un objeto simulado. Ese objeto simulado debe simular la __enter__()llamada ( MagicMockhará esto por nosotros) para devolver el objeto simulado de datos / archivo que queremos (por lo tanto mm.__enter__.return_value). Hacer esto con 2 simulacros de la manera anterior nos permite capturar los argumentos pasados open()y pasarlos a nuestro do_something_with_datamétodo.

Pasé un archivo simulado completo como una cadena open()y mi do_something_with_dataaspecto era el siguiente:

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

Esto transforma la cadena en una lista para que pueda hacer lo siguiente como lo haría con un archivo normal:

for line in file:
    #do action

Puede que llegue un poco tarde al juego, pero esto funcionó cuando llamé opena otro módulo sin tener que crear un nuevo archivo.

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

Al parchear la openfunción dentro del __builtin__módulo a mi mock_open(), puedo simular escribir en un archivo sin crear uno.

Nota: Si está utilizando un módulo que usa cython, o si su programa depende de cython de alguna manera, deberá importar el __builtin__módulo de cython al incluirlo import __builtin__en la parte superior de su archivo. No podrá burlarse de lo universal __builtin__si está utilizando cython.

Para parchear la función incorporada open () con unittest:

Esto funcionó para un parche para leer una configuración json.

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

El objeto burlado es el objeto io.TextIOWrapper devuelto por la función open ()

@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):

Si no necesita más archivos, puede decorar el método de prueba:

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