PYTHON-5262 Better test assertions for isinstance

test/asynchronous/test_bulk.py

@@ -281,7 +281,7 @@ async def test_upsert(self):
         self.assertEqual(1, result.upserted_count)
         assert result.upserted_ids is not None
         self.assertEqual(1, len(result.upserted_ids))
-        self.assertTrue(isinstance(result.upserted_ids.get(0), ObjectId))
+        self.assertIsInstance(result.upserted_ids.get(0), ObjectId)
 
         self.assertEqual(await self.coll.count_documents({"foo": "bar"}), 1)
 
@@ -998,7 +998,7 @@ async def test_write_concern_failure_ordered(self):
 
         failed = details["writeConcernErrors"][0]
         self.assertEqual(64, failed["code"])
-        self.assertTrue(isinstance(failed["errmsg"], str))
+        self.assertIsInstance(failed["errmsg"], str)
 
         await self.coll.delete_many({})
         await self.coll.create_index("a", unique=True)
@@ -1105,12 +1105,12 @@ async def test_write_concern_failure_unordered(self):
         failed = details["writeErrors"][0]
         self.assertEqual(2, failed["index"])
         self.assertEqual(11000, failed["code"])
-        self.assertTrue(isinstance(failed["errmsg"], str))
+        self.assertIsInstance(failed["errmsg"], str)
         self.assertEqual(1, failed["op"]["a"])
 
         failed = details["writeConcernErrors"][0]
         self.assertEqual(64, failed["code"])
-        self.assertTrue(isinstance(failed["errmsg"], str))
+        self.assertIsInstance(failed["errmsg"], str)
 
         upserts = details["upserted"]
         self.assertEqual(1, len(upserts))

test/asynchronous/test_client.py

@@ -214,7 +214,7 @@ def make_db(base, name):
         self.assertRaises(InvalidName, make_db, self.client, "te/t")
         self.assertRaises(InvalidName, make_db, self.client, "te st")
 
-        self.assertTrue(isinstance(self.client.test, AsyncDatabase))
+        self.assertIsInstance(self.client.test, AsyncDatabase)
         self.assertEqual(self.client.test, self.client["test"])
         self.assertEqual(self.client.test, AsyncDatabase(self.client, "test"))
 
@@ -228,7 +228,7 @@ def test_get_database(self):
         self.assertEqual(write_concern, db.write_concern)
 
     def test_getattr(self):
-        self.assertTrue(isinstance(self.client["_does_not_exist"], AsyncDatabase))
+        self.assertIsInstance(self.client["_does_not_exist"], AsyncDatabase)
 
         with self.assertRaises(AttributeError) as context:
             self.client._does_not_exist
@@ -1274,15 +1274,15 @@ async def test_document_class(self):
         await db.test.insert_one({"x": 1})
 
         self.assertEqual(dict, c.codec_options.document_class)
-        self.assertTrue(isinstance(await db.test.find_one(), dict))
-        self.assertFalse(isinstance(await db.test.find_one(), SON))
+        self.assertIsInstance(await db.test.find_one(), dict)
+        self.assertNotIsInstance(await db.test.find_one(), SON)
 
         c = await self.async_rs_or_single_client(document_class=SON)
 
         db = c.pymongo_test
 
         self.assertEqual(SON, c.codec_options.document_class)
