gh-98624 Add mutex to unittest.mock.NonCallableMock (#98688)

* Added lock to NonCallableMock in unittest.mock

* Add blurb

* Nitpick blurb

* Edit comment based on @Jason-Y-Z's review

* Add link to GH issue

Lib/unittest/mock.py

@@ -35,6 +35,7 @@ from asyncio import iscoroutinefunction
 from types import CodeType, ModuleType, MethodType
 from unittest.util import safe_repr
 from functools import wraps, partial
+from threading import RLock
 
 
 class InvalidSpecError(Exception):
@@ -402,6 +403,14 @@ class Base(object):
 class NonCallableMock(Base):
     """A non-callable version of `Mock`"""
 
+    # Store a mutex as a class attribute in order to protect concurrent access
+    # to mock attributes. Using a class attribute allows all NonCallableMock
+    # instances to share the mutex for simplicity.
+    #
+    # See https://github.com/python/cpython/issues/98624 for why this is
+    # necessary.
+    _lock = RLock()
+
     def __new__(cls, /, *args, **kw):
         # every instance has its own class
         # so we can create magic methods on the
@@ -644,35 +653,36 @@ class NonCallableMock(Base):
                     f"{name!r} is not a valid assertion. Use a spec "
                     f"for the mock if {name!r} is meant to be an attribute.")
 
-        result = self._mock_children.get(name)
+        with NonCallableMock._lock:
-        if result is _deleted:
+            result = self._mock_children.get(name)
-            raise AttributeError(name)
+            if result is _deleted:
-        elif result is None:
+                raise AttributeError(name)
-            wraps = None
+            elif result is None:
-            if self._mock_wraps is not None:
+                wraps = None
-                # XXXX should we get the attribute without triggering code
+                if self._mock_wraps is not None:
-                # execution?
+                    # XXXX should we get the attribute without triggering code
-                wraps = getattr(self._mock_wraps, name)
+                    # execution?
+                    wraps = getattr(self._mock_wraps, name)
 
-            result = self._get_child_mock(
+                result = self._get_child_mock(
-                parent=self, name=name, wraps=wraps, _new_name=name,
+                    parent=self, name=name, wraps=wraps, _new_name=name,
-                _new_parent=self
+                    _new_parent=self
-            )
-            self._mock_children[name]  = result
-
-        elif isinstance(result, _SpecState):
-            try:
-                result = create_autospec(
-                    result.spec, result.spec_set, result.instance,
-                    result.parent, result.name
                 )
-            except InvalidSpecError:
+                self._mock_children[name]  = result
-                target_name = self.__dict__['_mock_name'] or self
+
-                raise InvalidSpecError(
+            elif isinstance(result, _SpecState):
-                    f'Cannot autospec attr {name!r} from target '
+                try:
-                    f'{target_name!r} as it has already been mocked out. '
+                    result = create_autospec(
-                    f'[target={self!r}, attr={result.spec!r}]')
+                        result.spec, result.spec_set, result.instance,
-            self._mock_children[name]  = result
+                        result.parent, result.name
+                    )
+                except InvalidSpecError:
+                    target_name = self.__dict__['_mock_name'] or self
+                    raise InvalidSpecError(
+                        f'Cannot autospec attr {name!r} from target '
+                        f'{target_name!r} as it has already been mocked out. '
+                        f'[target={self!r}, attr={result.spec!r}]')
+                self._mock_children[name]  = result
 
         return result
 

Misc/NEWS.d/next/Library/2022-10-25-20-17-34.gh-issue-98624.YQUPFy.rst

@@ -0,0 +1,2 @@
+Add a mutex to unittest.mock.NonCallableMock to protect concurrent access
+to mock attributes.