Comment tester le code suivant avec des simulacres (en utilisant des simulations, le décorateur de patchs et les sentinelles fournis par le framework Mock de Michael Foord ):

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

La façon de faire a changé dans mock 0.7.0 qui prend enfin en charge la moquerie des méthodes de protocole python (méthodes magiques), en particulier en utilisant MagicMock:

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

Un exemple de mocking ouvert en tant que gestionnaire de contexte (à partir de la page d'exemples dans la documentation fictive):

>>> 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_openfait partie du mockframework et est très simple à utiliser. patchutilisé comme contexte renvoie l'objet utilisé pour remplacer celui qui a été corrigé: vous pouvez l'utiliser pour simplifier votre test.

Python 3.x

Utilisez à la builtinsplace 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

mockne fait pas partie de unittestet vous devriez patcher__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")

Coffret décorateur

Si vous patchutilisiez comme décorateur en utilisant mock_open()le résultat de s comme new patchargument de s, cela peut être un peu bizarre.

Dans ce cas, il est préférable d 'utiliser l new_callable patch' argument s et de se rappeler que tous les arguments supplémentaires qui patchne sont pas utilisés seront passés à la new_callablefonction comme décrit dans la patchdocumentation .

patch () prend des arguments de mot-clé arbitraires. Ceux-ci seront transmis au Mock (ou new_callable) lors de la construction.

Par exemple, la version décorée pour Python 3.x est:

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

N'oubliez pas que dans ce cas patch, vous ajouterez l'objet fictif comme argument de votre fonction de test.

Avec les dernières versions de mock, vous pouvez utiliser l' assistant mock_open vraiment utile :

mock_open (mock = None, read_data = None)

Une fonction d'assistance pour créer une maquette pour remplacer l'utilisation de open. Il fonctionne pour ouvrir appelé directement ou utilisé comme gestionnaire de contexte.

L'argument fictif est l'objet fictif à configurer. Si Aucun (valeur par défaut), un MagicMock sera créé pour vous, avec l'API limitée aux méthodes ou attributs disponibles sur les descripteurs de fichiers standard.

read_data est une chaîne que la méthode de lecture du descripteur de fichier doit renvoyer. Il s'agit d'une chaîne vide par défaut.

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

Pour utiliser mock_open pour un fichier simple read()(l'extrait de code original mock_open déjà donné sur cette page est davantage destiné à l'écriture):

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

Notez que selon la documentation pour mock_open, ceci est spécifiquement pour read(), donc ne fonctionnera pas avec des modèles courants comme for line in f, par exemple.

Utilise python 2.6.6 / mock 1.0.1

La première réponse est utile, mais je l'ai un peu développée.

Si vous souhaitez définir la valeur de votre objet fichier (le fin as f) en fonction des arguments passés, open()voici une façon de le faire:

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

Fondamentalement, open()retournera un objet et withappellera __enter__()cet objet.

Pour se moquer correctement, il faut se moquer open()pour renvoyer un objet factice. Cet objet factice devrait alors se moquer de l' __enter__()appel (le MagicMockfera pour nous) pour renvoyer l'objet de données / fichier factice que nous voulons (par conséquent mm.__enter__.return_value). Faire cela avec 2 mocks comme ci-dessus nous permet de capturer les arguments passés à open()et de les transmettre à notre do_something_with_dataméthode.

J'ai passé un fichier simulé entier sous forme de chaîne à open()et mon do_something_with_dataressemblait à ceci:

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

Cela transforme la chaîne en une liste afin que vous puissiez faire ce qui suit comme vous le feriez avec un fichier normal:

for line in file:
    #do action

Je suis peut-être un peu en retard dans le jeu, mais cela a fonctionné pour moi lors de l'appel opend'un autre module sans avoir à créer un nouveau fichier.

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

En patchant la openfonction à l'intérieur du __builtin__module sur my mock_open(), je peux me moquer de l'écriture dans un fichier sans en créer un.

Remarque: Si vous utilisez un module qui utilise cython, ou que votre programme dépend de cython de quelque manière que ce soit, vous devrez importer le __builtin__module de cython en l'incluant import __builtin__en haut de votre fichier. Vous ne pourrez pas vous moquer de l'universel __builtin__si vous utilisez cython.

Pour patcher la fonction open () intégrée avec unittest:

Cela a fonctionné pour un correctif pour lire une configuration json.

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

L'objet simulé est l'objet io.TextIOWrapper renvoyé par la fonction 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 vous n'avez plus besoin de fichier, vous pouvez décorer la méthode de test:

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