-        self.assertTrue(isinstance(await db.test.find_one(), SON))
+        self.assertIsInstance(await db.test.find_one(), SON)
 
     async def test_timeouts(self):
         client = await self.async_rs_or_single_client(

test/asynchronous/test_cursor.py

@@ -959,7 +959,7 @@ async def test_clone(self):
         cursor = self.db.test.find().hint([("z", 1), ("a", 1)])
         cursor2 = copy.deepcopy(cursor)
         # Internal types are now dict rather than SON by default
-        self.assertTrue(isinstance(cursor2._hint, dict))
+        self.assertIsInstance(cursor2._hint, dict)
         self.assertEqual(cursor._hint, cursor2._hint)
 
     @async_client_context.require_sync

test/asynchronous/test_custom_types.py

@@ -793,7 +793,7 @@ async def test_grid_out_custom_opts(self):
         self.assertEqual(5, two._id)
         self.assertEqual(11, two.length)
         self.assertEqual(1000, two.chunk_size)
-        self.assertTrue(isinstance(two.upload_date, datetime.datetime))
+        self.assertIsInstance(two.upload_date, datetime.datetime)
         self.assertEqual({"foo": "red", "bar": "blue"}, two.metadata)
         self.assertEqual(3, two.bar)
 

test/asynchronous/test_database.py

@@ -91,7 +91,7 @@ def test_get_collection(self):
 
     def test_getattr(self):
         db = self.client.pymongo_test
-        self.assertTrue(isinstance(db["_does_not_exist"], AsyncCollection))
+        self.assertIsInstance(db["_does_not_exist"], AsyncCollection)
 
         with self.assertRaises(AttributeError) as context:
             db._does_not_exist
@@ -428,7 +428,7 @@ async def test_command_with_regex(self):
 
         result = await db.command("aggregate", "test", pipeline=[], cursor={})
         for doc in result["cursor"]["firstBatch"]:
-            self.assertTrue(isinstance(doc["r"], Regex))
+            self.assertIsInstance(doc["r"], Regex)
 
     async def test_command_bulkWrite(self):
         # Ensure bulk write commands can be run directly via db.command().
@@ -472,7 +472,7 @@ def test_password_digest(self):
         with self.assertRaises(TypeError):
             auth._password_digest(None)  # type: ignore[arg-type, call-arg]
 
-        self.assertTrue(isinstance(auth._password_digest("mike", "password"), str))
+        self.assertIsInstance(auth._password_digest("mike", "password"), str)
         self.assertEqual(
             auth._password_digest("mike", "password"), "cd7e45b3b2767dc2fa9b6b548457ed00"
         )
@@ -543,7 +543,7 @@ async def test_insert_find_one(self):
 
         a_doc = SON({"hello": "world"})
         a_key = (await db.test.insert_one(a_doc)).inserted_id
-        self.assertTrue(isinstance(a_doc["_id"], ObjectId))
+        self.assertIsInstance(a_doc["_id"], ObjectId)
         self.assertEqual(a_doc["_id"], a_key)
         self.assertEqual(a_doc, await db.test.find_one({"_id": a_doc["_id"]}))
         self.assertEqual(a_doc, await db.test.find_one(a_key))

test/asynchronous/test_encryption.py

@@ -2469,16 +2469,16 @@ async def asyncSetUp(self):
 
         await encrypted_client.db.csfle.insert_one({"csfle": "csfle"})
         doc = await unencrypted_client.db.csfle.find_one()
-        self.assertTrue(isinstance(doc["csfle"], Binary))
+        self.assertIsInstance(doc["csfle"], Binary)
         await encrypted_client.db.csfle2.insert_one({"csfle2": "csfle2"})
         doc = await unencrypted_client.db.csfle2.find_one()
-        self.assertTrue(isinstance(doc["csfle2"], Binary))
+        self.assertIsInstance(doc["csfle2"], Binary)
         await encrypted_client.db.qe.insert_one({"qe": "qe"})
         doc = await unencrypted_client.db.qe.find_one()
-        self.assertTrue(isinstance(doc["qe"], Binary))
+        self.assertIsInstance(doc["qe"], Binary)
         await encrypted_client.db.qe2.insert_one({"qe2": "qe2"})
         doc = await unencrypted_client.db.qe2.find_one()
-        self.assertTrue(isinstance(doc["qe2"], Binary))
+        self.assertIsInstance(doc["qe2"], Binary)
         await encrypted_client.db.no_schema.insert_one({"no_schema": "no_schema"})
         await encrypted_client.db.no_schema2.insert_one({"no_schema2": "no_schema2"})
 

test/asynchronous/test_grid_file.py

@@ -150,7 +150,7 @@ async def test_grid_in_default_opts(self):
 
         a = AsyncGridIn(self.db.fs)
 
-        self.assertTrue(isinstance(a._id, ObjectId))
+        self.assertIsInstance(a._id, ObjectId)
         self.assertRaises(AttributeError, setattr, a, "_id", 5)
 
         self.assertEqual(None, a.filename)
@@ -195,7 +195,7 @@ async def test_grid_in_default_opts(self):
 
         self.assertEqual(42, a.forty_two)
 
-        self.assertTrue(isinstance(a._id, ObjectId))
+        self.assertIsInstance(a._id, ObjectId)
         self.assertRaises(AttributeError, setattr, a, "_id", 5)
 
         self.assertEqual("my_file", a.filename)
@@ -209,7 +209,7 @@ async def test_grid_in_default_opts(self):
         self.assertEqual(255 * 1024, a.chunk_size)
         self.assertRaises(AttributeError, setattr, a, "chunk_size", 5)
 
-        self.assertTrue(isinstance(a.upload_date, datetime.datetime))
+        self.assertIsInstance(a.upload_date, datetime.datetime)
         self.assertRaises(AttributeError, setattr, a, "upload_date", 5)
 
         self.assertEqual(["foo"], a.aliases)
@@ -248,7 +248,7 @@ async def test_grid_out_default_opts(self):
         self.assertEqual(None, b.name)
         self.assertEqual(None, b.filename)
         self.assertEqual(255 * 1024, b.chunk_size)
-        self.assertTrue(isinstance(b.upload_date, datetime.datetime))
+        self.assertIsInstance(b.upload_date, datetime.datetime)
         self.assertEqual(None, b.aliases)
         self.assertEqual(None, b.metadata)
         self.assertEqual(None, b.md5)
@@ -309,7 +309,7 @@ async def test_grid_out_custom_opts(self):
         self.assertEqual(11, two.length)
         self.assertEqual("text/html", two.content_type)
         self.assertEqual(1000, two.chunk_size)
-        self.assertTrue(isinstance(two.upload_date, datetime.datetime))
+        self.assertIsInstance(two.upload_date, datetime.datetime)
         self.assertEqual(["foo"], two.aliases)
         self.assertEqual({"foo": 1, "bar": 2}, two.metadata)
         self.assertEqual(3, two.bar)

test/asynchronous/test_gridfs.py

@@ -157,7 +157,7 @@ async def test_empty_file(self):
         assert raw is not None
         self.assertEqual(0, raw["length"])
         self.assertEqual(oid, raw["_id"])
-        self.assertTrue(isinstance(raw["uploadDate"], datetime.datetime))
+        self.assertIsInstance(raw["uploadDate"], datetime.datetime)
         self.assertEqual(255 * 1024, raw["chunkSize"])
         self.assertNotIn("md5", raw)
 

test/asynchronous/test_gridfs_bucket.py

@@ -136,7 +136,7 @@ async def test_empty_file(self):
         assert raw is not None
         self.assertEqual(0, raw["length"])
         self.assertEqual(oid, raw["_id"])
-        self.assertTrue(isinstance(raw["uploadDate"], datetime.datetime))
+        self.assertIsInstance(raw["uploadDate"], datetime.datetime)
         self.assertEqual(255 * 1024, raw["chunkSize"])
         self.assertNotIn("md5", raw)