diff --git a/test/asynchronous/test_bulk.py b/test/asynchronous/test_bulk.py
index 7c6f032e81..62022de24c 100644
--- a/test/asynchronous/test_bulk.py
+++ b/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,7 +107,7 @@ 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"])
 
@@ -115,7 +115,7 @@ def assertEqualWriteError(self, expected, actual):
         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
diff --git a/test/asynchronous/test_client.py b/test/asynchronous/test_client.py
index 4d247009e5..ad6614711d 100644
--- a/test/asynchronous/test_client.py
+++ b/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()
diff --git a/test/asynchronous/test_collection.py b/test/asynchronous/test_collection.py
index 9367c43a0b..b6f96cc999 100644
--- a/test/asynchronous/test_collection.py
+++ b/test/asynchronous/test_collection.py
@@ -212,7 +212,7 @@ async def lambda_test_2():
 
     async def test_drop_nonexistent_collection(self):
         await self.db.drop_collection("test")
-        self.assertFalse("test" in await self.db.list_collection_names())
+        self.assertNotIn("test", await self.db.list_collection_names())
 
         # No exception
         await self.db.drop_collection("test")
@@ -248,7 +248,7 @@ async def test_create_indexes(self):
         await db.test.drop_indexes()
         self.assertEqual(len(await db.test.index_information()), 1)
         await db.test.create_indexes([IndexModel("hello")])
-        self.assertTrue("hello_1" in await db.test.index_information())
+        self.assertIn("hello_1", await db.test.index_information())
 
         await db.test.drop_indexes()
         self.assertEqual(len(await db.test.index_information()), 1)
@@ -257,7 +257,7 @@ async def test_create_indexes(self):
         )
         info = await db.test.index_information()
         for name in names:
-            self.assertTrue(name in info)
+            self.assertIn(name, info)
 
         await db.test.drop()
         await db.test.insert_one({"a": 1})
@@ -311,16 +311,16 @@ async def test_create_index(self):
         await db.test.drop_indexes()
         self.assertEqual(len(await db.test.index_information()), 1)
         await db.test.create_index("hello")
-        self.assertTrue("hello_1" in await db.test.index_information())
+        self.assertIn("hello_1", await db.test.index_information())
 
         await db.test.drop_indexes()
         self.assertEqual(len(await db.test.index_information()), 1)
         await db.test.create_index([("hello", DESCENDING), ("world", ASCENDING)])
-        self.assertTrue("hello_-1_world_1" in await db.test.index_information())
+        self.assertIn("hello_-1_world_1", await db.test.index_information())
 
         await db.test.drop_indexes()
         await db.test.create_index([("hello", DESCENDING), ("world", ASCENDING)], name=None)
-        self.assertTrue("hello_-1_world_1" in await db.test.index_information())
+        self.assertIn("hello_-1_world_1", await db.test.index_information())
 
         await db.test.drop()
         await db.test.insert_one({"a": 1})
@@ -349,7 +349,7 @@ async def test_drop_index(self):
         with self.assertRaises(OperationFailure):
             await db.test.drop_index(name)
         self.assertEqual(len(await db.test.index_information()), 2)
-        self.assertTrue("hello_1" in await db.test.index_information())
+        self.assertIn("hello_1", await db.test.index_information())
 
         await db.test.drop_indexes()
         await db.test.create_index("hello")
@@ -359,7 +359,7 @@ async def test_drop_index(self):
         self.assertEqual(name, "goodbye_1")
         await db.test.drop_index([("goodbye", ASCENDING)])
         self.assertEqual(len(await db.test.index_information()), 2)
-        self.assertTrue("hello_1" in await db.test.index_information())
+        self.assertIn("hello_1", await db.test.index_information())
 
         with self.write_concern_collection() as coll:
             await coll.drop_index("hello_1")
@@ -395,7 +395,7 @@ def map_indexes(indexes):
 
         indexes = await (await db.test.list_indexes()).to_list()
         self.assertEqual(len(indexes), 1)
-        self.assertTrue("_id_" in map_indexes(indexes))
+        self.assertIn("_id_", map_indexes(indexes))
 
         await db.test.create_index("hello")
         indexes = await (await db.test.list_indexes()).to_list()
@@ -424,7 +424,7 @@ async def test_index_info(self):
         await db.test.drop()
         await db.test.insert_one({})  # create collection
         self.assertEqual(len(await db.test.index_information()), 1)
-        self.assertTrue("_id_" in await db.test.index_information())
+        self.assertIn("_id_", await db.test.index_information())
 
         await db.test.create_index("hello")
         self.assertEqual(len(await db.test.index_information()), 2)
@@ -488,7 +488,7 @@ async def test_index_text(self):
         await db.test.drop_indexes()
         self.assertEqual("t_text", await db.test.create_index([("t", TEXT)]))
         index_info = (await db.test.index_information())["t_text"]
-        self.assertTrue("weights" in index_info)
+        self.assertIn("weights", index_info)
 
         await db.test.insert_many(
             [{"t": "spam eggs and spam"}, {"t": "spam"}, {"t": "egg sausage and bacon"}]
@@ -549,7 +549,7 @@ async def test_index_background(self):
         await db.test.create_index([("keya", ASCENDING)])
         await db.test.create_index([("keyb", ASCENDING)], background=False)
         await db.test.create_index([("keyc", ASCENDING)], background=True)
-        self.assertFalse("background" in (await db.test.index_information())["keya_1"])
+        self.assertNotIn("background", (await db.test.index_information())["keya_1"])
         self.assertFalse((await db.test.index_information())["keyb_1"]["background"])
         self.assertTrue((await db.test.index_information())["keyc_1"]["background"])
 
@@ -702,7 +702,7 @@ async def test_field_selection(self):
 
         doc = await anext(db.test.find({}, {"_id": False}))
         l = list(doc)
-        self.assertFalse("_id" in l)
+        self.assertNotIn("_id", l)
 
     async def test_options(self):
         db = self.db
@@ -764,7 +764,7 @@ async def test_insert_many(self):
         for doc in docs:
             _id = doc["_id"]
             self.assertIsInstance(_id, ObjectId)
-            self.assertTrue(_id in result.inserted_ids)
+            self.assertIn(_id, result.inserted_ids)
             self.assertEqual(1, await db.test.count_documents({"_id": _id}))
         self.assertTrue(result.acknowledged)
 
@@ -776,7 +776,7 @@ async def test_insert_many(self):
         for doc in docs:
             _id = doc["_id"]
             self.assertIsInstance(_id, int)
-            self.assertTrue(_id in result.inserted_ids)
+            self.assertIn(_id, result.inserted_ids)
             self.assertEqual(1, await db.test.count_documents({"_id": _id}))
         self.assertTrue(result.acknowledged)
 
@@ -943,7 +943,7 @@ async def async_lambda():
         for doc in docs:
             _id = doc["_id"]
             self.assertIsInstance(_id, int)
-            self.assertTrue(_id in result.inserted_ids)
+            self.assertIn(_id, result.inserted_ids)
             self.assertEqual(1, await db.test.count_documents({"x": doc["x"]}))
         self.assertTrue(result.acknowledged)
         docs = [{"_id": i, "a": 200 - i} for i in range(100, 200)]
@@ -953,7 +953,7 @@ async def async_lambda():
         for doc in docs:
             _id = doc["_id"]
             self.assertIsInstance(_id, int)
-            self.assertTrue(_id in result.inserted_ids)
+            self.assertIn(_id, result.inserted_ids)
             self.assertEqual(1, await db.test.count_documents({"a": doc["a"]}))
         self.assertTrue(result.acknowledged)
 
@@ -1131,23 +1131,23 @@ async def test_find_w_fields(self):
         )
         self.assertEqual(1, await db.test.count_documents({}))
         doc = await anext(db.test.find({}))
-        self.assertTrue("x" in doc)
+        self.assertIn("x", doc)
         doc = await anext(db.test.find({}))
-        self.assertTrue("mike" in doc)
+        self.assertIn("mike", doc)
         doc = await anext(db.test.find({}))
-        self.assertTrue("extra thing" in doc)
+        self.assertIn("extra thing", doc)
         doc = await anext(db.test.find({}, ["x", "mike"]))
-        self.assertTrue("x" in doc)
+        self.assertIn("x", doc)
         doc = await anext(db.test.find({}, ["x", "mike"]))
-        self.assertTrue("mike" in doc)
+        self.assertIn("mike", doc)
         doc = await anext(db.test.find({}, ["x", "mike"]))
-        self.assertFalse("extra thing" in doc)
+        self.assertNotIn("extra thing", doc)
         doc = await anext(db.test.find({}, ["mike"]))
-        self.assertFalse("x" in doc)
+        self.assertNotIn("x", doc)
         doc = await anext(db.test.find({}, ["mike"]))
-        self.assertTrue("mike" in doc)
+        self.assertIn("mike", doc)
         doc = await anext(db.test.find({}, ["mike"]))
-        self.assertFalse("extra thing" in doc)
+        self.assertNotIn("extra thing", doc)
 
     @no_type_check
     async def test_fields_specifier_as_dict(self):
@@ -1158,8 +1158,8 @@ async def test_fields_specifier_as_dict(self):
 
         self.assertEqual([1, 2, 3], (await db.test.find_one())["x"])
         self.assertEqual([2, 3], (await db.test.find_one(projection={"x": {"$slice": -2}}))["x"])
-        self.assertTrue("x" not in await db.test.find_one(projection={"x": 0}))
-        self.assertTrue("mike" in await db.test.find_one(projection={"x": 0}))
+        self.assertNotIn("x", await db.test.find_one(projection={"x": 0}))
+        self.assertIn("mike", await db.test.find_one(projection={"x": 0}))
 
     async def test_find_w_regex(self):
         db = self.db
@@ -1194,7 +1194,7 @@ async def test_id_can_be_anything(self):
 
         async for x in db.test.find():
             self.assertEqual(x["hello"], "world")
