@patch - OLife'S · OLife'S

@patch

Testing Patterns

Meaning

Replaces a class or object with a mock during testing, allowing you to control its behavior and isolate the unit under test. The autospec argument ensures the mock mimics the original's signature, preventing accidental misuse.

Primary Function

Testing / Mocking

Communicative Purpose

Substitute a dependency with a controllable mock so tests run quickly and deterministically without side effects.

Pattern

@patch(; , autospec=;)

Core Structure

@patch(; , autospec=;)

Função primária

Testing / Mocking

Propósito comunicativo

Substitute a dependency with a controllable mock so tests run quickly and deterministically without side effects.

Situações de gatilho

Testing a function that instantiates or calls SomeClass; needing to simulate return values or side effects; avoiding external resources like databases or network calls.

Contextos

Python unit‑test suites using unittest or pytest, especially when applying the unittest.mock.patch decorator.

Padrão

@patch(; , autospec=;)

Estrutura central

@patch(; , autospec=;)

Slots de substituição

target: str (e.g. 'module.SomeClass'), autospec_value: bool (True|False)

Colocados típicos

unittest.TestCase
pytest
MagicMock
side_effect
return_value

Substituições comuns

Using patch as a context manager: with patch('module.SomeClass') as mock:

Erros comuns

Forgetting autospec leading to loose mocks; patching the wrong import path; leaving a patch active across multiple tests causing interference.

Similar / contraste

@mock.patch (alias); unittest.mock.create_autospec; pytest's monkeypatch fixture.

Interferências

Coming from Java: may confuse with @InjectMocks/@Mock; from JavaScript: mixing with sinon.stub.

Família do chunk

unittest.mock
MagicMock
mock.call
mock.assert_called_with

Nuance

autospec=True can fail if the class uses dynamic attributes via __getattr__; patch only works on objects importable by name; patching built‑ins requires a different target syntax.

Efeito pragmático

Makes unit tests deterministic and fast by eliminating external dependencies.

Dica de memória

Think 'patch the class, lock its spec'.

Nota

autospec enforces the mock’s signature and attribute spec, which prevents accidental attribute access; however, it can fail if the target uses __getattr__ or __getattribute__ dynamically, in which case autospec=False or a manually crafted spec may be needed.

Upgrade path

Using patch as a context manager for finer‑grained control: with patch('module.SomeClass') as mock:

Frequência: HighFormulaicidade: Semi-fixedTipo de construção: decoratorPrioridade de aquisição: Active recallPrioridade de output: BothTag de espaçamento: Medium-termIdioma?: Sim

Examples

import unittest from unittest.mock import patch class SomeClass: def get_value(self): return 42 def get_something(): return SomeClass().get_value() class TestSomething(unittest.TestCase): @patch('__main__.SomeClass', autospec=True) def test_something(self, MockSomeClass): instance = MockSomeClass.return_value instance.get_value.return_value = 99 self.assertEqual(get_something(), 99) if __name__ == '__main__': unittest.main()

import unittest from unittest.mock import patch class SomeClass: def process(self): return 'real' def use_something(): return SomeClass().process() class TestUseSomething(unittest.TestCase): def test_use_something(self): with patch('__main__.SomeClass', autospec=True) as MockSomeClass: instance = MockSomeClass.return_value instance.process.return_value = 'mocked' self.assertEqual(use_something(), 'mocked') if __name__ == '__main__': unittest.main()

import unittest from unittest.mock import patch class SomeClass: def fetch(self): return 'data' def get_data(): return SomeClass().fetch() class TestGetData(unittest.TestCase): def test_get_data(self): with patch.object(SomeClass, 'fetch', return_value='mocked') as mock_fetch: self.assertEqual(get_data(), 'mocked') mock_fetch.assert_called_once() if __name__ == '__main__': unittest.main()