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()
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()
Respostas:
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')
__enter__
e também __exit__
zomba de objetos - a última abordagem está desatualizada ou ainda é útil?
file
se foi!
mock_open
faz parte da mock
estrutura e é muito simples de usar. patch
usado como contexto retorna o objeto usado para substituir o corrigido: você pode usá-lo para simplificar seu teste.
Use em builtins
vez 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")
mock
não faz parte unittest
e 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")
Se você usasse patch
como decorador, usando mock_open()
o resultado de s como new
patch
argumento, pode ser um pouco estranho.
Nesse caso, é melhor usar o new_callable
patch
argumento do e lembre-se de que todos os argumentos extras que patch
não usarem serão passados para new_callable
funcionar como descrito na patch
documentaçã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.
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.
return_value
de mock_open
para outro objeto de simulação e afirmar o segundo return_value
), mas funcionou adicionando mock_open
como new_callable
.
six
módulo para ter um mock
módulo consistente . Mas não sei se ele mapeia também builtins
em um módulo comum.
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')
.write
chamadas?
handle.write.assert_any_call()
. Você também pode usar handle.write.call_args_list
para receber cada chamada, se o pedido for importante.
m.return_value.write.assert_called_once_with('some stuff')
é melhor imo. Evita o registro de uma chamada.
Mock.call_args_list
é mais seguro do que chamar qualquer um dos Mock.assert_xxx
métodos. Se você digitar incorretamente qualquer um dos últimos, sendo atributos de Mock, eles sempre serão silenciosamente transmitidos.
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
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.
read()
que não funcione no seu for line in opened_file
caso; Eu editei o post para esclarecer
for line in f:
suporte ao @EvgeniiPuchkaryov pode ser obtido trocando o valor de retorno open()
como um objeto StringIO .
with open("any_string") as f: print f.read()
A resposta principal é útil, mas eu a expandi um pouco.
Se você deseja definir o valor do seu objeto de arquivo (o f
in 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 with
o chamará __enter__()
.
Para zombar corretamente, precisamos zombar open()
para retornar um objeto zombado. Esse objeto simulado deve então simular a __enter__()
chamada ( MagicMock
fará 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_data
método.
Passei um arquivo simulado inteiro como uma string open()
e fiquei do_something_with_data
assim:
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
__enter__
? Definitivamente, parece mais um hack do que uma maneira recomendada.
Eu posso estar um pouco atrasado para o jogo, mas isso funcionou para mim ao chamar open
outro 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 à open
funçã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.
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
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):
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"