mongodb/mongo-python-driver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

PYTHON-5386 Better test assertions for isinstance (#2347)

Browse Source
This commit is contained in:
Iris 2025-05-22 16:15:44 -07:00 committed by GitHub
parent 717fb47c17
commit 65089ead4c
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
28 changed files with 308 additions and 308 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
test/asynchronous/test_bulk.py
View File

@ -281,7 +281,7 @@ class AsyncTestBulk(AsyncBulkTestBase):
self.assertEqual(1, result.upserted_count) self.assertEqual(1, result.upserted_count)
assert result.upserted_ids is not None assert result.upserted_ids is not None
self.assertEqual(1, len(result.upserted_ids)) 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) self.assertEqual(await self.coll.count_documents({"foo": "bar"}), 1)
@ -998,7 +998,7 @@ class AsyncTestBulkWriteConcern(AsyncBulkTestBase):
failed = details["writeConcernErrors"][0] failed = details["writeConcernErrors"][0]
self.assertEqual(64, failed["code"]) self.assertEqual(64, failed["code"])
self.assertTrue(isinstance(failed["errmsg"], str)) self.assertIsInstance(failed["errmsg"], str)
await self.coll.delete_many({}) await self.coll.delete_many({})
await self.coll.create_index("a", unique=True) await self.coll.create_index("a", unique=True)
@ -1105,12 +1105,12 @@ class AsyncTestBulkWriteConcern(AsyncBulkTestBase):
failed = details["writeErrors"][0] failed = details["writeErrors"][0]
self.assertEqual(2, failed["index"]) self.assertEqual(2, failed["index"])
self.assertEqual(11000, failed["code"]) self.assertEqual(11000, failed["code"])
self.assertTrue(isinstance(failed["errmsg"], str)) self.assertIsInstance(failed["errmsg"], str)
self.assertEqual(1, failed["op"]["a"]) self.assertEqual(1, failed["op"]["a"])
failed = details["writeConcernErrors"][0] failed = details["writeConcernErrors"][0]
self.assertEqual(64, failed["code"]) self.assertEqual(64, failed["code"])
self.assertTrue(isinstance(failed["errmsg"], str)) self.assertIsInstance(failed["errmsg"], str)
upserts = details["upserted"] upserts = details["upserted"]
self.assertEqual(1, len(upserts)) self.assertEqual(1, len(upserts))

10
test/asynchronous/test_client.py
View File

