Simulação com unittest.mock
Isole as unidades sob teste simulando suas dependências.
Simulação com unittest.mock é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python Academy inclui 4 aulas no total.
Por que usar Mock?
Os mocks substituem dependências reais (bancos de dados, APIs, sistema de arquivos) por falsificações controláveis, para que os testes sejam rápidos, determinísticos e isolados.
from unittest.mock import Mock
api = Mock()
api.get_user.return_value = {"id": 1, "name": "Alice"}
result = api.get_user(1)
print(result) # {'id': 1, 'name': 'Alice'}Mock e MagicMock
Mock é a classe base. MagicMock configura automaticamente métodos mágicos/dunder para que possa ser usado como iterador, gerenciador de contexto etc.
from unittest.mock import MagicMock
m = MagicMock()
m.__len__.return_value = 5
print(len(m)) # 5
m.__iter__.return_value = iter([1, 2, 3])
for x in m:
print(x)patch como decorador
Use @patch para substituir um objeto em um módulo por um mock durante o teste.
from unittest.mock import patch
def get_data():
import requests
return requests.get("https://api.example.com").json()
@patch("requests.get")
def test_get_data(mock_get):
mock_get.return_value.json.return_value = {"key": "value"}
result = get_data()
assert result == {"key": "value"}patch como gerenciador de contexto
Use patch() como gerenciador de contexto para um mocking mais localizado.
from unittest.mock import patch
def test_open():
with patch("builtins.open", create=True) as mock_open:
mock_open.return_value.__enter__.return_value.read.return_value = "data"
with open("file.txt") as f:
assert f.read() == "data"patch.object
patch.object(target, attribute) aplica um patch a um atributo específico de um objeto ou classe existente.
from unittest.mock import patch
import mymodule
def test_method():
with patch.object(mymodule.MyClass, "fetch", return_value=42):
obj = mymodule.MyClass()
assert obj.fetch() == 42Verificando chamadas
Os mocks registram todas as chamadas. Use assert_called_once_with, assert_called_with e call_count para verificar o comportamento.
from unittest.mock import Mock
send = Mock()
send("hello", to="alice")
send.assert_called_once_with("hello", to="alice")
print(send.call_count) # 1return_value e side_effect
Defina return_value para controlar o que o mock retorna. Use side_effect para gerar exceções ou retornar valores diferentes em chamadas sucessivas.
from unittest.mock import Mock
m = Mock(side_effect=[1, 2, ValueError("done")])
print(m()) # 1
print(m()) # 2
m() # raises ValueErrorspec: mocks com segurança de tipos
Passe spec=MyClass para restringir o mock apenas aos atributos existentes na classe real.
from unittest.mock import Mock
class Calc:
def add(self, a, b): return a + b
m = Mock(spec=Calc)
m.add(1, 2) # OK
# m.subtract(1, 2) # AttributeError: Mock does not have 'subtract'patch.dict
Use patch.dict para modificar temporariamente um dicionário (por exemplo, variáveis de ambiente ou configurações no nível do módulo).
from unittest.mock import patch
import os
def test_env():
with patch.dict(os.environ, {"DEBUG": "true"}):
assert os.environ["DEBUG"] == "true"
assert "DEBUG" not in os.environMock no pytest com pytest-mock
pytest-mock fornece uma fixture mocker que encapsula unittest.mock e desfaz automaticamente as alterações após cada teste.
# pip install pytest-mock
def test_service(mocker):
mocker.patch("mymodule.requests.get", return_value=mocker.Mock(
json=lambda: {"status": "ok"}
))
from mymodule import call_api
assert call_api()["status"] == "ok"AsyncMock para corrotinas
Use AsyncMock para simular funções assíncronas que são aguardadas.
from unittest.mock import AsyncMock, patch
import asyncio
async def fetch():
import httpx
async with httpx.AsyncClient() as c:
r = await c.get("https://example.com")
return r.json()
def test_fetch():
with patch("httpx.AsyncClient.get", new_callable=AsyncMock) as m:
m.return_value.json.return_value = {"ok": True}
result = asyncio.run(fetch())
assert result["ok"] is TrueVerificação rápida
Qual atributo você define em um Mock para controlar o valor retornado quando ele é chamado?
Recapitulação
unittest.mock fornece Mock, MagicMock, patch e AsyncMock. Use return_value e side_effect para controlar o comportamento e métodos de asserção para verificar como os mocks foram chamados.
Perguntas Frequentes
A aula “Simulação com unittest.mock” é grátis?
Sim — o texto completo de “Simulação com unittest.mock” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python Academy, atualize para CoddyKit PRO. O curso de Python Academy inclui 4 aulas no total.
O que vou aprender em “Simulação com unittest.mock”?
Isole as unidades sob teste simulando suas dependências. Você pratica Python Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Python Academy?
Nenhuma experiência prévia é necessária. Python Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.
Quanto tempo leva a aula “Simulação com unittest.mock”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Python Academy?
Sim. Cada aula de Python Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Escrevendo seus primeiros testes com pytest
- Fixtures e configuração/desmontagem
- Parametrização e cobertura de testes
- Simulação com unittest.mock