Como eu zombar um aberto usado em um com a declaração (usando a estrutura Mock em Python)?
-
18-09-2019 - |
Pergunta
Como faço para testar o seguinte código com simulações (usando simulações, o decorador de patch e sentinelas fornecidos pelo quadro Mock de Michael Foord):
def testme(filepath):
with open(filepath, 'r') as f:
return f.read()
Solução
A maneira de fazer isto mudou em simulada 0.7.0 que finalmente suporta zombando os métodos de protocolo pitão (métodos mágicas), em particular usando o MagicMock:
http://www.voidspace.org.uk/python/mock/magicmock.html
Um exemplo de zombando aberto como um gerente de contexto (a partir da página de exemplos na documentação falsa):
>>> 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')
Outras dicas
Há muito barulho nessas respostas; quase todas estão corretas, mas ultrapassada e não arrumado. mock_open
faz parte de mock
quadro e é muito simples de usar. patch
utilizado como contexto devolve o objecto utilizado para substituir a um patched :. você pode usá-lo para fazer o seu teste mais simples
Python 3.x
Use 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")
Python 2.7
mock
não faz parte do 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")
caso Decorator
Se você usaria patch
como decorador usando o resultado do mock_open()
como argumento do new
patch
pode ser um pouco estranho.
Neste caso, é melhor usar o argumento do new_callable
patch
e lembrar que cada argumentos extras que patch
não uso será passado para a função new_callable
conforme descrito em documentação patch
.
patch () leva argumentos chave arbitrárias. Estes serão passados ??para o Mock (ou new_callable) em construção.
Por exemplo versão decorada para o Python 3.x é a seguinte:
@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 que, neste caso patch
irá adicionar o objeto fictício como argumento de vocês função de teste.
Com as últimas versões de simulação, você pode usar o realmente útil mock_open helper:
mock_open (simulada = Nenhum, read_data = Nenhum) A função auxiliar para criar uma zombar para substituir o uso de aberto. Ele trabalha para aberto chamado direta ou usado como um gerente de contexto.
O argumento simulada é o objeto de simulação para configure. Se Nenhum (a padrão), então um MagicMock será criado para você, com a API limitada a métodos ou atributos disponíveis nos identificadores de arquivo padrão.
read_data é uma string para o método de leitura do identificador de arquivo para Retorna. Esta é uma cadeia 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')
Para usar mock_open para um arquivo simples read()
(o original mock_open trecho já dadas na presente página é voltado mais para escrever):
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()
Nota de acordo com docs para mock_open, este é especificamente para read()
, por isso não vai funcionar com padrões comuns, como for line in f
, por exemplo.
Usa python 2.6.6 / 1.0.1 simulada
Eu poderia ser um pouco tarde para o jogo, mas isso funcionou para mim quando chamado open
em outro módulo sem ter que 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")
Por remendar a função open
dentro do módulo __builtin__
ao meu mock_open()
, eu pode zombar escrever em um arquivo sem criar um.
Nota: Se você estiver usando um módulo que usa Cython, ou o seu programa depende Cython de qualquer forma, você precisará importar o Cython __builtin__
módulo incluindo import __builtin__
na parte superior do seu arquivo. Você não será capaz de zombar do __builtin__
universal se você estiver usando Cython.
A resposta máxima é útil, mas eu expandiu-lo um pouco.
Se você quiser definir o valor do seu objeto de arquivo (o f
em 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
chamará __enter__()
nesse objeto.
Para zombar corretamente, devemos zombar open()
para retornar um objeto fictício. Esse objeto fictício deve então zombar a chamada __enter__()
sobre ele (MagicMock
vai fazer isso por nós) para retornar o objeto de dados simulados / arquivo que queremos (daí mm.__enter__.return_value
). Fazer isso com 2 zomba da maneira acima nos permite captar os argumentos passados ??para open()
e passá-las para o nosso método do_something_with_data
.
Eu passei um arquivo de simulação inteira como uma string para open()
e meu do_something_with_data
ficou assim:
def do_something_with_data(*args, **kwargs):
return args[0].split("\n")
Isso transforma a string em uma lista para que você pode fazer o seguinte, como você faria com um arquivo normal:
for line in file:
#do action