@ -214,7 +214,7 @@ class AsyncClientUnitTest(AsyncUnitTest):
self.assertRaises(InvalidName, make_db, self.client, "te/t") self.assertRaises(InvalidName, make_db, self.client, "te/t")
self.assertRaises(InvalidName, make_db, self.client, "te st") 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, self.client["test"])
self.assertEqual(self.client.test, AsyncDatabase(self.client, "test")) self.assertEqual(self.client.test, AsyncDatabase(self.client, "test"))
@ -228,7 +228,7 @@ class AsyncClientUnitTest(AsyncUnitTest):
self.assertEqual(write_concern, db.write_concern) self.assertEqual(write_concern, db.write_concern)
def test_getattr(self): 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: with self.assertRaises(AttributeError) as context:
self.client._does_not_exist self.client._does_not_exist
@ -1274,15 +1274,15 @@ class TestClient(AsyncIntegrationTest):
await db.test.insert_one({"x": 1}) await db.test.insert_one({"x": 1})
self.assertEqual(dict, c.codec_options.document_class) self.assertEqual(dict, c.codec_options.document_class)
self.assertTrue(isinstance(await db.test.find_one(), dict)) self.assertIsInstance(await db.test.find_one(), dict)
self.assertFalse(isinstance(await db.test.find_one(), SON)) self.assertNotIsInstance(await db.test.find_one(), SON)
c = await self.async_rs_or_single_client(document_class=SON) c = await self.async_rs_or_single_client(document_class=SON)
db = c.pymongo_test db = c.pymongo_test
self.assertEqual(SON, c.codec_options.document_class) 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): async def test_timeouts(self):
client = await self.async_rs_or_single_client( client = await self.async_rs_or_single_client(

100
test/asynchronous/test_collection.py
View File

@ -111,7 +111,7 @@ class TestCollectionNoConnect(AsyncUnitTest):
def test_getattr(self): def test_getattr(self):
coll = self.db.test 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: with self.assertRaises(AttributeError) as context:
coll._does_not_exist coll._does_not_exist
@ -176,7 +176,7 @@ class AsyncTestCollection(AsyncIntegrationTest):
yield self.db.test yield self.db.test
async def test_equality(self): 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, self.db["test"])
self.assertEqual(self.db.test, AsyncCollection(self.db, "test")) self.assertEqual(self.db.test, AsyncCollection(self.db, "test"))
self.assertEqual(self.db.test.mike, self.db["test.mike"]) self.assertEqual(self.db.test.mike, self.db["test.mike"])
@ -718,8 +718,8 @@ class AsyncTestCollection(AsyncIntegrationTest):
document: dict[str, Any] = {"_id": 1000} document: dict[str, Any] = {"_id": 1000}
result = await db.test.insert_one(document) result = await db.test.insert_one(document)
self.assertTrue(isinstance(result, InsertOneResult)) self.assertIsInstance(result, InsertOneResult)
self.assertTrue(isinstance(result.inserted_id, int)) self.assertIsInstance(result.inserted_id, int)
self.assertEqual(document["_id"], result.inserted_id) self.assertEqual(document["_id"], result.inserted_id)
self.assertTrue(result.acknowledged) self.assertTrue(result.acknowledged)
self.assertIsNotNone(await db.test.find_one({"_id": document["_id"]})) self.assertIsNotNone(await db.test.find_one({"_id": document["_id"]}))
@ -727,8 +727,8 @@ class AsyncTestCollection(AsyncIntegrationTest):
document = {"foo": "bar"} document = {"foo": "bar"}
result = await db.test.insert_one(document) result = await db.test.insert_one(document)
self.assertTrue(isinstance(result, InsertOneResult)) self.assertIsInstance(result, InsertOneResult)
self.assertTrue(isinstance(result.inserted_id, ObjectId)) self.assertIsInstance(result.inserted_id, ObjectId)
self.assertEqual(document["_id"], result.inserted_id) self.assertEqual(document["_id"], result.inserted_id)
self.assertTrue(result.acknowledged) self.assertTrue(result.acknowledged)
self.assertIsNotNone(await db.test.find_one({"_id": document["_id"]})) self.assertIsNotNone(await db.test.find_one({"_id": document["_id"]}))
@ -736,8 +736,8 @@ class AsyncTestCollection(AsyncIntegrationTest):
db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0))
result = await db.test.insert_one(document) result = await db.test.insert_one(document)
self.assertTrue(isinstance(result, InsertOneResult)) self.assertIsInstance(result, InsertOneResult)
self.assertTrue(isinstance(result.inserted_id, ObjectId)) self.assertIsInstance(result.inserted_id, ObjectId)
self.assertEqual(document["_id"], result.inserted_id) self.assertEqual(document["_id"], result.inserted_id)
self.assertFalse(result.acknowledged) self.assertFalse(result.acknowledged)
# The insert failed duplicate key... # The insert failed duplicate key...
@ -749,7 +749,7 @@ class AsyncTestCollection(AsyncIntegrationTest):
document = RawBSONDocument(encode({"_id": ObjectId(), "foo": "bar"})) document = RawBSONDocument(encode({"_id": ObjectId(), "foo": "bar"}))
result = await db.test.insert_one(document) result = await db.test.insert_one(document)
self.assertTrue(isinstance(result, InsertOneResult)) self.assertIsInstance(result, InsertOneResult)
self.assertEqual(result.inserted_id, None) self.assertEqual(result.inserted_id, None)
async def test_insert_many(self): async def test_insert_many(self):
@ -758,38 +758,38 @@ class AsyncTestCollection(AsyncIntegrationTest):
docs: list = [{} for _ in range(5)] docs: list = [{} for _ in range(5)]
result = await db.test.insert_many(docs) result = await db.test.insert_many(docs)
self.assertTrue(isinstance(result, InsertManyResult)) self.assertIsInstance(result, InsertManyResult)
self.assertTrue(isinstance(result.inserted_ids, list)) self.assertIsInstance(result.inserted_ids, list)
self.assertEqual(5, len(result.inserted_ids)) self.assertEqual(5, len(result.inserted_ids))
for doc in docs: for doc in docs:
_id = doc["_id"] _id = doc["_id"]
self.assertTrue(isinstance(_id, ObjectId)) self.assertIsInstance(_id, ObjectId)
self.assertTrue(_id in result.inserted_ids) self.assertTrue(_id in result.inserted_ids)
self.assertEqual(1, await db.test.count_documents({"_id": _id})) self.assertEqual(1, await db.test.count_documents({"_id": _id}))
self.assertTrue(result.acknowledged) self.assertTrue(result.acknowledged)
docs = [{"_id": i} for i in range(5)] docs = [{"_id": i} for i in range(5)]
result = await db.test.insert_many(docs) result = await db.test.insert_many(docs)
self.assertTrue(isinstance(result, InsertManyResult)) self.assertIsInstance(result, InsertManyResult)
self.assertTrue(isinstance(result.inserted_ids, list)) self.assertIsInstance(result.inserted_ids, list)
self.assertEqual(5, len(result.inserted_ids)) self.assertEqual(5, len(result.inserted_ids))
for doc in docs: for doc in docs:
_id = doc["_id"] _id = doc["_id"]
self.assertTrue(isinstance(_id, int)) self.assertIsInstance(_id, int)
self.assertTrue(_id in result.inserted_ids) self.assertTrue(_id in result.inserted_ids)
self.assertEqual(1, await db.test.count_documents({"_id": _id})) self.assertEqual(1, await db.test.count_documents({"_id": _id}))
self.assertTrue(result.acknowledged) self.assertTrue(result.acknowledged)
docs = [RawBSONDocument(encode({"_id": i + 5})) for i in range(5)] docs = [RawBSONDocument(encode({"_id": i + 5})) for i in range(5)]
result = await db.test.insert_many(docs) result = await db.test.insert_many(docs)
self.assertTrue(isinstance(result, InsertManyResult)) self.assertIsInstance(result, InsertManyResult)
self.assertTrue(isinstance(result.inserted_ids, list)) self.assertIsInstance(result.inserted_ids, list)
self.assertEqual([], result.inserted_ids) self.assertEqual([], result.inserted_ids)
db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0))
docs: list = [{} for _ in range(5)] docs: list = [{} for _ in range(5)]
result = await db.test.insert_many(docs) result = await db.test.insert_many(docs)
self.assertTrue(isinstance(result, InsertManyResult)) self.assertIsInstance(result, InsertManyResult)
self.assertFalse(result.acknowledged) self.assertFalse(result.acknowledged)
self.assertEqual(20, await db.test.count_documents({})) self.assertEqual(20, await db.test.count_documents({}))
@ -830,20 +830,20 @@ class AsyncTestCollection(AsyncIntegrationTest):
await self.db.test.insert_one({"z": 1}) await self.db.test.insert_one({"z": 1})
result = await self.db.test.delete_one({"x": 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.assertEqual(1, result.deleted_count)
self.assertTrue(result.acknowledged) self.assertTrue(result.acknowledged)
self.assertEqual(2, await self.db.test.count_documents({})) self.assertEqual(2, await self.db.test.count_documents({}))
result = await self.db.test.delete_one({"y": 1}) 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.assertEqual(1, result.deleted_count)
self.assertTrue(result.acknowledged) self.assertTrue(result.acknowledged)
self.assertEqual(1, await self.db.test.count_documents({})) self.assertEqual(1, await self.db.test.count_documents({}))
db = self.db.client.get_database(self.db.name, write_concern=WriteConcern(w=0)) db = self.db.client.get_database(self.db.name, write_concern=WriteConcern(w=0))
result = await db.test.delete_one({"z": 1}) 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.assertRaises(InvalidOperation, lambda: result.deleted_count)
self.assertFalse(result.acknowledged) self.assertFalse(result.acknowledged)
@ -861,14 +861,14 @@ class AsyncTestCollection(AsyncIntegrationTest):
await self.db.test.insert_one({"y": 1}) await self.db.test.insert_one({"y": 1})
result = await self.db.test.delete_many({"x": 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.assertEqual(2, result.deleted_count)
self.assertTrue(result.acknowledged) self.assertTrue(result.acknowledged)
self.assertEqual(0, await self.db.test.count_documents({"x": 1})) 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)) db = self.db.client.get_database(self.db.name, write_concern=WriteConcern(w=0))
result = await db.test.delete_many({"y": 1}) 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.assertRaises(InvalidOperation, lambda: result.deleted_count)
self.assertFalse(result.acknowledged) self.assertFalse(result.acknowledged)
@ -920,10 +920,10 @@ class AsyncTestCollection(AsyncIntegrationTest):
with self.assertRaises(OperationFailure): with self.assertRaises(OperationFailure):
await db.test.insert_one({"_id": 1, "x": 100}) await db.test.insert_one({"_id": 1, "x": 100})
result = await db.test.insert_one({"_id": 1, "x": 100}, bypass_document_validation=True) 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) self.assertEqual(1, result.inserted_id)
result = await db.test.insert_one({"_id": 2, "a": 0}) 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) self.assertEqual(2, result.inserted_id)
await db_w0.test.insert_one({"y": 1}, bypass_document_validation=True) await db_w0.test.insert_one({"y": 1}, bypass_document_validation=True)
@ -938,21 +938,21 @@ class AsyncTestCollection(AsyncIntegrationTest):
with self.assertRaises(OperationFailure): with self.assertRaises(OperationFailure):
await db.test.insert_many(docs) await db.test.insert_many(docs)
result = await db.test.insert_many(docs, bypass_document_validation=True) 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)) self.assertTrue(97, len(result.inserted_ids))
for doc in docs: for doc in docs:
_id = doc["_id"] _id = doc["_id"]
self.assertTrue(isinstance(_id, int)) self.assertIsInstance(_id, int)
self.assertTrue(_id in result.inserted_ids) self.assertTrue(_id in result.inserted_ids)
self.assertEqual(1, await db.test.count_documents({"x": doc["x"]})) self.assertEqual(1, await db.test.count_documents({"x": doc["x"]}))
self.assertTrue(result.acknowledged) self.assertTrue(result.acknowledged)
docs = [{"_id": i, "a": 200 - i} for i in range(100, 200)] docs = [{"_id": i, "a": 200 - i} for i in range(100, 200)]
result = await db.test.insert_many(docs) result = await db.test.insert_many(docs)
self.assertTrue(isinstance(result, InsertManyResult)) self.assertIsInstance(result, InsertManyResult)
self.assertTrue(97, len(result.inserted_ids)) self.assertTrue(97, len(result.inserted_ids))
for doc in docs: for doc in docs:
_id = doc["_id"] _id = doc["_id"]
self.assertTrue(isinstance(_id, int)) self.assertIsInstance(_id, int)
self.assertTrue(_id in result.inserted_ids) self.assertTrue(_id in result.inserted_ids)
self.assertEqual(1, await db.test.count_documents({"a": doc["a"]})) self.assertEqual(1, await db.test.count_documents({"a": doc["a"]}))
self.assertTrue(result.acknowledged) self.assertTrue(result.acknowledged)
@ -1182,7 +1182,7 @@ class AsyncTestCollection(AsyncIntegrationTest):
await db.test.delete_many({}) await db.test.delete_many({})
auto_id = {"hello": "world"} auto_id = {"hello": "world"}
await db.test.insert_one(auto_id) 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"} numeric = {"_id": 240, "hello": "world"}
await db.test.insert_one(numeric) await db.test.insert_one(numeric)
@ -1346,7 +1346,7 @@ class AsyncTestCollection(AsyncIntegrationTest):
id1 = (await db.test.insert_one({"x": 1})).inserted_id id1 = (await db.test.insert_one({"x": 1})).inserted_id
result = await db.test.replace_one({"x": 1}, {"y": 1}) 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.assertEqual(1, result.matched_count)
self.assertTrue(result.modified_count in (None, 1)) self.assertTrue(result.modified_count in (None, 1))
self.assertIsNone(result.upserted_id) self.assertIsNone(result.upserted_id)
@ -1357,7 +1357,7 @@ class AsyncTestCollection(AsyncIntegrationTest):
replacement = RawBSONDocument(encode({"_id": id1, "z": 1})) replacement = RawBSONDocument(encode({"_id": id1, "z": 1}))
result = await db.test.replace_one({"y": 1}, replacement, True) 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.assertEqual(1, result.matched_count)
self.assertTrue(result.modified_count in (None, 1)) self.assertTrue(result.modified_count in (None, 1))
self.assertIsNone(result.upserted_id) self.assertIsNone(result.upserted_id)
@ -1367,16 +1367,16 @@ class AsyncTestCollection(AsyncIntegrationTest):
self.assertEqual((await db.test.find_one(id1))["z"], 1) # type: ignore self.assertEqual((await db.test.find_one(id1))["z"], 1) # type: ignore
result = await db.test.replace_one({"x": 2}, {"y": 2}, True) 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.assertEqual(0, result.matched_count)
self.assertTrue(result.modified_count in (None, 0)) 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.assertTrue(result.acknowledged)
self.assertEqual(1, await db.test.count_documents({"y": 2})) self.assertEqual(1, await db.test.count_documents({"y": 2}))
db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0))
result = await db.test.replace_one({"x": 0}, {"y": 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.matched_count)
self.assertRaises(InvalidOperation, lambda: result.modified_count) self.assertRaises(InvalidOperation, lambda: result.modified_count)
self.assertRaises(InvalidOperation, lambda: result.upserted_id) self.assertRaises(InvalidOperation, lambda: result.upserted_id)
@ -1391,7 +1391,7 @@ class AsyncTestCollection(AsyncIntegrationTest):
id1 = (await db.test.insert_one({"x": 5})).inserted_id id1 = (await db.test.insert_one({"x": 5})).inserted_id
result = await db.test.update_one({}, {"$inc": {"x": 1}}) 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.assertEqual(1, result.matched_count)
self.assertTrue(result.modified_count in (None, 1)) self.assertTrue(result.modified_count in (None, 1))
self.assertIsNone(result.upserted_id) self.assertIsNone(result.upserted_id)
@ -1400,7 +1400,7 @@ class AsyncTestCollection(AsyncIntegrationTest):
id2 = (await db.test.insert_one({"x": 1})).inserted_id id2 = (await db.test.insert_one({"x": 1})).inserted_id
result = await db.test.update_one({"x": 6}, {"$inc": {"x": 1}}) 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.assertEqual(1, result.matched_count)
self.assertTrue(result.modified_count in (None, 1)) self.assertTrue(result.modified_count in (None, 1))
self.assertIsNone(result.upserted_id) self.assertIsNone(result.upserted_id)
@ -1409,15 +1409,15 @@ class AsyncTestCollection(AsyncIntegrationTest):
self.assertEqual((await db.test.find_one(id2))["x"], 1) # type: ignore self.assertEqual((await db.test.find_one(id2))["x"], 1) # type: ignore
result = await db.test.update_one({"x": 2}, {"$set": {"y": 1}}, True) 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.assertEqual(0, result.matched_count)
self.assertTrue(result.modified_count in (None, 0)) 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.assertTrue(result.acknowledged)
db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0))
result = await db.test.update_one({"x": 0}, {"$inc": {"x": 1}}) 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.matched_count)
self.assertRaises(InvalidOperation, lambda: result.modified_count) self.assertRaises(InvalidOperation, lambda: result.modified_count)
self.assertRaises(InvalidOperation, lambda: result.upserted_id) self.assertRaises(InvalidOperation, lambda: result.upserted_id)
@ -1448,7 +1448,7 @@ class AsyncTestCollection(AsyncIntegrationTest):
await db.test.insert_one({"x": 4, "y": 4}) await db.test.insert_one({"x": 4, "y": 4})
result = await db.test.update_many({"x": 4}, {"$set": {"y": 5}}) 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.assertEqual(2, result.matched_count)
self.assertTrue(result.modified_count in (None, 2)) self.assertTrue(result.modified_count in (None, 2))
self.assertIsNone(result.upserted_id) self.assertIsNone(result.upserted_id)
@ -1456,7 +1456,7 @@ class AsyncTestCollection(AsyncIntegrationTest):
self.assertEqual(3, await db.test.count_documents({"y": 5})) self.assertEqual(3, await db.test.count_documents({"y": 5}))
result = await db.test.update_many({"x": 5}, {"$set": {"y": 6}}) 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.assertEqual(1, result.matched_count)
self.assertTrue(result.modified_count in (None, 1)) self.assertTrue(result.modified_count in (None, 1))
self.assertIsNone(result.upserted_id) self.assertIsNone(result.upserted_id)
@ -1464,15 +1464,15 @@ class AsyncTestCollection(AsyncIntegrationTest):
self.assertEqual(1, await db.test.count_documents({"y": 6})) self.assertEqual(1, await db.test.count_documents({"y": 6}))
result = await db.test.update_many({"x": 2}, {"$set": {"y": 1}}, True) 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.assertEqual(0, result.matched_count)
self.assertTrue(result.modified_count in (None, 0)) 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.assertTrue(result.acknowledged)
db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0))
result = await db.test.update_many({"x": 0}, {"$inc": {"x": 1}}) 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.matched_count)
self.assertRaises(InvalidOperation, lambda: result.modified_count) self.assertRaises(InvalidOperation, lambda: result.modified_count)
self.assertRaises(InvalidOperation, lambda: result.upserted_id) self.assertRaises(InvalidOperation, lambda: result.upserted_id)
@ -1556,7 +1556,7 @@ class AsyncTestCollection(AsyncIntegrationTest):
pipeline = {"$project": {"_id": False, "foo": True}} pipeline = {"$project": {"_id": False, "foo": True}}
result = await db.test.aggregate([pipeline]) result = await db.test.aggregate([pipeline])
self.assertTrue(isinstance(result, AsyncCommandCursor)) self.assertIsInstance(result, AsyncCommandCursor)
self.assertEqual([{"foo": [1, 2]}], await result.to_list()) self.assertEqual([{"foo": [1, 2]}], await result.to_list())
# Test write concern. # Test write concern.
@ -1574,7 +1574,7 @@ class AsyncTestCollection(AsyncIntegrationTest):
pipeline = {"$project": {"_id": False, "foo": True}} pipeline = {"$project": {"_id": False, "foo": True}}
coll = db.get_collection("test", codec_options=CodecOptions(document_class=RawBSONDocument)) coll = db.get_collection("test", codec_options=CodecOptions(document_class=RawBSONDocument))
result = await coll.aggregate([pipeline]) result = await coll.aggregate([pipeline])
self.assertTrue(isinstance(result, AsyncCommandCursor)) self.assertIsInstance(result, AsyncCommandCursor)
first_result = await anext(result) first_result = await anext(result)
self.assertIsInstance(first_result, RawBSONDocument) self.assertIsInstance(first_result, RawBSONDocument)
self.assertEqual([1, 2], list(first_result["foo"])) self.assertEqual([1, 2], list(first_result["foo"]))
@ -1583,7 +1583,7 @@ class AsyncTestCollection(AsyncIntegrationTest):
db = self.db db = self.db
projection = {"$project": {"_id": "$_id"}} projection = {"$project": {"_id": "$_id"}}
cursor = await db.test.aggregate([projection], cursor={}) cursor = await db.test.aggregate([projection], cursor={})
self.assertTrue(isinstance(cursor, AsyncCommandCursor)) self.assertIsInstance(cursor, AsyncCommandCursor)
async def test_aggregation_cursor(self): async def test_aggregation_cursor(self):
db = self.db db = self.db
@ -2208,9 +2208,9 @@ class AsyncTestCollection(AsyncIntegrationTest):
await c.drop() await c.drop()
await c.insert_one({"r": re.compile(".*")}) 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(): async for doc in c.find():
self.assertTrue(isinstance(doc["r"], Regex)) self.assertIsInstance(doc["r"], Regex)
def test_find_command_generation(self): def test_find_command_generation(self):
cmd = _gen_find_command( cmd = _gen_find_command(

2
test/asynchronous/test_cursor.py
View File

@ -959,7 +959,7 @@ class TestCursor(AsyncIntegrationTest):
cursor = self.db.test.find().hint([("z", 1), ("a", 1)]) cursor = self.db.test.find().hint([("z", 1), ("a", 1)])
cursor2 = copy.deepcopy(cursor) cursor2 = copy.deepcopy(cursor)
# Internal types are now dict rather than SON by default # 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) self.assertEqual(cursor._hint, cursor2._hint)
@async_client_context.require_sync @async_client_context.require_sync

2
test/asynchronous/test_custom_types.py
View File

@ -793,7 +793,7 @@ class TestGridFileCustomType(AsyncIntegrationTest):
self.assertEqual(5, two._id) self.assertEqual(5, two._id)
self.assertEqual(11, two.length) self.assertEqual(11, two.length)
self.assertEqual(1000, two.chunk_size) 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({"foo": "red", "bar": "blue"}, two.metadata)
self.assertEqual(3, two.bar) self.assertEqual(3, two.bar)

8
test/asynchronous/test_database.py
View File

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

8
test/asynchronous/test_encryption.py
View File

@ -2469,16 +2469,16 @@ class TestLookupProse(AsyncEncryptionIntegrationTest):
await encrypted_client.db.csfle.insert_one({"csfle": "csfle"}) await encrypted_client.db.csfle.insert_one({"csfle": "csfle"})
doc = await unencrypted_client.db.csfle.find_one() 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"}) await encrypted_client.db.csfle2.insert_one({"csfle2": "csfle2"})
doc = await unencrypted_client.db.csfle2.find_one() 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"}) await encrypted_client.db.qe.insert_one({"qe": "qe"})
doc = await unencrypted_client.db.qe.find_one() 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"}) await encrypted_client.db.qe2.insert_one({"qe2": "qe2"})
doc = await unencrypted_client.db.qe2.find_one() 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_schema.insert_one({"no_schema": "no_schema"})
await encrypted_client.db.no_schema2.insert_one({"no_schema2": "no_schema2"}) await encrypted_client.db.no_schema2.insert_one({"no_schema2": "no_schema2"})

10
test/asynchronous/test_grid_file.py
View File

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

2
test/asynchronous/test_gridfs.py
View File

@ -157,7 +157,7 @@ class TestGridfs(AsyncIntegrationTest):
assert raw is not None assert raw is not None
self.assertEqual(0, raw["length"]) self.assertEqual(0, raw["length"])
self.assertEqual(oid, raw["_id"]) 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.assertEqual(255 * 1024, raw["chunkSize"])
self.assertNotIn("md5", raw) self.assertNotIn("md5", raw)

2
test/asynchronous/test_gridfs_bucket.py
View File

@ -136,7 +136,7 @@ class TestGridfs(AsyncIntegrationTest):
assert raw is not None assert raw is not None
self.assertEqual(0, raw["length"]) self.assertEqual(0, raw["length"])
self.assertEqual(oid, raw["_id"]) 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.assertEqual(255 * 1024, raw["chunkSize"])
self.assertNotIn("md5", raw) self.assertNotIn("md5", raw)

142
test/asynchronous/test_monitoring.py
View File

@ -68,26 +68,26 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) self.assertEqual(0, len(self.listener.failed_events))
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertEqualCommand(SON([("ping", 1)]), started.command) self.assertEqualCommand(SON([("ping", 1)]), started.command)
self.assertEqual("ping", started.command_name) self.assertEqual("ping", started.command_name)
self.assertEqual(await self.client.address, started.connection_id) self.assertEqual(await self.client.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) 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): async def test_succeeded_simple(self):
await self.client.pymongo_test.command("ping") await self.client.pymongo_test.command("ping")
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) self.assertEqual(0, len(self.listener.failed_events))
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertEqual("ping", succeeded.command_name) self.assertEqual("ping", succeeded.command_name)
self.assertEqual(await self.client.address, succeeded.connection_id) self.assertEqual(await self.client.address, succeeded.connection_id)
self.assertEqual(1, succeeded.reply.get("ok")) self.assertEqual(1, succeeded.reply.get("ok"))
self.assertTrue(isinstance(succeeded.request_id, int)) self.assertIsInstance(succeeded.request_id, int)
self.assertTrue(isinstance(succeeded.duration_micros, int)) self.assertIsInstance(succeeded.duration_micros, int)
async def test_failed_simple(self): async def test_failed_simple(self):
try: try:
@ -97,21 +97,21 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
failed = self.listener.failed_events[0] failed = self.listener.failed_events[0]
self.assertEqual(0, len(self.listener.succeeded_events)) self.assertEqual(0, len(self.listener.succeeded_events))
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertTrue(isinstance(failed, monitoring.CommandFailedEvent)) self.assertIsInstance(failed, monitoring.CommandFailedEvent)
self.assertEqual("oops!", failed.command_name) self.assertEqual("oops!", failed.command_name)
self.assertEqual(await self.client.address, failed.connection_id) self.assertEqual(await self.client.address, failed.connection_id)
self.assertEqual(0, failed.failure.get("ok")) self.assertEqual(0, failed.failure.get("ok"))
self.assertTrue(isinstance(failed.request_id, int)) self.assertIsInstance(failed.request_id, int)
self.assertTrue(isinstance(failed.duration_micros, int)) self.assertIsInstance(failed.duration_micros, int)
async def test_find_one(self): async def test_find_one(self):
await self.client.pymongo_test.test.find_one() await self.client.pymongo_test.test.find_one()
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) self.assertEqual(0, len(self.listener.failed_events))
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertEqualCommand( self.assertEqualCommand(
SON([("find", "test"), ("filter", {}), ("limit", 1), ("singleBatch", True)]), SON([("find", "test"), ("filter", {}), ("limit", 1), ("singleBatch", True)]),
started.command, started.command,
@ -119,7 +119,7 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest):
self.assertEqual("find", started.command_name) self.assertEqual("find", started.command_name)
self.assertEqual(await self.client.address, started.connection_id) self.assertEqual(await self.client.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) 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): async def test_find_and_get_more(self):
await self.client.pymongo_test.test.drop() await self.client.pymongo_test.test.drop()
@ -132,7 +132,7 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) self.assertEqual(0, len(self.listener.failed_events))
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertEqualCommand( self.assertEqualCommand(
SON( SON(
[("find", "test"), ("filter", {}), ("projection", {"_id": False}), ("batchSize", 4)] [("find", "test"), ("filter", {}), ("projection", {"_id": False}), ("batchSize", 4)]
@ -142,11 +142,11 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest):
self.assertEqual("find", started.command_name) self.assertEqual("find", started.command_name)
self.assertEqual(await self.client.address, started.connection_id) self.assertEqual(await self.client.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) self.assertEqual("pymongo_test", started.database_name)
self.assertTrue(isinstance(started.request_id, int)) self.assertIsInstance(started.request_id, int)
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(succeeded.duration_micros, int)) self.assertIsInstance(succeeded.duration_micros, int)
self.assertEqual("find", succeeded.command_name) 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) self.assertEqual(cursor.address, succeeded.connection_id)
csr = succeeded.reply["cursor"] csr = succeeded.reply["cursor"]
self.assertEqual(csr["id"], cursor_id) self.assertEqual(csr["id"], cursor_id)
@ -161,7 +161,7 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) self.assertEqual(0, len(self.listener.failed_events))
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertEqualCommand( self.assertEqualCommand(
SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 4)]), SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 4)]),
started.command, started.command,
@ -169,11 +169,11 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest):
self.assertEqual("getMore", started.command_name) self.assertEqual("getMore", started.command_name)
self.assertEqual(await self.client.address, started.connection_id) self.assertEqual(await self.client.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) self.assertEqual("pymongo_test", started.database_name)
self.assertTrue(isinstance(started.request_id, int)) self.assertIsInstance(started.request_id, int)
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(succeeded.duration_micros, int)) self.assertIsInstance(succeeded.duration_micros, int)
self.assertEqual("getMore", succeeded.command_name) 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) self.assertEqual(cursor.address, succeeded.connection_id)
csr = succeeded.reply["cursor"] csr = succeeded.reply["cursor"]
self.assertEqual(csr["id"], cursor_id) self.assertEqual(csr["id"], cursor_id)
@ -196,16 +196,16 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) 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.assertEqualCommand(cmd, started.command)
self.assertEqual("explain", started.command_name) self.assertEqual("explain", started.command_name)
self.assertEqual(await self.client.address, started.connection_id) self.assertEqual(await self.client.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) self.assertEqual("pymongo_test", started.database_name)
self.assertTrue(isinstance(started.request_id, int)) self.assertIsInstance(started.request_id, int)
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(succeeded.duration_micros, int)) self.assertIsInstance(succeeded.duration_micros, int)
self.assertEqual("explain", succeeded.command_name) 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(await self.client.address, succeeded.connection_id)
self.assertEqual(res, succeeded.reply) self.assertEqual(res, succeeded.reply)
@ -227,16 +227,16 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) 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.assertEqualCommand(expected_cmd, started.command)
self.assertEqual("find", started.command_name) self.assertEqual("find", started.command_name)
self.assertEqual(await self.client.address, started.connection_id) self.assertEqual(await self.client.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) self.assertEqual("pymongo_test", started.database_name)
self.assertTrue(isinstance(started.request_id, int)) self.assertIsInstance(started.request_id, int)
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(succeeded.duration_micros, int)) self.assertIsInstance(succeeded.duration_micros, int)
self.assertEqual("find", succeeded.command_name) 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) self.assertEqual(await self.client.address, succeeded.connection_id)
finally: finally:
# Exhaust the cursor to avoid kill cursors. # Exhaust the cursor to avoid kill cursors.
@ -308,7 +308,7 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) self.assertEqual(0, len(self.listener.failed_events))
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertEqualCommand( self.assertEqualCommand(
SON( SON(
[ [
@ -322,11 +322,11 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest):
self.assertEqual("aggregate", started.command_name) self.assertEqual("aggregate", started.command_name)
self.assertEqual(await self.client.address, started.connection_id) self.assertEqual(await self.client.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) self.assertEqual("pymongo_test", started.database_name)
self.assertTrue(isinstance(started.request_id, int)) self.assertIsInstance(started.request_id, int)
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(succeeded.duration_micros, int)) self.assertIsInstance(succeeded.duration_micros, int)
self.assertEqual("aggregate", succeeded.command_name) 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) self.assertEqual(cursor.address, succeeded.connection_id)
expected_cursor = { expected_cursor = {
"id": cursor_id, "id": cursor_id,
@ -341,7 +341,7 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) self.assertEqual(0, len(self.listener.failed_events))
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertEqualCommand( self.assertEqualCommand(
SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 4)]), SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 4)]),
started.command, started.command,
@ -349,11 +349,11 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest):
self.assertEqual("getMore", started.command_name) self.assertEqual("getMore", started.command_name)
self.assertEqual(await self.client.address, started.connection_id) self.assertEqual(await self.client.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) self.assertEqual("pymongo_test", started.database_name)
self.assertTrue(isinstance(started.request_id, int)) self.assertIsInstance(started.request_id, int)
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(succeeded.duration_micros, int)) self.assertIsInstance(succeeded.duration_micros, int)
self.assertEqual("getMore", succeeded.command_name) 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) self.assertEqual(cursor.address, succeeded.connection_id)
expected_result = { expected_result = {
"cursor": { "cursor": {
@ -381,18 +381,18 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
self.assertEqual(0, len(self.listener.succeeded_events)) self.assertEqual(0, len(self.listener.succeeded_events))
failed = self.listener.failed_events[0] failed = self.listener.failed_events[0]
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertEqualCommand( self.assertEqualCommand(
SON([("getMore", cursor_id), ("collection", "test")]), started.command SON([("getMore", cursor_id), ("collection", "test")]), started.command
) )
self.assertEqual("getMore", started.command_name) self.assertEqual("getMore", started.command_name)
self.assertEqual(await self.client.address, started.connection_id) self.assertEqual(await self.client.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) self.assertEqual("pymongo_test", started.database_name)
self.assertTrue(isinstance(started.request_id, int)) self.assertIsInstance(started.request_id, int)
self.assertTrue(isinstance(failed, monitoring.CommandFailedEvent)) self.assertIsInstance(failed, monitoring.CommandFailedEvent)
self.assertTrue(isinstance(failed.duration_micros, int)) self.assertIsInstance(failed.duration_micros, int)
self.assertEqual("getMore", failed.command_name) 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(cursor.address, failed.connection_id)
self.assertEqual(0, failed.failure.get("ok")) self.assertEqual(0, failed.failure.get("ok"))
@ -412,13 +412,13 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
failed = self.listener.failed_events[0] failed = self.listener.failed_events[0]
self.assertEqual(0, len(self.listener.succeeded_events)) self.assertEqual(0, len(self.listener.succeeded_events))
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertTrue(isinstance(failed, monitoring.CommandFailedEvent)) self.assertIsInstance(failed, monitoring.CommandFailedEvent)
self.assertEqual("findAndModify", failed.command_name) self.assertEqual("findAndModify", failed.command_name)
self.assertEqual(address, failed.connection_id) self.assertEqual(address, failed.connection_id)
self.assertEqual(0, failed.failure.get("ok")) self.assertEqual(0, failed.failure.get("ok"))
self.assertTrue(isinstance(failed.request_id, int)) self.assertIsInstance(failed.request_id, int)
self.assertTrue(isinstance(failed.duration_micros, int)) self.assertIsInstance(failed.duration_micros, int)
self.assertEqual(error, failed.failure) self.assertEqual(error, failed.failure)
@async_client_context.require_no_mongos @async_client_context.require_no_mongos
@ -434,7 +434,7 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) self.assertEqual(0, len(self.listener.failed_events))
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertEqualCommand( self.assertEqualCommand(
SON( SON(
[("find", "test"), ("filter", {}), ("projection", {"_id": False}), ("batchSize", 5)] [("find", "test"), ("filter", {}), ("projection", {"_id": False}), ("batchSize", 5)]
@ -444,11 +444,11 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest):
self.assertEqual("find", started.command_name) self.assertEqual("find", started.command_name)
self.assertEqual(cursor.address, started.connection_id) self.assertEqual(cursor.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) self.assertEqual("pymongo_test", started.database_name)
self.assertTrue(isinstance(started.request_id, int)) self.assertIsInstance(started.request_id, int)
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(succeeded.duration_micros, int)) self.assertIsInstance(succeeded.duration_micros, int)
self.assertEqual("find", succeeded.command_name) 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) self.assertEqual(cursor.address, succeeded.connection_id)
expected_result = { expected_result = {
"cursor": { "cursor": {
@ -464,7 +464,7 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest):
tuple(await cursor.to_list()) tuple(await cursor.to_list())
self.assertEqual(0, len(self.listener.failed_events)) self.assertEqual(0, len(self.listener.failed_events))
for event in self.listener.started_events: for event in self.listener.started_events:
self.assertTrue(isinstance(event, monitoring.CommandStartedEvent)) self.assertIsInstance(event, monitoring.CommandStartedEvent)
self.assertEqualCommand( self.assertEqualCommand(
SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 5)]), SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 5)]),
event.command, event.command,
@ -472,12 +472,12 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest):
self.assertEqual("getMore", event.command_name) self.assertEqual("getMore", event.command_name)
self.assertEqual(cursor.address, event.connection_id) self.assertEqual(cursor.address, event.connection_id)
self.assertEqual("pymongo_test", event.database_name) 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: for event in self.listener.succeeded_events:
self.assertTrue(isinstance(event, monitoring.CommandSucceededEvent)) self.assertIsInstance(event, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(event.duration_micros, int)) self.assertIsInstance(event.duration_micros, int)
self.assertEqual("getMore", event.command_name) 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) self.assertEqual(cursor.address, event.connection_id)
# Last getMore receives a response with cursor id 0. # Last getMore receives a response with cursor id 0.
self.assertEqual(0, self.listener.succeeded_events[-1].reply["cursor"]["id"]) self.assertEqual(0, self.listener.succeeded_events[-1].reply["cursor"]["id"])
@ -495,7 +495,7 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) 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 # There could be more than one cursor_id here depending on
# when the thread last ran. # when the thread last ran.
self.assertIn(cursor_id, started.command["cursors"]) self.assertIn(cursor_id, started.command["cursors"])
@ -503,11 +503,11 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest):
self.assertIs(type(started.connection_id), tuple) self.assertIs(type(started.connection_id), tuple)
self.assertEqual(cursor.address, started.connection_id) self.assertEqual(cursor.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) self.assertEqual("pymongo_test", started.database_name)
self.assertTrue(isinstance(started.request_id, int)) self.assertIsInstance(started.request_id, int)
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(succeeded.duration_micros, int)) self.assertIsInstance(succeeded.duration_micros, int)
self.assertEqual("killCursors", succeeded.command_name) 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.assertIs(type(succeeded.connection_id), tuple)
self.assertEqual(cursor.address, succeeded.connection_id) self.assertEqual(cursor.address, succeeded.connection_id)
# There could be more than one cursor_id here depending on # There could be more than one cursor_id here depending on
@ -1157,13 +1157,13 @@ class AsyncTestGlobalListener(AsyncIntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) self.assertEqual(0, len(self.listener.failed_events))
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertEqualCommand(SON([("ping", 1)]), started.command) self.assertEqualCommand(SON([("ping", 1)]), started.command)
self.assertEqual("ping", started.command_name) self.assertEqual("ping", started.command_name)
self.assertEqual(await self.client.address, started.connection_id) self.assertEqual(await self.client.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) self.assertEqual("pymongo_test", started.database_name)
self.assertTrue(isinstance(started.request_id, int)) self.assertIsInstance(started.request_id, int)
class AsyncTestEventClasses(unittest.IsolatedAsyncioTestCase): class AsyncTestEventClasses(unittest.IsolatedAsyncioTestCase):

