Como zombar de um open usado em uma declaração with (usando a estrutura Mock no Python)?

188

Como testar o seguinte código com zombarias (usando zombarias, o decorador de patches e sentinelas fornecidos pela estrutura Mock de Michael Foord ):

def testme(filepath):
    with open(filepath, 'r') as f:
        return f.read()
Daryl Spitzer
fonte
@Daryl Spitzer: você poderia deixar de fora a meta-pergunta ("Eu sei a resposta ...") É confuso.
S.Lott
No passado, quando eu o deixei de fora, as pessoas se queixaram de que estou respondendo à minha própria pergunta. Vou tentar passar isso para a minha resposta.
Daryl Spitzer
1
@Daryl: A melhor maneira de evitar reclamações sobre responder à própria pergunta, que geralmente resultam de preocupações com "carma de putaria", é marcar a pergunta e / ou responder como um "wiki da comunidade".
John Millikin
3
Se responder a sua própria pergunta for considerado Karma Whoring, o FAQ deve ser esclarecido nesse ponto, eu acho.
EBGreen

Respostas:

132

A maneira de fazer isso foi alterada no mock 0.7.0, que finalmente suporta a zombaria dos métodos do protocolo python (métodos mágicos), principalmente usando o MagicMock:

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

Um exemplo de simulação aberta como um gerenciador de contexto (na página de exemplos na documentação da simulação):

>>> 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')
fuzzyman
fonte
Uau! Isso parece muito mais simples do que o exemplo do gerenciador de contexto atualmente em voidspace.org.uk/python/mock/magicmock.html, que define explicitamente __enter__e também __exit__zomba de objetos - a última abordagem está desatualizada ou ainda é útil?
Brandon Rhodes
6
A "última abordagem" está mostrando como fazê-lo sem usar um MagicMock (isto é, é apenas um exemplo de como o Mock suporta métodos mágicos). Se você usar um MagicMock (como acima), digite e saia pré-configurado para você.
Fuzzyman 06/06/11
5
você pode apontar para o seu blog, onde explica com mais detalhes por que / como isso funciona #
Rodrigue
9
No Python 3, 'arquivo' não está definido (usado na especificação MagicMock), então estou usando o io.IOBase.
Jonathan Hartley
1
Nota: no Python3 o builtin filese foi!
Exhuma
239

mock_openfaz parte da mockestrutura e é muito simples de usar. patchusado como contexto retorna o objeto usado para substituir o corrigido: você pode usá-lo para simplificar seu teste.

Python 3.x

Use em builtinsvez 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

mocknão faz parte unitteste você deve corrigir__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")

Caso decorador

Se você usasse patchcomo decorador, usando mock_open()o resultado de s como new patchargumento, pode ser um pouco estranho.

Nesse caso, é melhor usar o new_callable patchargumento do e lembre-se de que todos os argumentos extras que patchnão usarem serão passados ​​para new_callablefuncionar como descrito na patchdocumentação .

patch () usa argumentos arbitrários de palavras-chave. Estes serão passados ​​para o Mock (ou new_callable) na construção.

Por exemplo, a versão decorada para o 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")

Lembre-se de que, neste caso patch, o objeto simulado será adicionado como argumento de sua função de teste.

Michele d'Amico
fonte
Desculpe por perguntar, a with patch("builtins.open", mock_open(read_data="data")) as mock_file:conversão pode ser convertida em sintaxe de decorador? Eu tentei, mas não tenho certeza do que preciso passar @patch("builtins.open", ...) como segundo argumento.
Imrek
1
@DrunkenMaster Updateted .. obrigado por apontou. Usar o decorador não é trivial neste caso.
Michele d'Amico 4/17
Grazie! Meu problema era um pouco mais complexo (tive que canalizar o return_valuede mock_openpara outro objeto de simulação e afirmar o segundo return_value), mas funcionou adicionando mock_opencomo new_callable.
Imrek
1
O @ArthurZopellaro dá uma olhada no sixmódulo para ter um mockmódulo consistente . Mas não sei se ele mapeia também builtinsem um módulo comum.
Michele d'Amico
1
Como você encontra o nome correto para corrigir? Ou seja, como você encontra o primeiro argumento para @patch ('builtins.open' neste caso) para uma função arbitrária?
Zenperttu 7/11
73

Com as versões mais recentes do mock, você pode usar o realmente útil mock_open helper:

mock_open (mock = None, read_data = None)

Uma função auxiliar para criar uma simulação para substituir o uso de open. Ele funciona para o open chamado diretamente ou usado como um gerenciador de contexto.

O argumento de simulação é o objeto de simulação a ser configurado. Se Nenhum (o padrão), um MagicMock será criado para você, com a API limitada a métodos ou atributos disponíveis em identificadores de arquivo padrão.

