From 1bb2190d748d56dee82abef2dcc76b1a98f66960 Mon Sep 17 00:00:00 2001 From: Iris Ho Date: Wed, 21 May 2025 12:36:47 -0700 Subject: [PATCH] better test assertions for isinstance --- test/asynchronous/test_bulk.py | 8 +- test/asynchronous/test_client.py | 10 +- test/asynchronous/test_collection.py | 100 ++++++++--------- test/asynchronous/test_cursor.py | 2 +- test/asynchronous/test_custom_types.py | 2 +- test/asynchronous/test_database.py | 8 +- test/asynchronous/test_encryption.py | 8 +- test/asynchronous/test_grid_file.py | 10 +- test/asynchronous/test_gridfs.py | 2 +- test/asynchronous/test_gridfs_bucket.py | 2 +- test/asynchronous/test_monitoring.py | 142 ++++++++++++------------ test/test_binary.py | 4 +- test/test_bson.py | 4 +- test/test_bulk.py | 8 +- test/test_client.py | 10 +- test/test_code.py | 4 +- test/test_collection.py | 100 ++++++++--------- test/test_cursor.py | 2 +- test/test_custom_types.py | 2 +- test/test_database.py | 8 +- test/test_encryption.py | 8 +- test/test_grid_file.py | 10 +- test/test_gridfs.py | 2 +- test/test_gridfs_bucket.py | 2 +- test/test_monitoring.py | 142 ++++++++++++------------ 25 files changed, 300 insertions(+), 300 deletions(-) diff --git a/test/asynchronous/test_bulk.py b/test/asynchronous/test_bulk.py index 65ed6e236a..7c6f032e81 100644 --- a/test/asynchronous/test_bulk.py +++ b/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)) diff --git a/test/asynchronous/test_client.py b/test/asynchronous/test_client.py index 1e1faf0a2a..4d247009e5 100644 --- a/test/asynchronous/test_client.py +++ b/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( diff --git a/test/asynchronous/test_collection.py b/test/asynchronous/test_collection.py index 00ed020d88..9367c43a0b 100644 --- a/test/asynchronous/test_collection.py +++ b/test/asynchronous/test_collection.py @@ -111,7 +111,7 @@ def make_col(base, name): def test_getattr(self): coll = self.db.test - self.assertTrue(isinstance(coll["_does_not_exist"], AsyncCollection)) + self.assertIsInstance(coll["_does_not_exist"], AsyncCollection) with self.assertRaises(AttributeError) as context: coll._does_not_exist @@ -176,7 +176,7 @@ def write_concern_collection(self): yield self.db.test async def test_equality(self): - self.assertTrue(isinstance(self.db.test, AsyncCollection)) + self.assertIsInstance(self.db.test, AsyncCollection) self.assertEqual(self.db.test, self.db["test"]) self.assertEqual(self.db.test, AsyncCollection(self.db, "test")) self.assertEqual(self.db.test.mike, self.db["test.mike"]) @@ -718,8 +718,8 @@ async def test_insert_one(self): document: dict[str, Any] = {"_id": 1000} result = await db.test.insert_one(document) - self.assertTrue(isinstance(result, InsertOneResult)) - self.assertTrue(isinstance(result.inserted_id, int)) + self.assertIsInstance(result, InsertOneResult) + self.assertIsInstance(result.inserted_id, int) self.assertEqual(document["_id"], result.inserted_id) self.assertTrue(result.acknowledged) self.assertIsNotNone(await db.test.find_one({"_id": document["_id"]})) @@ -727,8 +727,8 @@ async def test_insert_one(self): document = {"foo": "bar"} result = await db.test.insert_one(document) - self.assertTrue(isinstance(result, InsertOneResult)) - self.assertTrue(isinstance(result.inserted_id, ObjectId)) + self.assertIsInstance(result, InsertOneResult) + self.assertIsInstance(result.inserted_id, ObjectId) self.assertEqual(document["_id"], result.inserted_id) self.assertTrue(result.acknowledged) self.assertIsNotNone(await db.test.find_one({"_id": document["_id"]})) @@ -736,8 +736,8 @@ async def test_insert_one(self): db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) result = await db.test.insert_one(document) - self.assertTrue(isinstance(result, InsertOneResult)) - self.assertTrue(isinstance(result.inserted_id, ObjectId)) + self.assertIsInstance(result, InsertOneResult) + self.assertIsInstance(result.inserted_id, ObjectId) self.assertEqual(document["_id"], result.inserted_id) self.assertFalse(result.acknowledged) # The insert failed duplicate key... @@ -749,7 +749,7 @@ async def async_lambda(): document = RawBSONDocument(encode({"_id": ObjectId(), "foo": "bar"})) result = await db.test.insert_one(document) - self.assertTrue(isinstance(result, InsertOneResult)) + self.assertIsInstance(result, InsertOneResult) self.assertEqual(result.inserted_id, None) async def test_insert_many(self): @@ -758,38 +758,38 @@ async def test_insert_many(self): docs: list = [{} for _ in range(5)] result = await db.test.insert_many(docs) - self.assertTrue(isinstance(result, InsertManyResult)) - self.assertTrue(isinstance(result.inserted_ids, list)) + self.assertIsInstance(result, InsertManyResult) + self.assertIsInstance(result.inserted_ids, list) self.assertEqual(5, len(result.inserted_ids)) for doc in docs: _id = doc["_id"] - self.assertTrue(isinstance(_id, ObjectId)) + self.assertIsInstance(_id, ObjectId) self.assertTrue(_id in result.inserted_ids) self.assertEqual(1, await db.test.count_documents({"_id": _id})) self.assertTrue(result.acknowledged) docs = [{"_id": i} for i in range(5)] result = await db.test.insert_many(docs) - self.assertTrue(isinstance(result, InsertManyResult)) - self.assertTrue(isinstance(result.inserted_ids, list)) + self.assertIsInstance(result, InsertManyResult) + self.assertIsInstance(result.inserted_ids, list) self.assertEqual(5, len(result.inserted_ids)) for doc in docs: _id = doc["_id"] - self.assertTrue(isinstance(_id, int)) + self.assertIsInstance(_id, int) self.assertTrue(_id in result.inserted_ids) self.assertEqual(1, await db.test.count_documents({"_id": _id})) self.assertTrue(result.acknowledged) docs = [RawBSONDocument(encode({"_id": i + 5})) for i in range(5)] result = await db.test.insert_many(docs) - self.assertTrue(isinstance(result, InsertManyResult)) - self.assertTrue(isinstance(result.inserted_ids, list)) + self.assertIsInstance(result, InsertManyResult) + self.assertIsInstance(result.inserted_ids, list) self.assertEqual([], result.inserted_ids) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) docs: list = [{} for _ in range(5)] result = await db.test.insert_many(docs) - self.assertTrue(isinstance(result, InsertManyResult)) + self.assertIsInstance(result, InsertManyResult) self.assertFalse(result.acknowledged) self.assertEqual(20, await db.test.count_documents({})) @@ -830,20 +830,20 @@ async def test_delete_one(self): await self.db.test.insert_one({"z": 1}) result = await self.db.test.delete_one({"x": 1}) - self.assertTrue(isinstance(result, DeleteResult)) + self.assertIsInstance(result, DeleteResult) self.assertEqual(1, result.deleted_count) self.assertTrue(result.acknowledged) self.assertEqual(2, await self.db.test.count_documents({})) result = await self.db.test.delete_one({"y": 1}) - self.assertTrue(isinstance(result, DeleteResult)) + self.assertIsInstance(result, DeleteResult) self.assertEqual(1, result.deleted_count) self.assertTrue(result.acknowledged) self.assertEqual(1, await self.db.test.count_documents({})) db = self.db.client.get_database(self.db.name, write_concern=WriteConcern(w=0)) result = await db.test.delete_one({"z": 1}) - self.assertTrue(isinstance(result, DeleteResult)) + self.assertIsInstance(result, DeleteResult) self.assertRaises(InvalidOperation, lambda: result.deleted_count) self.assertFalse(result.acknowledged) @@ -861,14 +861,14 @@ async def test_delete_many(self): await self.db.test.insert_one({"y": 1}) result = await self.db.test.delete_many({"x": 1}) - self.assertTrue(isinstance(result, DeleteResult)) + self.assertIsInstance(result, DeleteResult) self.assertEqual(2, result.deleted_count) self.assertTrue(result.acknowledged) self.assertEqual(0, await self.db.test.count_documents({"x": 1})) db = self.db.client.get_database(self.db.name, write_concern=WriteConcern(w=0)) result = await db.test.delete_many({"y": 1}) - self.assertTrue(isinstance(result, DeleteResult)) + self.assertIsInstance(result, DeleteResult) self.assertRaises(InvalidOperation, lambda: result.deleted_count) self.assertFalse(result.acknowledged) @@ -920,10 +920,10 @@ async def test_insert_bypass_document_validation(self): with self.assertRaises(OperationFailure): await db.test.insert_one({"_id": 1, "x": 100}) result = await db.test.insert_one({"_id": 1, "x": 100}, bypass_document_validation=True) - self.assertTrue(isinstance(result, InsertOneResult)) + self.assertIsInstance(result, InsertOneResult) self.assertEqual(1, result.inserted_id) result = await db.test.insert_one({"_id": 2, "a": 0}) - self.assertTrue(isinstance(result, InsertOneResult)) + self.assertIsInstance(result, InsertOneResult) self.assertEqual(2, result.inserted_id) await db_w0.test.insert_one({"y": 1}, bypass_document_validation=True) @@ -938,21 +938,21 @@ async def async_lambda(): with self.assertRaises(OperationFailure): await db.test.insert_many(docs) result = await db.test.insert_many(docs, bypass_document_validation=True) - self.assertTrue(isinstance(result, InsertManyResult)) + self.assertIsInstance(result, InsertManyResult) self.assertTrue(97, len(result.inserted_ids)) for doc in docs: _id = doc["_id"] - self.assertTrue(isinstance(_id, int)) + self.assertIsInstance(_id, int) self.assertTrue(_id in 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)] result = await db.test.insert_many(docs) - self.assertTrue(isinstance(result, InsertManyResult)) + self.assertIsInstance(result, InsertManyResult) self.assertTrue(97, len(result.inserted_ids)) for doc in docs: _id = doc["_id"] - self.assertTrue(isinstance(_id, int)) + self.assertIsInstance(_id, int) self.assertTrue(_id in result.inserted_ids) self.assertEqual(1, await db.test.count_documents({"a": doc["a"]})) self.assertTrue(result.acknowledged) @@ -1182,7 +1182,7 @@ async def test_id_can_be_anything(self): await db.test.delete_many({}) auto_id = {"hello": "world"} await db.test.insert_one(auto_id) - self.assertTrue(isinstance(auto_id["_id"], ObjectId)) + self.assertIsInstance(auto_id["_id"], ObjectId) numeric = {"_id": 240, "hello": "world"} await db.test.insert_one(numeric) @@ -1346,7 +1346,7 @@ async def test_replace_one(self): id1 = (await db.test.insert_one({"x": 1})).inserted_id result = await db.test.replace_one({"x": 1}, {"y": 1}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) self.assertTrue(result.modified_count in (None, 1)) self.assertIsNone(result.upserted_id) @@ -1357,7 +1357,7 @@ async def test_replace_one(self): replacement = RawBSONDocument(encode({"_id": id1, "z": 1})) result = await db.test.replace_one({"y": 1}, replacement, True) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) self.assertTrue(result.modified_count in (None, 1)) self.assertIsNone(result.upserted_id) @@ -1367,16 +1367,16 @@ async def test_replace_one(self): self.assertEqual((await db.test.find_one(id1))["z"], 1) # type: ignore result = await db.test.replace_one({"x": 2}, {"y": 2}, True) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(0, result.matched_count) self.assertTrue(result.modified_count in (None, 0)) - self.assertTrue(isinstance(result.upserted_id, ObjectId)) + self.assertIsInstance(result.upserted_id, ObjectId) self.assertTrue(result.acknowledged) self.assertEqual(1, await db.test.count_documents({"y": 2})) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) result = await db.test.replace_one({"x": 0}, {"y": 0}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertRaises(InvalidOperation, lambda: result.matched_count) self.assertRaises(InvalidOperation, lambda: result.modified_count) self.assertRaises(InvalidOperation, lambda: result.upserted_id) @@ -1391,7 +1391,7 @@ async def test_update_one(self): id1 = (await db.test.insert_one({"x": 5})).inserted_id result = await db.test.update_one({}, {"$inc": {"x": 1}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) self.assertTrue(result.modified_count in (None, 1)) self.assertIsNone(result.upserted_id) @@ -1400,7 +1400,7 @@ async def test_update_one(self): id2 = (await db.test.insert_one({"x": 1})).inserted_id result = await db.test.update_one({"x": 6}, {"$inc": {"x": 1}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) self.assertTrue(result.modified_count in (None, 1)) self.assertIsNone(result.upserted_id) @@ -1409,15 +1409,15 @@ async def test_update_one(self): self.assertEqual((await db.test.find_one(id2))["x"], 1) # type: ignore result = await db.test.update_one({"x": 2}, {"$set": {"y": 1}}, True) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(0, result.matched_count) self.assertTrue(result.modified_count in (None, 0)) - self.assertTrue(isinstance(result.upserted_id, ObjectId)) + self.assertIsInstance(result.upserted_id, ObjectId) self.assertTrue(result.acknowledged) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) result = await db.test.update_one({"x": 0}, {"$inc": {"x": 1}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertRaises(InvalidOperation, lambda: result.matched_count) self.assertRaises(InvalidOperation, lambda: result.modified_count) self.assertRaises(InvalidOperation, lambda: result.upserted_id) @@ -1448,7 +1448,7 @@ async def test_update_many(self): await db.test.insert_one({"x": 4, "y": 4}) result = await db.test.update_many({"x": 4}, {"$set": {"y": 5}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(2, result.matched_count) self.assertTrue(result.modified_count in (None, 2)) self.assertIsNone(result.upserted_id) @@ -1456,7 +1456,7 @@ async def test_update_many(self): self.assertEqual(3, await db.test.count_documents({"y": 5})) result = await db.test.update_many({"x": 5}, {"$set": {"y": 6}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) self.assertTrue(result.modified_count in (None, 1)) self.assertIsNone(result.upserted_id) @@ -1464,15 +1464,15 @@ async def test_update_many(self): self.assertEqual(1, await db.test.count_documents({"y": 6})) result = await db.test.update_many({"x": 2}, {"$set": {"y": 1}}, True) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(0, result.matched_count) self.assertTrue(result.modified_count in (None, 0)) - self.assertTrue(isinstance(result.upserted_id, ObjectId)) + self.assertIsInstance(result.upserted_id, ObjectId) self.assertTrue(result.acknowledged) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) result = await db.test.update_many({"x": 0}, {"$inc": {"x": 1}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertRaises(InvalidOperation, lambda: result.matched_count) self.assertRaises(InvalidOperation, lambda: result.modified_count) self.assertRaises(InvalidOperation, lambda: result.upserted_id) @@ -1556,7 +1556,7 @@ async def test_aggregate(self): pipeline = {"$project": {"_id": False, "foo": True}} result = await db.test.aggregate([pipeline]) - self.assertTrue(isinstance(result, AsyncCommandCursor)) + self.assertIsInstance(result, AsyncCommandCursor) self.assertEqual([{"foo": [1, 2]}], await result.to_list()) # Test write concern. @@ -1574,7 +1574,7 @@ async def test_aggregate_raw_bson(self): pipeline = {"$project": {"_id": False, "foo": True}} coll = db.get_collection("test", codec_options=CodecOptions(document_class=RawBSONDocument)) result = await coll.aggregate([pipeline]) - self.assertTrue(isinstance(result, AsyncCommandCursor)) + self.assertIsInstance(result, AsyncCommandCursor) first_result = await anext(result) self.assertIsInstance(first_result, RawBSONDocument) self.assertEqual([1, 2], list(first_result["foo"])) @@ -1583,7 +1583,7 @@ async def test_aggregation_cursor_validation(self): db = self.db projection = {"$project": {"_id": "$_id"}} cursor = await db.test.aggregate([projection], cursor={}) - self.assertTrue(isinstance(cursor, AsyncCommandCursor)) + self.assertIsInstance(cursor, AsyncCommandCursor) async def test_aggregation_cursor(self): db = self.db @@ -2208,9 +2208,9 @@ async def test_find_regex(self): await c.drop() await c.insert_one({"r": re.compile(".*")}) - self.assertTrue(isinstance((await c.find_one())["r"], Regex)) # type: ignore + self.assertIsInstance((await c.find_one())["r"], Regex) # type: ignore async for doc in c.find(): - self.assertTrue(isinstance(doc["r"], Regex)) + self.assertIsInstance(doc["r"], Regex) def test_find_command_generation(self): cmd = _gen_find_command( diff --git a/test/asynchronous/test_cursor.py b/test/asynchronous/test_cursor.py index 3c8570f336..5e4e590fef 100644 --- a/test/asynchronous/test_cursor.py +++ b/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 diff --git a/test/asynchronous/test_custom_types.py b/test/asynchronous/test_custom_types.py index 0ab9e95fe0..b3a51ae712 100644 --- a/test/asynchronous/test_custom_types.py +++ b/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) diff --git a/test/asynchronous/test_database.py b/test/asynchronous/test_database.py index b2ddd4122d..1e0f0c40d6 100644 --- a/test/asynchronous/test_database.py +++ b/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)) diff --git a/test/asynchronous/test_encryption.py b/test/asynchronous/test_encryption.py index 9e8758a1cd..9093b97ab4 100644 --- a/test/asynchronous/test_encryption.py +++ b/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"}) diff --git a/test/asynchronous/test_grid_file.py b/test/asynchronous/test_grid_file.py index 3f864367de..f3ca596142 100644 --- a/test/asynchronous/test_grid_file.py +++ b/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) diff --git a/test/asynchronous/test_gridfs.py b/test/asynchronous/test_gridfs.py index f886601f36..f60352f3cb 100644 --- a/test/asynchronous/test_gridfs.py +++ b/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) diff --git a/test/asynchronous/test_gridfs_bucket.py b/test/asynchronous/test_gridfs_bucket.py index e8d063b712..4640507e94 100644 --- a/test/asynchronous/test_gridfs_bucket.py +++ b/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) diff --git a/test/asynchronous/test_monitoring.py b/test/asynchronous/test_monitoring.py index a7d56a8cf7..b2ca1aaaa6 100644 --- a/test/asynchronous/test_monitoring.py +++ b/test/asynchronous/test_monitoring.py @@ -68,26 +68,26 @@ async def test_started_simple(self): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand(SON([("ping", 1)]), started.command) self.assertEqual("ping", started.command_name) self.assertEqual(await self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) + self.assertIsInstance(started.request_id, int) async def test_succeeded_simple(self): await self.client.pymongo_test.command("ping") started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) self.assertEqual("ping", succeeded.command_name) self.assertEqual(await self.client.address, succeeded.connection_id) self.assertEqual(1, succeeded.reply.get("ok")) - self.assertTrue(isinstance(succeeded.request_id, int)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(succeeded.request_id, int) + self.assertIsInstance(succeeded.duration_micros, int) async def test_failed_simple(self): try: @@ -97,21 +97,21 @@ async def test_failed_simple(self): started = self.listener.started_events[0] failed = self.listener.failed_events[0] self.assertEqual(0, len(self.listener.succeeded_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) - self.assertTrue(isinstance(failed, monitoring.CommandFailedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) + self.assertIsInstance(failed, monitoring.CommandFailedEvent) self.assertEqual("oops!", failed.command_name) self.assertEqual(await self.client.address, failed.connection_id) self.assertEqual(0, failed.failure.get("ok")) - self.assertTrue(isinstance(failed.request_id, int)) - self.assertTrue(isinstance(failed.duration_micros, int)) + self.assertIsInstance(failed.request_id, int) + self.assertIsInstance(failed.duration_micros, int) async def test_find_one(self): await self.client.pymongo_test.test.find_one() started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON([("find", "test"), ("filter", {}), ("limit", 1), ("singleBatch", True)]), started.command, @@ -119,7 +119,7 @@ async def test_find_one(self): self.assertEqual("find", started.command_name) self.assertEqual(await self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) + self.assertIsInstance(started.request_id, int) async def test_find_and_get_more(self): await self.client.pymongo_test.test.drop() @@ -132,7 +132,7 @@ async def test_find_and_get_more(self): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON( [("find", "test"), ("filter", {}), ("projection", {"_id": False}), ("batchSize", 4)] @@ -142,11 +142,11 @@ async def test_find_and_get_more(self): self.assertEqual("find", started.command_name) self.assertEqual(await self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("find", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(cursor.address, succeeded.connection_id) csr = succeeded.reply["cursor"] self.assertEqual(csr["id"], cursor_id) @@ -161,7 +161,7 @@ async def test_find_and_get_more(self): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 4)]), started.command, @@ -169,11 +169,11 @@ async def test_find_and_get_more(self): self.assertEqual("getMore", started.command_name) self.assertEqual(await self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("getMore", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(cursor.address, succeeded.connection_id) csr = succeeded.reply["cursor"] self.assertEqual(csr["id"], cursor_id) @@ -196,16 +196,16 @@ async def test_find_with_explain(self): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand(cmd, started.command) self.assertEqual("explain", started.command_name) self.assertEqual(await self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("explain", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(await self.client.address, succeeded.connection_id) self.assertEqual(res, succeeded.reply) @@ -227,16 +227,16 @@ async def _test_find_options(self, query, expected_cmd): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand(expected_cmd, started.command) self.assertEqual("find", started.command_name) self.assertEqual(await self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("find", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(await self.client.address, succeeded.connection_id) finally: # Exhaust the cursor to avoid kill cursors. @@ -308,7 +308,7 @@ async def test_command_and_get_more(self): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON( [ @@ -322,11 +322,11 @@ async def test_command_and_get_more(self): self.assertEqual("aggregate", started.command_name) self.assertEqual(await self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("aggregate", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(cursor.address, succeeded.connection_id) expected_cursor = { "id": cursor_id, @@ -341,7 +341,7 @@ async def test_command_and_get_more(self): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 4)]), started.command, @@ -349,11 +349,11 @@ async def test_command_and_get_more(self): self.assertEqual("getMore", started.command_name) self.assertEqual(await self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("getMore", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(cursor.address, succeeded.connection_id) expected_result = { "cursor": { @@ -381,18 +381,18 @@ async def test_get_more_failure(self): started = self.listener.started_events[0] self.assertEqual(0, len(self.listener.succeeded_events)) failed = self.listener.failed_events[0] - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON([("getMore", cursor_id), ("collection", "test")]), started.command ) self.assertEqual("getMore", started.command_name) self.assertEqual(await self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(failed, monitoring.CommandFailedEvent)) - self.assertTrue(isinstance(failed.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(failed, monitoring.CommandFailedEvent) + self.assertIsInstance(failed.duration_micros, int) self.assertEqual("getMore", failed.command_name) - self.assertTrue(isinstance(failed.request_id, int)) + self.assertIsInstance(failed.request_id, int) self.assertEqual(cursor.address, failed.connection_id) self.assertEqual(0, failed.failure.get("ok")) @@ -412,13 +412,13 @@ async def test_not_primary_error(self): started = self.listener.started_events[0] failed = self.listener.failed_events[0] self.assertEqual(0, len(self.listener.succeeded_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) - self.assertTrue(isinstance(failed, monitoring.CommandFailedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) + self.assertIsInstance(failed, monitoring.CommandFailedEvent) self.assertEqual("findAndModify", failed.command_name) self.assertEqual(address, failed.connection_id) self.assertEqual(0, failed.failure.get("ok")) - self.assertTrue(isinstance(failed.request_id, int)) - self.assertTrue(isinstance(failed.duration_micros, int)) + self.assertIsInstance(failed.request_id, int) + self.assertIsInstance(failed.duration_micros, int) self.assertEqual(error, failed.failure) @async_client_context.require_no_mongos @@ -434,7 +434,7 @@ async def test_exhaust(self): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON( [("find", "test"), ("filter", {}), ("projection", {"_id": False}), ("batchSize", 5)] @@ -444,11 +444,11 @@ async def test_exhaust(self): self.assertEqual("find", started.command_name) self.assertEqual(cursor.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("find", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(cursor.address, succeeded.connection_id) expected_result = { "cursor": { @@ -464,7 +464,7 @@ async def test_exhaust(self): tuple(await cursor.to_list()) self.assertEqual(0, len(self.listener.failed_events)) for event in self.listener.started_events: - self.assertTrue(isinstance(event, monitoring.CommandStartedEvent)) + self.assertIsInstance(event, monitoring.CommandStartedEvent) self.assertEqualCommand( SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 5)]), event.command, @@ -472,12 +472,12 @@ async def test_exhaust(self): self.assertEqual("getMore", event.command_name) self.assertEqual(cursor.address, event.connection_id) self.assertEqual("pymongo_test", event.database_name) - self.assertTrue(isinstance(event.request_id, int)) + self.assertIsInstance(event.request_id, int) for event in self.listener.succeeded_events: - self.assertTrue(isinstance(event, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(event.duration_micros, int)) + self.assertIsInstance(event, monitoring.CommandSucceededEvent) + self.assertIsInstance(event.duration_micros, int) self.assertEqual("getMore", event.command_name) - self.assertTrue(isinstance(event.request_id, int)) + self.assertIsInstance(event.request_id, int) self.assertEqual(cursor.address, event.connection_id) # Last getMore receives a response with cursor id 0. self.assertEqual(0, self.listener.succeeded_events[-1].reply["cursor"]["id"]) @@ -495,7 +495,7 @@ async def test_kill_cursors(self): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) # There could be more than one cursor_id here depending on # when the thread last ran. self.assertIn(cursor_id, started.command["cursors"]) @@ -503,11 +503,11 @@ async def test_kill_cursors(self): self.assertIs(type(started.connection_id), tuple) self.assertEqual(cursor.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("killCursors", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertIs(type(succeeded.connection_id), tuple) self.assertEqual(cursor.address, succeeded.connection_id) # There could be more than one cursor_id here depending on @@ -1157,13 +1157,13 @@ async def test_simple(self): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand(SON([("ping", 1)]), started.command) self.assertEqual("ping", started.command_name) self.assertEqual(await self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) + self.assertIsInstance(started.request_id, int) class AsyncTestEventClasses(unittest.IsolatedAsyncioTestCase): diff --git a/test/test_binary.py b/test/test_binary.py index 567c5ae92f..a64aa42280 100644 --- a/test/test_binary.py +++ b/test/test_binary.py @@ -82,8 +82,8 @@ def test_binary(self): a_binary = Binary(b"hello world") self.assertTrue(a_binary.startswith(b"hello")) self.assertTrue(a_binary.endswith(b"world")) - self.assertTrue(isinstance(a_binary, Binary)) - self.assertFalse(isinstance(a_string, Binary)) + self.assertIsInstance(a_binary, Binary) + self.assertNotIsInstance(a_string, Binary) def test_exceptions(self): self.assertRaises(TypeError, Binary, None) diff --git a/test/test_bson.py b/test/test_bson.py index 1616c513c2..4d230ba513 100644 --- a/test/test_bson.py +++ b/test/test_bson.py @@ -142,7 +142,7 @@ def helper(doc): helper({}) helper({"test": "hello"}) - self.assertTrue(isinstance(decoder(encoder({"hello": "world"}))["hello"], str)) + self.assertIsInstance(decoder(encoder({"hello": "world"}))["hello"], str) helper({"mike": -10120}) helper({"long": Int64(10)}) helper({"really big long": 2147483648}) @@ -557,7 +557,7 @@ def test_unknown_type(self): try: decode(bs) except Exception as exc: - self.assertTrue(isinstance(exc, InvalidBSON)) + self.assertIsInstance(exc, InvalidBSON) self.assertIn(part, str(exc)) else: self.fail("Failed to raise an exception.") diff --git a/test/test_bulk.py b/test/test_bulk.py index 8a863cc49b..00c6c5e649 100644 --- a/test/test_bulk.py +++ b/test/test_bulk.py @@ -281,7 +281,7 @@ 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(self.coll.count_documents({"foo": "bar"}), 1) @@ -996,7 +996,7 @@ 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) self.coll.delete_many({}) self.coll.create_index("a", unique=True) @@ -1101,12 +1101,12 @@ 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)) diff --git a/test/test_client.py b/test/test_client.py index 189e58e803..4f2e5751ad 100644 --- a/test/test_client.py +++ b/test/test_client.py @@ -211,7 +211,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, Database)) + self.assertIsInstance(self.client.test, Database) self.assertEqual(self.client.test, self.client["test"]) self.assertEqual(self.client.test, Database(self.client, "test")) @@ -225,7 +225,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"], Database)) + self.assertIsInstance(self.client["_does_not_exist"], Database) with self.assertRaises(AttributeError) as context: self.client._does_not_exist @@ -1237,15 +1237,15 @@ def test_document_class(self): db.test.insert_one({"x": 1}) self.assertEqual(dict, c.codec_options.document_class) - self.assertTrue(isinstance(db.test.find_one(), dict)) - self.assertFalse(isinstance(db.test.find_one(), SON)) + self.assertIsInstance(db.test.find_one(), dict) + self.assertNotIsInstance(db.test.find_one(), SON) c = self.rs_or_single_client(document_class=SON) db = c.pymongo_test self.assertEqual(SON, c.codec_options.document_class) - self.assertTrue(isinstance(db.test.find_one(), SON)) + self.assertIsInstance(db.test.find_one(), SON) def test_timeouts(self): client = self.rs_or_single_client( diff --git a/test/test_code.py b/test/test_code.py index c564e3e04e..23f0af5cef 100644 --- a/test/test_code.py +++ b/test/test_code.py @@ -46,8 +46,8 @@ def test_code(self): a_code = Code("hello world") self.assertTrue(a_code.startswith("hello")) self.assertTrue(a_code.endswith("world")) - self.assertTrue(isinstance(a_code, Code)) - self.assertFalse(isinstance(a_string, Code)) + self.assertIsInstance(a_code, Code) + self.assertNotIsInstance(a_string, Code) self.assertIsNone(a_code.scope) with_scope = Code("hello world", {"my_var": 5}) self.assertEqual({"my_var": 5}, with_scope.scope) diff --git a/test/test_collection.py b/test/test_collection.py index 75c11383d0..6d1b02f1ac 100644 --- a/test/test_collection.py +++ b/test/test_collection.py @@ -111,7 +111,7 @@ def make_col(base, name): def test_getattr(self): coll = self.db.test - self.assertTrue(isinstance(coll["_does_not_exist"], Collection)) + self.assertIsInstance(coll["_does_not_exist"], Collection) with self.assertRaises(AttributeError) as context: coll._does_not_exist @@ -176,7 +176,7 @@ def write_concern_collection(self): yield self.db.test def test_equality(self): - self.assertTrue(isinstance(self.db.test, Collection)) + self.assertIsInstance(self.db.test, Collection) self.assertEqual(self.db.test, self.db["test"]) self.assertEqual(self.db.test, Collection(self.db, "test")) self.assertEqual(self.db.test.mike, self.db["test.mike"]) @@ -706,8 +706,8 @@ def test_insert_one(self): document: dict[str, Any] = {"_id": 1000} result = db.test.insert_one(document) - self.assertTrue(isinstance(result, InsertOneResult)) - self.assertTrue(isinstance(result.inserted_id, int)) + self.assertIsInstance(result, InsertOneResult) + self.assertIsInstance(result.inserted_id, int) self.assertEqual(document["_id"], result.inserted_id) self.assertTrue(result.acknowledged) self.assertIsNotNone(db.test.find_one({"_id": document["_id"]})) @@ -715,8 +715,8 @@ def test_insert_one(self): document = {"foo": "bar"} result = db.test.insert_one(document) - self.assertTrue(isinstance(result, InsertOneResult)) - self.assertTrue(isinstance(result.inserted_id, ObjectId)) + self.assertIsInstance(result, InsertOneResult) + self.assertIsInstance(result.inserted_id, ObjectId) self.assertEqual(document["_id"], result.inserted_id) self.assertTrue(result.acknowledged) self.assertIsNotNone(db.test.find_one({"_id": document["_id"]})) @@ -724,8 +724,8 @@ def test_insert_one(self): db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) result = db.test.insert_one(document) - self.assertTrue(isinstance(result, InsertOneResult)) - self.assertTrue(isinstance(result.inserted_id, ObjectId)) + self.assertIsInstance(result, InsertOneResult) + self.assertIsInstance(result.inserted_id, ObjectId) self.assertEqual(document["_id"], result.inserted_id) self.assertFalse(result.acknowledged) # The insert failed duplicate key... @@ -737,7 +737,7 @@ def async_lambda(): document = RawBSONDocument(encode({"_id": ObjectId(), "foo": "bar"})) result = db.test.insert_one(document) - self.assertTrue(isinstance(result, InsertOneResult)) + self.assertIsInstance(result, InsertOneResult) self.assertEqual(result.inserted_id, None) def test_insert_many(self): @@ -746,38 +746,38 @@ def test_insert_many(self): docs: list = [{} for _ in range(5)] result = db.test.insert_many(docs) - self.assertTrue(isinstance(result, InsertManyResult)) - self.assertTrue(isinstance(result.inserted_ids, list)) + self.assertIsInstance(result, InsertManyResult) + self.assertIsInstance(result.inserted_ids, list) self.assertEqual(5, len(result.inserted_ids)) for doc in docs: _id = doc["_id"] - self.assertTrue(isinstance(_id, ObjectId)) + self.assertIsInstance(_id, ObjectId) self.assertTrue(_id in result.inserted_ids) self.assertEqual(1, db.test.count_documents({"_id": _id})) self.assertTrue(result.acknowledged) docs = [{"_id": i} for i in range(5)] result = db.test.insert_many(docs) - self.assertTrue(isinstance(result, InsertManyResult)) - self.assertTrue(isinstance(result.inserted_ids, list)) + self.assertIsInstance(result, InsertManyResult) + self.assertIsInstance(result.inserted_ids, list) self.assertEqual(5, len(result.inserted_ids)) for doc in docs: _id = doc["_id"] - self.assertTrue(isinstance(_id, int)) + self.assertIsInstance(_id, int) self.assertTrue(_id in result.inserted_ids) self.assertEqual(1, db.test.count_documents({"_id": _id})) self.assertTrue(result.acknowledged) docs = [RawBSONDocument(encode({"_id": i + 5})) for i in range(5)] result = db.test.insert_many(docs) - self.assertTrue(isinstance(result, InsertManyResult)) - self.assertTrue(isinstance(result.inserted_ids, list)) + self.assertIsInstance(result, InsertManyResult) + self.assertIsInstance(result.inserted_ids, list) self.assertEqual([], result.inserted_ids) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) docs: list = [{} for _ in range(5)] result = db.test.insert_many(docs) - self.assertTrue(isinstance(result, InsertManyResult)) + self.assertIsInstance(result, InsertManyResult) self.assertFalse(result.acknowledged) self.assertEqual(20, db.test.count_documents({})) @@ -818,20 +818,20 @@ def test_delete_one(self): self.db.test.insert_one({"z": 1}) result = self.db.test.delete_one({"x": 1}) - self.assertTrue(isinstance(result, DeleteResult)) + self.assertIsInstance(result, DeleteResult) self.assertEqual(1, result.deleted_count) self.assertTrue(result.acknowledged) self.assertEqual(2, self.db.test.count_documents({})) result = self.db.test.delete_one({"y": 1}) - self.assertTrue(isinstance(result, DeleteResult)) + self.assertIsInstance(result, DeleteResult) self.assertEqual(1, result.deleted_count) self.assertTrue(result.acknowledged) self.assertEqual(1, self.db.test.count_documents({})) db = self.db.client.get_database(self.db.name, write_concern=WriteConcern(w=0)) result = db.test.delete_one({"z": 1}) - self.assertTrue(isinstance(result, DeleteResult)) + self.assertIsInstance(result, DeleteResult) self.assertRaises(InvalidOperation, lambda: result.deleted_count) self.assertFalse(result.acknowledged) @@ -849,14 +849,14 @@ def test_delete_many(self): self.db.test.insert_one({"y": 1}) result = self.db.test.delete_many({"x": 1}) - self.assertTrue(isinstance(result, DeleteResult)) + self.assertIsInstance(result, DeleteResult) self.assertEqual(2, result.deleted_count) self.assertTrue(result.acknowledged) self.assertEqual(0, self.db.test.count_documents({"x": 1})) db = self.db.client.get_database(self.db.name, write_concern=WriteConcern(w=0)) result = db.test.delete_many({"y": 1}) - self.assertTrue(isinstance(result, DeleteResult)) + self.assertIsInstance(result, DeleteResult) self.assertRaises(InvalidOperation, lambda: result.deleted_count) self.assertFalse(result.acknowledged) @@ -908,10 +908,10 @@ def test_insert_bypass_document_validation(self): with self.assertRaises(OperationFailure): db.test.insert_one({"_id": 1, "x": 100}) result = db.test.insert_one({"_id": 1, "x": 100}, bypass_document_validation=True) - self.assertTrue(isinstance(result, InsertOneResult)) + self.assertIsInstance(result, InsertOneResult) self.assertEqual(1, result.inserted_id) result = db.test.insert_one({"_id": 2, "a": 0}) - self.assertTrue(isinstance(result, InsertOneResult)) + self.assertIsInstance(result, InsertOneResult) self.assertEqual(2, result.inserted_id) db_w0.test.insert_one({"y": 1}, bypass_document_validation=True) @@ -926,21 +926,21 @@ def async_lambda(): with self.assertRaises(OperationFailure): db.test.insert_many(docs) result = db.test.insert_many(docs, bypass_document_validation=True) - self.assertTrue(isinstance(result, InsertManyResult)) + self.assertIsInstance(result, InsertManyResult) self.assertTrue(97, len(result.inserted_ids)) for doc in docs: _id = doc["_id"] - self.assertTrue(isinstance(_id, int)) + self.assertIsInstance(_id, int) self.assertTrue(_id in 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)] result = db.test.insert_many(docs) - self.assertTrue(isinstance(result, InsertManyResult)) + self.assertIsInstance(result, InsertManyResult) self.assertTrue(97, len(result.inserted_ids)) for doc in docs: _id = doc["_id"] - self.assertTrue(isinstance(_id, int)) + self.assertIsInstance(_id, int) self.assertTrue(_id in result.inserted_ids) self.assertEqual(1, db.test.count_documents({"a": doc["a"]})) self.assertTrue(result.acknowledged) @@ -1168,7 +1168,7 @@ def test_id_can_be_anything(self): db.test.delete_many({}) auto_id = {"hello": "world"} db.test.insert_one(auto_id) - self.assertTrue(isinstance(auto_id["_id"], ObjectId)) + self.assertIsInstance(auto_id["_id"], ObjectId) numeric = {"_id": 240, "hello": "world"} db.test.insert_one(numeric) @@ -1332,7 +1332,7 @@ def test_replace_one(self): id1 = (db.test.insert_one({"x": 1})).inserted_id result = db.test.replace_one({"x": 1}, {"y": 1}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) self.assertTrue(result.modified_count in (None, 1)) self.assertIsNone(result.upserted_id) @@ -1343,7 +1343,7 @@ def test_replace_one(self): replacement = RawBSONDocument(encode({"_id": id1, "z": 1})) result = db.test.replace_one({"y": 1}, replacement, True) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) self.assertTrue(result.modified_count in (None, 1)) self.assertIsNone(result.upserted_id) @@ -1353,16 +1353,16 @@ def test_replace_one(self): self.assertEqual((db.test.find_one(id1))["z"], 1) # type: ignore result = db.test.replace_one({"x": 2}, {"y": 2}, True) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(0, result.matched_count) self.assertTrue(result.modified_count in (None, 0)) - self.assertTrue(isinstance(result.upserted_id, ObjectId)) + self.assertIsInstance(result.upserted_id, ObjectId) self.assertTrue(result.acknowledged) self.assertEqual(1, db.test.count_documents({"y": 2})) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) result = db.test.replace_one({"x": 0}, {"y": 0}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertRaises(InvalidOperation, lambda: result.matched_count) self.assertRaises(InvalidOperation, lambda: result.modified_count) self.assertRaises(InvalidOperation, lambda: result.upserted_id) @@ -1377,7 +1377,7 @@ def test_update_one(self): id1 = (db.test.insert_one({"x": 5})).inserted_id result = db.test.update_one({}, {"$inc": {"x": 1}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) self.assertTrue(result.modified_count in (None, 1)) self.assertIsNone(result.upserted_id) @@ -1386,7 +1386,7 @@ def test_update_one(self): id2 = (db.test.insert_one({"x": 1})).inserted_id result = db.test.update_one({"x": 6}, {"$inc": {"x": 1}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) self.assertTrue(result.modified_count in (None, 1)) self.assertIsNone(result.upserted_id) @@ -1395,15 +1395,15 @@ def test_update_one(self): self.assertEqual((db.test.find_one(id2))["x"], 1) # type: ignore result = db.test.update_one({"x": 2}, {"$set": {"y": 1}}, True) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(0, result.matched_count) self.assertTrue(result.modified_count in (None, 0)) - self.assertTrue(isinstance(result.upserted_id, ObjectId)) + self.assertIsInstance(result.upserted_id, ObjectId) self.assertTrue(result.acknowledged) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) result = db.test.update_one({"x": 0}, {"$inc": {"x": 1}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertRaises(InvalidOperation, lambda: result.matched_count) self.assertRaises(InvalidOperation, lambda: result.modified_count) self.assertRaises(InvalidOperation, lambda: result.upserted_id) @@ -1434,7 +1434,7 @@ def test_update_many(self): db.test.insert_one({"x": 4, "y": 4}) result = db.test.update_many({"x": 4}, {"$set": {"y": 5}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(2, result.matched_count) self.assertTrue(result.modified_count in (None, 2)) self.assertIsNone(result.upserted_id) @@ -1442,7 +1442,7 @@ def test_update_many(self): self.assertEqual(3, db.test.count_documents({"y": 5})) result = db.test.update_many({"x": 5}, {"$set": {"y": 6}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) self.assertTrue(result.modified_count in (None, 1)) self.assertIsNone(result.upserted_id) @@ -1450,15 +1450,15 @@ def test_update_many(self): self.assertEqual(1, db.test.count_documents({"y": 6})) result = db.test.update_many({"x": 2}, {"$set": {"y": 1}}, True) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(0, result.matched_count) self.assertTrue(result.modified_count in (None, 0)) - self.assertTrue(isinstance(result.upserted_id, ObjectId)) + self.assertIsInstance(result.upserted_id, ObjectId) self.assertTrue(result.acknowledged) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) result = db.test.update_many({"x": 0}, {"$inc": {"x": 1}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertRaises(InvalidOperation, lambda: result.matched_count) self.assertRaises(InvalidOperation, lambda: result.modified_count) self.assertRaises(InvalidOperation, lambda: result.upserted_id) @@ -1538,7 +1538,7 @@ def test_aggregate(self): pipeline = {"$project": {"_id": False, "foo": True}} result = db.test.aggregate([pipeline]) - self.assertTrue(isinstance(result, CommandCursor)) + self.assertIsInstance(result, CommandCursor) self.assertEqual([{"foo": [1, 2]}], result.to_list()) # Test write concern. @@ -1556,7 +1556,7 @@ def test_aggregate_raw_bson(self): pipeline = {"$project": {"_id": False, "foo": True}} coll = db.get_collection("test", codec_options=CodecOptions(document_class=RawBSONDocument)) result = coll.aggregate([pipeline]) - self.assertTrue(isinstance(result, CommandCursor)) + self.assertIsInstance(result, CommandCursor) first_result = next(result) self.assertIsInstance(first_result, RawBSONDocument) self.assertEqual([1, 2], list(first_result["foo"])) @@ -1565,7 +1565,7 @@ def test_aggregation_cursor_validation(self): db = self.db projection = {"$project": {"_id": "$_id"}} cursor = db.test.aggregate([projection], cursor={}) - self.assertTrue(isinstance(cursor, CommandCursor)) + self.assertIsInstance(cursor, CommandCursor) def test_aggregation_cursor(self): db = self.db @@ -2186,9 +2186,9 @@ def test_find_regex(self): c.drop() c.insert_one({"r": re.compile(".*")}) - self.assertTrue(isinstance((c.find_one())["r"], Regex)) # type: ignore + self.assertIsInstance((c.find_one())["r"], Regex) # type: ignore for doc in c.find(): - self.assertTrue(isinstance(doc["r"], Regex)) + self.assertIsInstance(doc["r"], Regex) def test_find_command_generation(self): cmd = _gen_find_command( diff --git a/test/test_cursor.py b/test/test_cursor.py index 7b75f4ddc4..d5845e39b0 100644 --- a/test/test_cursor.py +++ b/test/test_cursor.py @@ -950,7 +950,7 @@ 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) @client_context.require_sync diff --git a/test/test_custom_types.py b/test/test_custom_types.py index bcdc14f2e9..9e8dbcfbeb 100644 --- a/test/test_custom_types.py +++ b/test/test_custom_types.py @@ -793,7 +793,7 @@ 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) diff --git a/test/test_database.py b/test/test_database.py index 4c09b421cf..0cb016e269 100644 --- a/test/test_database.py +++ b/test/test_database.py @@ -90,7 +90,7 @@ def test_get_collection(self): def test_getattr(self): db = self.client.pymongo_test - self.assertTrue(isinstance(db["_does_not_exist"], Collection)) + self.assertIsInstance(db["_does_not_exist"], Collection) with self.assertRaises(AttributeError) as context: db._does_not_exist @@ -423,7 +423,7 @@ def test_command_with_regex(self): result = db.command("aggregate", "test", pipeline=[], cursor={}) for doc in result["cursor"]["firstBatch"]: - self.assertTrue(isinstance(doc["r"], Regex)) + self.assertIsInstance(doc["r"], Regex) def test_command_bulkWrite(self): # Ensure bulk write commands can be run directly via db.command(). @@ -467,7 +467,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" ) @@ -538,7 +538,7 @@ def test_insert_find_one(self): a_doc = SON({"hello": "world"}) a_key = (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, db.test.find_one({"_id": a_doc["_id"]})) self.assertEqual(a_doc, db.test.find_one(a_key)) diff --git a/test/test_encryption.py b/test/test_encryption.py index 4b055b68d3..3a86838af3 100644 --- a/test/test_encryption.py +++ b/test/test_encryption.py @@ -2453,16 +2453,16 @@ def setUp(self): encrypted_client.db.csfle.insert_one({"csfle": "csfle"}) doc = unencrypted_client.db.csfle.find_one() - self.assertTrue(isinstance(doc["csfle"], Binary)) + self.assertIsInstance(doc["csfle"], Binary) encrypted_client.db.csfle2.insert_one({"csfle2": "csfle2"}) doc = unencrypted_client.db.csfle2.find_one() - self.assertTrue(isinstance(doc["csfle2"], Binary)) + self.assertIsInstance(doc["csfle2"], Binary) encrypted_client.db.qe.insert_one({"qe": "qe"}) doc = unencrypted_client.db.qe.find_one() - self.assertTrue(isinstance(doc["qe"], Binary)) + self.assertIsInstance(doc["qe"], Binary) encrypted_client.db.qe2.insert_one({"qe2": "qe2"}) doc = unencrypted_client.db.qe2.find_one() - self.assertTrue(isinstance(doc["qe2"], Binary)) + self.assertIsInstance(doc["qe2"], Binary) encrypted_client.db.no_schema.insert_one({"no_schema": "no_schema"}) encrypted_client.db.no_schema2.insert_one({"no_schema2": "no_schema2"}) diff --git a/test/test_grid_file.py b/test/test_grid_file.py index 0baeb5ae19..6fe209f438 100644 --- a/test/test_grid_file.py +++ b/test/test_grid_file.py @@ -150,7 +150,7 @@ def test_grid_in_default_opts(self): a = GridIn(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 @@ 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 @@ 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 @@ 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 @@ 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) diff --git a/test/test_gridfs.py b/test/test_gridfs.py index 75342ee437..8bda041447 100644 --- a/test/test_gridfs.py +++ b/test/test_gridfs.py @@ -157,7 +157,7 @@ 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) diff --git a/test/test_gridfs_bucket.py b/test/test_gridfs_bucket.py index e941369f99..33902c9cfc 100644 --- a/test/test_gridfs_bucket.py +++ b/test/test_gridfs_bucket.py @@ -136,7 +136,7 @@ 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) diff --git a/test/test_monitoring.py b/test/test_monitoring.py index ae3e50db77..fc8be127e3 100644 --- a/test/test_monitoring.py +++ b/test/test_monitoring.py @@ -66,26 +66,26 @@ def test_started_simple(self): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand(SON([("ping", 1)]), started.command) self.assertEqual("ping", started.command_name) self.assertEqual(self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) + self.assertIsInstance(started.request_id, int) def test_succeeded_simple(self): self.client.pymongo_test.command("ping") started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) self.assertEqual("ping", succeeded.command_name) self.assertEqual(self.client.address, succeeded.connection_id) self.assertEqual(1, succeeded.reply.get("ok")) - self.assertTrue(isinstance(succeeded.request_id, int)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(succeeded.request_id, int) + self.assertIsInstance(succeeded.duration_micros, int) def test_failed_simple(self): try: @@ -95,21 +95,21 @@ def test_failed_simple(self): started = self.listener.started_events[0] failed = self.listener.failed_events[0] self.assertEqual(0, len(self.listener.succeeded_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) - self.assertTrue(isinstance(failed, monitoring.CommandFailedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) + self.assertIsInstance(failed, monitoring.CommandFailedEvent) self.assertEqual("oops!", failed.command_name) self.assertEqual(self.client.address, failed.connection_id) self.assertEqual(0, failed.failure.get("ok")) - self.assertTrue(isinstance(failed.request_id, int)) - self.assertTrue(isinstance(failed.duration_micros, int)) + self.assertIsInstance(failed.request_id, int) + self.assertIsInstance(failed.duration_micros, int) def test_find_one(self): self.client.pymongo_test.test.find_one() started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON([("find", "test"), ("filter", {}), ("limit", 1), ("singleBatch", True)]), started.command, @@ -117,7 +117,7 @@ def test_find_one(self): self.assertEqual("find", started.command_name) self.assertEqual(self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) + self.assertIsInstance(started.request_id, int) def test_find_and_get_more(self): self.client.pymongo_test.test.drop() @@ -130,7 +130,7 @@ def test_find_and_get_more(self): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON( [("find", "test"), ("filter", {}), ("projection", {"_id": False}), ("batchSize", 4)] @@ -140,11 +140,11 @@ def test_find_and_get_more(self): self.assertEqual("find", started.command_name) self.assertEqual(self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("find", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(cursor.address, succeeded.connection_id) csr = succeeded.reply["cursor"] self.assertEqual(csr["id"], cursor_id) @@ -159,7 +159,7 @@ def test_find_and_get_more(self): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 4)]), started.command, @@ -167,11 +167,11 @@ def test_find_and_get_more(self): self.assertEqual("getMore", started.command_name) self.assertEqual(self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("getMore", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(cursor.address, succeeded.connection_id) csr = succeeded.reply["cursor"] self.assertEqual(csr["id"], cursor_id) @@ -194,16 +194,16 @@ def test_find_with_explain(self): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand(cmd, started.command) self.assertEqual("explain", started.command_name) self.assertEqual(self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("explain", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(self.client.address, succeeded.connection_id) self.assertEqual(res, succeeded.reply) @@ -225,16 +225,16 @@ def _test_find_options(self, query, expected_cmd): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand(expected_cmd, started.command) self.assertEqual("find", started.command_name) self.assertEqual(self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("find", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(self.client.address, succeeded.connection_id) finally: # Exhaust the cursor to avoid kill cursors. @@ -306,7 +306,7 @@ def test_command_and_get_more(self): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON( [ @@ -320,11 +320,11 @@ def test_command_and_get_more(self): self.assertEqual("aggregate", started.command_name) self.assertEqual(self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("aggregate", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(cursor.address, succeeded.connection_id) expected_cursor = { "id": cursor_id, @@ -339,7 +339,7 @@ def test_command_and_get_more(self): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 4)]), started.command, @@ -347,11 +347,11 @@ def test_command_and_get_more(self): self.assertEqual("getMore", started.command_name) self.assertEqual(self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("getMore", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(cursor.address, succeeded.connection_id) expected_result = { "cursor": { @@ -379,18 +379,18 @@ def test_get_more_failure(self): started = self.listener.started_events[0] self.assertEqual(0, len(self.listener.succeeded_events)) failed = self.listener.failed_events[0] - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON([("getMore", cursor_id), ("collection", "test")]), started.command ) self.assertEqual("getMore", started.command_name) self.assertEqual(self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(failed, monitoring.CommandFailedEvent)) - self.assertTrue(isinstance(failed.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(failed, monitoring.CommandFailedEvent) + self.assertIsInstance(failed.duration_micros, int) self.assertEqual("getMore", failed.command_name) - self.assertTrue(isinstance(failed.request_id, int)) + self.assertIsInstance(failed.request_id, int) self.assertEqual(cursor.address, failed.connection_id) self.assertEqual(0, failed.failure.get("ok")) @@ -410,13 +410,13 @@ def test_not_primary_error(self): started = self.listener.started_events[0] failed = self.listener.failed_events[0] self.assertEqual(0, len(self.listener.succeeded_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) - self.assertTrue(isinstance(failed, monitoring.CommandFailedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) + self.assertIsInstance(failed, monitoring.CommandFailedEvent) self.assertEqual("findAndModify", failed.command_name) self.assertEqual(address, failed.connection_id) self.assertEqual(0, failed.failure.get("ok")) - self.assertTrue(isinstance(failed.request_id, int)) - self.assertTrue(isinstance(failed.duration_micros, int)) + self.assertIsInstance(failed.request_id, int) + self.assertIsInstance(failed.duration_micros, int) self.assertEqual(error, failed.failure) @client_context.require_no_mongos @@ -432,7 +432,7 @@ def test_exhaust(self): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON( [("find", "test"), ("filter", {}), ("projection", {"_id": False}), ("batchSize", 5)] @@ -442,11 +442,11 @@ def test_exhaust(self): self.assertEqual("find", started.command_name) self.assertEqual(cursor.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("find", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(cursor.address, succeeded.connection_id) expected_result = { "cursor": { @@ -462,7 +462,7 @@ def test_exhaust(self): tuple(cursor.to_list()) self.assertEqual(0, len(self.listener.failed_events)) for event in self.listener.started_events: - self.assertTrue(isinstance(event, monitoring.CommandStartedEvent)) + self.assertIsInstance(event, monitoring.CommandStartedEvent) self.assertEqualCommand( SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 5)]), event.command, @@ -470,12 +470,12 @@ def test_exhaust(self): self.assertEqual("getMore", event.command_name) self.assertEqual(cursor.address, event.connection_id) self.assertEqual("pymongo_test", event.database_name) - self.assertTrue(isinstance(event.request_id, int)) + self.assertIsInstance(event.request_id, int) for event in self.listener.succeeded_events: - self.assertTrue(isinstance(event, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(event.duration_micros, int)) + self.assertIsInstance(event, monitoring.CommandSucceededEvent) + self.assertIsInstance(event.duration_micros, int) self.assertEqual("getMore", event.command_name) - self.assertTrue(isinstance(event.request_id, int)) + self.assertIsInstance(event.request_id, int) self.assertEqual(cursor.address, event.connection_id) # Last getMore receives a response with cursor id 0. self.assertEqual(0, self.listener.succeeded_events[-1].reply["cursor"]["id"]) @@ -493,7 +493,7 @@ def test_kill_cursors(self): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) # There could be more than one cursor_id here depending on # when the thread last ran. self.assertIn(cursor_id, started.command["cursors"]) @@ -501,11 +501,11 @@ def test_kill_cursors(self): self.assertIs(type(started.connection_id), tuple) self.assertEqual(cursor.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("killCursors", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertIs(type(succeeded.connection_id), tuple) self.assertEqual(cursor.address, succeeded.connection_id) # There could be more than one cursor_id here depending on @@ -1155,13 +1155,13 @@ def test_simple(self): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand(SON([("ping", 1)]), started.command) self.assertEqual("ping", started.command_name) self.assertEqual(self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) + self.assertIsInstance(started.request_id, int) class TestEventClasses(unittest.TestCase):