4
test/test_binary.py
View File

@ -82,8 +82,8 @@ class TestBinary(unittest.TestCase):
a_binary = Binary(b"hello world") a_binary = Binary(b"hello world")
self.assertTrue(a_binary.startswith(b"hello")) self.assertTrue(a_binary.startswith(b"hello"))
self.assertTrue(a_binary.endswith(b"world")) self.assertTrue(a_binary.endswith(b"world"))
self.assertTrue(isinstance(a_binary, Binary)) self.assertIsInstance(a_binary, Binary)
self.assertFalse(isinstance(a_string, Binary)) self.assertNotIsInstance(a_string, Binary)
def test_exceptions(self): def test_exceptions(self):
self.assertRaises(TypeError, Binary, None) self.assertRaises(TypeError, Binary, None)

12
test/test_bson.py
View File

@ -142,7 +142,7 @@ class TestBSON(unittest.TestCase):
helper({}) helper({})
helper({"test": "hello"}) helper({"test": "hello"})
self.assertTrue(isinstance(decoder(encoder({"hello": "world"}))["hello"], str)) self.assertIsInstance(decoder(encoder({"hello": "world"}))["hello"], str)
helper({"mike": -10120}) helper({"mike": -10120})
helper({"long": Int64(10)}) helper({"long": Int64(10)})
helper({"really big long": 2147483648}) helper({"really big long": 2147483648})
@ -557,7 +557,7 @@ class TestBSON(unittest.TestCase):
try: try:
decode(bs) decode(bs)
except Exception as exc: except Exception as exc:
self.assertTrue(isinstance(exc, InvalidBSON)) self.assertIsInstance(exc, InvalidBSON)
self.assertIn(part, str(exc)) self.assertIn(part, str(exc))
else: else:
self.fail("Failed to raise an exception.") self.fail("Failed to raise an exception.")
@ -722,7 +722,7 @@ class TestBSON(unittest.TestCase):
opts = CodecOptions(uuid_representation=UuidRepresentation.STANDARD) opts = CodecOptions(uuid_representation=UuidRepresentation.STANDARD)
transformed_id = decode(encode({"id": id}, codec_options=opts), codec_options=opts)["id"] transformed_id = decode(encode({"id": id}, codec_options=opts), codec_options=opts)["id"]
self.assertTrue(isinstance(transformed_id, uuid.UUID)) self.assertIsInstance(transformed_id, uuid.UUID)
self.assertEqual(id, transformed_id) self.assertEqual(id, transformed_id)
self.assertNotEqual(uuid.uuid4(), transformed_id) self.assertNotEqual(uuid.uuid4(), transformed_id)
@ -731,7 +731,7 @@ class TestBSON(unittest.TestCase):
legacy = Binary.from_uuid(id, UuidRepresentation.PYTHON_LEGACY) legacy = Binary.from_uuid(id, UuidRepresentation.PYTHON_LEGACY)
self.assertEqual(3, legacy.subtype) self.assertEqual(3, legacy.subtype)
bin = decode(encode({"uuid": legacy}))["uuid"] bin = decode(encode({"uuid": legacy}))["uuid"]
self.assertTrue(isinstance(bin, Binary)) self.assertIsInstance(bin, Binary)
transformed = bin.as_uuid(UuidRepresentation.PYTHON_LEGACY) transformed = bin.as_uuid(UuidRepresentation.PYTHON_LEGACY)
self.assertEqual(id, transformed) self.assertEqual(id, transformed)
@ -787,7 +787,7 @@ class TestBSON(unittest.TestCase):
try: try:
Binary.from_vector([x], BinaryVectorDtype.PACKED_BIT) Binary.from_vector([x], BinaryVectorDtype.PACKED_BIT)
except Exception as exc: except Exception as exc:
self.assertTrue(isinstance(exc, struct.error)) self.assertIsInstance(exc, struct.error)
else: else:
self.fail("Failed to raise an exception.") self.fail("Failed to raise an exception.")
@ -886,7 +886,7 @@ class TestBSON(unittest.TestCase):
y = {"hello": iso8859_bytes} y = {"hello": iso8859_bytes}
# Stored as BSON binary subtype 0. # Stored as BSON binary subtype 0.
out = decode(encode(y)) out = decode(encode(y))
self.assertTrue(isinstance(out["hello"], bytes)) self.assertIsInstance(out["hello"], bytes)
self.assertEqual(out["hello"], iso8859_bytes) self.assertEqual(out["hello"], iso8859_bytes)
def test_null_character(self): def test_null_character(self):