-            self.assertTrue("_id" in x)
+            self.assertIn("_id", x)
 
     async def test_unique_index(self):
         db = self.db
@@ -1314,7 +1314,7 @@ async def test_error_code(self):
         try:
             await self.db.test.update_many({}, {"$thismodifierdoesntexist": 1})
         except OperationFailure as exc:
-            self.assertTrue(exc.code in (9, 10147, 16840, 17009))
+            self.assertIn(exc.code, (9, 10147, 16840, 17009))
             # Just check that we set the error document. Fields
             # vary by MongoDB version.
             self.assertTrue(exc.details is not None)
@@ -1348,7 +1348,7 @@ async def test_replace_one(self):
         result = await db.test.replace_one({"x": 1}, {"y": 1})
         self.assertIsInstance(result, UpdateResult)
         self.assertEqual(1, result.matched_count)
-        self.assertTrue(result.modified_count in (None, 1))
+        self.assertIn(result.modified_count, (None, 1))
         self.assertIsNone(result.upserted_id)
         self.assertTrue(result.acknowledged)
         self.assertEqual(1, await db.test.count_documents({"y": 1}))
@@ -1359,7 +1359,7 @@ async def test_replace_one(self):
         result = await db.test.replace_one({"y": 1}, replacement, True)
         self.assertIsInstance(result, UpdateResult)
         self.assertEqual(1, result.matched_count)
-        self.assertTrue(result.modified_count in (None, 1))
+        self.assertIn(result.modified_count, (None, 1))
         self.assertIsNone(result.upserted_id)
         self.assertTrue(result.acknowledged)
         self.assertEqual(1, await db.test.count_documents({"z": 1}))
@@ -1369,7 +1369,7 @@ async def test_replace_one(self):
         result = await db.test.replace_one({"x": 2}, {"y": 2}, True)
         self.assertIsInstance(result, UpdateResult)
         self.assertEqual(0, result.matched_count)
-        self.assertTrue(result.modified_count in (None, 0))
+        self.assertIn(result.modified_count, (None, 0))
         self.assertIsInstance(result.upserted_id, ObjectId)
         self.assertTrue(result.acknowledged)
         self.assertEqual(1, await db.test.count_documents({"y": 2}))
@@ -1393,7 +1393,7 @@ async def test_update_one(self):
         result = await db.test.update_one({}, {"$inc": {"x": 1}})
         self.assertIsInstance(result, UpdateResult)
         self.assertEqual(1, result.matched_count)
-        self.assertTrue(result.modified_count in (None, 1))
+        self.assertIn(result.modified_count, (None, 1))
         self.assertIsNone(result.upserted_id)
         self.assertTrue(result.acknowledged)
         self.assertEqual((await db.test.find_one(id1))["x"], 6)  # type: ignore
@@ -1402,7 +1402,7 @@ async def test_update_one(self):
         result = await db.test.update_one({"x": 6}, {"$inc": {"x": 1}})
         self.assertIsInstance(result, UpdateResult)
         self.assertEqual(1, result.matched_count)
-        self.assertTrue(result.modified_count in (None, 1))
+        self.assertIn(result.modified_count, (None, 1))
         self.assertIsNone(result.upserted_id)
         self.assertTrue(result.acknowledged)
         self.assertEqual((await db.test.find_one(id1))["x"], 7)  # type: ignore
@@ -1411,7 +1411,7 @@ async def test_update_one(self):
         result = await db.test.update_one({"x": 2}, {"$set": {"y": 1}}, True)
         self.assertIsInstance(result, UpdateResult)
         self.assertEqual(0, result.matched_count)
-        self.assertTrue(result.modified_count in (None, 0))
+        self.assertIn(result.modified_count, (None, 0))
         self.assertIsInstance(result.upserted_id, ObjectId)
         self.assertTrue(result.acknowledged)
 
@@ -1450,7 +1450,7 @@ async def test_update_many(self):
         result = await db.test.update_many({"x": 4}, {"$set": {"y": 5}})
         self.assertIsInstance(result, UpdateResult)
         self.assertEqual(2, result.matched_count)
-        self.assertTrue(result.modified_count in (None, 2))
+        self.assertIn(result.modified_count, (None, 2))
         self.assertIsNone(result.upserted_id)
         self.assertTrue(result.acknowledged)
         self.assertEqual(3, await db.test.count_documents({"y": 5}))
@@ -1458,7 +1458,7 @@ async def test_update_many(self):
         result = await db.test.update_many({"x": 5}, {"$set": {"y": 6}})
         self.assertIsInstance(result, UpdateResult)
         self.assertEqual(1, result.matched_count)
-        self.assertTrue(result.modified_count in (None, 1))
+        self.assertIn(result.modified_count, (None, 1))
         self.assertIsNone(result.upserted_id)
         self.assertTrue(result.acknowledged)
         self.assertEqual(1, await db.test.count_documents({"y": 6}))
@@ -1466,7 +1466,7 @@ async def test_update_many(self):
         result = await db.test.update_many({"x": 2}, {"$set": {"y": 1}}, True)
         self.assertIsInstance(result, UpdateResult)
         self.assertEqual(0, result.matched_count)
-        self.assertTrue(result.modified_count in (None, 0))
+        self.assertIn(result.modified_count, (None, 0))
         self.assertIsInstance(result.upserted_id, ObjectId)
         self.assertTrue(result.acknowledged)
 
@@ -1725,21 +1725,21 @@ async def test_find_one(self):
         self.assertEqual(await db.test.find_one({}), await db.test.find_one())
         self.assertEqual(await db.test.find_one({"hello": "world"}), await db.test.find_one())
 
-        self.assertTrue("hello" in await db.test.find_one(projection=["hello"]))
-        self.assertTrue("hello" not in await db.test.find_one(projection=["foo"]))
+        self.assertIn("hello", await db.test.find_one(projection=["hello"]))
+        self.assertNotIn("hello", await db.test.find_one(projection=["foo"]))
 
-        self.assertTrue("hello" in await db.test.find_one(projection=("hello",)))
-        self.assertTrue("hello" not in await db.test.find_one(projection=("foo",)))
+        self.assertIn("hello", await db.test.find_one(projection=("hello",)))
+        self.assertNotIn("hello", await db.test.find_one(projection=("foo",)))
 
-        self.assertTrue("hello" in await db.test.find_one(projection={"hello"}))
-        self.assertTrue("hello" not in await db.test.find_one(projection={"foo"}))
+        self.assertIn("hello", await db.test.find_one(projection={"hello"}))
+        self.assertNotIn("hello", await db.test.find_one(projection={"foo"}))
 
-        self.assertTrue("hello" in await db.test.find_one(projection=frozenset(["hello"])))
-        self.assertTrue("hello" not in await db.test.find_one(projection=frozenset(["foo"])))
+        self.assertIn("hello", await db.test.find_one(projection=frozenset(["hello"])))
+        self.assertNotIn("hello", await db.test.find_one(projection=frozenset(["foo"])))
 
         self.assertEqual(["_id"], list(await db.test.find_one(projection={"_id": True})))
-        self.assertTrue("hello" in list(await db.test.find_one(projection={})))
-        self.assertTrue("hello" in list(await db.test.find_one(projection=[])))
+        self.assertIn("hello", list(await db.test.find_one(projection={})))
+        self.assertIn("hello", list(await db.test.find_one(projection=[])))
 
         self.assertEqual(None, await db.test.find_one({"hello": "foo"}))
         self.assertEqual(None, await db.test.find_one(ObjectId()))
diff --git a/test/asynchronous/test_cursor.py b/test/asynchronous/test_cursor.py
index 5e4e590fef..861345cb08 100644
--- a/test/asynchronous/test_cursor.py
+++ b/test/asynchronous/test_cursor.py
@@ -174,8 +174,8 @@ async def test_max_time_ms(self):
         cursor = coll.find().max_time_ms(999)
         c2 = cursor.clone()
         self.assertEqual(999, c2._max_time_ms)
-        self.assertTrue("$maxTimeMS" in cursor._query_spec())
-        self.assertTrue("$maxTimeMS" in c2._query_spec())
+        self.assertIn("$maxTimeMS", cursor._query_spec())
+        self.assertIn("$maxTimeMS", c2._query_spec())
 
         self.assertTrue(await coll.find_one(max_time_ms=1000))
 
@@ -240,19 +240,19 @@ async def test_max_await_time_ms(self):
         # Tailable_await defaults.
         await coll.find(cursor_type=CursorType.TAILABLE_AWAIT).to_list()
         # find
-        self.assertFalse("maxTimeMS" in listener.started_events[0].command)
+        self.assertNotIn("maxTimeMS", listener.started_events[0].command)
         # getMore
-        self.assertFalse("maxTimeMS" in listener.started_events[1].command)
+        self.assertNotIn("maxTimeMS", listener.started_events[1].command)
         listener.reset()
 
         # Tailable_await with max_await_time_ms set.
         await coll.find(cursor_type=CursorType.TAILABLE_AWAIT).max_await_time_ms(99).to_list()
         # find
         self.assertEqual("find", listener.started_events[0].command_name)
-        self.assertFalse("maxTimeMS" in listener.started_events[0].command)
+        self.assertNotIn("maxTimeMS", listener.started_events[0].command)
         # getMore
         self.assertEqual("getMore", listener.started_events[1].command_name)
-        self.assertTrue("maxTimeMS" in listener.started_events[1].command)
+        self.assertIn("maxTimeMS", listener.started_events[1].command)
         self.assertEqual(99, listener.started_events[1].command["maxTimeMS"])
         listener.reset()
 
@@ -263,11 +263,11 @@ async def test_max_await_time_ms(self):
             await coll.find(cursor_type=CursorType.TAILABLE_AWAIT).max_time_ms(99).to_list()
         # find
         self.assertEqual("find", listener.started_events[0].command_name)
