PYTHON-5387 Better test assertions for membership

test/asynchronous/test_bulk.py

@@ -94,7 +94,7 @@ def assertEqualUpsert(self, expected, actual):
         self.assertEqual(expected["index"], actual["index"])
         if expected["_id"] == "...":
             # Unspecified value.
-            self.assertTrue("_id" in actual)
+            self.assertIn("_id", actual)
         else:
             self.assertEqual(expected["_id"], actual["_id"])
 
@@ -107,15 +107,15 @@ def assertEqualWriteError(self, expected, actual):
         self.assertEqual(expected["code"], actual["code"])
         if expected["errmsg"] == "...":
             # Unspecified value.
-            self.assertTrue("errmsg" in actual)
+            self.assertIn("errmsg", actual)
         else:
             self.assertEqual(expected["errmsg"], actual["errmsg"])
 
         expected_op = expected["op"].copy()
         actual_op = actual["op"].copy()
         if expected_op.get("_id") == "...":
             # Unspecified _id.
-            self.assertTrue("_id" in actual_op)
+            self.assertIn("_id", actual_op)
             actual_op.pop("_id")
             expected_op.pop("_id")
 
@@ -160,7 +160,7 @@ async def _test_update_many(self, update):
         result = await self.coll.bulk_write([UpdateMany({}, update)])
         self.assertEqualResponse(expected, result.bulk_api_result)
         self.assertEqual(2, result.matched_count)
-        self.assertTrue(result.modified_count in (2, None))
+        self.assertIn(result.modified_count, (2, None))
 
     async def test_update_many(self):
         await self._test_update_many({"$set": {"foo": "bar"}})
@@ -201,7 +201,7 @@ async def _test_update_one(self, update):
         result = await self.coll.bulk_write([UpdateOne({}, update)])
         self.assertEqualResponse(expected, result.bulk_api_result)
         self.assertEqual(1, result.matched_count)
-        self.assertTrue(result.modified_count in (1, None))
+        self.assertIn(result.modified_count, (1, None))
 
     async def test_update_one(self):
         await self._test_update_one({"$set": {"foo": "bar"}})
@@ -227,7 +227,7 @@ async def test_replace_one(self):
         result = await self.coll.bulk_write([ReplaceOne({}, {"foo": "bar"})])
         self.assertEqualResponse(expected, result.bulk_api_result)
         self.assertEqual(1, result.matched_count)
-        self.assertTrue(result.modified_count in (1, None))
+        self.assertIn(result.modified_count, (1, None))
 
     async def test_remove(self):
         # Test removing all documents, ordered.
@@ -1037,7 +1037,7 @@ async def test_write_concern_failure_ordered(self):
 
         self.assertTrue(len(details["writeConcernErrors"]) > 1)
         failed = details["writeErrors"][0]
-        self.assertTrue("duplicate" in failed["errmsg"])
+        self.assertIn("duplicate", failed["errmsg"])
 
     @async_client_context.require_version_max(7, 1)  # PYTHON-4560
     @async_client_context.require_replica_set

test/asynchronous/test_client.py

@@ -674,7 +674,7 @@ async def test_max_idle_time_reaper_default(self):
             async with server._pool.checkout() as conn:
                 pass
             self.assertEqual(1, len(server._pool.conns))
-            self.assertTrue(conn in server._pool.conns)
+            self.assertIn(conn, server._pool.conns)
 
     async def test_max_idle_time_reaper_removes_stale_minPoolSize(self):
         with client_knobs(kill_cursor_frequency=0.1):
@@ -752,7 +752,7 @@ async def test_min_pool_size(self):
                 lambda: len(server._pool.conns) == 10,
                 "a closed socket gets replaced from the pool",
             )
-            self.assertFalse(conn in server._pool.conns)
+            self.assertNotIn(conn, server._pool.conns)
 
     async def test_max_idle_time_checkout(self):
         # Use high frequency to test _get_socket_no_auth.
@@ -769,8 +769,8 @@ async def test_max_idle_time_checkout(self):
             async with server._pool.checkout() as new_con:
                 self.assertNotEqual(conn, new_con)
             self.assertEqual(1, len(server._pool.conns))
-            self.assertFalse(conn in server._pool.conns)
-            self.assertTrue(new_con in server._pool.conns)
+            self.assertNotIn(conn, server._pool.conns)
+            self.assertIn(new_con, server._pool.conns)
 
             # Test that connections are reused if maxIdleTimeMS is not set.
             client = await self.async_rs_or_single_client()
@@ -1032,8 +1032,8 @@ async def test_list_database_names(self):
         cmd_names = [doc["name"] for doc in cmd_docs]
 
         db_names = await self.client.list_database_names()
-        self.assertTrue("pymongo_test" in db_names)
-        self.assertTrue("pymongo_test_mike" in db_names)
+        self.assertIn("pymongo_test", db_names)
+        self.assertIn("pymongo_test_mike", db_names)
         self.assertEqual(db_names, cmd_names)
 
     async def test_drop_database(self):
@@ -1257,9 +1257,9 @@ async def test_unix_socket(self):
         client = await self.async_rs_or_single_client(uri)
         await client.pymongo_test.test.insert_one({"dummy": "object"})
         dbs = await client.list_database_names()
-        self.assertTrue("pymongo_test" in dbs)
+        self.assertIn("pymongo_test", dbs)
 
-        self.assertTrue(mongodb_socket in repr(client))
+        self.assertIn(mongodb_socket, repr(client))
 
         # Confirm it fails with a missing socket.
         with self.assertRaises(ConnectionFailure):
@@ -1431,8 +1431,8 @@ async def test_ipv6(self):
         await client.pymongo_test_bernie.test.insert_one({"dummy": "object"})
 
         dbs = await client.list_database_names()
-        self.assertTrue("pymongo_test" in dbs)
-        self.assertTrue("pymongo_test_bernie" in dbs)
+        self.assertIn("pymongo_test", dbs)
+        self.assertIn("pymongo_test_bernie", dbs)
 
     async def test_contextlib(self):
         client = await self.async_rs_or_single_client()