8
test/test_bulk.py
View File

@ -281,7 +281,7 @@ class TestBulk(BulkTestBase):
self.assertEqual(1, result.upserted_count) self.assertEqual(1, result.upserted_count)
assert result.upserted_ids is not None assert result.upserted_ids is not None
self.assertEqual(1, len(result.upserted_ids)) 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) self.assertEqual(self.coll.count_documents({"foo": "bar"}), 1)
@ -996,7 +996,7 @@ class TestBulkWriteConcern(BulkTestBase):
failed = details["writeConcernErrors"][0] failed = details["writeConcernErrors"][0]
self.assertEqual(64, failed["code"]) self.assertEqual(64, failed["code"])
self.assertTrue(isinstance(failed["errmsg"], str)) self.assertIsInstance(failed["errmsg"], str)
self.coll.delete_many({}) self.coll.delete_many({})
self.coll.create_index("a", unique=True) self.coll.create_index("a", unique=True)
@ -1101,12 +1101,12 @@ class TestBulkWriteConcern(BulkTestBase):
failed = details["writeErrors"][0] failed = details["writeErrors"][0]
self.assertEqual(2, failed["index"]) self.assertEqual(2, failed["index"])
self.assertEqual(11000, failed["code"]) self.assertEqual(11000, failed["code"])
self.assertTrue(isinstance(failed["errmsg"], str)) self.assertIsInstance(failed["errmsg"], str)
self.assertEqual(1, failed["op"]["a"]) self.assertEqual(1, failed["op"]["a"])
failed = details["writeConcernErrors"][0] failed = details["writeConcernErrors"][0]
self.assertEqual(64, failed["code"]) self.assertEqual(64, failed["code"])
self.assertTrue(isinstance(failed["errmsg"], str)) self.assertIsInstance(failed["errmsg"], str)
upserts = details["upserted"] upserts = details["upserted"]
self.assertEqual(1, len(upserts)) self.assertEqual(1, len(upserts))

10
test/test_client.py
View File