-        self.assertTrue("maxTimeMS" in listener.started_events[0].command)
+        self.assertIn("maxTimeMS", listener.started_events[0].command)
         self.assertEqual(99, listener.started_events[0].command["maxTimeMS"])
         # getMore
         self.assertEqual("getMore", listener.started_events[1].command_name)
-        self.assertFalse("maxTimeMS" in listener.started_events[1].command)
+        self.assertNotIn("maxTimeMS", listener.started_events[1].command)
         listener.reset()
 
         # Tailable_await with both max_time_ms and max_await_time_ms
@@ -279,11 +279,11 @@ async def test_max_await_time_ms(self):
         )
         # find
         self.assertEqual("find", listener.started_events[0].command_name)
-        self.assertTrue("maxTimeMS" in listener.started_events[0].command)
+        self.assertIn("maxTimeMS", listener.started_events[0].command)
         self.assertEqual(99, listener.started_events[0].command["maxTimeMS"])
         # getMore
         self.assertEqual("getMore", listener.started_events[1].command_name)
-        self.assertTrue("maxTimeMS" in listener.started_events[1].command)
+        self.assertIn("maxTimeMS", listener.started_events[1].command)
         self.assertEqual(99, listener.started_events[1].command["maxTimeMS"])
         listener.reset()
 
@@ -291,31 +291,31 @@ async def test_max_await_time_ms(self):
         await coll.find(batch_size=1).max_await_time_ms(99).to_list()
         # find
         self.assertEqual("find", listener.started_events[0].command_name)
-        self.assertFalse("maxTimeMS" in listener.started_events[0].command)
+        self.assertNotIn("maxTimeMS", listener.started_events[0].command)
         # getMore
         self.assertEqual("getMore", listener.started_events[1].command_name)
-        self.assertFalse("maxTimeMS" in listener.started_events[1].command)
+        self.assertNotIn("maxTimeMS", listener.started_events[1].command)
         listener.reset()
 
         # Non tailable_await with max_time_ms
         await coll.find(batch_size=1).max_time_ms(99).to_list()
         # find
         self.assertEqual("find", listener.started_events[0].command_name)
-        self.assertTrue("maxTimeMS" in listener.started_events[0].command)
+        self.assertIn("maxTimeMS", listener.started_events[0].command)
         self.assertEqual(99, listener.started_events[0].command["maxTimeMS"])
         # getMore
         self.assertEqual("getMore", listener.started_events[1].command_name)
-        self.assertFalse("maxTimeMS" in listener.started_events[1].command)
+        self.assertNotIn("maxTimeMS", listener.started_events[1].command)
 
         # Non tailable_await with both max_time_ms and max_await_time_ms
         await coll.find(batch_size=1).max_time_ms(99).max_await_time_ms(88).to_list()
         # find
         self.assertEqual("find", listener.started_events[0].command_name)
-        self.assertTrue("maxTimeMS" in listener.started_events[0].command)
+        self.assertIn("maxTimeMS", listener.started_events[0].command)
         self.assertEqual(99, listener.started_events[0].command["maxTimeMS"])
         # getMore
         self.assertEqual("getMore", listener.started_events[1].command_name)
-        self.assertFalse("maxTimeMS" in listener.started_events[1].command)
+        self.assertNotIn("maxTimeMS", listener.started_events[1].command)
 
     @async_client_context.require_test_commands
     @async_client_context.require_no_mongos
@@ -933,16 +933,19 @@ async def test_clone(self):
         # Shallow copies can so can mutate
         cursor2 = copy.copy(cursor)
         cursor2._projection["cursor2"] = False
-        self.assertTrue(cursor._projection and "cursor2" in cursor._projection)
+        self.assertIsNotNone(cursor._projection)
+        self.assertIn("cursor2", cursor._projection.keys())
 
         # Deepcopies and shouldn't mutate
         cursor3 = copy.deepcopy(cursor)
         cursor3._projection["cursor3"] = False
-        self.assertFalse(cursor._projection and "cursor3" in cursor._projection)
+        self.assertIsNotNone(cursor._projection)
+        self.assertNotIn("cursor3", cursor._projection.keys())
 
         cursor4 = cursor.clone()
         cursor4._projection["cursor4"] = False
-        self.assertFalse(cursor._projection and "cursor4" in cursor._projection)
+        self.assertIsNotNone(cursor._projection)
+        self.assertNotIn("cursor4", cursor._projection.keys())
 
         # Test memo when deepcopying queries
         query = {"hello": "world"}
diff --git a/test/asynchronous/test_database.py b/test/asynchronous/test_database.py
index 1e0f0c40d6..3195c74988 100644
--- a/test/asynchronous/test_database.py
+++ b/test/asynchronous/test_database.py
@@ -163,13 +163,13 @@ async def test_create_collection(self):
             await db.create_collection("coll..ection")  # type: ignore[arg-type]
 
         test = await db.create_collection("test")
-        self.assertTrue("test" in await db.list_collection_names())
+        self.assertIn("test", await db.list_collection_names())
         await test.insert_one({"hello": "world"})
         self.assertEqual((await db.test.find_one())["hello"], "world")
 
         await db.drop_collection("test.foo")
         await db.create_collection("test.foo")
-        self.assertTrue("test.foo" in await db.list_collection_names())
+        self.assertIn("test.foo", await db.list_collection_names())
         with self.assertRaises(CollectionInvalid):
             await db.create_collection("test.foo")
 
@@ -179,10 +179,10 @@ async def test_list_collection_names(self):
         await db.test.mike.insert_one({"dummy": "object"})
 
         colls = await db.list_collection_names()
-        self.assertTrue("test" in colls)
-        self.assertTrue("test.mike" in colls)
+        self.assertIn("test", colls)
+        self.assertIn("test.mike", colls)
         for coll in colls:
-            self.assertTrue("$" not in coll)
+            self.assertNotIn("$", coll)
 
         await db.systemcoll.test.insert_one({})
         no_system_collections = await db.list_collection_names(
@@ -252,12 +252,12 @@ async def test_list_collections(self):
         colls = [result["name"] async for result in results]
 
         # All the collections present.
-        self.assertTrue("test" in colls)
-        self.assertTrue("test.mike" in colls)
+        self.assertIn("test", colls)
+        self.assertIn("test.mike", colls)
 
         # No collection containing a '$'.
         for coll in colls:
-            self.assertTrue("$" not in coll)
+            self.assertNotIn("$", coll)
 
         # Duplicate check.
         coll_cnt: dict = {}
@@ -294,12 +294,12 @@ async def test_list_collections(self):
         colls = [result["name"] async for result in results]
 
         # Checking only capped collections are present
-        self.assertTrue("test" in colls)
-        self.assertFalse("test.mike" in colls)
+        self.assertIn("test", colls)
+        self.assertNotIn("test.mike", colls)
 
         # No collection containing a '$'.
         for coll in colls:
-            self.assertTrue("$" not in coll)
+            self.assertNotIn("$", coll)
 
         # Duplicate check.
         coll_cnt = {}
@@ -339,24 +339,24 @@ async def test_drop_collection(self):
             await db.drop_collection(None)  # type: ignore[arg-type]
 
         await db.test.insert_one({"dummy": "object"})
-        self.assertTrue("test" in await db.list_collection_names())
+        self.assertIn("test", await db.list_collection_names())
         await db.drop_collection("test")
-        self.assertFalse("test" in await db.list_collection_names())
+        self.assertNotIn("test", await db.list_collection_names())
 
         await db.test.insert_one({"dummy": "object"})
-        self.assertTrue("test" in await db.list_collection_names())
+        self.assertIn("test", await db.list_collection_names())
         await db.drop_collection("test")
-        self.assertFalse("test" in await db.list_collection_names())
+        self.assertNotIn("test", await db.list_collection_names())
 
         await db.test.insert_one({"dummy": "object"})
-        self.assertTrue("test" in await db.list_collection_names())
+        self.assertIn("test", await db.list_collection_names())
         await db.drop_collection(db.test)
-        self.assertFalse("test" in await db.list_collection_names())
+        self.assertNotIn("test", await db.list_collection_names())
 
         await db.test.insert_one({"dummy": "object"})
-        self.assertTrue("test" in await db.list_collection_names())
+        self.assertIn("test", await db.list_collection_names())
         await db.test.drop()
-        self.assertFalse("test" in await db.list_collection_names())
+        self.assertNotIn("test", await db.list_collection_names())
         await db.test.drop()
 
         await db.drop_collection(db.test.doesnotexist)
diff --git a/test/asynchronous/test_examples.py b/test/asynchronous/test_examples.py
index a334a3ed1d..a4ebf72df9 100644
--- a/test/asynchronous/test_examples.py
+++ b/test/asynchronous/test_examples.py
@@ -479,77 +479,77 @@ async def test_projection(self):
         # End Example 44
 
         async for doc in cursor:
-            self.assertTrue("_id" in doc)
-            self.assertTrue("item" in doc)
-            self.assertTrue("status" in doc)
-            self.assertFalse("size" in doc)
-            self.assertFalse("instock" in doc)
+            self.assertIn("_id", doc)
+            self.assertIn("item", doc)
+            self.assertIn("status", doc)
+            self.assertNotIn("size", doc)
+            self.assertNotIn("instock", doc)
 
         # Start Example 45
         cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "_id": 0})
         # End Example 45
 
         async for doc in cursor:
-            self.assertFalse("_id" in doc)
-            self.assertTrue("item" in doc)
-            self.assertTrue("status" in doc)
-            self.assertFalse("size" in doc)
-            self.assertFalse("instock" in doc)
+            self.assertNotIn("_id", doc)
+            self.assertIn("item", doc)
+            self.assertIn("status", doc)
+            self.assertNotIn("size", doc)
+            self.assertNotIn("instock", doc)
 
         # Start Example 46
         cursor = db.inventory.find({"status": "A"}, {"status": 0, "instock": 0})
         # End Example 46
 
         async for doc in cursor:
-            self.assertTrue("_id" in doc)
-            self.assertTrue("item" in doc)
-            self.assertFalse("status" in doc)
-            self.assertTrue("size" in doc)
-            self.assertFalse("instock" in doc)
+            self.assertIn("_id", doc)
+            self.assertIn("item", doc)
+            self.assertNotIn("status", doc)
+            self.assertIn("size", doc)
+            self.assertNotIn("instock", doc)
 
         # Start Example 47
         cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "size.uom": 1})
         # End Example 47
 
         async for doc in cursor:
-            self.assertTrue("_id" in doc)
-            self.assertTrue("item" in doc)
-            self.assertTrue("status" in doc)
-            self.assertTrue("size" in doc)
-            self.assertFalse("instock" in doc)
+            self.assertIn("_id", doc)
+            self.assertIn("item", doc)
+            self.assertIn("status", doc)
+            self.assertIn("size", doc)
+            self.assertNotIn("instock", doc)
             size = doc["size"]
-            self.assertTrue("uom" in size)
-            self.assertFalse("h" in size)
-            self.assertFalse("w" in size)
+            self.assertIn("uom", size)
+            self.assertNotIn("h", size)
+            self.assertNotIn("w", size)
 
         # Start Example 48
         cursor = db.inventory.find({"status": "A"}, {"size.uom": 0})
         # End Example 48
 
         async for doc in cursor:
-            self.assertTrue("_id" in doc)
-            self.assertTrue("item" in doc)
-            self.assertTrue("status" in doc)
-            self.assertTrue("size" in doc)
-            self.assertTrue("instock" in doc)
+            self.assertIn("_id", doc)
+            self.assertIn("item", doc)
+            self.assertIn("status", doc)
+            self.assertIn("size", doc)
+            self.assertIn("instock", doc)
             size = doc["size"]
-            self.assertFalse("uom" in size)
-            self.assertTrue("h" in size)
-            self.assertTrue("w" in size)
+            self.assertNotIn("uom", size)
+            self.assertIn("h", size)
+            self.assertIn("w", size)
 
         # Start Example 49
         cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "instock.qty": 1})
         # End Example 49
 
         async for doc in cursor:
-            self.assertTrue("_id" in doc)
-            self.assertTrue("item" in doc)
-            self.assertTrue("status" in doc)
-            self.assertFalse("size" in doc)
-            self.assertTrue("instock" in doc)
+            self.assertIn("_id", doc)
+            self.assertIn("item", doc)
+            self.assertIn("status", doc)
+            self.assertNotIn("size", doc)
+            self.assertIn("instock", doc)
             for subdoc in doc["instock"]:
-                self.assertFalse("warehouse" in subdoc)
-                self.assertTrue("qty" in subdoc)
+                self.assertNotIn("warehouse", subdoc)
+                self.assertIn("qty", subdoc)
 
         # Start Example 50
         cursor = db.inventory.find(
@@ -558,11 +558,11 @@ async def test_projection(self):
         # End Example 50
 
         async for doc in cursor:
-            self.assertTrue("_id" in doc)
-            self.assertTrue("item" in doc)
-            self.assertTrue("status" in doc)
-            self.assertFalse("size" in doc)
-            self.assertTrue("instock" in doc)
+            self.assertIn("_id", doc)
+            self.assertIn("item", doc)
+            self.assertIn("status", doc)
+            self.assertNotIn("size", doc)
+            self.assertIn("instock", doc)
             self.assertEqual(len(doc["instock"]), 1)
 
     async def test_update_and_replace(self):
@@ -645,7 +645,7 @@ async def test_update_and_replace(self):
         async for doc in db.inventory.find({"item": "paper"}):
             self.assertEqual(doc["size"]["uom"], "cm")
             self.assertEqual(doc["status"], "P")
-            self.assertTrue("lastModified" in doc)
+            self.assertIn("lastModified", doc)
 
         # Start Example 53
         await db.inventory.update_many(
@@ -657,7 +657,7 @@ async def test_update_and_replace(self):
         async for doc in db.inventory.find({"qty": {"$lt": 50}}):
             self.assertEqual(doc["size"]["uom"], "in")
             self.assertEqual(doc["status"], "P")
-            self.assertTrue("lastModified" in doc)
+            self.assertIn("lastModified", doc)
 
         # Start Example 54
         await db.inventory.replace_one(
@@ -671,8 +671,8 @@ async def test_update_and_replace(self):
 
         async for doc in db.inventory.find({"item": "paper"}, {"_id": 0}):
             self.assertEqual(len(doc.keys()), 2)
-            self.assertTrue("item" in doc)
-            self.assertTrue("instock" in doc)
+            self.assertIn("item", doc)
+            self.assertIn("instock", doc)
             self.assertEqual(len(doc["instock"]), 2)
 
     async def test_delete(self):
diff --git a/test/asynchronous/test_json_util_integration.py b/test/asynchronous/test_json_util_integration.py
index 4c02792d89..32312cb9d3 100644
--- a/test/asynchronous/test_json_util_integration.py
+++ b/test/asynchronous/test_json_util_integration.py
@@ -25,4 +25,4 @@ async def test_cursor(self):
         await db.test.insert_many(docs)
         reloaded_docs = json_util.loads(json_util.dumps(await (db.test.find()).to_list()))
         for doc in docs:
-            self.assertTrue(doc in reloaded_docs)
+            self.assertIn(doc, reloaded_docs)
diff --git a/test/asynchronous/test_monitoring.py b/test/asynchronous/test_monitoring.py
index b2ca1aaaa6..a44223a725 100644
--- a/test/asynchronous/test_monitoring.py
+++ b/test/asynchronous/test_monitoring.py
@@ -1088,8 +1088,8 @@ async def test_first_batch_helper(self):
         self.assertEqual(started.command_name, succeeded.command_name)
         self.assertEqual(started.request_id, succeeded.request_id)
         self.assertEqual(started.connection_id, succeeded.connection_id)
-        self.assertTrue("cursor" in succeeded.reply)
-        self.assertTrue("ok" in succeeded.reply)
+        self.assertIn("cursor", succeeded.reply)
+        self.assertIn("ok", succeeded.reply)
 
         self.listener.reset()
 
diff --git a/test/asynchronous/test_session.py b/test/asynchronous/test_session.py
index 3655f49aab..1f6fb0d319 100644
--- a/test/asynchronous/test_session.py
+++ b/test/asynchronous/test_session.py
@@ -134,8 +134,9 @@ async def _test_ops(self, client, *ops):
                 await f(*args, **kw)
                 self.assertGreaterEqual(len(listener.started_events), 1)
                 for event in listener.started_events:
-                    self.assertTrue(
-                        "lsid" in event.command,
+                    self.assertIn(
+                        "lsid",
+                        event.command,
                         f"{f.__name__} sent no lsid with {event.command_name}",
                     )
 
@@ -170,8 +171,9 @@ async def _test_ops(self, client, *ops):
             self.assertGreaterEqual(len(listener.started_events), 1)
             lsids = []
             for event in listener.started_events:
-                self.assertTrue(
-                    "lsid" in event.command,
+                self.assertIn(
+                    "lsid",
+                    event.command,
                     f"{f.__name__} sent no lsid with {event.command_name}",
                 )
 
@@ -422,8 +424,9 @@ async def test_cursor(self):
                 await f(session=s)
                 self.assertGreaterEqual(len(listener.started_events), 1)
                 for event in listener.started_events:
-                    self.assertTrue(
-                        "lsid" in event.command,
+                    self.assertIn(
+                        "lsid",
+                        event.command,
                         f"{name} sent no lsid with {event.command_name}",
                     )
 
@@ -441,15 +444,13 @@ async def test_cursor(self):
             listener.reset()
             await f(session=None)
             event0 = listener.first_command_started()
-            self.assertTrue(
-                "lsid" in event0.command, f"{name} sent no lsid with {event0.command_name}"
-            )
+            self.assertIn("lsid", event0.command, f"{name} sent no lsid with {event0.command_name}")
 
             lsid = event0.command["lsid"]
 
             for event in listener.started_events[1:]:
-                self.assertTrue(
-                    "lsid" in event.command, f"{name} sent no lsid with {event.command_name}"
+                self.assertIn(
+                    "lsid", event.command, f"{name} sent no lsid with {event.command_name}"
                 )
 
                 self.assertEqual(
@@ -1201,15 +1202,17 @@ async def aggregate():
 
             self.assertGreaterEqual(len(listener.started_events), 1)
             for i, event in enumerate(listener.started_events):
-                self.assertTrue(
-                    "$clusterTime" in event.command,
+                self.assertIn(
+                    "$clusterTime",
+                    event.command,
                     f"{f.__name__} sent no $clusterTime with {event.command_name}",
                 )
 
                 if i > 0:
                     succeeded = listener.succeeded_events[i - 1]
-                    self.assertTrue(
-                        "$clusterTime" in succeeded.reply,
+                    self.assertIn(
+                        "$clusterTime",
+                        succeeded.reply,
                         f"{f.__name__} received no $clusterTime with {succeeded.command_name}",
                     )
 
diff --git a/test/test_bulk.py b/test/test_bulk.py
index 00c6c5e649..77d0d6c06e 100644
--- a/test/test_bulk.py
+++ b/test/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,7 +107,7 @@ 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"])
 
@@ -115,7 +115,7 @@ def assertEqualWriteError(self, expected, actual):
         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 @@ def _test_update_many(self, update):
         result = 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))
 
     def test_update_many(self):
         self._test_update_many({"$set": {"foo": "bar"}})
@@ -201,7 +201,7 @@ def _test_update_one(self, update):
         result = 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))
 
     def test_update_one(self):
         self._test_update_one({"$set": {"foo": "bar"}})
@@ -227,7 +227,7 @@ def test_replace_one(self):
         result = 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))
 
     def test_remove(self):
         # Test removing all documents, ordered.
@@ -1035,7 +1035,7 @@ 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"])
 
     @client_context.require_version_max(7, 1)  # PYTHON-4560
     @client_context.require_replica_set
diff --git a/test/test_client.py b/test/test_client.py
index 4f2e5751ad..c50082797d 100644
--- a/test/test_client.py
+++ b/test/test_client.py
@@ -665,7 +665,7 @@ def test_max_idle_time_reaper_default(self):
             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)
 
     def test_max_idle_time_reaper_removes_stale_minPoolSize(self):
         with client_knobs(kill_cursor_frequency=0.1):
@@ -731,7 +731,7 @@ 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)
 
     def test_max_idle_time_checkout(self):
         # Use high frequency to test _get_socket_no_auth.
@@ -746,8 +746,8 @@ def test_max_idle_time_checkout(self):
             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 = self.rs_or_single_client()
@@ -1005,8 +1005,8 @@ def test_list_database_names(self):
         cmd_names = [doc["name"] for doc in cmd_docs]
 
         db_names = 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)
 
     def test_drop_database(self):
@@ -1220,9 +1220,9 @@ def test_unix_socket(self):
         client = self.rs_or_single_client(uri)
         client.pymongo_test.test.insert_one({"dummy": "object"})
         dbs = 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):