read_data é uma string para o método de leitura do identificador de arquivo retornar. Esta é uma string vazia por padrão.

>>> 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')
David
fonte
como você verifica se há várias .writechamadas?
N611x007 17/08/2015
1
@naxa Uma maneira é passar cada parâmetro esperado para handle.write.assert_any_call(). Você também pode usar handle.write.call_args_listpara receber cada chamada, se o pedido for importante.
22615 Robertmore
m.return_value.write.assert_called_once_with('some stuff')é melhor imo. Evita o registro de uma chamada.
Anônimo
2
Declarar manualmente Mock.call_args_listé mais seguro do que chamar qualquer um dos Mock.assert_xxxmétodos. Se você digitar incorretamente qualquer um dos últimos, sendo atributos de Mock, eles sempre serão silenciosamente transmitidos.
Jonathan Hartley
12

Para usar mock_open para um arquivo simples read()(o snippet mock_open original já fornecido nesta página é mais voltado para gravação):

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

Observe que, de acordo com os documentos de mock_open, isso é especificamente para read(), portanto, não funcionará com padrões comuns como for line in f, por exemplo.

Usa python 2.6.6 / mock 1.0.1

jlb83
fonte
Parece bom, mas não consigo fazê-lo funcionar com o for line in opened_file:tipo de código. Tentei experimentar o iterável StringIO que implementa __iter__e usa isso em vez de my_text, mas sem sorte.
Evgen
@EvgeniiPuchkaryov Isso funciona especificamente para read()que não funcione no seu for line in opened_filecaso; Eu editei o post para esclarecer
jlb83
1
O for line in f:suporte ao @EvgeniiPuchkaryov pode ser obtido trocando o valor de retorno open()como um objeto StringIO .
Iskar Jarak
1
Para esclarecer, o sistema em teste (SUT) neste exemplo é: with open("any_string") as f: print f.read()
Brad M
4

A resposta principal é útil, mas eu a expandi um pouco.

Se você deseja definir o valor do seu objeto de arquivo (o fin as f) com base nos argumentos passados ​​para, open()aqui está uma maneira de fazê-lo:

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

Basicamente, open()retornará um objeto e witho chamará __enter__().

Para zombar corretamente, precisamos zombar open()para retornar um objeto zombado. Esse objeto simulado deve então simular a __enter__()chamada ( MagicMockfará isso por nós) para retornar o objeto de dados / arquivo simulado que queremos (daí mm.__enter__.return_value). Fazer isso com 2 zombarias da maneira acima nos permite capturar os argumentos passados open()e passá-los ao nosso do_something_with_datamétodo.

Passei um arquivo simulado inteiro como uma string open()e fiquei do_something_with_dataassim:

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

Isso transforma a string em uma lista para que você possa fazer o seguinte como faria com um arquivo normal:

for line in file:
    #do action
theannouncer
fonte
Se o código que está sendo testado manipular o arquivo de uma maneira diferente, por exemplo, chamando sua função "readline", você poderá retornar qualquer objeto falso que desejar na função "do_something_with_data" com os atributos desejados.
user3289695
Existe uma maneira de evitar tocar __enter__? Definitivamente, parece mais um hack do que uma maneira recomendada.
imrek
enter é como os gerentes de contexto, como open (), são escritos. Mocks, muitas vezes, ser uma hacky bit em que você precisa para acesso coisas "privado" para falsa, mas a entrar aqui is not ingerintly hacky imo
theannouncer
3

Eu posso estar um pouco atrasado para o jogo, mas isso funcionou para mim ao chamar openoutro módulo sem precisar criar um novo arquivo.

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

Ao aplicar um patch à openfunção dentro do __builtin__módulo mock_open(), posso simular a gravação em um arquivo sem criar um.

Nota: Se você estiver usando um módulo que usa o cython, ou se o seu programa depende do cython de qualquer forma, será necessário importar o __builtin__módulo do cython, incluindo import __builtin__na parte superior do arquivo. Você não poderá zombar do universal __builtin__se estiver usando o cython.

Leo C Han
fonte
Uma variação disso abordada funcionou para mim, pois a maioria do código em teste estava em outros módulos, como mostrado aqui. Eu precisava me certificar de adicionar import __builtin__ao meu módulo de teste. Este artigo ajudou a esclarecer por que essa técnica funciona tão bem quanto: ichimonji10.name/blog/6
killthrush
0

Para corrigir a função open () interna com o mais unido:

Isso funcionou para um patch para ler uma configuração do json.

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

O objeto simulado é o objeto io.TextIOWrapper retornado pela função 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):
pabloberm
fonte
0

Se você não precisar de mais nenhum arquivo, poderá decorar o método de teste:

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