@ -211,7 +211,7 @@ class ClientUnitTest(UnitTest):
self.assertRaises(InvalidName, make_db, self.client, "te/t") self.assertRaises(InvalidName, make_db, self.client, "te/t")
self.assertRaises(InvalidName, make_db, self.client, "te st") 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, self.client["test"])
self.assertEqual(self.client.test, Database(self.client, "test")) self.assertEqual(self.client.test, Database(self.client, "test"))
@ -225,7 +225,7 @@ class ClientUnitTest(UnitTest):
self.assertEqual(write_concern, db.write_concern) self.assertEqual(write_concern, db.write_concern)
def test_getattr(self): 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: with self.assertRaises(AttributeError) as context:
self.client._does_not_exist self.client._does_not_exist
@ -1237,15 +1237,15 @@ class TestClient(IntegrationTest):
db.test.insert_one({"x": 1}) db.test.insert_one({"x": 1})
self.assertEqual(dict, c.codec_options.document_class) self.assertEqual(dict, c.codec_options.document_class)
self.assertTrue(isinstance(db.test.find_one(), dict)) self.assertIsInstance(db.test.find_one(), dict)
self.assertFalse(isinstance(db.test.find_one(), SON)) self.assertNotIsInstance(db.test.find_one(), SON)
c = self.rs_or_single_client(document_class=SON) c = self.rs_or_single_client(document_class=SON)
db = c.pymongo_test db = c.pymongo_test
self.assertEqual(SON, c.codec_options.document_class) 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): def test_timeouts(self):
client = self.rs_or_single_client( client = self.rs_or_single_client(

4
test/test_code.py
View File

@ -46,8 +46,8 @@ class TestCode(unittest.TestCase):
a_code = Code("hello world") a_code = Code("hello world")
self.assertTrue(a_code.startswith("hello")) self.assertTrue(a_code.startswith("hello"))
self.assertTrue(a_code.endswith("world")) self.assertTrue(a_code.endswith("world"))
self.assertTrue(isinstance(a_code, Code)) self.assertIsInstance(a_code, Code)
self.assertFalse(isinstance(a_string, Code)) self.assertNotIsInstance(a_string, Code)
self.assertIsNone(a_code.scope) self.assertIsNone(a_code.scope)
with_scope = Code("hello world", {"my_var": 5}) with_scope = Code("hello world", {"my_var": 5})
self.assertEqual({"my_var": 5}, with_scope.scope) self.assertEqual({"my_var": 5}, with_scope.scope)

100
test/test_collection.py
View File

@ -111,7 +111,7 @@ class TestCollectionNoConnect(UnitTest):
def test_getattr(self): def test_getattr(self):
coll = self.db.test 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: with self.assertRaises(AttributeError) as context:
coll._does_not_exist coll._does_not_exist
@ -176,7 +176,7 @@ class TestCollection(IntegrationTest):
yield self.db.test yield self.db.test
def test_equality(self): 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, self.db["test"])
self.assertEqual(self.db.test, Collection(self.db, "test")) self.assertEqual(self.db.test, Collection(self.db, "test"))
self.assertEqual(self.db.test.mike, self.db["test.mike"]) self.assertEqual(self.db.test.mike, self.db["test.mike"])
@ -706,8 +706,8 @@ class TestCollection(IntegrationTest):
document: dict[str, Any] = {"_id": 1000} document: dict[str, Any] = {"_id": 1000}
result = db.test.insert_one(document) result = db.test.insert_one(document)
self.assertTrue(isinstance(result, InsertOneResult)) self.assertIsInstance(result, InsertOneResult)
self.assertTrue(isinstance(result.inserted_id, int)) self.assertIsInstance(result.inserted_id, int)
self.assertEqual(document["_id"], result.inserted_id) self.assertEqual(document["_id"], result.inserted_id)
self.assertTrue(result.acknowledged) self.assertTrue(result.acknowledged)
self.assertIsNotNone(db.test.find_one({"_id": document["_id"]})) self.assertIsNotNone(db.test.find_one({"_id": document["_id"]}))
@ -715,8 +715,8 @@ class TestCollection(IntegrationTest):
document = {"foo": "bar"} document = {"foo": "bar"}
result = db.test.insert_one(document) result = db.test.insert_one(document)
self.assertTrue(isinstance(result, InsertOneResult)) self.assertIsInstance(result, InsertOneResult)
self.assertTrue(isinstance(result.inserted_id, ObjectId)) self.assertIsInstance(result.inserted_id, ObjectId)
self.assertEqual(document["_id"], result.inserted_id) self.assertEqual(document["_id"], result.inserted_id)
self.assertTrue(result.acknowledged) self.assertTrue(result.acknowledged)
self.assertIsNotNone(db.test.find_one({"_id": document["_id"]})) self.assertIsNotNone(db.test.find_one({"_id": document["_id"]}))
@ -724,8 +724,8 @@ class TestCollection(IntegrationTest):
db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0))
result = db.test.insert_one(document) result = db.test.insert_one(document)
self.assertTrue(isinstance(result, InsertOneResult)) self.assertIsInstance(result, InsertOneResult)
self.assertTrue(isinstance(result.inserted_id, ObjectId)) self.assertIsInstance(result.inserted_id, ObjectId)
self.assertEqual(document["_id"], result.inserted_id) self.assertEqual(document["_id"], result.inserted_id)
self.assertFalse(result.acknowledged) self.assertFalse(result.acknowledged)
# The insert failed duplicate key... # The insert failed duplicate key...
@ -737,7 +737,7 @@ class TestCollection(IntegrationTest):
document = RawBSONDocument(encode({"_id": ObjectId(), "foo": "bar"})) document = RawBSONDocument(encode({"_id": ObjectId(), "foo": "bar"}))
result = db.test.insert_one(document) result = db.test.insert_one(document)
self.assertTrue(isinstance(result, InsertOneResult)) self.assertIsInstance(result, InsertOneResult)
self.assertEqual(result.inserted_id, None) self.assertEqual(result.inserted_id, None)
def test_insert_many(self): def test_insert_many(self):
@ -746,38 +746,38 @@ class TestCollection(IntegrationTest):
docs: list = [{} for _ in range(5)] docs: list = [{} for _ in range(5)]
result = db.test.insert_many(docs) result = db.test.insert_many(docs)
self.assertTrue(isinstance(result, InsertManyResult)) self.assertIsInstance(result, InsertManyResult)
self.assertTrue(isinstance(result.inserted_ids, list)) self.assertIsInstance(result.inserted_ids, list)
self.assertEqual(5, len(result.inserted_ids)) self.assertEqual(5, len(result.inserted_ids))
for doc in docs: for doc in docs:
_id = doc["_id"] _id = doc["_id"]
self.assertTrue(isinstance(_id, ObjectId)) self.assertIsInstance(_id, ObjectId)
self.assertTrue(_id in result.inserted_ids) self.assertTrue(_id in result.inserted_ids)
self.assertEqual(1, db.test.count_documents({"_id": _id})) self.assertEqual(1, db.test.count_documents({"_id": _id}))
self.assertTrue(result.acknowledged) self.assertTrue(result.acknowledged)
docs = [{"_id": i} for i in range(5)] docs = [{"_id": i} for i in range(5)]
result = db.test.insert_many(docs) result = db.test.insert_many(docs)
self.assertTrue(isinstance(result, InsertManyResult)) self.assertIsInstance(result, InsertManyResult)
self.assertTrue(isinstance(result.inserted_ids, list)) self.assertIsInstance(result.inserted_ids, list)
self.assertEqual(5, len(result.inserted_ids)) self.assertEqual(5, len(result.inserted_ids))
for doc in docs: for doc in docs:
_id = doc["_id"] _id = doc["_id"]
self.assertTrue(isinstance(_id, int)) self.assertIsInstance(_id, int)
self.assertTrue(_id in result.inserted_ids) self.assertTrue(_id in result.inserted_ids)
self.assertEqual(1, db.test.count_documents({"_id": _id})) self.assertEqual(1, db.test.count_documents({"_id": _id}))
self.assertTrue(result.acknowledged) self.assertTrue(result.acknowledged)
docs = [RawBSONDocument(encode({"_id": i + 5})) for i in range(5)] docs = [RawBSONDocument(encode({"_id": i + 5})) for i in range(5)]
result = db.test.insert_many(docs) result = db.test.insert_many(docs)
self.assertTrue(isinstance(result, InsertManyResult)) self.assertIsInstance(result, InsertManyResult)
self.assertTrue(isinstance(result.inserted_ids, list)) self.assertIsInstance(result.inserted_ids, list)
self.assertEqual([], result.inserted_ids) self.assertEqual([], result.inserted_ids)
db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0))
docs: list = [{} for _ in range(5)] docs: list = [{} for _ in range(5)]
result = db.test.insert_many(docs) result = db.test.insert_many(docs)
self.assertTrue(isinstance(result, InsertManyResult)) self.assertIsInstance(result, InsertManyResult)
self.assertFalse(result.acknowledged) self.assertFalse(result.acknowledged)
self.assertEqual(20, db.test.count_documents({})) self.assertEqual(20, db.test.count_documents({}))
@ -818,20 +818,20 @@ class TestCollection(IntegrationTest):
self.db.test.insert_one({"z": 1}) self.db.test.insert_one({"z": 1})
result = self.db.test.delete_one({"x": 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.assertEqual(1, result.deleted_count)
self.assertTrue(result.acknowledged) self.assertTrue(result.acknowledged)
self.assertEqual(2, self.db.test.count_documents({})) self.assertEqual(2, self.db.test.count_documents({}))
result = self.db.test.delete_one({"y": 1}) result = self.db.test.delete_one({"y": 1})
self.assertTrue(isinstance(result, DeleteResult)) self.assertIsInstance(result, DeleteResult)
self.assertEqual(1, result.deleted_count) self.assertEqual(1, result.deleted_count)
self.assertTrue(result.acknowledged) self.assertTrue(result.acknowledged)
self.assertEqual(1, self.db.test.count_documents({})) self.assertEqual(1, self.db.test.count_documents({}))
db = self.db.client.get_database(self.db.name, write_concern=WriteConcern(w=0)) db = self.db.client.get_database(self.db.name, write_concern=WriteConcern(w=0))
result = db.test.delete_one({"z": 1}) result = db.test.delete_one({"z": 1})
self.assertTrue(isinstance(result, DeleteResult)) self.assertIsInstance(result, DeleteResult)
self.assertRaises(InvalidOperation, lambda: result.deleted_count) self.assertRaises(InvalidOperation, lambda: result.deleted_count)
self.assertFalse(result.acknowledged) self.assertFalse(result.acknowledged)
@ -849,14 +849,14 @@ class TestCollection(IntegrationTest):
self.db.test.insert_one({"y": 1}) self.db.test.insert_one({"y": 1})
result = self.db.test.delete_many({"x": 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.assertEqual(2, result.deleted_count)
self.assertTrue(result.acknowledged) self.assertTrue(result.acknowledged)
self.assertEqual(0, self.db.test.count_documents({"x": 1})) self.assertEqual(0, self.db.test.count_documents({"x": 1}))
db = self.db.client.get_database(self.db.name, write_concern=WriteConcern(w=0)) db = self.db.client.get_database(self.db.name, write_concern=WriteConcern(w=0))
result = db.test.delete_many({"y": 1}) result = db.test.delete_many({"y": 1})
self.assertTrue(isinstance(result, DeleteResult)) self.assertIsInstance(result, DeleteResult)
self.assertRaises(InvalidOperation, lambda: result.deleted_count) self.assertRaises(InvalidOperation, lambda: result.deleted_count)
self.assertFalse(result.acknowledged) self.assertFalse(result.acknowledged)
@ -908,10 +908,10 @@ class TestCollection(IntegrationTest):
with self.assertRaises(OperationFailure): with self.assertRaises(OperationFailure):
db.test.insert_one({"_id": 1, "x": 100}) db.test.insert_one({"_id": 1, "x": 100})
result = db.test.insert_one({"_id": 1, "x": 100}, bypass_document_validation=True) 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) self.assertEqual(1, result.inserted_id)
result = db.test.insert_one({"_id": 2, "a": 0}) result = db.test.insert_one({"_id": 2, "a": 0})
self.assertTrue(isinstance(result, InsertOneResult)) self.assertIsInstance(result, InsertOneResult)
self.assertEqual(2, result.inserted_id) self.assertEqual(2, result.inserted_id)
db_w0.test.insert_one({"y": 1}, bypass_document_validation=True) db_w0.test.insert_one({"y": 1}, bypass_document_validation=True)
@ -926,21 +926,21 @@ class TestCollection(IntegrationTest):
with self.assertRaises(OperationFailure): with self.assertRaises(OperationFailure):
db.test.insert_many(docs) db.test.insert_many(docs)
result = db.test.insert_many(docs, bypass_document_validation=True) 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)) self.assertTrue(97, len(result.inserted_ids))
for doc in docs: for doc in docs:
_id = doc["_id"] _id = doc["_id"]
self.assertTrue(isinstance(_id, int)) self.assertIsInstance(_id, int)
self.assertTrue(_id in result.inserted_ids) self.assertTrue(_id in result.inserted_ids)
self.assertEqual(1, db.test.count_documents({"x": doc["x"]})) self.assertEqual(1, db.test.count_documents({"x": doc["x"]}))
self.assertTrue(result.acknowledged) self.assertTrue(result.acknowledged)
docs = [{"_id": i, "a": 200 - i} for i in range(100, 200)] docs = [{"_id": i, "a": 200 - i} for i in range(100, 200)]
result = db.test.insert_many(docs) result = db.test.insert_many(docs)
self.assertTrue(isinstance(result, InsertManyResult)) self.assertIsInstance(result, InsertManyResult)
self.assertTrue(97, len(result.inserted_ids)) self.assertTrue(97, len(result.inserted_ids))
for doc in docs: for doc in docs:
_id = doc["_id"] _id = doc["_id"]
self.assertTrue(isinstance(_id, int)) self.assertIsInstance(_id, int)
self.assertTrue(_id in result.inserted_ids) self.assertTrue(_id in result.inserted_ids)
self.assertEqual(1, db.test.count_documents({"a": doc["a"]})) self.assertEqual(1, db.test.count_documents({"a": doc["a"]}))
self.assertTrue(result.acknowledged) self.assertTrue(result.acknowledged)
@ -1168,7 +1168,7 @@ class TestCollection(IntegrationTest):
db.test.delete_many({}) db.test.delete_many({})
auto_id = {"hello": "world"} auto_id = {"hello": "world"}
db.test.insert_one(auto_id) db.test.insert_one(auto_id)
self.assertTrue(isinstance(auto_id["_id"], ObjectId)) self.assertIsInstance(auto_id["_id"], ObjectId)
numeric = {"_id": 240, "hello": "world"} numeric = {"_id": 240, "hello": "world"}
db.test.insert_one(numeric) db.test.insert_one(numeric)
@ -1332,7 +1332,7 @@ class TestCollection(IntegrationTest):
id1 = (db.test.insert_one({"x": 1})).inserted_id id1 = (db.test.insert_one({"x": 1})).inserted_id
result = db.test.replace_one({"x": 1}, {"y": 1}) 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.assertEqual(1, result.matched_count)
self.assertTrue(result.modified_count in (None, 1)) self.assertTrue(result.modified_count in (None, 1))
self.assertIsNone(result.upserted_id) self.assertIsNone(result.upserted_id)
@ -1343,7 +1343,7 @@ class TestCollection(IntegrationTest):
replacement = RawBSONDocument(encode({"_id": id1, "z": 1})) replacement = RawBSONDocument(encode({"_id": id1, "z": 1}))
result = db.test.replace_one({"y": 1}, replacement, True) 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.assertEqual(1, result.matched_count)
self.assertTrue(result.modified_count in (None, 1)) self.assertTrue(result.modified_count in (None, 1))
self.assertIsNone(result.upserted_id) self.assertIsNone(result.upserted_id)
@ -1353,16 +1353,16 @@ class TestCollection(IntegrationTest):
self.assertEqual((db.test.find_one(id1))["z"], 1) # type: ignore self.assertEqual((db.test.find_one(id1))["z"], 1) # type: ignore
result = db.test.replace_one({"x": 2}, {"y": 2}, True) 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.assertEqual(0, result.matched_count)
self.assertTrue(result.modified_count in (None, 0)) 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.assertTrue(result.acknowledged)
self.assertEqual(1, db.test.count_documents({"y": 2})) self.assertEqual(1, db.test.count_documents({"y": 2}))
db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0))
result = db.test.replace_one({"x": 0}, {"y": 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.matched_count)
self.assertRaises(InvalidOperation, lambda: result.modified_count) self.assertRaises(InvalidOperation, lambda: result.modified_count)
self.assertRaises(InvalidOperation, lambda: result.upserted_id) self.assertRaises(InvalidOperation, lambda: result.upserted_id)
@ -1377,7 +1377,7 @@ class TestCollection(IntegrationTest):
id1 = (db.test.insert_one({"x": 5})).inserted_id id1 = (db.test.insert_one({"x": 5})).inserted_id
result = db.test.update_one({}, {"$inc": {"x": 1}}) result = db.test.update_one({}, {"$inc": {"x": 1}})
self.assertTrue(isinstance(result, UpdateResult)) self.assertIsInstance(result, UpdateResult)
self.assertEqual(1, result.matched_count) self.assertEqual(1, result.matched_count)
self.assertTrue(result.modified_count in (None, 1)) self.assertTrue(result.modified_count in (None, 1))
self.assertIsNone(result.upserted_id) self.assertIsNone(result.upserted_id)
@ -1386,7 +1386,7 @@ class TestCollection(IntegrationTest):
id2 = (db.test.insert_one({"x": 1})).inserted_id id2 = (db.test.insert_one({"x": 1})).inserted_id
result = db.test.update_one({"x": 6}, {"$inc": {"x": 1}}) 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.assertEqual(1, result.matched_count)
self.assertTrue(result.modified_count in (None, 1)) self.assertTrue(result.modified_count in (None, 1))
self.assertIsNone(result.upserted_id) self.assertIsNone(result.upserted_id)
@ -1395,15 +1395,15 @@ class TestCollection(IntegrationTest):
self.assertEqual((db.test.find_one(id2))["x"], 1) # type: ignore self.assertEqual((db.test.find_one(id2))["x"], 1) # type: ignore
result = db.test.update_one({"x": 2}, {"$set": {"y": 1}}, True) 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.assertEqual(0, result.matched_count)
self.assertTrue(result.modified_count in (None, 0)) 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.assertTrue(result.acknowledged)
db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0))
result = db.test.update_one({"x": 0}, {"$inc": {"x": 1}}) 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.matched_count)
self.assertRaises(InvalidOperation, lambda: result.modified_count) self.assertRaises(InvalidOperation, lambda: result.modified_count)
self.assertRaises(InvalidOperation, lambda: result.upserted_id) self.assertRaises(InvalidOperation, lambda: result.upserted_id)
@ -1434,7 +1434,7 @@ class TestCollection(IntegrationTest):
db.test.insert_one({"x": 4, "y": 4}) db.test.insert_one({"x": 4, "y": 4})
result = db.test.update_many({"x": 4}, {"$set": {"y": 5}}) 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.assertEqual(2, result.matched_count)
self.assertTrue(result.modified_count in (None, 2)) self.assertTrue(result.modified_count in (None, 2))
self.assertIsNone(result.upserted_id) self.assertIsNone(result.upserted_id)
@ -1442,7 +1442,7 @@ class TestCollection(IntegrationTest):
self.assertEqual(3, db.test.count_documents({"y": 5})) self.assertEqual(3, db.test.count_documents({"y": 5}))
result = db.test.update_many({"x": 5}, {"$set": {"y": 6}}) 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.assertEqual(1, result.matched_count)
self.assertTrue(result.modified_count in (None, 1)) self.assertTrue(result.modified_count in (None, 1))
self.assertIsNone(result.upserted_id) self.assertIsNone(result.upserted_id)
@ -1450,15 +1450,15 @@ class TestCollection(IntegrationTest):
self.assertEqual(1, db.test.count_documents({"y": 6})) self.assertEqual(1, db.test.count_documents({"y": 6}))
result = db.test.update_many({"x": 2}, {"$set": {"y": 1}}, True) 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.assertEqual(0, result.matched_count)
self.assertTrue(result.modified_count in (None, 0)) 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.assertTrue(result.acknowledged)
db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0))
result = db.test.update_many({"x": 0}, {"$inc": {"x": 1}}) 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.matched_count)
self.assertRaises(InvalidOperation, lambda: result.modified_count) self.assertRaises(InvalidOperation, lambda: result.modified_count)
self.assertRaises(InvalidOperation, lambda: result.upserted_id) self.assertRaises(InvalidOperation, lambda: result.upserted_id)
@ -1538,7 +1538,7 @@ class TestCollection(IntegrationTest):
pipeline = {"$project": {"_id": False, "foo": True}} pipeline = {"$project": {"_id": False, "foo": True}}
result = db.test.aggregate([pipeline]) result = db.test.aggregate([pipeline])
self.assertTrue(isinstance(result, CommandCursor)) self.assertIsInstance(result, CommandCursor)
self.assertEqual([{"foo": [1, 2]}], result.to_list()) self.assertEqual([{"foo": [1, 2]}], result.to_list())
# Test write concern. # Test write concern.
@ -1556,7 +1556,7 @@ class TestCollection(IntegrationTest):
pipeline = {"$project": {"_id": False, "foo": True}} pipeline = {"$project": {"_id": False, "foo": True}}
coll = db.get_collection("test", codec_options=CodecOptions(document_class=RawBSONDocument)) coll = db.get_collection("test", codec_options=CodecOptions(document_class=RawBSONDocument))
result = coll.aggregate([pipeline]) result = coll.aggregate([pipeline])
self.assertTrue(isinstance(result, CommandCursor)) self.assertIsInstance(result, CommandCursor)
first_result = next(result) first_result = next(result)
self.assertIsInstance(first_result, RawBSONDocument) self.assertIsInstance(first_result, RawBSONDocument)
self.assertEqual([1, 2], list(first_result["foo"])) self.assertEqual([1, 2], list(first_result["foo"]))
@ -1565,7 +1565,7 @@ class TestCollection(IntegrationTest):
db = self.db db = self.db
projection = {"$project": {"_id": "$_id"}} projection = {"$project": {"_id": "$_id"}}
cursor = db.test.aggregate([projection], cursor={}) cursor = db.test.aggregate([projection], cursor={})
self.assertTrue(isinstance(cursor, CommandCursor)) self.assertIsInstance(cursor, CommandCursor)
def test_aggregation_cursor(self): def test_aggregation_cursor(self):
db = self.db db = self.db
@ -2186,9 +2186,9 @@ class TestCollection(IntegrationTest):
c.drop() c.drop()
c.insert_one({"r": re.compile(".*")}) 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(): for doc in c.find():
self.assertTrue(isinstance(doc["r"], Regex)) self.assertIsInstance(doc["r"], Regex)
def test_find_command_generation(self): def test_find_command_generation(self):
cmd = _gen_find_command( cmd = _gen_find_command(

2
test/test_cursor.py
View File

@ -950,7 +950,7 @@ class TestCursor(IntegrationTest):
cursor = self.db.test.find().hint([("z", 1), ("a", 1)]) cursor = self.db.test.find().hint([("z", 1), ("a", 1)])
cursor2 = copy.deepcopy(cursor) cursor2 = copy.deepcopy(cursor)
# Internal types are now dict rather than SON by default # 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) self.assertEqual(cursor._hint, cursor2._hint)
@client_context.require_sync @client_context.require_sync

2
test/test_custom_types.py
View File

@ -793,7 +793,7 @@ class TestGridFileCustomType(IntegrationTest):
self.assertEqual(5, two._id) self.assertEqual(5, two._id)
self.assertEqual(11, two.length) self.assertEqual(11, two.length)
self.assertEqual(1000, two.chunk_size) 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({"foo": "red", "bar": "blue"}, two.metadata)
self.assertEqual(3, two.bar) self.assertEqual(3, two.bar)

8
test/test_database.py
View File

@ -90,7 +90,7 @@ class TestDatabaseNoConnect(unittest.TestCase):
def test_getattr(self): def test_getattr(self):
db = self.client.pymongo_test 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: with self.assertRaises(AttributeError) as context:
db._does_not_exist db._does_not_exist
@ -423,7 +423,7 @@ class TestDatabase(IntegrationTest):
result = db.command("aggregate", "test", pipeline=[], cursor={}) result = db.command("aggregate", "test", pipeline=[], cursor={})
for doc in result["cursor"]["firstBatch"]: for doc in result["cursor"]["firstBatch"]:
self.assertTrue(isinstance(doc["r"], Regex)) self.assertIsInstance(doc["r"], Regex)
def test_command_bulkWrite(self): def test_command_bulkWrite(self):
# Ensure bulk write commands can be run directly via db.command(). # Ensure bulk write commands can be run directly via db.command().
@ -467,7 +467,7 @@ class TestDatabase(IntegrationTest):
with self.assertRaises(TypeError): with self.assertRaises(TypeError):
auth._password_digest(None) # type: ignore[arg-type, call-arg] 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( self.assertEqual(
auth._password_digest("mike", "password"), "cd7e45b3b2767dc2fa9b6b548457ed00" auth._password_digest("mike", "password"), "cd7e45b3b2767dc2fa9b6b548457ed00"
) )
@ -538,7 +538,7 @@ class TestDatabase(IntegrationTest):
a_doc = SON({"hello": "world"}) a_doc = SON({"hello": "world"})
a_key = (db.test.insert_one(a_doc)).inserted_id 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["_id"], a_key)
self.assertEqual(a_doc, db.test.find_one({"_id": a_doc["_id"]})) self.assertEqual(a_doc, db.test.find_one({"_id": a_doc["_id"]}))
self.assertEqual(a_doc, db.test.find_one(a_key)) self.assertEqual(a_doc, db.test.find_one(a_key))

