Скачать или смотреть Understanding the strange behaviour of unittest.mock.patch in Python Testing

A comprehensive guide explaining the unusual behavior of `unittest.mock.patch` in Python. Learn why your mocks might not behave as expected and how to fix it!
---
This video is based on the question https://stackoverflow.com/q/73780431/ asked by the user 'Trenton D. Adams' ( https://stackoverflow.com/u/1030641/ ) and on the answer https://stackoverflow.com/a/74687787/ provided by the user 'Serhii Kushchenko' ( https://stackoverflow.com/u/3139228/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: python unittest.mock.patch strange behaviour

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding the strange behaviour of unittest.mock.patch in Python Testing

When testing your Python code, especially with the unittest framework, you might have encountered some oddities with the mocking functionality provided by the unittest.mock module. One such peculiar behavior arises when using mock.patch() to mock classes that are imported from different modules. This can lead to confusion, especially for those who are new to Python's testing ecosystem. Let’s dive in and unravel this mystery!

The Issue

Consider the following simple setup:

You have a class SomeClass defined in the yhab.blah module that has a method returning a string:

[[See Video to Reveal this Text or Code Snippet]]

Now, you have a function some_func in the yhab.main namespace that creates an instance of SomeClass and calls its method:

[[See Video to Reveal this Text or Code Snippet]]

When you write a test using the patch decorator as follows:

[[See Video to Reveal this Text or Code Snippet]]

You might expect that some_func() would call the mocked version of SomeClass, but instead, it calls the real instance of the class. This behavior can be perplexing!

Why Does This Happen?

The confusion stems from where you apply the patch. When you import SomeClass into the yhab.main namespace, that specific instance of SomeClass is what some_func() uses. Thus, patching yhab.blah.SomeClass will not affect the already imported SomeClass in yhab.main as it refers to the original class.

Correct Way to Patch

To ensure your test actually uses the mock, you need to patch the namespace where the class is used -- which in this case is yhab.main. The correct test would look like this:

[[See Video to Reveal this Text or Code Snippet]]

Summary of Findings

Patching the Correct Namespace: Always ensure you are patching the class in the namespace it is being used. In this example, since SomeClass is instantiated in yhab.main, you need to patch it there.

Understanding Imports: Remember that when you import a class, it becomes part of the module namespace you are importing into. This means that changes (like mocks) in the original module won’t affect the already imported class.

Conclusion

The nuances of unittest.mock.patch can be tricky, especially when dealing with imports across different modules. By remembering to patch the class in its usage context, you can avoid the strange behavior you might initially encounter. If you're still facing difficulties, the Python documentation is a great reference, though it might benefit from enhancing clarity for newcomers.

By following these guidelines, you can make your unit tests more predictable and effective. Happy testing!