Revert "gh-71339: Add additional assertion methods for unittest (GH-128707)"

This reverts commit 7cf5bc4.

Older python versions don't have these new assert methods

Author: cjw296

NEWS.d/2025-01-10-15-06-45.gh-issue-71339.EKnpzw.rst

@@ -1 +1 @@
-e6d5ff55d0816d7f5eb45e49c810e936b09d2be7
+5892853fb71acd6530e1e241a9a4bcf71a61fb21

lastsync.txt

@@ -600,16 +600,16 @@ def test_sync_magic_methods_return_magic_mocks(self):
 
     def test_magicmock_has_async_magic_methods(self):
         m_mock = MagicMock()
-        self.assertHasAttr(m_mock, "__aenter__")
-        self.assertHasAttr(m_mock, "__aexit__")
-        self.assertHasAttr(m_mock, "__anext__")
+        self.assertTrue(hasattr(m_mock, "__aenter__"))
+        self.assertTrue(hasattr(m_mock, "__aexit__"))
+        self.assertTrue(hasattr(m_mock, "__anext__"))
 
     def test_asyncmock_has_sync_magic_methods(self):
         a_mock = AsyncMock()
-        self.assertHasAttr(a_mock, "__enter__")
-        self.assertHasAttr(a_mock, "__exit__")
-        self.assertHasAttr(a_mock, "__next__")
-        self.assertHasAttr(a_mock, "__len__")
+        self.assertTrue(hasattr(a_mock, "__enter__"))
+        self.assertTrue(hasattr(a_mock, "__exit__"))
+        self.assertTrue(hasattr(a_mock, "__next__"))
+        self.assertTrue(hasattr(a_mock, "__len__"))
 
     def test_magic_methods_are_async_functions(self):
         m_mock = MagicMock()

mock/tests/testasync.py

@@ -22,35 +22,35 @@ def assertNotCallable(self, mock):
     def test_non_callable(self):
         for mock in NonCallableMagicMock(), NonCallableMock():
             self.assertRaises(TypeError, mock)
-            self.assertNotHasAttr(mock, '__call__')
+            self.assertFalse(hasattr(mock, '__call__'))
             self.assertIn(mock.__class__.__name__, repr(mock))
 
 
     def test_hierarchy(self):
-        self.assertIsSubclass(MagicMock, Mock)
-        self.assertIsSubclass(NonCallableMagicMock, NonCallableMock)
+        self.assertTrue(issubclass(MagicMock, Mock))
+        self.assertTrue(issubclass(NonCallableMagicMock, NonCallableMock))
 
 
     def test_attributes(self):
         one = NonCallableMock()
-        self.assertIsSubclass(type(one.one), Mock)
+        self.assertTrue(issubclass(type(one.one), Mock))
 
         two = NonCallableMagicMock()
-        self.assertIsSubclass(type(two.two), MagicMock)
+        self.assertTrue(issubclass(type(two.two), MagicMock))
 
 
     def test_subclasses(self):
         class MockSub(Mock):
             pass
 
         one = MockSub()
-        self.assertIsSubclass(type(one.one), MockSub)
+        self.assertTrue(issubclass(type(one.one), MockSub))
 
         class MagicSub(MagicMock):
             pass
 
         two = MagicSub()
-        self.assertIsSubclass(type(two.two), MagicSub)
+        self.assertTrue(issubclass(type(two.two), MagicSub))
 
 
     def test_patch_spec(self):

mock/tests/testcallable.py

@@ -965,7 +965,7 @@ def __getattr__(self, attribute):
 
         proxy = Foo()
         autospec = create_autospec(proxy)
-        self.assertNotHasAttr(autospec, '__name__')
+        self.assertFalse(hasattr(autospec, '__name__'))
 
 
     def test_autospec_signature_staticmethod(self):

mock/tests/testhelpers.py

@@ -10,13 +10,13 @@ class TestMockingMagicMethods(unittest.TestCase):
 
     def test_deleting_magic_methods(self):
         mock = Mock()
-        self.assertNotHasAttr(mock, '__getitem__')
+        self.assertFalse(hasattr(mock, '__getitem__'))
 
         mock.__getitem__ = Mock()