8
test/test_encryption.py
View File

@ -2453,16 +2453,16 @@ class TestLookupProse(EncryptionIntegrationTest):
encrypted_client.db.csfle.insert_one({"csfle": "csfle"}) encrypted_client.db.csfle.insert_one({"csfle": "csfle"})
doc = unencrypted_client.db.csfle.find_one() 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"}) encrypted_client.db.csfle2.insert_one({"csfle2": "csfle2"})
doc = unencrypted_client.db.csfle2.find_one() 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"}) encrypted_client.db.qe.insert_one({"qe": "qe"})
doc = unencrypted_client.db.qe.find_one() 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"}) encrypted_client.db.qe2.insert_one({"qe2": "qe2"})
doc = unencrypted_client.db.qe2.find_one() 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_schema.insert_one({"no_schema": "no_schema"})
encrypted_client.db.no_schema2.insert_one({"no_schema2": "no_schema2"}) encrypted_client.db.no_schema2.insert_one({"no_schema2": "no_schema2"})

10
test/test_grid_file.py
View File

@ -150,7 +150,7 @@ class TestGridFile(IntegrationTest):
a = GridIn(self.db.fs) a = GridIn(self.db.fs)
self.assertTrue(isinstance(a._id, ObjectId)) self.assertIsInstance(a._id, ObjectId)
self.assertRaises(AttributeError, setattr, a, "_id", 5) self.assertRaises(AttributeError, setattr, a, "_id", 5)
self.assertEqual(None, a.filename) self.assertEqual(None, a.filename)
@ -195,7 +195,7 @@ class TestGridFile(IntegrationTest):
self.assertEqual(42, a.forty_two) 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.assertRaises(AttributeError, setattr, a, "_id", 5)
self.assertEqual("my_file", a.filename) self.assertEqual("my_file", a.filename)
@ -209,7 +209,7 @@ class TestGridFile(IntegrationTest):
self.assertEqual(255 * 1024, a.chunk_size) self.assertEqual(255 * 1024, a.chunk_size)
self.assertRaises(AttributeError, setattr, a, "chunk_size", 5) 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.assertRaises(AttributeError, setattr, a, "upload_date", 5)
self.assertEqual(["foo"], a.aliases) self.assertEqual(["foo"], a.aliases)
@ -248,7 +248,7 @@ class TestGridFile(IntegrationTest):
self.assertEqual(None, b.name) self.assertEqual(None, b.name)
self.assertEqual(None, b.filename) self.assertEqual(None, b.filename)
self.assertEqual(255 * 1024, b.chunk_size) 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.aliases)
self.assertEqual(None, b.metadata) self.assertEqual(None, b.metadata)
self.assertEqual(None, b.md5) self.assertEqual(None, b.md5)
@ -309,7 +309,7 @@ class TestGridFile(IntegrationTest):
self.assertEqual(11, two.length) self.assertEqual(11, two.length)
self.assertEqual("text/html", two.content_type) self.assertEqual("text/html", two.content_type)
self.assertEqual(1000, two.chunk_size) 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"], two.aliases)
self.assertEqual({"foo": 1, "bar": 2}, two.metadata) self.assertEqual({"foo": 1, "bar": 2}, two.metadata)
self.assertEqual(3, two.bar) self.assertEqual(3, two.bar)