@@ -1390,8 +1390,8 @@ def test_ipv6(self):
         client.pymongo_test_bernie.test.insert_one({"dummy": "object"})
 
         dbs = 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)
 
     def test_contextlib(self):
         client = self.rs_or_single_client()
diff --git a/test/test_collection.py b/test/test_collection.py
index 6d1b02f1ac..5643a62022 100644
--- a/test/test_collection.py
+++ b/test/test_collection.py
@@ -212,7 +212,7 @@ def lambda_test_2():
 
     def test_drop_nonexistent_collection(self):
         self.db.drop_collection("test")
-        self.assertFalse("test" in self.db.list_collection_names())
+        self.assertNotIn("test", self.db.list_collection_names())
 
         # No exception
         self.db.drop_collection("test")
@@ -248,7 +248,7 @@ def test_create_indexes(self):
         db.test.drop_indexes()
         self.assertEqual(len(db.test.index_information()), 1)
         db.test.create_indexes([IndexModel("hello")])
-        self.assertTrue("hello_1" in db.test.index_information())
+        self.assertIn("hello_1", db.test.index_information())
 
         db.test.drop_indexes()
         self.assertEqual(len(db.test.index_information()), 1)
@@ -257,7 +257,7 @@ def test_create_indexes(self):
         )
         info = db.test.index_information()
         for name in names:
-            self.assertTrue(name in info)
+            self.assertIn(name, info)
 
         db.test.drop()
         db.test.insert_one({"a": 1})
@@ -309,16 +309,16 @@ def test_create_index(self):
         db.test.drop_indexes()
         self.assertEqual(len(db.test.index_information()), 1)
         db.test.create_index("hello")
-        self.assertTrue("hello_1" in db.test.index_information())
+        self.assertIn("hello_1", db.test.index_information())
 
         db.test.drop_indexes()
         self.assertEqual(len(db.test.index_information()), 1)
         db.test.create_index([("hello", DESCENDING), ("world", ASCENDING)])
-        self.assertTrue("hello_-1_world_1" in db.test.index_information())
+        self.assertIn("hello_-1_world_1", db.test.index_information())
 
         db.test.drop_indexes()
         db.test.create_index([("hello", DESCENDING), ("world", ASCENDING)], name=None)
-        self.assertTrue("hello_-1_world_1" in db.test.index_information())
+        self.assertIn("hello_-1_world_1", db.test.index_information())
 
         db.test.drop()
         db.test.insert_one({"a": 1})
@@ -347,7 +347,7 @@ def test_drop_index(self):
         with self.assertRaises(OperationFailure):
             db.test.drop_index(name)
         self.assertEqual(len(db.test.index_information()), 2)
-        self.assertTrue("hello_1" in db.test.index_information())
+        self.assertIn("hello_1", db.test.index_information())
 
         db.test.drop_indexes()
         db.test.create_index("hello")
@@ -357,7 +357,7 @@ def test_drop_index(self):
         self.assertEqual(name, "goodbye_1")
         db.test.drop_index([("goodbye", ASCENDING)])
         self.assertEqual(len(db.test.index_information()), 2)
-        self.assertTrue("hello_1" in db.test.index_information())
+        self.assertIn("hello_1", db.test.index_information())
 
         with self.write_concern_collection() as coll:
             coll.drop_index("hello_1")
@@ -389,7 +389,7 @@ def map_indexes(indexes):
 
         indexes = (db.test.list_indexes()).to_list()
         self.assertEqual(len(indexes), 1)
-        self.assertTrue("_id_" in map_indexes(indexes))
+        self.assertIn("_id_", map_indexes(indexes))
 
         db.test.create_index("hello")
         indexes = (db.test.list_indexes()).to_list()
@@ -418,7 +418,7 @@ def test_index_info(self):
         db.test.drop()
         db.test.insert_one({})  # create collection
         self.assertEqual(len(db.test.index_information()), 1)
-        self.assertTrue("_id_" in db.test.index_information())
+        self.assertIn("_id_", db.test.index_information())
 
         db.test.create_index("hello")
         self.assertEqual(len(db.test.index_information()), 2)
@@ -478,7 +478,7 @@ def test_index_text(self):
         db.test.drop_indexes()
         self.assertEqual("t_text", db.test.create_index([("t", TEXT)]))
         index_info = (db.test.index_information())["t_text"]