-        self.assertHasAttr(mock, '__getitem__')
+        self.assertTrue(hasattr(mock, '__getitem__'))
 
         del mock.__getitem__
-        self.assertNotHasAttr(mock, '__getitem__')
+        self.assertFalse(hasattr(mock, '__getitem__'))
 
 
     def test_magicmock_del(self):
@@ -252,12 +252,12 @@ def test_magicmock(self):
         self.assertEqual(list(mock), [1, 2, 3])
 
         getattr(mock, '__bool__').return_value = False
-        self.assertNotHasAttr(mock, '__nonzero__')
+        self.assertFalse(hasattr(mock, '__nonzero__'))
         self.assertFalse(bool(mock))
 
         for entry in _magics:
-            self.assertHasAttr(mock, entry)
-        self.assertNotHasAttr(mock, '__imaginary__')
+            self.assertTrue(hasattr(mock, entry))
+        self.assertFalse(hasattr(mock, '__imaginary__'))
 
 
     def test_magic_mock_equality(self):

mock/tests/testmagicmethods.py

@@ -2225,13 +2225,13 @@ def test_attach_mock_patch_autospec_signature(self):
     def test_attribute_deletion(self):
         for mock in (Mock(), MagicMock(), NonCallableMagicMock(),
                      NonCallableMock()):
-            self.assertHasAttr(mock, 'm')
+            self.assertTrue(hasattr(mock, 'm'))
 
             del mock.m
-            self.assertNotHasAttr(mock, 'm')
+            self.assertFalse(hasattr(mock, 'm'))
 
             del mock.f
-            self.assertNotHasAttr(mock, 'f')
+            self.assertFalse(hasattr(mock, 'f'))
             self.assertRaises(AttributeError, getattr, mock, 'f')
 
 
@@ -2240,18 +2240,18 @@ def test_mock_does_not_raise_on_repeated_attribute_deletion(self):
         for mock in (Mock(), MagicMock(), NonCallableMagicMock(),
                      NonCallableMock()):
             mock.foo = 3
-            self.assertHasAttr(mock, 'foo')
+            self.assertTrue(hasattr(mock, 'foo'))
             self.assertEqual(mock.foo, 3)
 
             del mock.foo
-            self.assertNotHasAttr(mock, 'foo')
+            self.assertFalse(hasattr(mock, 'foo'))
 
             mock.foo = 4
-            self.assertHasAttr(mock, 'foo')
+            self.assertTrue(hasattr(mock, 'foo'))
             self.assertEqual(mock.foo, 4)
 
             del mock.foo
-            self.assertNotHasAttr(mock, 'foo')
+            self.assertFalse(hasattr(mock, 'foo'))
 
 
     def test_mock_raises_when_deleting_nonexistent_attribute(self):
@@ -2269,7 +2269,7 @@ def test_reset_mock_does_not_raise_on_attr_deletion(self):
         mock.child = True
         del mock.child
         mock.reset_mock()
-        self.assertNotHasAttr(mock, 'child')
+        self.assertFalse(hasattr(mock, 'child'))
 
 
     def test_class_assignable(self):

mock/tests/testmock.py

@@ -364,7 +364,7 @@ def test():
             self.assertEqual(SomeClass.frooble, sentinel.Frooble)
 
         test()
-        self.assertNotHasAttr(SomeClass, 'frooble')
+        self.assertFalse(hasattr(SomeClass, 'frooble'))
 
 
     def test_patch_wont_create_by_default(self):
@@ -381,7 +381,7 @@ def test_patchobject_wont_create_by_default(self):
             @patch.object(SomeClass, 'ord', sentinel.Frooble)
             def test(): pass
             test()
-        self.assertNotHasAttr(SomeClass, 'ord')
+        self.assertFalse(hasattr(SomeClass, 'ord'))
 
 
     def test_patch_builtins_without_create(self):
@@ -1475,7 +1475,7 @@ def test_patch_multiple_create(self):
         finally:
             patcher.stop()
 
-        self.assertNotHasAttr(Foo, 'blam')
+        self.assertFalse(hasattr(Foo, 'blam'))
 
 
     def test_patch_multiple_spec_set(self):