2
test/test_gridfs.py
View File

@ -157,7 +157,7 @@ class TestGridfs(IntegrationTest):
assert raw is not None assert raw is not None
self.assertEqual(0, raw["length"]) self.assertEqual(0, raw["length"])
self.assertEqual(oid, raw["_id"]) 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.assertEqual(255 * 1024, raw["chunkSize"])
self.assertNotIn("md5", raw) self.assertNotIn("md5", raw)

2
test/test_gridfs_bucket.py
View File

@ -136,7 +136,7 @@ class TestGridfs(IntegrationTest):
assert raw is not None assert raw is not None
self.assertEqual(0, raw["length"]) self.assertEqual(0, raw["length"])
self.assertEqual(oid, raw["_id"]) 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.assertEqual(255 * 1024, raw["chunkSize"])
self.assertNotIn("md5", raw) self.assertNotIn("md5", raw)

2
test/test_json_util.py
View File

@ -341,7 +341,7 @@ class TestJsonUtil(unittest.TestCase):
pat = "a*b" pat = "a*b"
json_re = '{"$regex": "%s", "$options": "u"}' % pat json_re = '{"$regex": "%s", "$options": "u"}' % pat
loaded = json_util.object_hook(json.loads(json_re)) loaded = json_util.object_hook(json.loads(json_re))
self.assertTrue(isinstance(loaded, Regex)) self.assertIsInstance(loaded, Regex)
self.assertEqual(pat, loaded.pattern) self.assertEqual(pat, loaded.pattern)
self.assertEqual(re.U, loaded.flags) self.assertEqual(re.U, loaded.flags)

142
test/test_monitoring.py
View File