-        self.assertTrue("weights" in index_info)
+        self.assertIn("weights", index_info)
 
         db.test.insert_many(
             [{"t": "spam eggs and spam"}, {"t": "spam"}, {"t": "egg sausage and bacon"}]
@@ -539,7 +539,7 @@ def test_index_background(self):
         db.test.create_index([("keya", ASCENDING)])
         db.test.create_index([("keyb", ASCENDING)], background=False)
         db.test.create_index([("keyc", ASCENDING)], background=True)
-        self.assertFalse("background" in (db.test.index_information())["keya_1"])
+        self.assertNotIn("background", (db.test.index_information())["keya_1"])
         self.assertFalse((db.test.index_information())["keyb_1"]["background"])
         self.assertTrue((db.test.index_information())["keyc_1"]["background"])
 
@@ -690,7 +690,7 @@ def test_field_selection(self):
 
         doc = next(db.test.find({}, {"_id": False}))
         l = list(doc)
-        self.assertFalse("_id" in l)
+        self.assertNotIn("_id", l)
 
     def test_options(self):
         db = self.db
@@ -752,7 +752,7 @@ def test_insert_many(self):
         for doc in docs:
             _id = doc["_id"]
             self.assertIsInstance(_id, ObjectId)
-            self.assertTrue(_id in result.inserted_ids)
+            self.assertIn(_id, result.inserted_ids)
             self.assertEqual(1, db.test.count_documents({"_id": _id}))
         self.assertTrue(result.acknowledged)
 
@@ -764,7 +764,7 @@ def test_insert_many(self):
         for doc in docs:
             _id = doc["_id"]
             self.assertIsInstance(_id, int)
-            self.assertTrue(_id in result.inserted_ids)
+            self.assertIn(_id, result.inserted_ids)
             self.assertEqual(1, db.test.count_documents({"_id": _id}))
         self.assertTrue(result.acknowledged)
 
@@ -931,7 +931,7 @@ def async_lambda():
         for doc in docs:
             _id = doc["_id"]
             self.assertIsInstance(_id, int)
-            self.assertTrue(_id in result.inserted_ids)
+            self.assertIn(_id, result.inserted_ids)
             self.assertEqual(1, db.test.count_documents({"x": doc["x"]}))
         self.assertTrue(result.acknowledged)
         docs = [{"_id": i, "a": 200 - i} for i in range(100, 200)]
@@ -941,7 +941,7 @@ def async_lambda():
         for doc in docs:
             _id = doc["_id"]
             self.assertIsInstance(_id, int)
-            self.assertTrue(_id in result.inserted_ids)
+            self.assertIn(_id, result.inserted_ids)
             self.assertEqual(1, db.test.count_documents({"a": doc["a"]}))
         self.assertTrue(result.acknowledged)
 
@@ -1117,23 +1117,23 @@ def test_find_w_fields(self):
         db.test.insert_one({"x": 1, "mike": "awesome", "extra thing": "abcdefghijklmnopqrstuvwxyz"})
         self.assertEqual(1, db.test.count_documents({}))
         doc = next(db.test.find({}))
-        self.assertTrue("x" in doc)
+        self.assertIn("x", doc)
         doc = next(db.test.find({}))
-        self.assertTrue("mike" in doc)
+        self.assertIn("mike", doc)
         doc = next(db.test.find({}))
-        self.assertTrue("extra thing" in doc)
+        self.assertIn("extra thing", doc)
         doc = next(db.test.find({}, ["x", "mike"]))
-        self.assertTrue("x" in doc)
+        self.assertIn("x", doc)
         doc = next(db.test.find({}, ["x", "mike"]))
-        self.assertTrue("mike" in doc)
+        self.assertIn("mike", doc)
         doc = next(db.test.find({}, ["x", "mike"]))
-        self.assertFalse("extra thing" in doc)
+        self.assertNotIn("extra thing", doc)
         doc = next(db.test.find({}, ["mike"]))
-        self.assertFalse("x" in doc)
+        self.assertNotIn("x", doc)
         doc = next(db.test.find({}, ["mike"]))
-        self.assertTrue("mike" in doc)
+        self.assertIn("mike", doc)
         doc = next(db.test.find({}, ["mike"]))
-        self.assertFalse("extra thing" in doc)
+        self.assertNotIn("extra thing", doc)
 
     @no_type_check
     def test_fields_specifier_as_dict(self):
@@ -1144,8 +1144,8 @@ def test_fields_specifier_as_dict(self):
 
         self.assertEqual([1, 2, 3], (db.test.find_one())["x"])
         self.assertEqual([2, 3], (db.test.find_one(projection={"x": {"$slice": -2}}))["x"])
-        self.assertTrue("x" not in db.test.find_one(projection={"x": 0}))
-        self.assertTrue("mike" in db.test.find_one(projection={"x": 0}))
+        self.assertNotIn("x", db.test.find_one(projection={"x": 0}))
+        self.assertIn("mike", db.test.find_one(projection={"x": 0}))
 
     def test_find_w_regex(self):
         db = self.db
@@ -1180,7 +1180,7 @@ def test_id_can_be_anything(self):
 
         for x in db.test.find():
             self.assertEqual(x["hello"], "world")
-            self.assertTrue("_id" in x)
+            self.assertIn("_id", x)
 
     def test_unique_index(self):
         db = self.db
@@ -1300,7 +1300,7 @@ def test_error_code(self):
         try:
             self.db.test.update_many({}, {"$thismodifierdoesntexist": 1})
         except OperationFailure as exc:
-            self.assertTrue(exc.code in (9, 10147, 16840, 17009))
+            self.assertIn(exc.code, (9, 10147, 16840, 17009))
             # Just check that we set the error document. Fields
             # vary by MongoDB version.
             self.assertTrue(exc.details is not None)
@@ -1334,7 +1334,7 @@ def test_replace_one(self):
         result = db.test.replace_one({"x": 1}, {"y": 1})
         self.assertIsInstance(result, UpdateResult)
         self.assertEqual(1, result.matched_count)
-        self.assertTrue(result.modified_count in (None, 1))
+        self.assertIn(result.modified_count, (None, 1))
         self.assertIsNone(result.upserted_id)
         self.assertTrue(result.acknowledged)
         self.assertEqual(1, db.test.count_documents({"y": 1}))
@@ -1345,7 +1345,7 @@ def test_replace_one(self):
         result = db.test.replace_one({"y": 1}, replacement, True)
         self.assertIsInstance(result, UpdateResult)
         self.assertEqual(1, result.matched_count)
-        self.assertTrue(result.modified_count in (None, 1))
+        self.assertIn(result.modified_count, (None, 1))
         self.assertIsNone(result.upserted_id)
         self.assertTrue(result.acknowledged)
         self.assertEqual(1, db.test.count_documents({"z": 1}))
@@ -1355,7 +1355,7 @@ def test_replace_one(self):
         result = db.test.replace_one({"x": 2}, {"y": 2}, True)
         self.assertIsInstance(result, UpdateResult)
         self.assertEqual(0, result.matched_count)
-        self.assertTrue(result.modified_count in (None, 0))
+        self.assertIn(result.modified_count, (None, 0))
         self.assertIsInstance(result.upserted_id, ObjectId)
         self.assertTrue(result.acknowledged)
         self.assertEqual(1, db.test.count_documents({"y": 2}))
@@ -1379,7 +1379,7 @@ def test_update_one(self):
         result = db.test.update_one({}, {"$inc": {"x": 1}})
         self.assertIsInstance(result, UpdateResult)
         self.assertEqual(1, result.matched_count)
-        self.assertTrue(result.modified_count in (None, 1))
+        self.assertIn(result.modified_count, (None, 1))
         self.assertIsNone(result.upserted_id)
         self.assertTrue(result.acknowledged)
         self.assertEqual((db.test.find_one(id1))["x"], 6)  # type: ignore
@@ -1388,7 +1388,7 @@ def test_update_one(self):
         result = db.test.update_one({"x": 6}, {"$inc": {"x": 1}})
         self.assertIsInstance(result, UpdateResult)
         self.assertEqual(1, result.matched_count)
-        self.assertTrue(result.modified_count in (None, 1))
+        self.assertIn(result.modified_count, (None, 1))
         self.assertIsNone(result.upserted_id)
         self.assertTrue(result.acknowledged)
         self.assertEqual((db.test.find_one(id1))["x"], 7)  # type: ignore
@@ -1397,7 +1397,7 @@ def test_update_one(self):
         result = db.test.update_one({"x": 2}, {"$set": {"y": 1}}, True)
         self.assertIsInstance(result, UpdateResult)
         self.assertEqual(0, result.matched_count)
-        self.assertTrue(result.modified_count in (None, 0))
+        self.assertIn(result.modified_count, (None, 0))
         self.assertIsInstance(result.upserted_id, ObjectId)
         self.assertTrue(result.acknowledged)
 
@@ -1436,7 +1436,7 @@ def test_update_many(self):
         result = db.test.update_many({"x": 4}, {"$set": {"y": 5}})
         self.assertIsInstance(result, UpdateResult)
         self.assertEqual(2, result.matched_count)
-        self.assertTrue(result.modified_count in (None, 2))
+        self.assertIn(result.modified_count, (None, 2))
         self.assertIsNone(result.upserted_id)
         self.assertTrue(result.acknowledged)
         self.assertEqual(3, db.test.count_documents({"y": 5}))
@@ -1444,7 +1444,7 @@ def test_update_many(self):
         result = db.test.update_many({"x": 5}, {"$set": {"y": 6}})
         self.assertIsInstance(result, UpdateResult)
         self.assertEqual(1, result.matched_count)
-        self.assertTrue(result.modified_count in (None, 1))
+        self.assertIn(result.modified_count, (None, 1))
         self.assertIsNone(result.upserted_id)
         self.assertTrue(result.acknowledged)
         self.assertEqual(1, db.test.count_documents({"y": 6}))
@@ -1452,7 +1452,7 @@ def test_update_many(self):
         result = db.test.update_many({"x": 2}, {"$set": {"y": 1}}, True)
         self.assertIsInstance(result, UpdateResult)
         self.assertEqual(0, result.matched_count)
-        self.assertTrue(result.modified_count in (None, 0))
+        self.assertIn(result.modified_count, (None, 0))
         self.assertIsInstance(result.upserted_id, ObjectId)
         self.assertTrue(result.acknowledged)
 
@@ -1707,21 +1707,21 @@ def test_find_one(self):
         self.assertEqual(db.test.find_one({}), db.test.find_one())
         self.assertEqual(db.test.find_one({"hello": "world"}), db.test.find_one())
 
-        self.assertTrue("hello" in db.test.find_one(projection=["hello"]))
-        self.assertTrue("hello" not in db.test.find_one(projection=["foo"]))
+        self.assertIn("hello", db.test.find_one(projection=["hello"]))
+        self.assertNotIn("hello", db.test.find_one(projection=["foo"]))
 
-        self.assertTrue("hello" in db.test.find_one(projection=("hello",)))
-        self.assertTrue("hello" not in db.test.find_one(projection=("foo",)))
+        self.assertIn("hello", db.test.find_one(projection=("hello",)))
+        self.assertNotIn("hello", db.test.find_one(projection=("foo",)))
 
-        self.assertTrue("hello" in db.test.find_one(projection={"hello"}))
-        self.assertTrue("hello" not in db.test.find_one(projection={"foo"}))
+        self.assertIn("hello", db.test.find_one(projection={"hello"}))
+        self.assertNotIn("hello", db.test.find_one(projection={"foo"}))
 
-        self.assertTrue("hello" in db.test.find_one(projection=frozenset(["hello"])))
-        self.assertTrue("hello" not in db.test.find_one(projection=frozenset(["foo"])))
+        self.assertIn("hello", db.test.find_one(projection=frozenset(["hello"])))
+        self.assertNotIn("hello", db.test.find_one(projection=frozenset(["foo"])))
 
         self.assertEqual(["_id"], list(db.test.find_one(projection={"_id": True})))
-        self.assertTrue("hello" in list(db.test.find_one(projection={})))
-        self.assertTrue("hello" in list(db.test.find_one(projection=[])))
+        self.assertIn("hello", list(db.test.find_one(projection={})))
+        self.assertIn("hello", list(db.test.find_one(projection=[])))
 
         self.assertEqual(None, db.test.find_one({"hello": "foo"}))
         self.assertEqual(None, db.test.find_one(ObjectId()))
diff --git a/test/test_cursor.py b/test/test_cursor.py
index d5845e39b0..c33f509565 100644
--- a/test/test_cursor.py
+++ b/test/test_cursor.py
@@ -174,8 +174,8 @@ def test_max_time_ms(self):
         cursor = coll.find().max_time_ms(999)
         c2 = cursor.clone()
         self.assertEqual(999, c2._max_time_ms)
-        self.assertTrue("$maxTimeMS" in cursor._query_spec())
-        self.assertTrue("$maxTimeMS" in c2._query_spec())
+        self.assertIn("$maxTimeMS", cursor._query_spec())
+        self.assertIn("$maxTimeMS", c2._query_spec())
 
         self.assertTrue(coll.find_one(max_time_ms=1000))
 
@@ -236,19 +236,19 @@ def test_max_await_time_ms(self):
         # Tailable_defaults.
         coll.find(cursor_type=CursorType.TAILABLE_AWAIT).to_list()
         # find
-        self.assertFalse("maxTimeMS" in listener.started_events[0].command)
+        self.assertNotIn("maxTimeMS", listener.started_events[0].command)
         # getMore
-        self.assertFalse("maxTimeMS" in listener.started_events[1].command)
+        self.assertNotIn("maxTimeMS", listener.started_events[1].command)
         listener.reset()
 
         # Tailable_with max_await_time_ms set.
         coll.find(cursor_type=CursorType.TAILABLE_AWAIT).max_await_time_ms(99).to_list()
         # find
         self.assertEqual("find", listener.started_events[0].command_name)
-        self.assertFalse("maxTimeMS" in listener.started_events[0].command)
+        self.assertNotIn("maxTimeMS", listener.started_events[0].command)
         # getMore
         self.assertEqual("getMore", listener.started_events[1].command_name)
-        self.assertTrue("maxTimeMS" in listener.started_events[1].command)
+        self.assertIn("maxTimeMS", listener.started_events[1].command)
         self.assertEqual(99, listener.started_events[1].command["maxTimeMS"])
         listener.reset()
 
@@ -259,11 +259,11 @@ def test_max_await_time_ms(self):
             coll.find(cursor_type=CursorType.TAILABLE_AWAIT).max_time_ms(99).to_list()
         # find
         self.assertEqual("find", listener.started_events[0].command_name)
-        self.assertTrue("maxTimeMS" in listener.started_events[0].command)
+        self.assertIn("maxTimeMS", listener.started_events[0].command)
         self.assertEqual(99, listener.started_events[0].command["maxTimeMS"])
         # getMore
         self.assertEqual("getMore", listener.started_events[1].command_name)
-        self.assertFalse("maxTimeMS" in listener.started_events[1].command)
+        self.assertNotIn("maxTimeMS", listener.started_events[1].command)
         listener.reset()
 
         # Tailable_with both max_time_ms and max_await_time_ms
@@ -275,11 +275,11 @@ def test_max_await_time_ms(self):
         )
         # find
         self.assertEqual("find", listener.started_events[0].command_name)
