Sets the side_effect attribute of a mock object to an Exception instance so that calling the mock raises that exception.

Signals the tester’s intention to simulate an error condition for the mock, enabling verification of defensive code paths.

When writing unit tests that need to exercise exception‑handling code such as try/except blocks, retry logic, or fallback mechanisms, or when verifying that a function propagates errors correctly.

Unit testing with Python’s unittest.mock library, test‑driven development, integration tests that rely on mocks, any scenario requiring simulated failures.

<mock_object>.side_effect = Exception('<exception_message>')

Attribute assignment: <mock_object>.side_effect assigned to an instance of Exception (or subclass) containing a message.

mock_object: any mock object (e.g., unittest.mock.MagicMock); exception_message: string or Exception instance to be raised.

• assertRaises
• patch
• try/except
• mock.call_args_list
• side_effect as iterable
• side_effect as callable

• Using side_effect = lambda *args: raise ValueError('msg') – invalid syntax (lambda cannot contain raise)
• using side_effect = [ValueError('msg')] to raise on successive calls
• using side_effect = ValueError (exception class) which raises an instance of that class
• using side_effect = Exception() without a message.

Using side_effect = Exception (the class) instead of an instance – causes TypeError when the mock is called because the class is not callable. Writing side_effect = lambda: raise ValueError('msg') – invalid syntax because lambda statements cannot contain a raise statement. Assigning a string to side_effect (e.g., side_effect = 'error') – leads to TypeError when the mock is invoked because a string is not callable or an exception. Failing to import the exception class (e.g., using ValueError without importing) – results in NameError. Setting side_effect after the mock has already been called in the test, so the earlier call does not raise the exception.

side_effect = lambda *args: return_value – returns a value instead of raising an exception. side_effect = iter([val1, val2, exc]) – returns values then raises an exception on subsequent calls. side_effect = PropertyMock(...) – used to mock property access rather than call behavior.

Coming from Java: may expect checked exceptions and forget to raise inside a lambda – Python’s mock expects an exception instance or class to be raised automatically. Coming from JavaScript: may try to assign a string to side_effect expecting it to be thrown – in Python, side_effect must be callable, an iterable, or an exception instance. Coming from Ruby: may confuse side_effect with raising via raise inside a block – Python’s mock mechanism differs.

• mocking patterns
• test doubles
• test doubles configuration

Do not use side_effect for simple value returns; use the return_value attribute for clarity. Performance impact is negligible; setting side_effect is O(1) and does not noticeably affect test runtime. Be aware that if side_effect is an iterable, it is consumed on each call; reusing the same mock across tests may cause unexpected StopIteration.

Enables reliable testing of error‑handling pathways, increasing confidence that production code correctly handles exceptions and reducing the risk of uncaught errors in production.

Think of setting side_effect like rigging a toy jack‑in‑the‑box to pop up when the crank is turned, so you can verify the lid springs open as expected.

When using side_effect with an exception class (not an instance), mock will instantiate the class with no arguments; to pass arguments, instantiate the exception yourself.

Using side_effect with iterables or callable sequences to simulate sequences of return values or exceptions, or employing PropertyMock for property‑specific behavior.