@ -66,26 +66,26 @@ class TestCommandMonitoring(IntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) self.assertEqual(0, len(self.listener.failed_events))
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertEqualCommand(SON([("ping", 1)]), started.command) self.assertEqualCommand(SON([("ping", 1)]), started.command)
self.assertEqual("ping", started.command_name) self.assertEqual("ping", started.command_name)
self.assertEqual(self.client.address, started.connection_id) self.assertEqual(self.client.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) 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): def test_succeeded_simple(self):
self.client.pymongo_test.command("ping") self.client.pymongo_test.command("ping")
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) self.assertEqual(0, len(self.listener.failed_events))
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertEqual("ping", succeeded.command_name) self.assertEqual("ping", succeeded.command_name)
self.assertEqual(self.client.address, succeeded.connection_id) self.assertEqual(self.client.address, succeeded.connection_id)
self.assertEqual(1, succeeded.reply.get("ok")) self.assertEqual(1, succeeded.reply.get("ok"))
self.assertTrue(isinstance(succeeded.request_id, int)) self.assertIsInstance(succeeded.request_id, int)
self.assertTrue(isinstance(succeeded.duration_micros, int)) self.assertIsInstance(succeeded.duration_micros, int)
def test_failed_simple(self): def test_failed_simple(self):
try: try:
@ -95,21 +95,21 @@ class TestCommandMonitoring(IntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
failed = self.listener.failed_events[0] failed = self.listener.failed_events[0]
self.assertEqual(0, len(self.listener.succeeded_events)) self.assertEqual(0, len(self.listener.succeeded_events))
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertTrue(isinstance(failed, monitoring.CommandFailedEvent)) self.assertIsInstance(failed, monitoring.CommandFailedEvent)
self.assertEqual("oops!", failed.command_name) self.assertEqual("oops!", failed.command_name)
self.assertEqual(self.client.address, failed.connection_id) self.assertEqual(self.client.address, failed.connection_id)
self.assertEqual(0, failed.failure.get("ok")) self.assertEqual(0, failed.failure.get("ok"))
self.assertTrue(isinstance(failed.request_id, int)) self.assertIsInstance(failed.request_id, int)
self.assertTrue(isinstance(failed.duration_micros, int)) self.assertIsInstance(failed.duration_micros, int)
def test_find_one(self): def test_find_one(self):
self.client.pymongo_test.test.find_one() self.client.pymongo_test.test.find_one()
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) self.assertEqual(0, len(self.listener.failed_events))
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertEqualCommand( self.assertEqualCommand(
SON([("find", "test"), ("filter", {}), ("limit", 1), ("singleBatch", True)]), SON([("find", "test"), ("filter", {}), ("limit", 1), ("singleBatch", True)]),
started.command, started.command,
@ -117,7 +117,7 @@ class TestCommandMonitoring(IntegrationTest):
self.assertEqual("find", started.command_name) self.assertEqual("find", started.command_name)
self.assertEqual(self.client.address, started.connection_id) self.assertEqual(self.client.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) 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): def test_find_and_get_more(self):
self.client.pymongo_test.test.drop() self.client.pymongo_test.test.drop()
@ -130,7 +130,7 @@ class TestCommandMonitoring(IntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) self.assertEqual(0, len(self.listener.failed_events))
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertEqualCommand( self.assertEqualCommand(
SON( SON(
[("find", "test"), ("filter", {}), ("projection", {"_id": False}), ("batchSize", 4)] [("find", "test"), ("filter", {}), ("projection", {"_id": False}), ("batchSize", 4)]
@ -140,11 +140,11 @@ class TestCommandMonitoring(IntegrationTest):
self.assertEqual("find", started.command_name) self.assertEqual("find", started.command_name)
self.assertEqual(self.client.address, started.connection_id) self.assertEqual(self.client.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) self.assertEqual("pymongo_test", started.database_name)
self.assertTrue(isinstance(started.request_id, int)) self.assertIsInstance(started.request_id, int)
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(succeeded.duration_micros, int)) self.assertIsInstance(succeeded.duration_micros, int)
self.assertEqual("find", succeeded.command_name) 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) self.assertEqual(cursor.address, succeeded.connection_id)
csr = succeeded.reply["cursor"] csr = succeeded.reply["cursor"]
self.assertEqual(csr["id"], cursor_id) self.assertEqual(csr["id"], cursor_id)
@ -159,7 +159,7 @@ class TestCommandMonitoring(IntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) self.assertEqual(0, len(self.listener.failed_events))
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertEqualCommand( self.assertEqualCommand(
SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 4)]), SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 4)]),
started.command, started.command,
@ -167,11 +167,11 @@ class TestCommandMonitoring(IntegrationTest):
self.assertEqual("getMore", started.command_name) self.assertEqual("getMore", started.command_name)
self.assertEqual(self.client.address, started.connection_id) self.assertEqual(self.client.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) self.assertEqual("pymongo_test", started.database_name)
self.assertTrue(isinstance(started.request_id, int)) self.assertIsInstance(started.request_id, int)
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(succeeded.duration_micros, int)) self.assertIsInstance(succeeded.duration_micros, int)
self.assertEqual("getMore", succeeded.command_name) 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) self.assertEqual(cursor.address, succeeded.connection_id)
csr = succeeded.reply["cursor"] csr = succeeded.reply["cursor"]
self.assertEqual(csr["id"], cursor_id) self.assertEqual(csr["id"], cursor_id)
@ -194,16 +194,16 @@ class TestCommandMonitoring(IntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) 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.assertEqualCommand(cmd, started.command)
self.assertEqual("explain", started.command_name) self.assertEqual("explain", started.command_name)
self.assertEqual(self.client.address, started.connection_id) self.assertEqual(self.client.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) self.assertEqual("pymongo_test", started.database_name)
self.assertTrue(isinstance(started.request_id, int)) self.assertIsInstance(started.request_id, int)
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(succeeded.duration_micros, int)) self.assertIsInstance(succeeded.duration_micros, int)
self.assertEqual("explain", succeeded.command_name) 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(self.client.address, succeeded.connection_id)
self.assertEqual(res, succeeded.reply) self.assertEqual(res, succeeded.reply)
@ -225,16 +225,16 @@ class TestCommandMonitoring(IntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) 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.assertEqualCommand(expected_cmd, started.command)
self.assertEqual("find", started.command_name) self.assertEqual("find", started.command_name)
self.assertEqual(self.client.address, started.connection_id) self.assertEqual(self.client.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) self.assertEqual("pymongo_test", started.database_name)
self.assertTrue(isinstance(started.request_id, int)) self.assertIsInstance(started.request_id, int)
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(succeeded.duration_micros, int)) self.assertIsInstance(succeeded.duration_micros, int)
self.assertEqual("find", succeeded.command_name) 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) self.assertEqual(self.client.address, succeeded.connection_id)
finally: finally:
# Exhaust the cursor to avoid kill cursors. # Exhaust the cursor to avoid kill cursors.
@ -306,7 +306,7 @@ class TestCommandMonitoring(IntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) self.assertEqual(0, len(self.listener.failed_events))
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertEqualCommand( self.assertEqualCommand(
SON( SON(
[ [
@ -320,11 +320,11 @@ class TestCommandMonitoring(IntegrationTest):
self.assertEqual("aggregate", started.command_name) self.assertEqual("aggregate", started.command_name)
self.assertEqual(self.client.address, started.connection_id) self.assertEqual(self.client.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) self.assertEqual("pymongo_test", started.database_name)
self.assertTrue(isinstance(started.request_id, int)) self.assertIsInstance(started.request_id, int)
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(succeeded.duration_micros, int)) self.assertIsInstance(succeeded.duration_micros, int)
self.assertEqual("aggregate", succeeded.command_name) 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) self.assertEqual(cursor.address, succeeded.connection_id)
expected_cursor = { expected_cursor = {
"id": cursor_id, "id": cursor_id,
@ -339,7 +339,7 @@ class TestCommandMonitoring(IntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) self.assertEqual(0, len(self.listener.failed_events))
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertEqualCommand( self.assertEqualCommand(
SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 4)]), SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 4)]),
started.command, started.command,
@ -347,11 +347,11 @@ class TestCommandMonitoring(IntegrationTest):
self.assertEqual("getMore", started.command_name) self.assertEqual("getMore", started.command_name)
self.assertEqual(self.client.address, started.connection_id) self.assertEqual(self.client.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) self.assertEqual("pymongo_test", started.database_name)
self.assertTrue(isinstance(started.request_id, int)) self.assertIsInstance(started.request_id, int)
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(succeeded.duration_micros, int)) self.assertIsInstance(succeeded.duration_micros, int)
self.assertEqual("getMore", succeeded.command_name) 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) self.assertEqual(cursor.address, succeeded.connection_id)
expected_result = { expected_result = {
"cursor": { "cursor": {
@ -379,18 +379,18 @@ class TestCommandMonitoring(IntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
self.assertEqual(0, len(self.listener.succeeded_events)) self.assertEqual(0, len(self.listener.succeeded_events))
failed = self.listener.failed_events[0] failed = self.listener.failed_events[0]
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertEqualCommand( self.assertEqualCommand(
SON([("getMore", cursor_id), ("collection", "test")]), started.command SON([("getMore", cursor_id), ("collection", "test")]), started.command
) )
self.assertEqual("getMore", started.command_name) self.assertEqual("getMore", started.command_name)
self.assertEqual(self.client.address, started.connection_id) self.assertEqual(self.client.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) self.assertEqual("pymongo_test", started.database_name)
self.assertTrue(isinstance(started.request_id, int)) self.assertIsInstance(started.request_id, int)
self.assertTrue(isinstance(failed, monitoring.CommandFailedEvent)) self.assertIsInstance(failed, monitoring.CommandFailedEvent)
self.assertTrue(isinstance(failed.duration_micros, int)) self.assertIsInstance(failed.duration_micros, int)
self.assertEqual("getMore", failed.command_name) 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(cursor.address, failed.connection_id)
self.assertEqual(0, failed.failure.get("ok")) self.assertEqual(0, failed.failure.get("ok"))
@ -410,13 +410,13 @@ class TestCommandMonitoring(IntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
failed = self.listener.failed_events[0] failed = self.listener.failed_events[0]
self.assertEqual(0, len(self.listener.succeeded_events)) self.assertEqual(0, len(self.listener.succeeded_events))
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertTrue(isinstance(failed, monitoring.CommandFailedEvent)) self.assertIsInstance(failed, monitoring.CommandFailedEvent)
self.assertEqual("findAndModify", failed.command_name) self.assertEqual("findAndModify", failed.command_name)
self.assertEqual(address, failed.connection_id) self.assertEqual(address, failed.connection_id)
self.assertEqual(0, failed.failure.get("ok")) self.assertEqual(0, failed.failure.get("ok"))
self.assertTrue(isinstance(failed.request_id, int)) self.assertIsInstance(failed.request_id, int)
self.assertTrue(isinstance(failed.duration_micros, int)) self.assertIsInstance(failed.duration_micros, int)
self.assertEqual(error, failed.failure) self.assertEqual(error, failed.failure)
@client_context.require_no_mongos @client_context.require_no_mongos
@ -432,7 +432,7 @@ class TestCommandMonitoring(IntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) self.assertEqual(0, len(self.listener.failed_events))
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertEqualCommand( self.assertEqualCommand(
SON( SON(
[("find", "test"), ("filter", {}), ("projection", {"_id": False}), ("batchSize", 5)] [("find", "test"), ("filter", {}), ("projection", {"_id": False}), ("batchSize", 5)]
@ -442,11 +442,11 @@ class TestCommandMonitoring(IntegrationTest):
self.assertEqual("find", started.command_name) self.assertEqual("find", started.command_name)
self.assertEqual(cursor.address, started.connection_id) self.assertEqual(cursor.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) self.assertEqual("pymongo_test", started.database_name)
self.assertTrue(isinstance(started.request_id, int)) self.assertIsInstance(started.request_id, int)
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(succeeded.duration_micros, int)) self.assertIsInstance(succeeded.duration_micros, int)
self.assertEqual("find", succeeded.command_name) 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) self.assertEqual(cursor.address, succeeded.connection_id)
expected_result = { expected_result = {
"cursor": { "cursor": {
@ -462,7 +462,7 @@ class TestCommandMonitoring(IntegrationTest):
tuple(cursor.to_list()) tuple(cursor.to_list())
self.assertEqual(0, len(self.listener.failed_events)) self.assertEqual(0, len(self.listener.failed_events))
for event in self.listener.started_events: for event in self.listener.started_events:
self.assertTrue(isinstance(event, monitoring.CommandStartedEvent)) self.assertIsInstance(event, monitoring.CommandStartedEvent)
self.assertEqualCommand( self.assertEqualCommand(
SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 5)]), SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 5)]),
event.command, event.command,
@ -470,12 +470,12 @@ class TestCommandMonitoring(IntegrationTest):
self.assertEqual("getMore", event.command_name) self.assertEqual("getMore", event.command_name)
self.assertEqual(cursor.address, event.connection_id) self.assertEqual(cursor.address, event.connection_id)
self.assertEqual("pymongo_test", event.database_name) 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: for event in self.listener.succeeded_events:
self.assertTrue(isinstance(event, monitoring.CommandSucceededEvent)) self.assertIsInstance(event, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(event.duration_micros, int)) self.assertIsInstance(event.duration_micros, int)
self.assertEqual("getMore", event.command_name) 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) self.assertEqual(cursor.address, event.connection_id)
# Last getMore receives a response with cursor id 0. # Last getMore receives a response with cursor id 0.
self.assertEqual(0, self.listener.succeeded_events[-1].reply["cursor"]["id"]) self.assertEqual(0, self.listener.succeeded_events[-1].reply["cursor"]["id"])
@ -493,7 +493,7 @@ class TestCommandMonitoring(IntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) 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 # There could be more than one cursor_id here depending on
# when the thread last ran. # when the thread last ran.
self.assertIn(cursor_id, started.command["cursors"]) self.assertIn(cursor_id, started.command["cursors"])
@ -501,11 +501,11 @@ class TestCommandMonitoring(IntegrationTest):
self.assertIs(type(started.connection_id), tuple) self.assertIs(type(started.connection_id), tuple)
self.assertEqual(cursor.address, started.connection_id) self.assertEqual(cursor.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) self.assertEqual("pymongo_test", started.database_name)
self.assertTrue(isinstance(started.request_id, int)) self.assertIsInstance(started.request_id, int)
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(succeeded.duration_micros, int)) self.assertIsInstance(succeeded.duration_micros, int)
self.assertEqual("killCursors", succeeded.command_name) 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.assertIs(type(succeeded.connection_id), tuple)
self.assertEqual(cursor.address, succeeded.connection_id) self.assertEqual(cursor.address, succeeded.connection_id)
# There could be more than one cursor_id here depending on # There could be more than one cursor_id here depending on
@ -1155,13 +1155,13 @@ class TestGlobalListener(IntegrationTest):
started = self.listener.started_events[0] started = self.listener.started_events[0]
succeeded = self.listener.succeeded_events[0] succeeded = self.listener.succeeded_events[0]
self.assertEqual(0, len(self.listener.failed_events)) self.assertEqual(0, len(self.listener.failed_events))
self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent)
self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) self.assertIsInstance(started, monitoring.CommandStartedEvent)
self.assertEqualCommand(SON([("ping", 1)]), started.command) self.assertEqualCommand(SON([("ping", 1)]), started.command)
self.assertEqual("ping", started.command_name) self.assertEqual("ping", started.command_name)
self.assertEqual(self.client.address, started.connection_id) self.assertEqual(self.client.address, started.connection_id)
self.assertEqual("pymongo_test", started.database_name) self.assertEqual("pymongo_test", started.database_name)
self.assertTrue(isinstance(started.request_id, int)) self.assertIsInstance(started.request_id, int)
class TestEventClasses(unittest.TestCase): class TestEventClasses(unittest.TestCase):

2
test/test_timestamp.py
View File

@ -33,7 +33,7 @@ class TestTimestamp(unittest.TestCase):
t = Timestamp(123, 456) t = Timestamp(123, 456)
self.assertEqual(t.time, 123) self.assertEqual(t.time, 123)
self.assertEqual(t.inc, 456) self.assertEqual(t.inc, 456)
self.assertTrue(isinstance(t, Timestamp)) self.assertIsInstance(t, Timestamp)
def test_datetime(self): def test_datetime(self):
d = datetime.datetime(2010, 5, 5, tzinfo=utc) d = datetime.datetime(2010, 5, 5, tzinfo=utc)

4
test/test_uri_parser.py
View File

@ -135,8 +135,8 @@ class TestURI(unittest.TestCase):
self.assertEqual({"connecttimeoutms": 0.3}, split_options("connectTimeoutMS=300")) self.assertEqual({"connecttimeoutms": 0.3}, split_options("connectTimeoutMS=300"))
self.assertEqual({"connecttimeoutms": 0.0001}, split_options("connectTimeoutMS=0.1")) self.assertEqual({"connecttimeoutms": 0.0001}, split_options("connectTimeoutMS=0.1"))
self.assertTrue(split_options("connectTimeoutMS=300")) self.assertTrue(split_options("connectTimeoutMS=300"))
self.assertTrue(isinstance(split_options("w=5")["w"], int)) self.assertIsInstance(split_options("w=5")["w"], int)
self.assertTrue(isinstance(split_options("w=5.5")["w"], str)) self.assertIsInstance(split_options("w=5.5")["w"], str)
self.assertTrue(split_options("w=foo")) self.assertTrue(split_options("w=foo"))
self.assertTrue(split_options("w=majority")) self.assertTrue(split_options("w=majority"))
self.assertTrue(split_options("wtimeoutms=500")) self.assertTrue(split_options("wtimeoutms=500"))