-        self.assertTrue("maxTimeMS" in listener.started_events[0].command)
+        self.assertIn("maxTimeMS", listener.started_events[0].command)
         self.assertEqual(99, listener.started_events[0].command["maxTimeMS"])
         # getMore
         self.assertEqual("getMore", listener.started_events[1].command_name)
-        self.assertTrue("maxTimeMS" in listener.started_events[1].command)
+        self.assertIn("maxTimeMS", listener.started_events[1].command)
         self.assertEqual(99, listener.started_events[1].command["maxTimeMS"])
         listener.reset()
 
@@ -287,31 +287,31 @@ def test_max_await_time_ms(self):
         coll.find(batch_size=1).max_await_time_ms(99).to_list()
         # find
         self.assertEqual("find", listener.started_events[0].command_name)
-        self.assertFalse("maxTimeMS" in listener.started_events[0].command)
+        self.assertNotIn("maxTimeMS", listener.started_events[0].command)
         # getMore
         self.assertEqual("getMore", listener.started_events[1].command_name)
-        self.assertFalse("maxTimeMS" in listener.started_events[1].command)
+        self.assertNotIn("maxTimeMS", listener.started_events[1].command)
         listener.reset()
 
         # Non tailable_await with max_time_ms
         coll.find(batch_size=1).max_time_ms(99).to_list()
         # find
         self.assertEqual("find", listener.started_events[0].command_name)
-        self.assertTrue("maxTimeMS" in listener.started_events[0].command)
+        self.assertIn("maxTimeMS", listener.started_events[0].command)
         self.assertEqual(99, listener.started_events[0].command["maxTimeMS"])
         # getMore
         self.assertEqual("getMore", listener.started_events[1].command_name)
-        self.assertFalse("maxTimeMS" in listener.started_events[1].command)
+        self.assertNotIn("maxTimeMS", listener.started_events[1].command)
 
         # Non tailable_await with both max_time_ms and max_await_time_ms
         coll.find(batch_size=1).max_time_ms(99).max_await_time_ms(88).to_list()
         # find
         self.assertEqual("find", listener.started_events[0].command_name)
-        self.assertTrue("maxTimeMS" in listener.started_events[0].command)
+        self.assertIn("maxTimeMS", listener.started_events[0].command)
         self.assertEqual(99, listener.started_events[0].command["maxTimeMS"])
         # getMore
         self.assertEqual("getMore", listener.started_events[1].command_name)
-        self.assertFalse("maxTimeMS" in listener.started_events[1].command)
+        self.assertNotIn("maxTimeMS", listener.started_events[1].command)
 
     @client_context.require_test_commands
     @client_context.require_no_mongos
@@ -924,16 +924,19 @@ def test_clone(self):
         # Shallow copies can so can mutate
         cursor2 = copy.copy(cursor)
         cursor2._projection["cursor2"] = False
-        self.assertTrue(cursor._projection and "cursor2" in cursor._projection)
+        self.assertIsNotNone(cursor._projection)
+        self.assertIn("cursor2", cursor._projection.keys())
 
         # Deepcopies and shouldn't mutate
         cursor3 = copy.deepcopy(cursor)
         cursor3._projection["cursor3"] = False
-        self.assertFalse(cursor._projection and "cursor3" in cursor._projection)
+        self.assertIsNotNone(cursor._projection)
+        self.assertNotIn("cursor3", cursor._projection.keys())
 
         cursor4 = cursor.clone()
         cursor4._projection["cursor4"] = False
-        self.assertFalse(cursor._projection and "cursor4" in cursor._projection)
+        self.assertIsNotNone(cursor._projection)
+        self.assertNotIn("cursor4", cursor._projection.keys())
 
         # Test memo when deepcopying queries
         query = {"hello": "world"}
diff --git a/test/test_database.py b/test/test_database.py
index 0cb016e269..0fe6c01a9d 100644
--- a/test/test_database.py
+++ b/test/test_database.py
@@ -162,13 +162,13 @@ def test_create_collection(self):
             db.create_collection("coll..ection")  # type: ignore[arg-type]
 
         test = db.create_collection("test")
-        self.assertTrue("test" in db.list_collection_names())
+        self.assertIn("test", db.list_collection_names())
         test.insert_one({"hello": "world"})
         self.assertEqual((db.test.find_one())["hello"], "world")
 
         db.drop_collection("test.foo")
         db.create_collection("test.foo")
-        self.assertTrue("test.foo" in db.list_collection_names())
+        self.assertIn("test.foo", db.list_collection_names())
         with self.assertRaises(CollectionInvalid):
             db.create_collection("test.foo")
 
@@ -178,10 +178,10 @@ def test_list_collection_names(self):
         db.test.mike.insert_one({"dummy": "object"})
 
         colls = db.list_collection_names()
-        self.assertTrue("test" in colls)
-        self.assertTrue("test.mike" in colls)
+        self.assertIn("test", colls)
+        self.assertIn("test.mike", colls)
         for coll in colls:
-            self.assertTrue("$" not in coll)
+            self.assertNotIn("$", coll)
 
         db.systemcoll.test.insert_one({})
         no_system_collections = db.list_collection_names(
@@ -251,12 +251,12 @@ def test_list_collections(self):
         colls = [result["name"] for result in results]
 
         # All the collections present.
-        self.assertTrue("test" in colls)
-        self.assertTrue("test.mike" in colls)
+        self.assertIn("test", colls)
+        self.assertIn("test.mike", colls)
 
         # No collection containing a '$'.
         for coll in colls:
-            self.assertTrue("$" not in coll)
+            self.assertNotIn("$", coll)
 
         # Duplicate check.
         coll_cnt: dict = {}
@@ -291,12 +291,12 @@ def test_list_collections(self):
         colls = [result["name"] for result in results]
 
         # Checking only capped collections are present
-        self.assertTrue("test" in colls)
-        self.assertFalse("test.mike" in colls)
+        self.assertIn("test", colls)
+        self.assertNotIn("test.mike", colls)
 
         # No collection containing a '$'.
         for coll in colls:
-            self.assertTrue("$" not in coll)
+            self.assertNotIn("$", coll)
 
         # Duplicate check.
         coll_cnt = {}
@@ -336,24 +336,24 @@ def test_drop_collection(self):
             db.drop_collection(None)  # type: ignore[arg-type]
 
         db.test.insert_one({"dummy": "object"})
-        self.assertTrue("test" in db.list_collection_names())
+        self.assertIn("test", db.list_collection_names())
         db.drop_collection("test")
-        self.assertFalse("test" in db.list_collection_names())
+        self.assertNotIn("test", db.list_collection_names())
 
         db.test.insert_one({"dummy": "object"})
-        self.assertTrue("test" in db.list_collection_names())
+        self.assertIn("test", db.list_collection_names())
         db.drop_collection("test")
-        self.assertFalse("test" in db.list_collection_names())
+        self.assertNotIn("test", db.list_collection_names())
 
         db.test.insert_one({"dummy": "object"})
-        self.assertTrue("test" in db.list_collection_names())
+        self.assertIn("test", db.list_collection_names())
         db.drop_collection(db.test)
-        self.assertFalse("test" in db.list_collection_names())
+        self.assertNotIn("test", db.list_collection_names())
 
         db.test.insert_one({"dummy": "object"})
-        self.assertTrue("test" in db.list_collection_names())
+        self.assertIn("test", db.list_collection_names())
         db.test.drop()
-        self.assertFalse("test" in db.list_collection_names())
+        self.assertNotIn("test", db.list_collection_names())
         db.test.drop()
 
         db.drop_collection(db.test.doesnotexist)
diff --git a/test/test_examples.py b/test/test_examples.py
index 0585d1e057..bda5403200 100644
--- a/test/test_examples.py
+++ b/test/test_examples.py
@@ -479,77 +479,77 @@ def test_projection(self):
         # End Example 44
 
         for doc in cursor:
-            self.assertTrue("_id" in doc)
-            self.assertTrue("item" in doc)
-            self.assertTrue("status" in doc)
-            self.assertFalse("size" in doc)
-            self.assertFalse("instock" in doc)
+            self.assertIn("_id", doc)
+            self.assertIn("item", doc)
+            self.assertIn("status", doc)
+            self.assertNotIn("size", doc)
+            self.assertNotIn("instock", doc)
 
         # Start Example 45
         cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "_id": 0})
         # End Example 45
 
         for doc in cursor:
-            self.assertFalse("_id" in doc)
-            self.assertTrue("item" in doc)
-            self.assertTrue("status" in doc)
-            self.assertFalse("size" in doc)
-            self.assertFalse("instock" in doc)
+            self.assertNotIn("_id", doc)
+            self.assertIn("item", doc)
+            self.assertIn("status", doc)
+            self.assertNotIn("size", doc)
+            self.assertNotIn("instock", doc)
 
         # Start Example 46
         cursor = db.inventory.find({"status": "A"}, {"status": 0, "instock": 0})
         # End Example 46
 
         for doc in cursor:
-            self.assertTrue("_id" in doc)
-            self.assertTrue("item" in doc)
-            self.assertFalse("status" in doc)
-            self.assertTrue("size" in doc)
-            self.assertFalse("instock" in doc)
+            self.assertIn("_id", doc)
+            self.assertIn("item", doc)
+            self.assertNotIn("status", doc)
+            self.assertIn("size", doc)
+            self.assertNotIn("instock", doc)
 
         # Start Example 47
         cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "size.uom": 1})
         # End Example 47
 
         for doc in cursor:
-            self.assertTrue("_id" in doc)
-            self.assertTrue("item" in doc)
-            self.assertTrue("status" in doc)
-            self.assertTrue("size" in doc)
-            self.assertFalse("instock" in doc)
+            self.assertIn("_id", doc)
+            self.assertIn("item", doc)
+            self.assertIn("status", doc)
+            self.assertIn("size", doc)
+            self.assertNotIn("instock", doc)
             size = doc["size"]
-            self.assertTrue("uom" in size)
-            self.assertFalse("h" in size)
-            self.assertFalse("w" in size)
+            self.assertIn("uom", size)
+            self.assertNotIn("h", size)
+            self.assertNotIn("w", size)
 
         # Start Example 48
         cursor = db.inventory.find({"status": "A"}, {"size.uom": 0})
         # End Example 48
 
         for doc in cursor:
-            self.assertTrue("_id" in doc)
-            self.assertTrue("item" in doc)
-            self.assertTrue("status" in doc)
-            self.assertTrue("size" in doc)
-            self.assertTrue("instock" in doc)
+            self.assertIn("_id", doc)
+            self.assertIn("item", doc)
+            self.assertIn("status", doc)
+            self.assertIn("size", doc)
+            self.assertIn("instock", doc)
             size = doc["size"]
-            self.assertFalse("uom" in size)
-            self.assertTrue("h" in size)
-            self.assertTrue("w" in size)
+            self.assertNotIn("uom", size)
+            self.assertIn("h", size)
+            self.assertIn("w", size)
 
         # Start Example 49
         cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "instock.qty": 1})
         # End Example 49
 
         for doc in cursor:
-            self.assertTrue("_id" in doc)
-            self.assertTrue("item" in doc)
-            self.assertTrue("status" in doc)
-            self.assertFalse("size" in doc)
-            self.assertTrue("instock" in doc)
+            self.assertIn("_id", doc)
+            self.assertIn("item", doc)
+            self.assertIn("status", doc)
+            self.assertNotIn("size", doc)
+            self.assertIn("instock", doc)
             for subdoc in doc["instock"]:
-                self.assertFalse("warehouse" in subdoc)
-                self.assertTrue("qty" in subdoc)
+                self.assertNotIn("warehouse", subdoc)
+                self.assertIn("qty", subdoc)
 
         # Start Example 50
         cursor = db.inventory.find(
@@ -558,11 +558,11 @@ def test_projection(self):
         # End Example 50
 
         for doc in cursor:
-            self.assertTrue("_id" in doc)
-            self.assertTrue("item" in doc)
-            self.assertTrue("status" in doc)
-            self.assertFalse("size" in doc)
-            self.assertTrue("instock" in doc)
+            self.assertIn("_id", doc)
+            self.assertIn("item", doc)
+            self.assertIn("status", doc)
+            self.assertNotIn("size", doc)
+            self.assertIn("instock", doc)
             self.assertEqual(len(doc["instock"]), 1)
 
     def test_update_and_replace(self):
@@ -645,7 +645,7 @@ def test_update_and_replace(self):
         for doc in db.inventory.find({"item": "paper"}):
             self.assertEqual(doc["size"]["uom"], "cm")
             self.assertEqual(doc["status"], "P")
-            self.assertTrue("lastModified" in doc)
+            self.assertIn("lastModified", doc)
 
         # Start Example 53
         db.inventory.update_many(
@@ -657,7 +657,7 @@ def test_update_and_replace(self):
         for doc in db.inventory.find({"qty": {"$lt": 50}}):
             self.assertEqual(doc["size"]["uom"], "in")
             self.assertEqual(doc["status"], "P")
-            self.assertTrue("lastModified" in doc)
+            self.assertIn("lastModified", doc)
 
         # Start Example 54
         db.inventory.replace_one(
@@ -671,8 +671,8 @@ def test_update_and_replace(self):
 
         for doc in db.inventory.find({"item": "paper"}, {"_id": 0}):
             self.assertEqual(len(doc.keys()), 2)
-            self.assertTrue("item" in doc)
-            self.assertTrue("instock" in doc)
+            self.assertIn("item", doc)
+            self.assertIn("instock", doc)
             self.assertEqual(len(doc["instock"]), 2)
 
     def test_delete(self):
diff --git a/test/test_json_util_integration.py b/test/test_json_util_integration.py
index acab4f3182..4ef5f10fe2 100644
--- a/test/test_json_util_integration.py
+++ b/test/test_json_util_integration.py
@@ -25,4 +25,4 @@ def test_cursor(self):
         db.test.insert_many(docs)
         reloaded_docs = json_util.loads(json_util.dumps((db.test.find()).to_list()))
         for doc in docs:
-            self.assertTrue(doc in reloaded_docs)
+            self.assertIn(doc, reloaded_docs)
diff --git a/test/test_monitoring.py b/test/test_monitoring.py
index fc8be127e3..8b54793a36 100644
--- a/test/test_monitoring.py
+++ b/test/test_monitoring.py
@@ -1086,8 +1086,8 @@ def test_first_batch_helper(self):
         self.assertEqual(started.command_name, succeeded.command_name)
         self.assertEqual(started.request_id, succeeded.request_id)
         self.assertEqual(started.connection_id, succeeded.connection_id)
-        self.assertTrue("cursor" in succeeded.reply)
-        self.assertTrue("ok" in succeeded.reply)
+        self.assertIn("cursor", succeeded.reply)
+        self.assertIn("ok", succeeded.reply)
 
         self.listener.reset()
 
diff --git a/test/test_session.py b/test/test_session.py
index a6266884aa..49cb9dba91 100644
--- a/test/test_session.py
+++ b/test/test_session.py
@@ -134,8 +134,9 @@ def _test_ops(self, client, *ops):
                 f(*args, **kw)
                 self.assertGreaterEqual(len(listener.started_events), 1)
                 for event in listener.started_events:
-                    self.assertTrue(
-                        "lsid" in event.command,
+                    self.assertIn(
+                        "lsid",
+                        event.command,
                         f"{f.__name__} sent no lsid with {event.command_name}",
                     )
 
@@ -170,8 +171,9 @@ def _test_ops(self, client, *ops):
             self.assertGreaterEqual(len(listener.started_events), 1)
             lsids = []
             for event in listener.started_events:
-                self.assertTrue(
-                    "lsid" in event.command,
+                self.assertIn(
+                    "lsid",
+                    event.command,
                     f"{f.__name__} sent no lsid with {event.command_name}",
                 )
 
@@ -422,8 +424,9 @@ def test_cursor(self):
                 f(session=s)
                 self.assertGreaterEqual(len(listener.started_events), 1)
                 for event in listener.started_events:
-                    self.assertTrue(
-                        "lsid" in event.command,
+                    self.assertIn(
+                        "lsid",
+                        event.command,
                         f"{name} sent no lsid with {event.command_name}",
                     )
 
@@ -441,15 +444,13 @@ def test_cursor(self):
             listener.reset()
             f(session=None)
             event0 = listener.first_command_started()
-            self.assertTrue(
-                "lsid" in event0.command, f"{name} sent no lsid with {event0.command_name}"
-            )
+            self.assertIn("lsid", event0.command, f"{name} sent no lsid with {event0.command_name}")
 
             lsid = event0.command["lsid"]
 
             for event in listener.started_events[1:]:
-                self.assertTrue(
-                    "lsid" in event.command, f"{name} sent no lsid with {event.command_name}"
+                self.assertIn(
+                    "lsid", event.command, f"{name} sent no lsid with {event.command_name}"
                 )
 
                 self.assertEqual(
@@ -1187,15 +1188,17 @@ def aggregate():
 
             self.assertGreaterEqual(len(listener.started_events), 1)
             for i, event in enumerate(listener.started_events):
-                self.assertTrue(
-                    "$clusterTime" in event.command,
+                self.assertIn(
+                    "$clusterTime",
+                    event.command,
                     f"{f.__name__} sent no $clusterTime with {event.command_name}",
                 )
 
                 if i > 0:
                     succeeded = listener.succeeded_events[i - 1]
-                    self.assertTrue(
-                        "$clusterTime" in succeeded.reply,
+                    self.assertIn(
+                        "$clusterTime",
+                        succeeded.reply,
                         f"{f.__name__} received no $clusterTime with {succeeded.command_name}",
                     )
 
diff --git a/test/test_son.py b/test/test_son.py
index a06d92bcb2..36a6834889 100644
--- a/test/test_son.py
+++ b/test/test_son.py
@@ -148,8 +148,8 @@ def test_contains_has(self):
         """has_key and __contains__"""
         test_son = SON([(1, 100), (2, 200), (3, 300)])
         self.assertIn(1, test_son)
-        self.assertTrue(2 in test_son, "in failed")
-        self.assertFalse(22 in test_son, "in succeeded when it shouldn't")
+        self.assertIn(2, test_son, "in failed")
+        self.assertNotIn(22, test_son, "in succeeded when it shouldn't")
         self.assertTrue(test_son.has_key(2), "has_key failed")
         self.assertFalse(test_son.has_key(22), "has_key succeeded when it shouldn't")