From 726a6fa98dddc38cf5ffaee22d843d94ddd0244d Mon Sep 17 00:00:00 2001 From: "Jeffrey A. Clark" Date: Mon, 19 May 2025 19:12:41 -0400 Subject: [PATCH 1/6] PYTHON-5384 Describe MongoDB specifications (#2344) --- CONTRIBUTING.md | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index e0b6260e2..fa500273a 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -384,7 +384,14 @@ If you are running one of the `no-responder` tests, omit the `run-server` step. - Regenerate the test variants and tasks using `pre-commit run --all-files generate-config`. - Make sure to add instructions for running the test suite to `CONTRIBUTING.md`. -## Re-sync Spec Tests +## Specification Tests + +The MongoDB [specifications repository](https://github.com/mongodb/specifications) +holds in progress and completed specifications for features of MongoDB, drivers, +and associated products. PyMongo supports the [Unified Test Format](https://jira.mongodb.org/browse/DRIVERS-709) +for running specification tests to confirm PyMongo behaves as expected. + +### Resynchronizing the Specification Tests If you would like to re-sync the copy of the specification tests in the PyMongo repository with that which is inside the [specifications From 106343a6a2688c9869a7909b31ab227dd077ee1f Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 20 May 2025 07:30:00 -0500 Subject: [PATCH 2/6] Bump github/codeql-action from 3.28.17 to 3.28.18 in the actions group (#2343) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- .github/workflows/codeql.yml | 4 ++-- .github/workflows/zizmor.yml | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml index 3becfd72b..e88f86f27 100644 --- a/.github/workflows/codeql.yml +++ b/.github/workflows/codeql.yml @@ -46,7 +46,7 @@ jobs: # Initializes the CodeQL tools for scanning. - name: Initialize CodeQL - uses: github/codeql-action/init@60168efe1c415ce0f5521ea06d5c2062adbeed1b # v3 + uses: github/codeql-action/init@ff0a06e83cb2de871e5a09832bc6a81e7276941f # v3 with: languages: ${{ matrix.language }} build-mode: ${{ matrix.build-mode }} @@ -63,6 +63,6 @@ jobs: pip install -e . - name: Perform CodeQL Analysis - uses: github/codeql-action/analyze@60168efe1c415ce0f5521ea06d5c2062adbeed1b # v3 + uses: github/codeql-action/analyze@ff0a06e83cb2de871e5a09832bc6a81e7276941f # v3 with: category: "/language:${{matrix.language}}" diff --git a/.github/workflows/zizmor.yml b/.github/workflows/zizmor.yml index b0d4e7cf2..1c6c65505 100644 --- a/.github/workflows/zizmor.yml +++ b/.github/workflows/zizmor.yml @@ -26,7 +26,7 @@ jobs: env: GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} - name: Upload SARIF file - uses: github/codeql-action/upload-sarif@60168efe1c415ce0f5521ea06d5c2062adbeed1b # v3 + uses: github/codeql-action/upload-sarif@ff0a06e83cb2de871e5a09832bc6a81e7276941f # v3 with: sarif_file: results.sarif category: zizmor From 717fb47c17ea46ec66cfdbb9f6a6979294b6ac44 Mon Sep 17 00:00:00 2001 From: Noah Stapp Date: Wed, 21 May 2025 13:45:36 -0400 Subject: [PATCH 3/6] PYTHON-5061 - Add an API to extend the bson TypeRegistry (#2345) --- bson/codec_options.py | 10 ++++++++++ doc/changelog.rst | 7 +++++++ test/asynchronous/test_custom_types.py | 9 +++++++++ test/test_custom_types.py | 9 +++++++++ 4 files changed, 35 insertions(+) diff --git a/bson/codec_options.py b/bson/codec_options.py index 258a777a1..0428cf843 100644 --- a/bson/codec_options.py +++ b/bson/codec_options.py @@ -160,6 +160,16 @@ class TypeRegistry: f"Expected an instance of {TypeEncoder.__name__}, {TypeDecoder.__name__}, or {TypeCodec.__name__}, got {codec!r} instead" ) + @property + def codecs(self) -> list[TypeEncoder | TypeDecoder | TypeCodec]: + """The list of type codecs in this registry.""" + return self.__type_codecs + + @property + def fallback_encoder(self) -> Optional[_Fallback]: + """The fallback encoder in this registry.""" + return self._fallback_encoder + def _validate_type_encoder(self, codec: _Codec) -> None: from bson import _BUILT_IN_TYPES diff --git a/doc/changelog.rst b/doc/changelog.rst index 80d1c4e2f..c44cfb41a 100644 --- a/doc/changelog.rst +++ b/doc/changelog.rst @@ -1,6 +1,13 @@ Changelog ========= +Changes in Version 4.14.0 (XXXX/XX/XX) +-------------------------------------- +PyMongo 4.14 brings a number of changes including: + +- Added :attr:`bson.codec_options.TypeRegistry.codecs` and :attr:`bson.codec_options.TypeRegistry.fallback_encoder` properties + to allow users to directly access the type codecs and fallback encoder for a given :class:`bson.codec_options.TypeRegistry`. + Changes in Version 4.13.0 (2025/05/14) -------------------------------------- diff --git a/test/asynchronous/test_custom_types.py b/test/asynchronous/test_custom_types.py index 0f9d737af..0ab9e95fe 100644 --- a/test/asynchronous/test_custom_types.py +++ b/test/asynchronous/test_custom_types.py @@ -579,6 +579,15 @@ class TestTypeRegistry(unittest.TestCase): with self.assertRaisesRegex(TypeError, err_msg): TypeRegistry(fallback_encoder="hello") # type: ignore[arg-type] + def test_type_registry_codecs(self): + codec_instances = [codec() for codec in self.codecs] + type_registry = TypeRegistry(codec_instances) + self.assertEqual(type_registry.codecs, codec_instances) + + def test_type_registry_fallback(self): + type_registry = TypeRegistry(fallback_encoder=self.fallback_encoder) + self.assertEqual(type_registry.fallback_encoder, self.fallback_encoder) + def test_type_registry_repr(self): codec_instances = [codec() for codec in self.codecs] type_registry = TypeRegistry(codec_instances) diff --git a/test/test_custom_types.py b/test/test_custom_types.py index 08e2a46f8..bcdc14f2e 100644 --- a/test/test_custom_types.py +++ b/test/test_custom_types.py @@ -579,6 +579,15 @@ class TestTypeRegistry(unittest.TestCase): with self.assertRaisesRegex(TypeError, err_msg): TypeRegistry(fallback_encoder="hello") # type: ignore[arg-type] + def test_type_registry_codecs(self): + codec_instances = [codec() for codec in self.codecs] + type_registry = TypeRegistry(codec_instances) + self.assertEqual(type_registry.codecs, codec_instances) + + def test_type_registry_fallback(self): + type_registry = TypeRegistry(fallback_encoder=self.fallback_encoder) + self.assertEqual(type_registry.fallback_encoder, self.fallback_encoder) + def test_type_registry_repr(self): codec_instances = [codec() for codec in self.codecs] type_registry = TypeRegistry(codec_instances) From 65089ead4cd71dc7cd4c0196a3878c420f77eee1 Mon Sep 17 00:00:00 2001 From: Iris <58442094+sleepyStick@users.noreply.github.com> Date: Thu, 22 May 2025 16:15:44 -0700 Subject: [PATCH 4/6] PYTHON-5386 Better test assertions for isinstance (#2347) --- test/asynchronous/test_bulk.py | 8 +- test/asynchronous/test_client.py | 10 +- test/asynchronous/test_collection.py | 100 ++++++++--------- test/asynchronous/test_cursor.py | 2 +- test/asynchronous/test_custom_types.py | 2 +- test/asynchronous/test_database.py | 8 +- test/asynchronous/test_encryption.py | 8 +- test/asynchronous/test_grid_file.py | 10 +- test/asynchronous/test_gridfs.py | 2 +- test/asynchronous/test_gridfs_bucket.py | 2 +- test/asynchronous/test_monitoring.py | 142 ++++++++++++------------ test/test_binary.py | 4 +- test/test_bson.py | 12 +- test/test_bulk.py | 8 +- test/test_client.py | 10 +- test/test_code.py | 4 +- test/test_collection.py | 100 ++++++++--------- test/test_cursor.py | 2 +- test/test_custom_types.py | 2 +- test/test_database.py | 8 +- test/test_encryption.py | 8 +- test/test_grid_file.py | 10 +- test/test_gridfs.py | 2 +- test/test_gridfs_bucket.py | 2 +- test/test_json_util.py | 2 +- test/test_monitoring.py | 142 ++++++++++++------------ test/test_timestamp.py | 2 +- test/test_uri_parser.py | 4 +- 28 files changed, 308 insertions(+), 308 deletions(-) diff --git a/test/asynchronous/test_bulk.py b/test/asynchronous/test_bulk.py index 65ed6e236..7c6f032e8 100644 --- a/test/asynchronous/test_bulk.py +++ b/test/asynchronous/test_bulk.py @@ -281,7 +281,7 @@ class AsyncTestBulk(AsyncBulkTestBase): self.assertEqual(1, result.upserted_count) assert result.upserted_ids is not None self.assertEqual(1, len(result.upserted_ids)) - self.assertTrue(isinstance(result.upserted_ids.get(0), ObjectId)) + self.assertIsInstance(result.upserted_ids.get(0), ObjectId) self.assertEqual(await self.coll.count_documents({"foo": "bar"}), 1) @@ -998,7 +998,7 @@ class AsyncTestBulkWriteConcern(AsyncBulkTestBase): failed = details["writeConcernErrors"][0] self.assertEqual(64, failed["code"]) - self.assertTrue(isinstance(failed["errmsg"], str)) + self.assertIsInstance(failed["errmsg"], str) await self.coll.delete_many({}) await self.coll.create_index("a", unique=True) @@ -1105,12 +1105,12 @@ class AsyncTestBulkWriteConcern(AsyncBulkTestBase): failed = details["writeErrors"][0] self.assertEqual(2, failed["index"]) self.assertEqual(11000, failed["code"]) - self.assertTrue(isinstance(failed["errmsg"], str)) + self.assertIsInstance(failed["errmsg"], str) self.assertEqual(1, failed["op"]["a"]) failed = details["writeConcernErrors"][0] self.assertEqual(64, failed["code"]) - self.assertTrue(isinstance(failed["errmsg"], str)) + self.assertIsInstance(failed["errmsg"], str) upserts = details["upserted"] self.assertEqual(1, len(upserts)) diff --git a/test/asynchronous/test_client.py b/test/asynchronous/test_client.py index 1e1faf0a2..4d247009e 100644 --- a/test/asynchronous/test_client.py +++ b/test/asynchronous/test_client.py @@ -214,7 +214,7 @@ class AsyncClientUnitTest(AsyncUnitTest): self.assertRaises(InvalidName, make_db, self.client, "te/t") self.assertRaises(InvalidName, make_db, self.client, "te st") - self.assertTrue(isinstance(self.client.test, AsyncDatabase)) + self.assertIsInstance(self.client.test, AsyncDatabase) self.assertEqual(self.client.test, self.client["test"]) self.assertEqual(self.client.test, AsyncDatabase(self.client, "test")) @@ -228,7 +228,7 @@ class AsyncClientUnitTest(AsyncUnitTest): self.assertEqual(write_concern, db.write_concern) def test_getattr(self): - self.assertTrue(isinstance(self.client["_does_not_exist"], AsyncDatabase)) + self.assertIsInstance(self.client["_does_not_exist"], AsyncDatabase) with self.assertRaises(AttributeError) as context: self.client._does_not_exist @@ -1274,15 +1274,15 @@ class TestClient(AsyncIntegrationTest): await db.test.insert_one({"x": 1}) self.assertEqual(dict, c.codec_options.document_class) - self.assertTrue(isinstance(await db.test.find_one(), dict)) - self.assertFalse(isinstance(await db.test.find_one(), SON)) + self.assertIsInstance(await db.test.find_one(), dict) + self.assertNotIsInstance(await db.test.find_one(), SON) c = await self.async_rs_or_single_client(document_class=SON) db = c.pymongo_test self.assertEqual(SON, c.codec_options.document_class) - self.assertTrue(isinstance(await db.test.find_one(), SON)) + self.assertIsInstance(await db.test.find_one(), SON) async def test_timeouts(self): client = await self.async_rs_or_single_client( diff --git a/test/asynchronous/test_collection.py b/test/asynchronous/test_collection.py index 00ed020d8..9367c43a0 100644 --- a/test/asynchronous/test_collection.py +++ b/test/asynchronous/test_collection.py @@ -111,7 +111,7 @@ class TestCollectionNoConnect(AsyncUnitTest): def test_getattr(self): coll = self.db.test - self.assertTrue(isinstance(coll["_does_not_exist"], AsyncCollection)) + self.assertIsInstance(coll["_does_not_exist"], AsyncCollection) with self.assertRaises(AttributeError) as context: coll._does_not_exist @@ -176,7 +176,7 @@ class AsyncTestCollection(AsyncIntegrationTest): yield self.db.test async def test_equality(self): - self.assertTrue(isinstance(self.db.test, AsyncCollection)) + self.assertIsInstance(self.db.test, AsyncCollection) self.assertEqual(self.db.test, self.db["test"]) self.assertEqual(self.db.test, AsyncCollection(self.db, "test")) self.assertEqual(self.db.test.mike, self.db["test.mike"]) @@ -718,8 +718,8 @@ class AsyncTestCollection(AsyncIntegrationTest): document: dict[str, Any] = {"_id": 1000} result = await db.test.insert_one(document) - self.assertTrue(isinstance(result, InsertOneResult)) - self.assertTrue(isinstance(result.inserted_id, int)) + self.assertIsInstance(result, InsertOneResult) + self.assertIsInstance(result.inserted_id, int) self.assertEqual(document["_id"], result.inserted_id) self.assertTrue(result.acknowledged) self.assertIsNotNone(await db.test.find_one({"_id": document["_id"]})) @@ -727,8 +727,8 @@ class AsyncTestCollection(AsyncIntegrationTest): document = {"foo": "bar"} result = await db.test.insert_one(document) - self.assertTrue(isinstance(result, InsertOneResult)) - self.assertTrue(isinstance(result.inserted_id, ObjectId)) + self.assertIsInstance(result, InsertOneResult) + self.assertIsInstance(result.inserted_id, ObjectId) self.assertEqual(document["_id"], result.inserted_id) self.assertTrue(result.acknowledged) self.assertIsNotNone(await db.test.find_one({"_id": document["_id"]})) @@ -736,8 +736,8 @@ class AsyncTestCollection(AsyncIntegrationTest): db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) result = await db.test.insert_one(document) - self.assertTrue(isinstance(result, InsertOneResult)) - self.assertTrue(isinstance(result.inserted_id, ObjectId)) + self.assertIsInstance(result, InsertOneResult) + self.assertIsInstance(result.inserted_id, ObjectId) self.assertEqual(document["_id"], result.inserted_id) self.assertFalse(result.acknowledged) # The insert failed duplicate key... @@ -749,7 +749,7 @@ class AsyncTestCollection(AsyncIntegrationTest): document = RawBSONDocument(encode({"_id": ObjectId(), "foo": "bar"})) result = await db.test.insert_one(document) - self.assertTrue(isinstance(result, InsertOneResult)) + self.assertIsInstance(result, InsertOneResult) self.assertEqual(result.inserted_id, None) async def test_insert_many(self): @@ -758,38 +758,38 @@ class AsyncTestCollection(AsyncIntegrationTest): docs: list = [{} for _ in range(5)] result = await db.test.insert_many(docs) - self.assertTrue(isinstance(result, InsertManyResult)) - self.assertTrue(isinstance(result.inserted_ids, list)) + self.assertIsInstance(result, InsertManyResult) + self.assertIsInstance(result.inserted_ids, list) self.assertEqual(5, len(result.inserted_ids)) for doc in docs: _id = doc["_id"] - self.assertTrue(isinstance(_id, ObjectId)) + self.assertIsInstance(_id, ObjectId) self.assertTrue(_id in result.inserted_ids) self.assertEqual(1, await db.test.count_documents({"_id": _id})) self.assertTrue(result.acknowledged) docs = [{"_id": i} for i in range(5)] result = await db.test.insert_many(docs) - self.assertTrue(isinstance(result, InsertManyResult)) - self.assertTrue(isinstance(result.inserted_ids, list)) + self.assertIsInstance(result, InsertManyResult) + self.assertIsInstance(result.inserted_ids, list) self.assertEqual(5, len(result.inserted_ids)) for doc in docs: _id = doc["_id"] - self.assertTrue(isinstance(_id, int)) + self.assertIsInstance(_id, int) self.assertTrue(_id in result.inserted_ids) self.assertEqual(1, await db.test.count_documents({"_id": _id})) self.assertTrue(result.acknowledged) docs = [RawBSONDocument(encode({"_id": i + 5})) for i in range(5)] result = await db.test.insert_many(docs) - self.assertTrue(isinstance(result, InsertManyResult)) - self.assertTrue(isinstance(result.inserted_ids, list)) + self.assertIsInstance(result, InsertManyResult) + self.assertIsInstance(result.inserted_ids, list) self.assertEqual([], result.inserted_ids) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) docs: list = [{} for _ in range(5)] result = await db.test.insert_many(docs) - self.assertTrue(isinstance(result, InsertManyResult)) + self.assertIsInstance(result, InsertManyResult) self.assertFalse(result.acknowledged) self.assertEqual(20, await db.test.count_documents({})) @@ -830,20 +830,20 @@ class AsyncTestCollection(AsyncIntegrationTest): await self.db.test.insert_one({"z": 1}) result = await self.db.test.delete_one({"x": 1}) - self.assertTrue(isinstance(result, DeleteResult)) + self.assertIsInstance(result, DeleteResult) self.assertEqual(1, result.deleted_count) self.assertTrue(result.acknowledged) self.assertEqual(2, await self.db.test.count_documents({})) result = await self.db.test.delete_one({"y": 1}) - self.assertTrue(isinstance(result, DeleteResult)) + self.assertIsInstance(result, DeleteResult) self.assertEqual(1, result.deleted_count) self.assertTrue(result.acknowledged) self.assertEqual(1, await self.db.test.count_documents({})) db = self.db.client.get_database(self.db.name, write_concern=WriteConcern(w=0)) result = await db.test.delete_one({"z": 1}) - self.assertTrue(isinstance(result, DeleteResult)) + self.assertIsInstance(result, DeleteResult) self.assertRaises(InvalidOperation, lambda: result.deleted_count) self.assertFalse(result.acknowledged) @@ -861,14 +861,14 @@ class AsyncTestCollection(AsyncIntegrationTest): await self.db.test.insert_one({"y": 1}) result = await self.db.test.delete_many({"x": 1}) - self.assertTrue(isinstance(result, DeleteResult)) + self.assertIsInstance(result, DeleteResult) self.assertEqual(2, result.deleted_count) self.assertTrue(result.acknowledged) self.assertEqual(0, await self.db.test.count_documents({"x": 1})) db = self.db.client.get_database(self.db.name, write_concern=WriteConcern(w=0)) result = await db.test.delete_many({"y": 1}) - self.assertTrue(isinstance(result, DeleteResult)) + self.assertIsInstance(result, DeleteResult) self.assertRaises(InvalidOperation, lambda: result.deleted_count) self.assertFalse(result.acknowledged) @@ -920,10 +920,10 @@ class AsyncTestCollection(AsyncIntegrationTest): with self.assertRaises(OperationFailure): await db.test.insert_one({"_id": 1, "x": 100}) result = await db.test.insert_one({"_id": 1, "x": 100}, bypass_document_validation=True) - self.assertTrue(isinstance(result, InsertOneResult)) + self.assertIsInstance(result, InsertOneResult) self.assertEqual(1, result.inserted_id) result = await db.test.insert_one({"_id": 2, "a": 0}) - self.assertTrue(isinstance(result, InsertOneResult)) + self.assertIsInstance(result, InsertOneResult) self.assertEqual(2, result.inserted_id) await db_w0.test.insert_one({"y": 1}, bypass_document_validation=True) @@ -938,21 +938,21 @@ class AsyncTestCollection(AsyncIntegrationTest): with self.assertRaises(OperationFailure): await db.test.insert_many(docs) result = await db.test.insert_many(docs, bypass_document_validation=True) - self.assertTrue(isinstance(result, InsertManyResult)) + self.assertIsInstance(result, InsertManyResult) self.assertTrue(97, len(result.inserted_ids)) for doc in docs: _id = doc["_id"] - self.assertTrue(isinstance(_id, int)) + self.assertIsInstance(_id, int) self.assertTrue(_id in result.inserted_ids) self.assertEqual(1, await db.test.count_documents({"x": doc["x"]})) self.assertTrue(result.acknowledged) docs = [{"_id": i, "a": 200 - i} for i in range(100, 200)] result = await db.test.insert_many(docs) - self.assertTrue(isinstance(result, InsertManyResult)) + self.assertIsInstance(result, InsertManyResult) self.assertTrue(97, len(result.inserted_ids)) for doc in docs: _id = doc["_id"] - self.assertTrue(isinstance(_id, int)) + self.assertIsInstance(_id, int) self.assertTrue(_id in result.inserted_ids) self.assertEqual(1, await db.test.count_documents({"a": doc["a"]})) self.assertTrue(result.acknowledged) @@ -1182,7 +1182,7 @@ class AsyncTestCollection(AsyncIntegrationTest): await db.test.delete_many({}) auto_id = {"hello": "world"} await db.test.insert_one(auto_id) - self.assertTrue(isinstance(auto_id["_id"], ObjectId)) + self.assertIsInstance(auto_id["_id"], ObjectId) numeric = {"_id": 240, "hello": "world"} await db.test.insert_one(numeric) @@ -1346,7 +1346,7 @@ class AsyncTestCollection(AsyncIntegrationTest): id1 = (await db.test.insert_one({"x": 1})).inserted_id result = await db.test.replace_one({"x": 1}, {"y": 1}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) self.assertTrue(result.modified_count in (None, 1)) self.assertIsNone(result.upserted_id) @@ -1357,7 +1357,7 @@ class AsyncTestCollection(AsyncIntegrationTest): replacement = RawBSONDocument(encode({"_id": id1, "z": 1})) result = await db.test.replace_one({"y": 1}, replacement, True) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) self.assertTrue(result.modified_count in (None, 1)) self.assertIsNone(result.upserted_id) @@ -1367,16 +1367,16 @@ class AsyncTestCollection(AsyncIntegrationTest): self.assertEqual((await db.test.find_one(id1))["z"], 1) # type: ignore result = await db.test.replace_one({"x": 2}, {"y": 2}, True) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(0, result.matched_count) self.assertTrue(result.modified_count in (None, 0)) - self.assertTrue(isinstance(result.upserted_id, ObjectId)) + self.assertIsInstance(result.upserted_id, ObjectId) self.assertTrue(result.acknowledged) self.assertEqual(1, await db.test.count_documents({"y": 2})) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) result = await db.test.replace_one({"x": 0}, {"y": 0}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertRaises(InvalidOperation, lambda: result.matched_count) self.assertRaises(InvalidOperation, lambda: result.modified_count) self.assertRaises(InvalidOperation, lambda: result.upserted_id) @@ -1391,7 +1391,7 @@ class AsyncTestCollection(AsyncIntegrationTest): id1 = (await db.test.insert_one({"x": 5})).inserted_id result = await db.test.update_one({}, {"$inc": {"x": 1}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) self.assertTrue(result.modified_count in (None, 1)) self.assertIsNone(result.upserted_id) @@ -1400,7 +1400,7 @@ class AsyncTestCollection(AsyncIntegrationTest): id2 = (await db.test.insert_one({"x": 1})).inserted_id result = await db.test.update_one({"x": 6}, {"$inc": {"x": 1}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) self.assertTrue(result.modified_count in (None, 1)) self.assertIsNone(result.upserted_id) @@ -1409,15 +1409,15 @@ class AsyncTestCollection(AsyncIntegrationTest): self.assertEqual((await db.test.find_one(id2))["x"], 1) # type: ignore result = await db.test.update_one({"x": 2}, {"$set": {"y": 1}}, True) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(0, result.matched_count) self.assertTrue(result.modified_count in (None, 0)) - self.assertTrue(isinstance(result.upserted_id, ObjectId)) + self.assertIsInstance(result.upserted_id, ObjectId) self.assertTrue(result.acknowledged) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) result = await db.test.update_one({"x": 0}, {"$inc": {"x": 1}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertRaises(InvalidOperation, lambda: result.matched_count) self.assertRaises(InvalidOperation, lambda: result.modified_count) self.assertRaises(InvalidOperation, lambda: result.upserted_id) @@ -1448,7 +1448,7 @@ class AsyncTestCollection(AsyncIntegrationTest): await db.test.insert_one({"x": 4, "y": 4}) result = await db.test.update_many({"x": 4}, {"$set": {"y": 5}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(2, result.matched_count) self.assertTrue(result.modified_count in (None, 2)) self.assertIsNone(result.upserted_id) @@ -1456,7 +1456,7 @@ class AsyncTestCollection(AsyncIntegrationTest): self.assertEqual(3, await db.test.count_documents({"y": 5})) result = await db.test.update_many({"x": 5}, {"$set": {"y": 6}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) self.assertTrue(result.modified_count in (None, 1)) self.assertIsNone(result.upserted_id) @@ -1464,15 +1464,15 @@ class AsyncTestCollection(AsyncIntegrationTest): self.assertEqual(1, await db.test.count_documents({"y": 6})) result = await db.test.update_many({"x": 2}, {"$set": {"y": 1}}, True) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(0, result.matched_count) self.assertTrue(result.modified_count in (None, 0)) - self.assertTrue(isinstance(result.upserted_id, ObjectId)) + self.assertIsInstance(result.upserted_id, ObjectId) self.assertTrue(result.acknowledged) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) result = await db.test.update_many({"x": 0}, {"$inc": {"x": 1}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertRaises(InvalidOperation, lambda: result.matched_count) self.assertRaises(InvalidOperation, lambda: result.modified_count) self.assertRaises(InvalidOperation, lambda: result.upserted_id) @@ -1556,7 +1556,7 @@ class AsyncTestCollection(AsyncIntegrationTest): pipeline = {"$project": {"_id": False, "foo": True}} result = await db.test.aggregate([pipeline]) - self.assertTrue(isinstance(result, AsyncCommandCursor)) + self.assertIsInstance(result, AsyncCommandCursor) self.assertEqual([{"foo": [1, 2]}], await result.to_list()) # Test write concern. @@ -1574,7 +1574,7 @@ class AsyncTestCollection(AsyncIntegrationTest): pipeline = {"$project": {"_id": False, "foo": True}} coll = db.get_collection("test", codec_options=CodecOptions(document_class=RawBSONDocument)) result = await coll.aggregate([pipeline]) - self.assertTrue(isinstance(result, AsyncCommandCursor)) + self.assertIsInstance(result, AsyncCommandCursor) first_result = await anext(result) self.assertIsInstance(first_result, RawBSONDocument) self.assertEqual([1, 2], list(first_result["foo"])) @@ -1583,7 +1583,7 @@ class AsyncTestCollection(AsyncIntegrationTest): db = self.db projection = {"$project": {"_id": "$_id"}} cursor = await db.test.aggregate([projection], cursor={}) - self.assertTrue(isinstance(cursor, AsyncCommandCursor)) + self.assertIsInstance(cursor, AsyncCommandCursor) async def test_aggregation_cursor(self): db = self.db @@ -2208,9 +2208,9 @@ class AsyncTestCollection(AsyncIntegrationTest): await c.drop() await c.insert_one({"r": re.compile(".*")}) - self.assertTrue(isinstance((await c.find_one())["r"], Regex)) # type: ignore + self.assertIsInstance((await c.find_one())["r"], Regex) # type: ignore async for doc in c.find(): - self.assertTrue(isinstance(doc["r"], Regex)) + self.assertIsInstance(doc["r"], Regex) def test_find_command_generation(self): cmd = _gen_find_command( diff --git a/test/asynchronous/test_cursor.py b/test/asynchronous/test_cursor.py index 3c8570f33..5e4e590fe 100644 --- a/test/asynchronous/test_cursor.py +++ b/test/asynchronous/test_cursor.py @@ -959,7 +959,7 @@ class TestCursor(AsyncIntegrationTest): cursor = self.db.test.find().hint([("z", 1), ("a", 1)]) cursor2 = copy.deepcopy(cursor) # Internal types are now dict rather than SON by default - self.assertTrue(isinstance(cursor2._hint, dict)) + self.assertIsInstance(cursor2._hint, dict) self.assertEqual(cursor._hint, cursor2._hint) @async_client_context.require_sync diff --git a/test/asynchronous/test_custom_types.py b/test/asynchronous/test_custom_types.py index 0ab9e95fe..b3a51ae71 100644 --- a/test/asynchronous/test_custom_types.py +++ b/test/asynchronous/test_custom_types.py @@ -793,7 +793,7 @@ class TestGridFileCustomType(AsyncIntegrationTest): self.assertEqual(5, two._id) self.assertEqual(11, two.length) self.assertEqual(1000, two.chunk_size) - self.assertTrue(isinstance(two.upload_date, datetime.datetime)) + self.assertIsInstance(two.upload_date, datetime.datetime) self.assertEqual({"foo": "red", "bar": "blue"}, two.metadata) self.assertEqual(3, two.bar) diff --git a/test/asynchronous/test_database.py b/test/asynchronous/test_database.py index b2ddd4122..1e0f0c40d 100644 --- a/test/asynchronous/test_database.py +++ b/test/asynchronous/test_database.py @@ -91,7 +91,7 @@ class TestDatabaseNoConnect(unittest.TestCase): def test_getattr(self): db = self.client.pymongo_test - self.assertTrue(isinstance(db["_does_not_exist"], AsyncCollection)) + self.assertIsInstance(db["_does_not_exist"], AsyncCollection) with self.assertRaises(AttributeError) as context: db._does_not_exist @@ -428,7 +428,7 @@ class TestDatabase(AsyncIntegrationTest): result = await db.command("aggregate", "test", pipeline=[], cursor={}) for doc in result["cursor"]["firstBatch"]: - self.assertTrue(isinstance(doc["r"], Regex)) + self.assertIsInstance(doc["r"], Regex) async def test_command_bulkWrite(self): # Ensure bulk write commands can be run directly via db.command(). @@ -472,7 +472,7 @@ class TestDatabase(AsyncIntegrationTest): with self.assertRaises(TypeError): auth._password_digest(None) # type: ignore[arg-type, call-arg] - self.assertTrue(isinstance(auth._password_digest("mike", "password"), str)) + self.assertIsInstance(auth._password_digest("mike", "password"), str) self.assertEqual( auth._password_digest("mike", "password"), "cd7e45b3b2767dc2fa9b6b548457ed00" ) @@ -543,7 +543,7 @@ class TestDatabase(AsyncIntegrationTest): a_doc = SON({"hello": "world"}) a_key = (await db.test.insert_one(a_doc)).inserted_id - self.assertTrue(isinstance(a_doc["_id"], ObjectId)) + self.assertIsInstance(a_doc["_id"], ObjectId) self.assertEqual(a_doc["_id"], a_key) self.assertEqual(a_doc, await db.test.find_one({"_id": a_doc["_id"]})) self.assertEqual(a_doc, await db.test.find_one(a_key)) diff --git a/test/asynchronous/test_encryption.py b/test/asynchronous/test_encryption.py index 9e8758a1c..9093b97ab 100644 --- a/test/asynchronous/test_encryption.py +++ b/test/asynchronous/test_encryption.py @@ -2469,16 +2469,16 @@ class TestLookupProse(AsyncEncryptionIntegrationTest): await encrypted_client.db.csfle.insert_one({"csfle": "csfle"}) doc = await unencrypted_client.db.csfle.find_one() - self.assertTrue(isinstance(doc["csfle"], Binary)) + self.assertIsInstance(doc["csfle"], Binary) await encrypted_client.db.csfle2.insert_one({"csfle2": "csfle2"}) doc = await unencrypted_client.db.csfle2.find_one() - self.assertTrue(isinstance(doc["csfle2"], Binary)) + self.assertIsInstance(doc["csfle2"], Binary) await encrypted_client.db.qe.insert_one({"qe": "qe"}) doc = await unencrypted_client.db.qe.find_one() - self.assertTrue(isinstance(doc["qe"], Binary)) + self.assertIsInstance(doc["qe"], Binary) await encrypted_client.db.qe2.insert_one({"qe2": "qe2"}) doc = await unencrypted_client.db.qe2.find_one() - self.assertTrue(isinstance(doc["qe2"], Binary)) + self.assertIsInstance(doc["qe2"], Binary) await encrypted_client.db.no_schema.insert_one({"no_schema": "no_schema"}) await encrypted_client.db.no_schema2.insert_one({"no_schema2": "no_schema2"}) diff --git a/test/asynchronous/test_grid_file.py b/test/asynchronous/test_grid_file.py index 3f864367d..f3ca59614 100644 --- a/test/asynchronous/test_grid_file.py +++ b/test/asynchronous/test_grid_file.py @@ -150,7 +150,7 @@ class AsyncTestGridFile(AsyncIntegrationTest): a = AsyncGridIn(self.db.fs) - self.assertTrue(isinstance(a._id, ObjectId)) + self.assertIsInstance(a._id, ObjectId) self.assertRaises(AttributeError, setattr, a, "_id", 5) self.assertEqual(None, a.filename) @@ -195,7 +195,7 @@ class AsyncTestGridFile(AsyncIntegrationTest): self.assertEqual(42, a.forty_two) - self.assertTrue(isinstance(a._id, ObjectId)) + self.assertIsInstance(a._id, ObjectId) self.assertRaises(AttributeError, setattr, a, "_id", 5) self.assertEqual("my_file", a.filename) @@ -209,7 +209,7 @@ class AsyncTestGridFile(AsyncIntegrationTest): self.assertEqual(255 * 1024, a.chunk_size) self.assertRaises(AttributeError, setattr, a, "chunk_size", 5) - self.assertTrue(isinstance(a.upload_date, datetime.datetime)) + self.assertIsInstance(a.upload_date, datetime.datetime) self.assertRaises(AttributeError, setattr, a, "upload_date", 5) self.assertEqual(["foo"], a.aliases) @@ -248,7 +248,7 @@ class AsyncTestGridFile(AsyncIntegrationTest): self.assertEqual(None, b.name) self.assertEqual(None, b.filename) self.assertEqual(255 * 1024, b.chunk_size) - self.assertTrue(isinstance(b.upload_date, datetime.datetime)) + self.assertIsInstance(b.upload_date, datetime.datetime) self.assertEqual(None, b.aliases) self.assertEqual(None, b.metadata) self.assertEqual(None, b.md5) @@ -309,7 +309,7 @@ class AsyncTestGridFile(AsyncIntegrationTest): self.assertEqual(11, two.length) self.assertEqual("text/html", two.content_type) self.assertEqual(1000, two.chunk_size) - self.assertTrue(isinstance(two.upload_date, datetime.datetime)) + self.assertIsInstance(two.upload_date, datetime.datetime) self.assertEqual(["foo"], two.aliases) self.assertEqual({"foo": 1, "bar": 2}, two.metadata) self.assertEqual(3, two.bar) diff --git a/test/asynchronous/test_gridfs.py b/test/asynchronous/test_gridfs.py index f886601f3..f60352f3c 100644 --- a/test/asynchronous/test_gridfs.py +++ b/test/asynchronous/test_gridfs.py @@ -157,7 +157,7 @@ class TestGridfs(AsyncIntegrationTest): assert raw is not None self.assertEqual(0, raw["length"]) self.assertEqual(oid, raw["_id"]) - self.assertTrue(isinstance(raw["uploadDate"], datetime.datetime)) + self.assertIsInstance(raw["uploadDate"], datetime.datetime) self.assertEqual(255 * 1024, raw["chunkSize"]) self.assertNotIn("md5", raw) diff --git a/test/asynchronous/test_gridfs_bucket.py b/test/asynchronous/test_gridfs_bucket.py index e8d063b71..4640507e9 100644 --- a/test/asynchronous/test_gridfs_bucket.py +++ b/test/asynchronous/test_gridfs_bucket.py @@ -136,7 +136,7 @@ class TestGridfs(AsyncIntegrationTest): assert raw is not None self.assertEqual(0, raw["length"]) self.assertEqual(oid, raw["_id"]) - self.assertTrue(isinstance(raw["uploadDate"], datetime.datetime)) + self.assertIsInstance(raw["uploadDate"], datetime.datetime) self.assertEqual(255 * 1024, raw["chunkSize"]) self.assertNotIn("md5", raw) diff --git a/test/asynchronous/test_monitoring.py b/test/asynchronous/test_monitoring.py index a7d56a8cf..b2ca1aaaa 100644 --- a/test/asynchronous/test_monitoring.py +++ b/test/asynchronous/test_monitoring.py @@ -68,26 +68,26 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand(SON([("ping", 1)]), started.command) self.assertEqual("ping", started.command_name) self.assertEqual(await self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) + self.assertIsInstance(started.request_id, int) async def test_succeeded_simple(self): await self.client.pymongo_test.command("ping") started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) self.assertEqual("ping", succeeded.command_name) self.assertEqual(await self.client.address, succeeded.connection_id) self.assertEqual(1, succeeded.reply.get("ok")) - self.assertTrue(isinstance(succeeded.request_id, int)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(succeeded.request_id, int) + self.assertIsInstance(succeeded.duration_micros, int) async def test_failed_simple(self): try: @@ -97,21 +97,21 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest): started = self.listener.started_events[0] failed = self.listener.failed_events[0] self.assertEqual(0, len(self.listener.succeeded_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) - self.assertTrue(isinstance(failed, monitoring.CommandFailedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) + self.assertIsInstance(failed, monitoring.CommandFailedEvent) self.assertEqual("oops!", failed.command_name) self.assertEqual(await self.client.address, failed.connection_id) self.assertEqual(0, failed.failure.get("ok")) - self.assertTrue(isinstance(failed.request_id, int)) - self.assertTrue(isinstance(failed.duration_micros, int)) + self.assertIsInstance(failed.request_id, int) + self.assertIsInstance(failed.duration_micros, int) async def test_find_one(self): await self.client.pymongo_test.test.find_one() started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON([("find", "test"), ("filter", {}), ("limit", 1), ("singleBatch", True)]), started.command, @@ -119,7 +119,7 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest): self.assertEqual("find", started.command_name) self.assertEqual(await self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) + self.assertIsInstance(started.request_id, int) async def test_find_and_get_more(self): await self.client.pymongo_test.test.drop() @@ -132,7 +132,7 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON( [("find", "test"), ("filter", {}), ("projection", {"_id": False}), ("batchSize", 4)] @@ -142,11 +142,11 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest): self.assertEqual("find", started.command_name) self.assertEqual(await self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("find", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(cursor.address, succeeded.connection_id) csr = succeeded.reply["cursor"] self.assertEqual(csr["id"], cursor_id) @@ -161,7 +161,7 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 4)]), started.command, @@ -169,11 +169,11 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest): self.assertEqual("getMore", started.command_name) self.assertEqual(await self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("getMore", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(cursor.address, succeeded.connection_id) csr = succeeded.reply["cursor"] self.assertEqual(csr["id"], cursor_id) @@ -196,16 +196,16 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand(cmd, started.command) self.assertEqual("explain", started.command_name) self.assertEqual(await self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("explain", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(await self.client.address, succeeded.connection_id) self.assertEqual(res, succeeded.reply) @@ -227,16 +227,16 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand(expected_cmd, started.command) self.assertEqual("find", started.command_name) self.assertEqual(await self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("find", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(await self.client.address, succeeded.connection_id) finally: # Exhaust the cursor to avoid kill cursors. @@ -308,7 +308,7 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON( [ @@ -322,11 +322,11 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest): self.assertEqual("aggregate", started.command_name) self.assertEqual(await self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("aggregate", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(cursor.address, succeeded.connection_id) expected_cursor = { "id": cursor_id, @@ -341,7 +341,7 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 4)]), started.command, @@ -349,11 +349,11 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest): self.assertEqual("getMore", started.command_name) self.assertEqual(await self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("getMore", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(cursor.address, succeeded.connection_id) expected_result = { "cursor": { @@ -381,18 +381,18 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest): started = self.listener.started_events[0] self.assertEqual(0, len(self.listener.succeeded_events)) failed = self.listener.failed_events[0] - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON([("getMore", cursor_id), ("collection", "test")]), started.command ) self.assertEqual("getMore", started.command_name) self.assertEqual(await self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(failed, monitoring.CommandFailedEvent)) - self.assertTrue(isinstance(failed.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(failed, monitoring.CommandFailedEvent) + self.assertIsInstance(failed.duration_micros, int) self.assertEqual("getMore", failed.command_name) - self.assertTrue(isinstance(failed.request_id, int)) + self.assertIsInstance(failed.request_id, int) self.assertEqual(cursor.address, failed.connection_id) self.assertEqual(0, failed.failure.get("ok")) @@ -412,13 +412,13 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest): started = self.listener.started_events[0] failed = self.listener.failed_events[0] self.assertEqual(0, len(self.listener.succeeded_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) - self.assertTrue(isinstance(failed, monitoring.CommandFailedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) + self.assertIsInstance(failed, monitoring.CommandFailedEvent) self.assertEqual("findAndModify", failed.command_name) self.assertEqual(address, failed.connection_id) self.assertEqual(0, failed.failure.get("ok")) - self.assertTrue(isinstance(failed.request_id, int)) - self.assertTrue(isinstance(failed.duration_micros, int)) + self.assertIsInstance(failed.request_id, int) + self.assertIsInstance(failed.duration_micros, int) self.assertEqual(error, failed.failure) @async_client_context.require_no_mongos @@ -434,7 +434,7 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON( [("find", "test"), ("filter", {}), ("projection", {"_id": False}), ("batchSize", 5)] @@ -444,11 +444,11 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest): self.assertEqual("find", started.command_name) self.assertEqual(cursor.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("find", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(cursor.address, succeeded.connection_id) expected_result = { "cursor": { @@ -464,7 +464,7 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest): tuple(await cursor.to_list()) self.assertEqual(0, len(self.listener.failed_events)) for event in self.listener.started_events: - self.assertTrue(isinstance(event, monitoring.CommandStartedEvent)) + self.assertIsInstance(event, monitoring.CommandStartedEvent) self.assertEqualCommand( SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 5)]), event.command, @@ -472,12 +472,12 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest): self.assertEqual("getMore", event.command_name) self.assertEqual(cursor.address, event.connection_id) self.assertEqual("pymongo_test", event.database_name) - self.assertTrue(isinstance(event.request_id, int)) + self.assertIsInstance(event.request_id, int) for event in self.listener.succeeded_events: - self.assertTrue(isinstance(event, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(event.duration_micros, int)) + self.assertIsInstance(event, monitoring.CommandSucceededEvent) + self.assertIsInstance(event.duration_micros, int) self.assertEqual("getMore", event.command_name) - self.assertTrue(isinstance(event.request_id, int)) + self.assertIsInstance(event.request_id, int) self.assertEqual(cursor.address, event.connection_id) # Last getMore receives a response with cursor id 0. self.assertEqual(0, self.listener.succeeded_events[-1].reply["cursor"]["id"]) @@ -495,7 +495,7 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) # There could be more than one cursor_id here depending on # when the thread last ran. self.assertIn(cursor_id, started.command["cursors"]) @@ -503,11 +503,11 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest): self.assertIs(type(started.connection_id), tuple) self.assertEqual(cursor.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("killCursors", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertIs(type(succeeded.connection_id), tuple) self.assertEqual(cursor.address, succeeded.connection_id) # There could be more than one cursor_id here depending on @@ -1157,13 +1157,13 @@ class AsyncTestGlobalListener(AsyncIntegrationTest): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand(SON([("ping", 1)]), started.command) self.assertEqual("ping", started.command_name) self.assertEqual(await self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) + self.assertIsInstance(started.request_id, int) class AsyncTestEventClasses(unittest.IsolatedAsyncioTestCase): diff --git a/test/test_binary.py b/test/test_binary.py index 567c5ae92..a64aa4228 100644 --- a/test/test_binary.py +++ b/test/test_binary.py @@ -82,8 +82,8 @@ class TestBinary(unittest.TestCase): a_binary = Binary(b"hello world") self.assertTrue(a_binary.startswith(b"hello")) self.assertTrue(a_binary.endswith(b"world")) - self.assertTrue(isinstance(a_binary, Binary)) - self.assertFalse(isinstance(a_string, Binary)) + self.assertIsInstance(a_binary, Binary) + self.assertNotIsInstance(a_string, Binary) def test_exceptions(self): self.assertRaises(TypeError, Binary, None) diff --git a/test/test_bson.py b/test/test_bson.py index 1616c513c..23e0a29c4 100644 --- a/test/test_bson.py +++ b/test/test_bson.py @@ -142,7 +142,7 @@ class TestBSON(unittest.TestCase): helper({}) helper({"test": "hello"}) - self.assertTrue(isinstance(decoder(encoder({"hello": "world"}))["hello"], str)) + self.assertIsInstance(decoder(encoder({"hello": "world"}))["hello"], str) helper({"mike": -10120}) helper({"long": Int64(10)}) helper({"really big long": 2147483648}) @@ -557,7 +557,7 @@ class TestBSON(unittest.TestCase): try: decode(bs) except Exception as exc: - self.assertTrue(isinstance(exc, InvalidBSON)) + self.assertIsInstance(exc, InvalidBSON) self.assertIn(part, str(exc)) else: self.fail("Failed to raise an exception.") @@ -722,7 +722,7 @@ class TestBSON(unittest.TestCase): opts = CodecOptions(uuid_representation=UuidRepresentation.STANDARD) 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.assertNotEqual(uuid.uuid4(), transformed_id) @@ -731,7 +731,7 @@ class TestBSON(unittest.TestCase): legacy = Binary.from_uuid(id, UuidRepresentation.PYTHON_LEGACY) self.assertEqual(3, legacy.subtype) bin = decode(encode({"uuid": legacy}))["uuid"] - self.assertTrue(isinstance(bin, Binary)) + self.assertIsInstance(bin, Binary) transformed = bin.as_uuid(UuidRepresentation.PYTHON_LEGACY) self.assertEqual(id, transformed) @@ -787,7 +787,7 @@ class TestBSON(unittest.TestCase): try: Binary.from_vector([x], BinaryVectorDtype.PACKED_BIT) except Exception as exc: - self.assertTrue(isinstance(exc, struct.error)) + self.assertIsInstance(exc, struct.error) else: self.fail("Failed to raise an exception.") @@ -886,7 +886,7 @@ class TestBSON(unittest.TestCase): y = {"hello": iso8859_bytes} # Stored as BSON binary subtype 0. out = decode(encode(y)) - self.assertTrue(isinstance(out["hello"], bytes)) + self.assertIsInstance(out["hello"], bytes) self.assertEqual(out["hello"], iso8859_bytes) def test_null_character(self): diff --git a/test/test_bulk.py b/test/test_bulk.py index 8a863cc49..00c6c5e64 100644 --- a/test/test_bulk.py +++ b/test/test_bulk.py @@ -281,7 +281,7 @@ class TestBulk(BulkTestBase): self.assertEqual(1, result.upserted_count) assert result.upserted_ids is not None self.assertEqual(1, len(result.upserted_ids)) - self.assertTrue(isinstance(result.upserted_ids.get(0), ObjectId)) + self.assertIsInstance(result.upserted_ids.get(0), ObjectId) self.assertEqual(self.coll.count_documents({"foo": "bar"}), 1) @@ -996,7 +996,7 @@ class TestBulkWriteConcern(BulkTestBase): failed = details["writeConcernErrors"][0] self.assertEqual(64, failed["code"]) - self.assertTrue(isinstance(failed["errmsg"], str)) + self.assertIsInstance(failed["errmsg"], str) self.coll.delete_many({}) self.coll.create_index("a", unique=True) @@ -1101,12 +1101,12 @@ class TestBulkWriteConcern(BulkTestBase): failed = details["writeErrors"][0] self.assertEqual(2, failed["index"]) self.assertEqual(11000, failed["code"]) - self.assertTrue(isinstance(failed["errmsg"], str)) + self.assertIsInstance(failed["errmsg"], str) self.assertEqual(1, failed["op"]["a"]) failed = details["writeConcernErrors"][0] self.assertEqual(64, failed["code"]) - self.assertTrue(isinstance(failed["errmsg"], str)) + self.assertIsInstance(failed["errmsg"], str) upserts = details["upserted"] self.assertEqual(1, len(upserts)) diff --git a/test/test_client.py b/test/test_client.py index 189e58e80..4f2e5751a 100644 --- a/test/test_client.py +++ b/test/test_client.py @@ -211,7 +211,7 @@ class ClientUnitTest(UnitTest): self.assertRaises(InvalidName, make_db, self.client, "te/t") self.assertRaises(InvalidName, make_db, self.client, "te st") - self.assertTrue(isinstance(self.client.test, Database)) + self.assertIsInstance(self.client.test, Database) self.assertEqual(self.client.test, self.client["test"]) self.assertEqual(self.client.test, Database(self.client, "test")) @@ -225,7 +225,7 @@ class ClientUnitTest(UnitTest): self.assertEqual(write_concern, db.write_concern) def test_getattr(self): - self.assertTrue(isinstance(self.client["_does_not_exist"], Database)) + self.assertIsInstance(self.client["_does_not_exist"], Database) with self.assertRaises(AttributeError) as context: self.client._does_not_exist @@ -1237,15 +1237,15 @@ class TestClient(IntegrationTest): db.test.insert_one({"x": 1}) self.assertEqual(dict, c.codec_options.document_class) - self.assertTrue(isinstance(db.test.find_one(), dict)) - self.assertFalse(isinstance(db.test.find_one(), SON)) + self.assertIsInstance(db.test.find_one(), dict) + self.assertNotIsInstance(db.test.find_one(), SON) c = self.rs_or_single_client(document_class=SON) db = c.pymongo_test self.assertEqual(SON, c.codec_options.document_class) - self.assertTrue(isinstance(db.test.find_one(), SON)) + self.assertIsInstance(db.test.find_one(), SON) def test_timeouts(self): client = self.rs_or_single_client( diff --git a/test/test_code.py b/test/test_code.py index c564e3e04..23f0af5ce 100644 --- a/test/test_code.py +++ b/test/test_code.py @@ -46,8 +46,8 @@ class TestCode(unittest.TestCase): a_code = Code("hello world") self.assertTrue(a_code.startswith("hello")) self.assertTrue(a_code.endswith("world")) - self.assertTrue(isinstance(a_code, Code)) - self.assertFalse(isinstance(a_string, Code)) + self.assertIsInstance(a_code, Code) + self.assertNotIsInstance(a_string, Code) self.assertIsNone(a_code.scope) with_scope = Code("hello world", {"my_var": 5}) self.assertEqual({"my_var": 5}, with_scope.scope) diff --git a/test/test_collection.py b/test/test_collection.py index 75c11383d..6d1b02f1a 100644 --- a/test/test_collection.py +++ b/test/test_collection.py @@ -111,7 +111,7 @@ class TestCollectionNoConnect(UnitTest): def test_getattr(self): coll = self.db.test - self.assertTrue(isinstance(coll["_does_not_exist"], Collection)) + self.assertIsInstance(coll["_does_not_exist"], Collection) with self.assertRaises(AttributeError) as context: coll._does_not_exist @@ -176,7 +176,7 @@ class TestCollection(IntegrationTest): yield self.db.test def test_equality(self): - self.assertTrue(isinstance(self.db.test, Collection)) + self.assertIsInstance(self.db.test, Collection) self.assertEqual(self.db.test, self.db["test"]) self.assertEqual(self.db.test, Collection(self.db, "test")) self.assertEqual(self.db.test.mike, self.db["test.mike"]) @@ -706,8 +706,8 @@ class TestCollection(IntegrationTest): document: dict[str, Any] = {"_id": 1000} result = db.test.insert_one(document) - self.assertTrue(isinstance(result, InsertOneResult)) - self.assertTrue(isinstance(result.inserted_id, int)) + self.assertIsInstance(result, InsertOneResult) + self.assertIsInstance(result.inserted_id, int) self.assertEqual(document["_id"], result.inserted_id) self.assertTrue(result.acknowledged) self.assertIsNotNone(db.test.find_one({"_id": document["_id"]})) @@ -715,8 +715,8 @@ class TestCollection(IntegrationTest): document = {"foo": "bar"} result = db.test.insert_one(document) - self.assertTrue(isinstance(result, InsertOneResult)) - self.assertTrue(isinstance(result.inserted_id, ObjectId)) + self.assertIsInstance(result, InsertOneResult) + self.assertIsInstance(result.inserted_id, ObjectId) self.assertEqual(document["_id"], result.inserted_id) self.assertTrue(result.acknowledged) self.assertIsNotNone(db.test.find_one({"_id": document["_id"]})) @@ -724,8 +724,8 @@ class TestCollection(IntegrationTest): db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) result = db.test.insert_one(document) - self.assertTrue(isinstance(result, InsertOneResult)) - self.assertTrue(isinstance(result.inserted_id, ObjectId)) + self.assertIsInstance(result, InsertOneResult) + self.assertIsInstance(result.inserted_id, ObjectId) self.assertEqual(document["_id"], result.inserted_id) self.assertFalse(result.acknowledged) # The insert failed duplicate key... @@ -737,7 +737,7 @@ class TestCollection(IntegrationTest): document = RawBSONDocument(encode({"_id": ObjectId(), "foo": "bar"})) result = db.test.insert_one(document) - self.assertTrue(isinstance(result, InsertOneResult)) + self.assertIsInstance(result, InsertOneResult) self.assertEqual(result.inserted_id, None) def test_insert_many(self): @@ -746,38 +746,38 @@ class TestCollection(IntegrationTest): docs: list = [{} for _ in range(5)] result = db.test.insert_many(docs) - self.assertTrue(isinstance(result, InsertManyResult)) - self.assertTrue(isinstance(result.inserted_ids, list)) + self.assertIsInstance(result, InsertManyResult) + self.assertIsInstance(result.inserted_ids, list) self.assertEqual(5, len(result.inserted_ids)) for doc in docs: _id = doc["_id"] - self.assertTrue(isinstance(_id, ObjectId)) + self.assertIsInstance(_id, ObjectId) self.assertTrue(_id in result.inserted_ids) self.assertEqual(1, db.test.count_documents({"_id": _id})) self.assertTrue(result.acknowledged) docs = [{"_id": i} for i in range(5)] result = db.test.insert_many(docs) - self.assertTrue(isinstance(result, InsertManyResult)) - self.assertTrue(isinstance(result.inserted_ids, list)) + self.assertIsInstance(result, InsertManyResult) + self.assertIsInstance(result.inserted_ids, list) self.assertEqual(5, len(result.inserted_ids)) for doc in docs: _id = doc["_id"] - self.assertTrue(isinstance(_id, int)) + self.assertIsInstance(_id, int) self.assertTrue(_id in result.inserted_ids) self.assertEqual(1, db.test.count_documents({"_id": _id})) self.assertTrue(result.acknowledged) docs = [RawBSONDocument(encode({"_id": i + 5})) for i in range(5)] result = db.test.insert_many(docs) - self.assertTrue(isinstance(result, InsertManyResult)) - self.assertTrue(isinstance(result.inserted_ids, list)) + self.assertIsInstance(result, InsertManyResult) + self.assertIsInstance(result.inserted_ids, list) self.assertEqual([], result.inserted_ids) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) docs: list = [{} for _ in range(5)] result = db.test.insert_many(docs) - self.assertTrue(isinstance(result, InsertManyResult)) + self.assertIsInstance(result, InsertManyResult) self.assertFalse(result.acknowledged) self.assertEqual(20, db.test.count_documents({})) @@ -818,20 +818,20 @@ class TestCollection(IntegrationTest): self.db.test.insert_one({"z": 1}) result = self.db.test.delete_one({"x": 1}) - self.assertTrue(isinstance(result, DeleteResult)) + self.assertIsInstance(result, DeleteResult) self.assertEqual(1, result.deleted_count) self.assertTrue(result.acknowledged) self.assertEqual(2, self.db.test.count_documents({})) result = self.db.test.delete_one({"y": 1}) - self.assertTrue(isinstance(result, DeleteResult)) + self.assertIsInstance(result, DeleteResult) self.assertEqual(1, result.deleted_count) self.assertTrue(result.acknowledged) self.assertEqual(1, self.db.test.count_documents({})) db = self.db.client.get_database(self.db.name, write_concern=WriteConcern(w=0)) result = db.test.delete_one({"z": 1}) - self.assertTrue(isinstance(result, DeleteResult)) + self.assertIsInstance(result, DeleteResult) self.assertRaises(InvalidOperation, lambda: result.deleted_count) self.assertFalse(result.acknowledged) @@ -849,14 +849,14 @@ class TestCollection(IntegrationTest): self.db.test.insert_one({"y": 1}) result = self.db.test.delete_many({"x": 1}) - self.assertTrue(isinstance(result, DeleteResult)) + self.assertIsInstance(result, DeleteResult) self.assertEqual(2, result.deleted_count) self.assertTrue(result.acknowledged) self.assertEqual(0, self.db.test.count_documents({"x": 1})) db = self.db.client.get_database(self.db.name, write_concern=WriteConcern(w=0)) result = db.test.delete_many({"y": 1}) - self.assertTrue(isinstance(result, DeleteResult)) + self.assertIsInstance(result, DeleteResult) self.assertRaises(InvalidOperation, lambda: result.deleted_count) self.assertFalse(result.acknowledged) @@ -908,10 +908,10 @@ class TestCollection(IntegrationTest): with self.assertRaises(OperationFailure): db.test.insert_one({"_id": 1, "x": 100}) result = db.test.insert_one({"_id": 1, "x": 100}, bypass_document_validation=True) - self.assertTrue(isinstance(result, InsertOneResult)) + self.assertIsInstance(result, InsertOneResult) self.assertEqual(1, result.inserted_id) result = db.test.insert_one({"_id": 2, "a": 0}) - self.assertTrue(isinstance(result, InsertOneResult)) + self.assertIsInstance(result, InsertOneResult) self.assertEqual(2, result.inserted_id) db_w0.test.insert_one({"y": 1}, bypass_document_validation=True) @@ -926,21 +926,21 @@ class TestCollection(IntegrationTest): with self.assertRaises(OperationFailure): db.test.insert_many(docs) result = db.test.insert_many(docs, bypass_document_validation=True) - self.assertTrue(isinstance(result, InsertManyResult)) + self.assertIsInstance(result, InsertManyResult) self.assertTrue(97, len(result.inserted_ids)) for doc in docs: _id = doc["_id"] - self.assertTrue(isinstance(_id, int)) + self.assertIsInstance(_id, int) self.assertTrue(_id in result.inserted_ids) self.assertEqual(1, db.test.count_documents({"x": doc["x"]})) self.assertTrue(result.acknowledged) docs = [{"_id": i, "a": 200 - i} for i in range(100, 200)] result = db.test.insert_many(docs) - self.assertTrue(isinstance(result, InsertManyResult)) + self.assertIsInstance(result, InsertManyResult) self.assertTrue(97, len(result.inserted_ids)) for doc in docs: _id = doc["_id"] - self.assertTrue(isinstance(_id, int)) + self.assertIsInstance(_id, int) self.assertTrue(_id in result.inserted_ids) self.assertEqual(1, db.test.count_documents({"a": doc["a"]})) self.assertTrue(result.acknowledged) @@ -1168,7 +1168,7 @@ class TestCollection(IntegrationTest): db.test.delete_many({}) auto_id = {"hello": "world"} db.test.insert_one(auto_id) - self.assertTrue(isinstance(auto_id["_id"], ObjectId)) + self.assertIsInstance(auto_id["_id"], ObjectId) numeric = {"_id": 240, "hello": "world"} db.test.insert_one(numeric) @@ -1332,7 +1332,7 @@ class TestCollection(IntegrationTest): id1 = (db.test.insert_one({"x": 1})).inserted_id result = db.test.replace_one({"x": 1}, {"y": 1}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) self.assertTrue(result.modified_count in (None, 1)) self.assertIsNone(result.upserted_id) @@ -1343,7 +1343,7 @@ class TestCollection(IntegrationTest): replacement = RawBSONDocument(encode({"_id": id1, "z": 1})) result = db.test.replace_one({"y": 1}, replacement, True) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) self.assertTrue(result.modified_count in (None, 1)) self.assertIsNone(result.upserted_id) @@ -1353,16 +1353,16 @@ class TestCollection(IntegrationTest): self.assertEqual((db.test.find_one(id1))["z"], 1) # type: ignore result = db.test.replace_one({"x": 2}, {"y": 2}, True) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(0, result.matched_count) self.assertTrue(result.modified_count in (None, 0)) - self.assertTrue(isinstance(result.upserted_id, ObjectId)) + self.assertIsInstance(result.upserted_id, ObjectId) self.assertTrue(result.acknowledged) self.assertEqual(1, db.test.count_documents({"y": 2})) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) result = db.test.replace_one({"x": 0}, {"y": 0}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertRaises(InvalidOperation, lambda: result.matched_count) self.assertRaises(InvalidOperation, lambda: result.modified_count) self.assertRaises(InvalidOperation, lambda: result.upserted_id) @@ -1377,7 +1377,7 @@ class TestCollection(IntegrationTest): id1 = (db.test.insert_one({"x": 5})).inserted_id result = db.test.update_one({}, {"$inc": {"x": 1}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) self.assertTrue(result.modified_count in (None, 1)) self.assertIsNone(result.upserted_id) @@ -1386,7 +1386,7 @@ class TestCollection(IntegrationTest): id2 = (db.test.insert_one({"x": 1})).inserted_id result = db.test.update_one({"x": 6}, {"$inc": {"x": 1}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) self.assertTrue(result.modified_count in (None, 1)) self.assertIsNone(result.upserted_id) @@ -1395,15 +1395,15 @@ class TestCollection(IntegrationTest): self.assertEqual((db.test.find_one(id2))["x"], 1) # type: ignore result = db.test.update_one({"x": 2}, {"$set": {"y": 1}}, True) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(0, result.matched_count) self.assertTrue(result.modified_count in (None, 0)) - self.assertTrue(isinstance(result.upserted_id, ObjectId)) + self.assertIsInstance(result.upserted_id, ObjectId) self.assertTrue(result.acknowledged) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) result = db.test.update_one({"x": 0}, {"$inc": {"x": 1}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertRaises(InvalidOperation, lambda: result.matched_count) self.assertRaises(InvalidOperation, lambda: result.modified_count) self.assertRaises(InvalidOperation, lambda: result.upserted_id) @@ -1434,7 +1434,7 @@ class TestCollection(IntegrationTest): db.test.insert_one({"x": 4, "y": 4}) result = db.test.update_many({"x": 4}, {"$set": {"y": 5}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(2, result.matched_count) self.assertTrue(result.modified_count in (None, 2)) self.assertIsNone(result.upserted_id) @@ -1442,7 +1442,7 @@ class TestCollection(IntegrationTest): self.assertEqual(3, db.test.count_documents({"y": 5})) result = db.test.update_many({"x": 5}, {"$set": {"y": 6}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) self.assertTrue(result.modified_count in (None, 1)) self.assertIsNone(result.upserted_id) @@ -1450,15 +1450,15 @@ class TestCollection(IntegrationTest): self.assertEqual(1, db.test.count_documents({"y": 6})) result = db.test.update_many({"x": 2}, {"$set": {"y": 1}}, True) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertEqual(0, result.matched_count) self.assertTrue(result.modified_count in (None, 0)) - self.assertTrue(isinstance(result.upserted_id, ObjectId)) + self.assertIsInstance(result.upserted_id, ObjectId) self.assertTrue(result.acknowledged) db = db.client.get_database(db.name, write_concern=WriteConcern(w=0)) result = db.test.update_many({"x": 0}, {"$inc": {"x": 1}}) - self.assertTrue(isinstance(result, UpdateResult)) + self.assertIsInstance(result, UpdateResult) self.assertRaises(InvalidOperation, lambda: result.matched_count) self.assertRaises(InvalidOperation, lambda: result.modified_count) self.assertRaises(InvalidOperation, lambda: result.upserted_id) @@ -1538,7 +1538,7 @@ class TestCollection(IntegrationTest): pipeline = {"$project": {"_id": False, "foo": True}} result = db.test.aggregate([pipeline]) - self.assertTrue(isinstance(result, CommandCursor)) + self.assertIsInstance(result, CommandCursor) self.assertEqual([{"foo": [1, 2]}], result.to_list()) # Test write concern. @@ -1556,7 +1556,7 @@ class TestCollection(IntegrationTest): pipeline = {"$project": {"_id": False, "foo": True}} coll = db.get_collection("test", codec_options=CodecOptions(document_class=RawBSONDocument)) result = coll.aggregate([pipeline]) - self.assertTrue(isinstance(result, CommandCursor)) + self.assertIsInstance(result, CommandCursor) first_result = next(result) self.assertIsInstance(first_result, RawBSONDocument) self.assertEqual([1, 2], list(first_result["foo"])) @@ -1565,7 +1565,7 @@ class TestCollection(IntegrationTest): db = self.db projection = {"$project": {"_id": "$_id"}} cursor = db.test.aggregate([projection], cursor={}) - self.assertTrue(isinstance(cursor, CommandCursor)) + self.assertIsInstance(cursor, CommandCursor) def test_aggregation_cursor(self): db = self.db @@ -2186,9 +2186,9 @@ class TestCollection(IntegrationTest): c.drop() c.insert_one({"r": re.compile(".*")}) - self.assertTrue(isinstance((c.find_one())["r"], Regex)) # type: ignore + self.assertIsInstance((c.find_one())["r"], Regex) # type: ignore for doc in c.find(): - self.assertTrue(isinstance(doc["r"], Regex)) + self.assertIsInstance(doc["r"], Regex) def test_find_command_generation(self): cmd = _gen_find_command( diff --git a/test/test_cursor.py b/test/test_cursor.py index 7b75f4ddc..d5845e39b 100644 --- a/test/test_cursor.py +++ b/test/test_cursor.py @@ -950,7 +950,7 @@ class TestCursor(IntegrationTest): cursor = self.db.test.find().hint([("z", 1), ("a", 1)]) cursor2 = copy.deepcopy(cursor) # Internal types are now dict rather than SON by default - self.assertTrue(isinstance(cursor2._hint, dict)) + self.assertIsInstance(cursor2._hint, dict) self.assertEqual(cursor._hint, cursor2._hint) @client_context.require_sync diff --git a/test/test_custom_types.py b/test/test_custom_types.py index bcdc14f2e..9e8dbcfbe 100644 --- a/test/test_custom_types.py +++ b/test/test_custom_types.py @@ -793,7 +793,7 @@ class TestGridFileCustomType(IntegrationTest): self.assertEqual(5, two._id) self.assertEqual(11, two.length) self.assertEqual(1000, two.chunk_size) - self.assertTrue(isinstance(two.upload_date, datetime.datetime)) + self.assertIsInstance(two.upload_date, datetime.datetime) self.assertEqual({"foo": "red", "bar": "blue"}, two.metadata) self.assertEqual(3, two.bar) diff --git a/test/test_database.py b/test/test_database.py index 4c09b421c..0cb016e26 100644 --- a/test/test_database.py +++ b/test/test_database.py @@ -90,7 +90,7 @@ class TestDatabaseNoConnect(unittest.TestCase): def test_getattr(self): db = self.client.pymongo_test - self.assertTrue(isinstance(db["_does_not_exist"], Collection)) + self.assertIsInstance(db["_does_not_exist"], Collection) with self.assertRaises(AttributeError) as context: db._does_not_exist @@ -423,7 +423,7 @@ class TestDatabase(IntegrationTest): result = db.command("aggregate", "test", pipeline=[], cursor={}) for doc in result["cursor"]["firstBatch"]: - self.assertTrue(isinstance(doc["r"], Regex)) + self.assertIsInstance(doc["r"], Regex) def test_command_bulkWrite(self): # Ensure bulk write commands can be run directly via db.command(). @@ -467,7 +467,7 @@ class TestDatabase(IntegrationTest): with self.assertRaises(TypeError): auth._password_digest(None) # type: ignore[arg-type, call-arg] - self.assertTrue(isinstance(auth._password_digest("mike", "password"), str)) + self.assertIsInstance(auth._password_digest("mike", "password"), str) self.assertEqual( auth._password_digest("mike", "password"), "cd7e45b3b2767dc2fa9b6b548457ed00" ) @@ -538,7 +538,7 @@ class TestDatabase(IntegrationTest): a_doc = SON({"hello": "world"}) a_key = (db.test.insert_one(a_doc)).inserted_id - self.assertTrue(isinstance(a_doc["_id"], ObjectId)) + self.assertIsInstance(a_doc["_id"], ObjectId) self.assertEqual(a_doc["_id"], a_key) self.assertEqual(a_doc, db.test.find_one({"_id": a_doc["_id"]})) self.assertEqual(a_doc, db.test.find_one(a_key)) diff --git a/test/test_encryption.py b/test/test_encryption.py index 4b055b68d..3a86838af 100644 --- a/test/test_encryption.py +++ b/test/test_encryption.py @@ -2453,16 +2453,16 @@ class TestLookupProse(EncryptionIntegrationTest): encrypted_client.db.csfle.insert_one({"csfle": "csfle"}) doc = unencrypted_client.db.csfle.find_one() - self.assertTrue(isinstance(doc["csfle"], Binary)) + self.assertIsInstance(doc["csfle"], Binary) encrypted_client.db.csfle2.insert_one({"csfle2": "csfle2"}) doc = unencrypted_client.db.csfle2.find_one() - self.assertTrue(isinstance(doc["csfle2"], Binary)) + self.assertIsInstance(doc["csfle2"], Binary) encrypted_client.db.qe.insert_one({"qe": "qe"}) doc = unencrypted_client.db.qe.find_one() - self.assertTrue(isinstance(doc["qe"], Binary)) + self.assertIsInstance(doc["qe"], Binary) encrypted_client.db.qe2.insert_one({"qe2": "qe2"}) doc = unencrypted_client.db.qe2.find_one() - self.assertTrue(isinstance(doc["qe2"], Binary)) + self.assertIsInstance(doc["qe2"], Binary) encrypted_client.db.no_schema.insert_one({"no_schema": "no_schema"}) encrypted_client.db.no_schema2.insert_one({"no_schema2": "no_schema2"}) diff --git a/test/test_grid_file.py b/test/test_grid_file.py index 0baeb5ae1..6fe209f43 100644 --- a/test/test_grid_file.py +++ b/test/test_grid_file.py @@ -150,7 +150,7 @@ class TestGridFile(IntegrationTest): a = GridIn(self.db.fs) - self.assertTrue(isinstance(a._id, ObjectId)) + self.assertIsInstance(a._id, ObjectId) self.assertRaises(AttributeError, setattr, a, "_id", 5) self.assertEqual(None, a.filename) @@ -195,7 +195,7 @@ class TestGridFile(IntegrationTest): self.assertEqual(42, a.forty_two) - self.assertTrue(isinstance(a._id, ObjectId)) + self.assertIsInstance(a._id, ObjectId) self.assertRaises(AttributeError, setattr, a, "_id", 5) self.assertEqual("my_file", a.filename) @@ -209,7 +209,7 @@ class TestGridFile(IntegrationTest): self.assertEqual(255 * 1024, a.chunk_size) self.assertRaises(AttributeError, setattr, a, "chunk_size", 5) - self.assertTrue(isinstance(a.upload_date, datetime.datetime)) + self.assertIsInstance(a.upload_date, datetime.datetime) self.assertRaises(AttributeError, setattr, a, "upload_date", 5) self.assertEqual(["foo"], a.aliases) @@ -248,7 +248,7 @@ class TestGridFile(IntegrationTest): self.assertEqual(None, b.name) self.assertEqual(None, b.filename) self.assertEqual(255 * 1024, b.chunk_size) - self.assertTrue(isinstance(b.upload_date, datetime.datetime)) + self.assertIsInstance(b.upload_date, datetime.datetime) self.assertEqual(None, b.aliases) self.assertEqual(None, b.metadata) self.assertEqual(None, b.md5) @@ -309,7 +309,7 @@ class TestGridFile(IntegrationTest): self.assertEqual(11, two.length) self.assertEqual("text/html", two.content_type) self.assertEqual(1000, two.chunk_size) - self.assertTrue(isinstance(two.upload_date, datetime.datetime)) + self.assertIsInstance(two.upload_date, datetime.datetime) self.assertEqual(["foo"], two.aliases) self.assertEqual({"foo": 1, "bar": 2}, two.metadata) self.assertEqual(3, two.bar) diff --git a/test/test_gridfs.py b/test/test_gridfs.py index 75342ee43..8bda04144 100644 --- a/test/test_gridfs.py +++ b/test/test_gridfs.py @@ -157,7 +157,7 @@ class TestGridfs(IntegrationTest): assert raw is not None self.assertEqual(0, raw["length"]) self.assertEqual(oid, raw["_id"]) - self.assertTrue(isinstance(raw["uploadDate"], datetime.datetime)) + self.assertIsInstance(raw["uploadDate"], datetime.datetime) self.assertEqual(255 * 1024, raw["chunkSize"]) self.assertNotIn("md5", raw) diff --git a/test/test_gridfs_bucket.py b/test/test_gridfs_bucket.py index e941369f9..33902c9cf 100644 --- a/test/test_gridfs_bucket.py +++ b/test/test_gridfs_bucket.py @@ -136,7 +136,7 @@ class TestGridfs(IntegrationTest): assert raw is not None self.assertEqual(0, raw["length"]) self.assertEqual(oid, raw["_id"]) - self.assertTrue(isinstance(raw["uploadDate"], datetime.datetime)) + self.assertIsInstance(raw["uploadDate"], datetime.datetime) self.assertEqual(255 * 1024, raw["chunkSize"]) self.assertNotIn("md5", raw) diff --git a/test/test_json_util.py b/test/test_json_util.py index 8aed4a82b..cf2c0efb9 100644 --- a/test/test_json_util.py +++ b/test/test_json_util.py @@ -341,7 +341,7 @@ class TestJsonUtil(unittest.TestCase): pat = "a*b" json_re = '{"$regex": "%s", "$options": "u"}' % pat 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(re.U, loaded.flags) diff --git a/test/test_monitoring.py b/test/test_monitoring.py index ae3e50db7..fc8be127e 100644 --- a/test/test_monitoring.py +++ b/test/test_monitoring.py @@ -66,26 +66,26 @@ class TestCommandMonitoring(IntegrationTest): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand(SON([("ping", 1)]), started.command) self.assertEqual("ping", started.command_name) self.assertEqual(self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) + self.assertIsInstance(started.request_id, int) def test_succeeded_simple(self): self.client.pymongo_test.command("ping") started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) self.assertEqual("ping", succeeded.command_name) self.assertEqual(self.client.address, succeeded.connection_id) self.assertEqual(1, succeeded.reply.get("ok")) - self.assertTrue(isinstance(succeeded.request_id, int)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(succeeded.request_id, int) + self.assertIsInstance(succeeded.duration_micros, int) def test_failed_simple(self): try: @@ -95,21 +95,21 @@ class TestCommandMonitoring(IntegrationTest): started = self.listener.started_events[0] failed = self.listener.failed_events[0] self.assertEqual(0, len(self.listener.succeeded_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) - self.assertTrue(isinstance(failed, monitoring.CommandFailedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) + self.assertIsInstance(failed, monitoring.CommandFailedEvent) self.assertEqual("oops!", failed.command_name) self.assertEqual(self.client.address, failed.connection_id) self.assertEqual(0, failed.failure.get("ok")) - self.assertTrue(isinstance(failed.request_id, int)) - self.assertTrue(isinstance(failed.duration_micros, int)) + self.assertIsInstance(failed.request_id, int) + self.assertIsInstance(failed.duration_micros, int) def test_find_one(self): self.client.pymongo_test.test.find_one() started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON([("find", "test"), ("filter", {}), ("limit", 1), ("singleBatch", True)]), started.command, @@ -117,7 +117,7 @@ class TestCommandMonitoring(IntegrationTest): self.assertEqual("find", started.command_name) self.assertEqual(self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) + self.assertIsInstance(started.request_id, int) def test_find_and_get_more(self): self.client.pymongo_test.test.drop() @@ -130,7 +130,7 @@ class TestCommandMonitoring(IntegrationTest): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON( [("find", "test"), ("filter", {}), ("projection", {"_id": False}), ("batchSize", 4)] @@ -140,11 +140,11 @@ class TestCommandMonitoring(IntegrationTest): self.assertEqual("find", started.command_name) self.assertEqual(self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("find", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(cursor.address, succeeded.connection_id) csr = succeeded.reply["cursor"] self.assertEqual(csr["id"], cursor_id) @@ -159,7 +159,7 @@ class TestCommandMonitoring(IntegrationTest): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 4)]), started.command, @@ -167,11 +167,11 @@ class TestCommandMonitoring(IntegrationTest): self.assertEqual("getMore", started.command_name) self.assertEqual(self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("getMore", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(cursor.address, succeeded.connection_id) csr = succeeded.reply["cursor"] self.assertEqual(csr["id"], cursor_id) @@ -194,16 +194,16 @@ class TestCommandMonitoring(IntegrationTest): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand(cmd, started.command) self.assertEqual("explain", started.command_name) self.assertEqual(self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("explain", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(self.client.address, succeeded.connection_id) self.assertEqual(res, succeeded.reply) @@ -225,16 +225,16 @@ class TestCommandMonitoring(IntegrationTest): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand(expected_cmd, started.command) self.assertEqual("find", started.command_name) self.assertEqual(self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("find", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(self.client.address, succeeded.connection_id) finally: # Exhaust the cursor to avoid kill cursors. @@ -306,7 +306,7 @@ class TestCommandMonitoring(IntegrationTest): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON( [ @@ -320,11 +320,11 @@ class TestCommandMonitoring(IntegrationTest): self.assertEqual("aggregate", started.command_name) self.assertEqual(self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("aggregate", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(cursor.address, succeeded.connection_id) expected_cursor = { "id": cursor_id, @@ -339,7 +339,7 @@ class TestCommandMonitoring(IntegrationTest): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 4)]), started.command, @@ -347,11 +347,11 @@ class TestCommandMonitoring(IntegrationTest): self.assertEqual("getMore", started.command_name) self.assertEqual(self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("getMore", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(cursor.address, succeeded.connection_id) expected_result = { "cursor": { @@ -379,18 +379,18 @@ class TestCommandMonitoring(IntegrationTest): started = self.listener.started_events[0] self.assertEqual(0, len(self.listener.succeeded_events)) failed = self.listener.failed_events[0] - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON([("getMore", cursor_id), ("collection", "test")]), started.command ) self.assertEqual("getMore", started.command_name) self.assertEqual(self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(failed, monitoring.CommandFailedEvent)) - self.assertTrue(isinstance(failed.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(failed, monitoring.CommandFailedEvent) + self.assertIsInstance(failed.duration_micros, int) self.assertEqual("getMore", failed.command_name) - self.assertTrue(isinstance(failed.request_id, int)) + self.assertIsInstance(failed.request_id, int) self.assertEqual(cursor.address, failed.connection_id) self.assertEqual(0, failed.failure.get("ok")) @@ -410,13 +410,13 @@ class TestCommandMonitoring(IntegrationTest): started = self.listener.started_events[0] failed = self.listener.failed_events[0] self.assertEqual(0, len(self.listener.succeeded_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) - self.assertTrue(isinstance(failed, monitoring.CommandFailedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) + self.assertIsInstance(failed, monitoring.CommandFailedEvent) self.assertEqual("findAndModify", failed.command_name) self.assertEqual(address, failed.connection_id) self.assertEqual(0, failed.failure.get("ok")) - self.assertTrue(isinstance(failed.request_id, int)) - self.assertTrue(isinstance(failed.duration_micros, int)) + self.assertIsInstance(failed.request_id, int) + self.assertIsInstance(failed.duration_micros, int) self.assertEqual(error, failed.failure) @client_context.require_no_mongos @@ -432,7 +432,7 @@ class TestCommandMonitoring(IntegrationTest): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand( SON( [("find", "test"), ("filter", {}), ("projection", {"_id": False}), ("batchSize", 5)] @@ -442,11 +442,11 @@ class TestCommandMonitoring(IntegrationTest): self.assertEqual("find", started.command_name) self.assertEqual(cursor.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("find", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertEqual(cursor.address, succeeded.connection_id) expected_result = { "cursor": { @@ -462,7 +462,7 @@ class TestCommandMonitoring(IntegrationTest): tuple(cursor.to_list()) self.assertEqual(0, len(self.listener.failed_events)) for event in self.listener.started_events: - self.assertTrue(isinstance(event, monitoring.CommandStartedEvent)) + self.assertIsInstance(event, monitoring.CommandStartedEvent) self.assertEqualCommand( SON([("getMore", cursor_id), ("collection", "test"), ("batchSize", 5)]), event.command, @@ -470,12 +470,12 @@ class TestCommandMonitoring(IntegrationTest): self.assertEqual("getMore", event.command_name) self.assertEqual(cursor.address, event.connection_id) self.assertEqual("pymongo_test", event.database_name) - self.assertTrue(isinstance(event.request_id, int)) + self.assertIsInstance(event.request_id, int) for event in self.listener.succeeded_events: - self.assertTrue(isinstance(event, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(event.duration_micros, int)) + self.assertIsInstance(event, monitoring.CommandSucceededEvent) + self.assertIsInstance(event.duration_micros, int) self.assertEqual("getMore", event.command_name) - self.assertTrue(isinstance(event.request_id, int)) + self.assertIsInstance(event.request_id, int) self.assertEqual(cursor.address, event.connection_id) # Last getMore receives a response with cursor id 0. self.assertEqual(0, self.listener.succeeded_events[-1].reply["cursor"]["id"]) @@ -493,7 +493,7 @@ class TestCommandMonitoring(IntegrationTest): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(started, monitoring.CommandStartedEvent) # There could be more than one cursor_id here depending on # when the thread last ran. self.assertIn(cursor_id, started.command["cursors"]) @@ -501,11 +501,11 @@ class TestCommandMonitoring(IntegrationTest): self.assertIs(type(started.connection_id), tuple) self.assertEqual(cursor.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(succeeded.duration_micros, int)) + self.assertIsInstance(started.request_id, int) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(succeeded.duration_micros, int) self.assertEqual("killCursors", succeeded.command_name) - self.assertTrue(isinstance(succeeded.request_id, int)) + self.assertIsInstance(succeeded.request_id, int) self.assertIs(type(succeeded.connection_id), tuple) self.assertEqual(cursor.address, succeeded.connection_id) # There could be more than one cursor_id here depending on @@ -1155,13 +1155,13 @@ class TestGlobalListener(IntegrationTest): started = self.listener.started_events[0] succeeded = self.listener.succeeded_events[0] self.assertEqual(0, len(self.listener.failed_events)) - self.assertTrue(isinstance(succeeded, monitoring.CommandSucceededEvent)) - self.assertTrue(isinstance(started, monitoring.CommandStartedEvent)) + self.assertIsInstance(succeeded, monitoring.CommandSucceededEvent) + self.assertIsInstance(started, monitoring.CommandStartedEvent) self.assertEqualCommand(SON([("ping", 1)]), started.command) self.assertEqual("ping", started.command_name) self.assertEqual(self.client.address, started.connection_id) self.assertEqual("pymongo_test", started.database_name) - self.assertTrue(isinstance(started.request_id, int)) + self.assertIsInstance(started.request_id, int) class TestEventClasses(unittest.TestCase): diff --git a/test/test_timestamp.py b/test/test_timestamp.py index 7495d2ec9..ef7d8bde1 100644 --- a/test/test_timestamp.py +++ b/test/test_timestamp.py @@ -33,7 +33,7 @@ class TestTimestamp(unittest.TestCase): t = Timestamp(123, 456) self.assertEqual(t.time, 123) self.assertEqual(t.inc, 456) - self.assertTrue(isinstance(t, Timestamp)) + self.assertIsInstance(t, Timestamp) def test_datetime(self): d = datetime.datetime(2010, 5, 5, tzinfo=utc) diff --git a/test/test_uri_parser.py b/test/test_uri_parser.py index d4d17ac21..ec1c6c164 100644 --- a/test/test_uri_parser.py +++ b/test/test_uri_parser.py @@ -135,8 +135,8 @@ class TestURI(unittest.TestCase): self.assertEqual({"connecttimeoutms": 0.3}, split_options("connectTimeoutMS=300")) self.assertEqual({"connecttimeoutms": 0.0001}, split_options("connectTimeoutMS=0.1")) self.assertTrue(split_options("connectTimeoutMS=300")) - self.assertTrue(isinstance(split_options("w=5")["w"], int)) - self.assertTrue(isinstance(split_options("w=5.5")["w"], str)) + self.assertIsInstance(split_options("w=5")["w"], int) + self.assertIsInstance(split_options("w=5.5")["w"], str) self.assertTrue(split_options("w=foo")) self.assertTrue(split_options("w=majority")) self.assertTrue(split_options("wtimeoutms=500")) From b8460b6001c261ad5704710a6430b194b43ac398 Mon Sep 17 00:00:00 2001 From: Iris <58442094+sleepyStick@users.noreply.github.com> Date: Fri, 23 May 2025 09:04:32 -0700 Subject: [PATCH 5/6] PYTHON-5387 Better test assertions for membership (#2348) --- test/asynchronous/test_bulk.py | 14 +-- test/asynchronous/test_client.py | 20 ++-- test/asynchronous/test_collection.py | 98 +++++++++---------- test/asynchronous/test_cursor.py | 41 ++++---- test/asynchronous/test_database.py | 38 +++---- test/asynchronous/test_examples.py | 94 +++++++++--------- .../test_json_util_integration.py | 2 +- test/asynchronous/test_monitoring.py | 4 +- test/asynchronous/test_session.py | 33 ++++--- test/test_bulk.py | 14 +-- test/test_client.py | 20 ++-- test/test_collection.py | 98 +++++++++---------- test/test_cursor.py | 41 ++++---- test/test_database.py | 38 +++---- test/test_examples.py | 94 +++++++++--------- test/test_json_util_integration.py | 2 +- test/test_monitoring.py | 4 +- test/test_session.py | 33 ++++--- test/test_son.py | 4 +- 19 files changed, 352 insertions(+), 340 deletions(-) diff --git a/test/asynchronous/test_bulk.py b/test/asynchronous/test_bulk.py index 7c6f032e8..62022de24 100644 --- a/test/asynchronous/test_bulk.py +++ b/test/asynchronous/test_bulk.py @@ -94,7 +94,7 @@ class AsyncBulkTestBase(AsyncIntegrationTest): self.assertEqual(expected["index"], actual["index"]) if expected["_id"] == "...": # Unspecified value. - self.assertTrue("_id" in actual) + self.assertIn("_id", actual) else: self.assertEqual(expected["_id"], actual["_id"]) @@ -107,7 +107,7 @@ class AsyncBulkTestBase(AsyncIntegrationTest): self.assertEqual(expected["code"], actual["code"]) if expected["errmsg"] == "...": # Unspecified value. - self.assertTrue("errmsg" in actual) + self.assertIn("errmsg", actual) else: self.assertEqual(expected["errmsg"], actual["errmsg"]) @@ -115,7 +115,7 @@ class AsyncBulkTestBase(AsyncIntegrationTest): actual_op = actual["op"].copy() if expected_op.get("_id") == "...": # Unspecified _id. - self.assertTrue("_id" in actual_op) + self.assertIn("_id", actual_op) actual_op.pop("_id") expected_op.pop("_id") @@ -160,7 +160,7 @@ class AsyncTestBulk(AsyncBulkTestBase): result = await self.coll.bulk_write([UpdateMany({}, update)]) self.assertEqualResponse(expected, result.bulk_api_result) self.assertEqual(2, result.matched_count) - self.assertTrue(result.modified_count in (2, None)) + self.assertIn(result.modified_count, (2, None)) async def test_update_many(self): await self._test_update_many({"$set": {"foo": "bar"}}) @@ -201,7 +201,7 @@ class AsyncTestBulk(AsyncBulkTestBase): result = await self.coll.bulk_write([UpdateOne({}, update)]) self.assertEqualResponse(expected, result.bulk_api_result) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (1, None)) + self.assertIn(result.modified_count, (1, None)) async def test_update_one(self): await self._test_update_one({"$set": {"foo": "bar"}}) @@ -227,7 +227,7 @@ class AsyncTestBulk(AsyncBulkTestBase): result = await self.coll.bulk_write([ReplaceOne({}, {"foo": "bar"})]) self.assertEqualResponse(expected, result.bulk_api_result) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (1, None)) + self.assertIn(result.modified_count, (1, None)) async def test_remove(self): # Test removing all documents, ordered. @@ -1037,7 +1037,7 @@ class AsyncTestBulkWriteConcern(AsyncBulkTestBase): self.assertTrue(len(details["writeConcernErrors"]) > 1) failed = details["writeErrors"][0] - self.assertTrue("duplicate" in failed["errmsg"]) + self.assertIn("duplicate", failed["errmsg"]) @async_client_context.require_version_max(7, 1) # PYTHON-4560 @async_client_context.require_replica_set diff --git a/test/asynchronous/test_client.py b/test/asynchronous/test_client.py index 4d247009e..ad6614711 100644 --- a/test/asynchronous/test_client.py +++ b/test/asynchronous/test_client.py @@ -674,7 +674,7 @@ class TestClient(AsyncIntegrationTest): async with server._pool.checkout() as conn: pass self.assertEqual(1, len(server._pool.conns)) - self.assertTrue(conn in server._pool.conns) + self.assertIn(conn, server._pool.conns) async def test_max_idle_time_reaper_removes_stale_minPoolSize(self): with client_knobs(kill_cursor_frequency=0.1): @@ -752,7 +752,7 @@ class TestClient(AsyncIntegrationTest): lambda: len(server._pool.conns) == 10, "a closed socket gets replaced from the pool", ) - self.assertFalse(conn in server._pool.conns) + self.assertNotIn(conn, server._pool.conns) async def test_max_idle_time_checkout(self): # Use high frequency to test _get_socket_no_auth. @@ -769,8 +769,8 @@ class TestClient(AsyncIntegrationTest): async with server._pool.checkout() as new_con: self.assertNotEqual(conn, new_con) self.assertEqual(1, len(server._pool.conns)) - self.assertFalse(conn in server._pool.conns) - self.assertTrue(new_con in server._pool.conns) + self.assertNotIn(conn, server._pool.conns) + self.assertIn(new_con, server._pool.conns) # Test that connections are reused if maxIdleTimeMS is not set. client = await self.async_rs_or_single_client() @@ -1032,8 +1032,8 @@ class TestClient(AsyncIntegrationTest): cmd_names = [doc["name"] for doc in cmd_docs] db_names = await self.client.list_database_names() - self.assertTrue("pymongo_test" in db_names) - self.assertTrue("pymongo_test_mike" in db_names) + self.assertIn("pymongo_test", db_names) + self.assertIn("pymongo_test_mike", db_names) self.assertEqual(db_names, cmd_names) async def test_drop_database(self): @@ -1257,9 +1257,9 @@ class TestClient(AsyncIntegrationTest): client = await self.async_rs_or_single_client(uri) await client.pymongo_test.test.insert_one({"dummy": "object"}) dbs = await client.list_database_names() - self.assertTrue("pymongo_test" in dbs) + self.assertIn("pymongo_test", dbs) - self.assertTrue(mongodb_socket in repr(client)) + self.assertIn(mongodb_socket, repr(client)) # Confirm it fails with a missing socket. with self.assertRaises(ConnectionFailure): @@ -1431,8 +1431,8 @@ class TestClient(AsyncIntegrationTest): await client.pymongo_test_bernie.test.insert_one({"dummy": "object"}) dbs = await client.list_database_names() - self.assertTrue("pymongo_test" in dbs) - self.assertTrue("pymongo_test_bernie" in dbs) + self.assertIn("pymongo_test", dbs) + self.assertIn("pymongo_test_bernie", dbs) async def test_contextlib(self): client = await self.async_rs_or_single_client() diff --git a/test/asynchronous/test_collection.py b/test/asynchronous/test_collection.py index 9367c43a0..b6f96cc99 100644 --- a/test/asynchronous/test_collection.py +++ b/test/asynchronous/test_collection.py @@ -212,7 +212,7 @@ class AsyncTestCollection(AsyncIntegrationTest): async def test_drop_nonexistent_collection(self): await self.db.drop_collection("test") - self.assertFalse("test" in await self.db.list_collection_names()) + self.assertNotIn("test", await self.db.list_collection_names()) # No exception await self.db.drop_collection("test") @@ -248,7 +248,7 @@ class AsyncTestCollection(AsyncIntegrationTest): await db.test.drop_indexes() self.assertEqual(len(await db.test.index_information()), 1) await db.test.create_indexes([IndexModel("hello")]) - self.assertTrue("hello_1" in await db.test.index_information()) + self.assertIn("hello_1", await db.test.index_information()) await db.test.drop_indexes() self.assertEqual(len(await db.test.index_information()), 1) @@ -257,7 +257,7 @@ class AsyncTestCollection(AsyncIntegrationTest): ) info = await db.test.index_information() for name in names: - self.assertTrue(name in info) + self.assertIn(name, info) await db.test.drop() await db.test.insert_one({"a": 1}) @@ -311,16 +311,16 @@ class AsyncTestCollection(AsyncIntegrationTest): await db.test.drop_indexes() self.assertEqual(len(await db.test.index_information()), 1) await db.test.create_index("hello") - self.assertTrue("hello_1" in await db.test.index_information()) + self.assertIn("hello_1", await db.test.index_information()) await db.test.drop_indexes() self.assertEqual(len(await db.test.index_information()), 1) await db.test.create_index([("hello", DESCENDING), ("world", ASCENDING)]) - self.assertTrue("hello_-1_world_1" in await db.test.index_information()) + self.assertIn("hello_-1_world_1", await db.test.index_information()) await db.test.drop_indexes() await db.test.create_index([("hello", DESCENDING), ("world", ASCENDING)], name=None) - self.assertTrue("hello_-1_world_1" in await db.test.index_information()) + self.assertIn("hello_-1_world_1", await db.test.index_information()) await db.test.drop() await db.test.insert_one({"a": 1}) @@ -349,7 +349,7 @@ class AsyncTestCollection(AsyncIntegrationTest): with self.assertRaises(OperationFailure): await db.test.drop_index(name) self.assertEqual(len(await db.test.index_information()), 2) - self.assertTrue("hello_1" in await db.test.index_information()) + self.assertIn("hello_1", await db.test.index_information()) await db.test.drop_indexes() await db.test.create_index("hello") @@ -359,7 +359,7 @@ class AsyncTestCollection(AsyncIntegrationTest): self.assertEqual(name, "goodbye_1") await db.test.drop_index([("goodbye", ASCENDING)]) self.assertEqual(len(await db.test.index_information()), 2) - self.assertTrue("hello_1" in await db.test.index_information()) + self.assertIn("hello_1", await db.test.index_information()) with self.write_concern_collection() as coll: await coll.drop_index("hello_1") @@ -395,7 +395,7 @@ class AsyncTestCollection(AsyncIntegrationTest): indexes = await (await db.test.list_indexes()).to_list() self.assertEqual(len(indexes), 1) - self.assertTrue("_id_" in map_indexes(indexes)) + self.assertIn("_id_", map_indexes(indexes)) await db.test.create_index("hello") indexes = await (await db.test.list_indexes()).to_list() @@ -424,7 +424,7 @@ class AsyncTestCollection(AsyncIntegrationTest): await db.test.drop() await db.test.insert_one({}) # create collection self.assertEqual(len(await db.test.index_information()), 1) - self.assertTrue("_id_" in await db.test.index_information()) + self.assertIn("_id_", await db.test.index_information()) await db.test.create_index("hello") self.assertEqual(len(await db.test.index_information()), 2) @@ -488,7 +488,7 @@ class AsyncTestCollection(AsyncIntegrationTest): await db.test.drop_indexes() self.assertEqual("t_text", await db.test.create_index([("t", TEXT)])) index_info = (await db.test.index_information())["t_text"] - self.assertTrue("weights" in index_info) + self.assertIn("weights", index_info) await db.test.insert_many( [{"t": "spam eggs and spam"}, {"t": "spam"}, {"t": "egg sausage and bacon"}] @@ -549,7 +549,7 @@ class AsyncTestCollection(AsyncIntegrationTest): await db.test.create_index([("keya", ASCENDING)]) await db.test.create_index([("keyb", ASCENDING)], background=False) await db.test.create_index([("keyc", ASCENDING)], background=True) - self.assertFalse("background" in (await db.test.index_information())["keya_1"]) + self.assertNotIn("background", (await db.test.index_information())["keya_1"]) self.assertFalse((await db.test.index_information())["keyb_1"]["background"]) self.assertTrue((await db.test.index_information())["keyc_1"]["background"]) @@ -702,7 +702,7 @@ class AsyncTestCollection(AsyncIntegrationTest): doc = await anext(db.test.find({}, {"_id": False})) l = list(doc) - self.assertFalse("_id" in l) + self.assertNotIn("_id", l) async def test_options(self): db = self.db @@ -764,7 +764,7 @@ class AsyncTestCollection(AsyncIntegrationTest): for doc in docs: _id = doc["_id"] self.assertIsInstance(_id, ObjectId) - self.assertTrue(_id in result.inserted_ids) + self.assertIn(_id, result.inserted_ids) self.assertEqual(1, await db.test.count_documents({"_id": _id})) self.assertTrue(result.acknowledged) @@ -776,7 +776,7 @@ class AsyncTestCollection(AsyncIntegrationTest): for doc in docs: _id = doc["_id"] self.assertIsInstance(_id, int) - self.assertTrue(_id in result.inserted_ids) + self.assertIn(_id, result.inserted_ids) self.assertEqual(1, await db.test.count_documents({"_id": _id})) self.assertTrue(result.acknowledged) @@ -943,7 +943,7 @@ class AsyncTestCollection(AsyncIntegrationTest): for doc in docs: _id = doc["_id"] self.assertIsInstance(_id, int) - self.assertTrue(_id in result.inserted_ids) + self.assertIn(_id, result.inserted_ids) self.assertEqual(1, await db.test.count_documents({"x": doc["x"]})) self.assertTrue(result.acknowledged) docs = [{"_id": i, "a": 200 - i} for i in range(100, 200)] @@ -953,7 +953,7 @@ class AsyncTestCollection(AsyncIntegrationTest): for doc in docs: _id = doc["_id"] self.assertIsInstance(_id, int) - self.assertTrue(_id in result.inserted_ids) + self.assertIn(_id, result.inserted_ids) self.assertEqual(1, await db.test.count_documents({"a": doc["a"]})) self.assertTrue(result.acknowledged) @@ -1131,23 +1131,23 @@ class AsyncTestCollection(AsyncIntegrationTest): ) self.assertEqual(1, await db.test.count_documents({})) doc = await anext(db.test.find({})) - self.assertTrue("x" in doc) + self.assertIn("x", doc) doc = await anext(db.test.find({})) - self.assertTrue("mike" in doc) + self.assertIn("mike", doc) doc = await anext(db.test.find({})) - self.assertTrue("extra thing" in doc) + self.assertIn("extra thing", doc) doc = await anext(db.test.find({}, ["x", "mike"])) - self.assertTrue("x" in doc) + self.assertIn("x", doc) doc = await anext(db.test.find({}, ["x", "mike"])) - self.assertTrue("mike" in doc) + self.assertIn("mike", doc) doc = await anext(db.test.find({}, ["x", "mike"])) - self.assertFalse("extra thing" in doc) + self.assertNotIn("extra thing", doc) doc = await anext(db.test.find({}, ["mike"])) - self.assertFalse("x" in doc) + self.assertNotIn("x", doc) doc = await anext(db.test.find({}, ["mike"])) - self.assertTrue("mike" in doc) + self.assertIn("mike", doc) doc = await anext(db.test.find({}, ["mike"])) - self.assertFalse("extra thing" in doc) + self.assertNotIn("extra thing", doc) @no_type_check async def test_fields_specifier_as_dict(self): @@ -1158,8 +1158,8 @@ class AsyncTestCollection(AsyncIntegrationTest): self.assertEqual([1, 2, 3], (await db.test.find_one())["x"]) self.assertEqual([2, 3], (await db.test.find_one(projection={"x": {"$slice": -2}}))["x"]) - self.assertTrue("x" not in await db.test.find_one(projection={"x": 0})) - self.assertTrue("mike" in await db.test.find_one(projection={"x": 0})) + self.assertNotIn("x", await db.test.find_one(projection={"x": 0})) + self.assertIn("mike", await db.test.find_one(projection={"x": 0})) async def test_find_w_regex(self): db = self.db @@ -1194,7 +1194,7 @@ class AsyncTestCollection(AsyncIntegrationTest): async for x in db.test.find(): self.assertEqual(x["hello"], "world") - self.assertTrue("_id" in x) + self.assertIn("_id", x) async def test_unique_index(self): db = self.db @@ -1314,7 +1314,7 @@ class AsyncTestCollection(AsyncIntegrationTest): try: await self.db.test.update_many({}, {"$thismodifierdoesntexist": 1}) except OperationFailure as exc: - self.assertTrue(exc.code in (9, 10147, 16840, 17009)) + self.assertIn(exc.code, (9, 10147, 16840, 17009)) # Just check that we set the error document. Fields # vary by MongoDB version. self.assertTrue(exc.details is not None) @@ -1348,7 +1348,7 @@ class AsyncTestCollection(AsyncIntegrationTest): result = await db.test.replace_one({"x": 1}, {"y": 1}) self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (None, 1)) + self.assertIn(result.modified_count, (None, 1)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual(1, await db.test.count_documents({"y": 1})) @@ -1359,7 +1359,7 @@ class AsyncTestCollection(AsyncIntegrationTest): result = await db.test.replace_one({"y": 1}, replacement, True) self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (None, 1)) + self.assertIn(result.modified_count, (None, 1)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual(1, await db.test.count_documents({"z": 1})) @@ -1369,7 +1369,7 @@ class AsyncTestCollection(AsyncIntegrationTest): result = await db.test.replace_one({"x": 2}, {"y": 2}, True) self.assertIsInstance(result, UpdateResult) self.assertEqual(0, result.matched_count) - self.assertTrue(result.modified_count in (None, 0)) + self.assertIn(result.modified_count, (None, 0)) self.assertIsInstance(result.upserted_id, ObjectId) self.assertTrue(result.acknowledged) self.assertEqual(1, await db.test.count_documents({"y": 2})) @@ -1393,7 +1393,7 @@ class AsyncTestCollection(AsyncIntegrationTest): result = await db.test.update_one({}, {"$inc": {"x": 1}}) self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (None, 1)) + self.assertIn(result.modified_count, (None, 1)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual((await db.test.find_one(id1))["x"], 6) # type: ignore @@ -1402,7 +1402,7 @@ class AsyncTestCollection(AsyncIntegrationTest): result = await db.test.update_one({"x": 6}, {"$inc": {"x": 1}}) self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (None, 1)) + self.assertIn(result.modified_count, (None, 1)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual((await db.test.find_one(id1))["x"], 7) # type: ignore @@ -1411,7 +1411,7 @@ class AsyncTestCollection(AsyncIntegrationTest): result = await db.test.update_one({"x": 2}, {"$set": {"y": 1}}, True) self.assertIsInstance(result, UpdateResult) self.assertEqual(0, result.matched_count) - self.assertTrue(result.modified_count in (None, 0)) + self.assertIn(result.modified_count, (None, 0)) self.assertIsInstance(result.upserted_id, ObjectId) self.assertTrue(result.acknowledged) @@ -1450,7 +1450,7 @@ class AsyncTestCollection(AsyncIntegrationTest): result = await db.test.update_many({"x": 4}, {"$set": {"y": 5}}) self.assertIsInstance(result, UpdateResult) self.assertEqual(2, result.matched_count) - self.assertTrue(result.modified_count in (None, 2)) + self.assertIn(result.modified_count, (None, 2)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual(3, await db.test.count_documents({"y": 5})) @@ -1458,7 +1458,7 @@ class AsyncTestCollection(AsyncIntegrationTest): result = await db.test.update_many({"x": 5}, {"$set": {"y": 6}}) self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (None, 1)) + self.assertIn(result.modified_count, (None, 1)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual(1, await db.test.count_documents({"y": 6})) @@ -1466,7 +1466,7 @@ class AsyncTestCollection(AsyncIntegrationTest): result = await db.test.update_many({"x": 2}, {"$set": {"y": 1}}, True) self.assertIsInstance(result, UpdateResult) self.assertEqual(0, result.matched_count) - self.assertTrue(result.modified_count in (None, 0)) + self.assertIn(result.modified_count, (None, 0)) self.assertIsInstance(result.upserted_id, ObjectId) self.assertTrue(result.acknowledged) @@ -1725,21 +1725,21 @@ class AsyncTestCollection(AsyncIntegrationTest): self.assertEqual(await db.test.find_one({}), await db.test.find_one()) self.assertEqual(await db.test.find_one({"hello": "world"}), await db.test.find_one()) - self.assertTrue("hello" in await db.test.find_one(projection=["hello"])) - self.assertTrue("hello" not in await db.test.find_one(projection=["foo"])) + self.assertIn("hello", await db.test.find_one(projection=["hello"])) + self.assertNotIn("hello", await db.test.find_one(projection=["foo"])) - self.assertTrue("hello" in await db.test.find_one(projection=("hello",))) - self.assertTrue("hello" not in await db.test.find_one(projection=("foo",))) + self.assertIn("hello", await db.test.find_one(projection=("hello",))) + self.assertNotIn("hello", await db.test.find_one(projection=("foo",))) - self.assertTrue("hello" in await db.test.find_one(projection={"hello"})) - self.assertTrue("hello" not in await db.test.find_one(projection={"foo"})) + self.assertIn("hello", await db.test.find_one(projection={"hello"})) + self.assertNotIn("hello", await db.test.find_one(projection={"foo"})) - self.assertTrue("hello" in await db.test.find_one(projection=frozenset(["hello"]))) - self.assertTrue("hello" not in await db.test.find_one(projection=frozenset(["foo"]))) + self.assertIn("hello", await db.test.find_one(projection=frozenset(["hello"]))) + self.assertNotIn("hello", await db.test.find_one(projection=frozenset(["foo"]))) self.assertEqual(["_id"], list(await db.test.find_one(projection={"_id": True}))) - self.assertTrue("hello" in list(await db.test.find_one(projection={}))) - self.assertTrue("hello" in list(await db.test.find_one(projection=[]))) + self.assertIn("hello", list(await db.test.find_one(projection={}))) + self.assertIn("hello", list(await db.test.find_one(projection=[]))) self.assertEqual(None, await db.test.find_one({"hello": "foo"})) self.assertEqual(None, await db.test.find_one(ObjectId())) diff --git a/test/asynchronous/test_cursor.py b/test/asynchronous/test_cursor.py index 5e4e590fe..861345cb0 100644 --- a/test/asynchronous/test_cursor.py +++ b/test/asynchronous/test_cursor.py @@ -174,8 +174,8 @@ class TestCursor(AsyncIntegrationTest): cursor = coll.find().max_time_ms(999) c2 = cursor.clone() self.assertEqual(999, c2._max_time_ms) - self.assertTrue("$maxTimeMS" in cursor._query_spec()) - self.assertTrue("$maxTimeMS" in c2._query_spec()) + self.assertIn("$maxTimeMS", cursor._query_spec()) + self.assertIn("$maxTimeMS", c2._query_spec()) self.assertTrue(await coll.find_one(max_time_ms=1000)) @@ -240,19 +240,19 @@ class TestCursor(AsyncIntegrationTest): # Tailable_await defaults. await coll.find(cursor_type=CursorType.TAILABLE_AWAIT).to_list() # find - self.assertFalse("maxTimeMS" in listener.started_events[0].command) + self.assertNotIn("maxTimeMS", listener.started_events[0].command) # getMore - self.assertFalse("maxTimeMS" in listener.started_events[1].command) + self.assertNotIn("maxTimeMS", listener.started_events[1].command) listener.reset() # Tailable_await with max_await_time_ms set. await coll.find(cursor_type=CursorType.TAILABLE_AWAIT).max_await_time_ms(99).to_list() # find self.assertEqual("find", listener.started_events[0].command_name) - self.assertFalse("maxTimeMS" in listener.started_events[0].command) + self.assertNotIn("maxTimeMS", listener.started_events[0].command) # getMore self.assertEqual("getMore", listener.started_events[1].command_name) - self.assertTrue("maxTimeMS" in listener.started_events[1].command) + self.assertIn("maxTimeMS", listener.started_events[1].command) self.assertEqual(99, listener.started_events[1].command["maxTimeMS"]) listener.reset() @@ -263,11 +263,11 @@ class TestCursor(AsyncIntegrationTest): await coll.find(cursor_type=CursorType.TAILABLE_AWAIT).max_time_ms(99).to_list() # find self.assertEqual("find", listener.started_events[0].command_name) - self.assertTrue("maxTimeMS" in listener.started_events[0].command) + self.assertIn("maxTimeMS", listener.started_events[0].command) self.assertEqual(99, listener.started_events[0].command["maxTimeMS"]) # getMore self.assertEqual("getMore", listener.started_events[1].command_name) - self.assertFalse("maxTimeMS" in listener.started_events[1].command) + self.assertNotIn("maxTimeMS", listener.started_events[1].command) listener.reset() # Tailable_await with both max_time_ms and max_await_time_ms @@ -279,11 +279,11 @@ class TestCursor(AsyncIntegrationTest): ) # find self.assertEqual("find", listener.started_events[0].command_name) - self.assertTrue("maxTimeMS" in listener.started_events[0].command) + self.assertIn("maxTimeMS", listener.started_events[0].command) self.assertEqual(99, listener.started_events[0].command["maxTimeMS"]) # getMore self.assertEqual("getMore", listener.started_events[1].command_name) - self.assertTrue("maxTimeMS" in listener.started_events[1].command) + self.assertIn("maxTimeMS", listener.started_events[1].command) self.assertEqual(99, listener.started_events[1].command["maxTimeMS"]) listener.reset() @@ -291,31 +291,31 @@ class TestCursor(AsyncIntegrationTest): await coll.find(batch_size=1).max_await_time_ms(99).to_list() # find self.assertEqual("find", listener.started_events[0].command_name) - self.assertFalse("maxTimeMS" in listener.started_events[0].command) + self.assertNotIn("maxTimeMS", listener.started_events[0].command) # getMore self.assertEqual("getMore", listener.started_events[1].command_name) - self.assertFalse("maxTimeMS" in listener.started_events[1].command) + self.assertNotIn("maxTimeMS", listener.started_events[1].command) listener.reset() # Non tailable_await with max_time_ms await coll.find(batch_size=1).max_time_ms(99).to_list() # find self.assertEqual("find", listener.started_events[0].command_name) - self.assertTrue("maxTimeMS" in listener.started_events[0].command) + self.assertIn("maxTimeMS", listener.started_events[0].command) self.assertEqual(99, listener.started_events[0].command["maxTimeMS"]) # getMore self.assertEqual("getMore", listener.started_events[1].command_name) - self.assertFalse("maxTimeMS" in listener.started_events[1].command) + self.assertNotIn("maxTimeMS", listener.started_events[1].command) # Non tailable_await with both max_time_ms and max_await_time_ms await coll.find(batch_size=1).max_time_ms(99).max_await_time_ms(88).to_list() # find self.assertEqual("find", listener.started_events[0].command_name) - self.assertTrue("maxTimeMS" in listener.started_events[0].command) + self.assertIn("maxTimeMS", listener.started_events[0].command) self.assertEqual(99, listener.started_events[0].command["maxTimeMS"]) # getMore self.assertEqual("getMore", listener.started_events[1].command_name) - self.assertFalse("maxTimeMS" in listener.started_events[1].command) + self.assertNotIn("maxTimeMS", listener.started_events[1].command) @async_client_context.require_test_commands @async_client_context.require_no_mongos @@ -933,16 +933,19 @@ class TestCursor(AsyncIntegrationTest): # Shallow copies can so can mutate cursor2 = copy.copy(cursor) cursor2._projection["cursor2"] = False - self.assertTrue(cursor._projection and "cursor2" in cursor._projection) + self.assertIsNotNone(cursor._projection) + self.assertIn("cursor2", cursor._projection.keys()) # Deepcopies and shouldn't mutate cursor3 = copy.deepcopy(cursor) cursor3._projection["cursor3"] = False - self.assertFalse(cursor._projection and "cursor3" in cursor._projection) + self.assertIsNotNone(cursor._projection) + self.assertNotIn("cursor3", cursor._projection.keys()) cursor4 = cursor.clone() cursor4._projection["cursor4"] = False - self.assertFalse(cursor._projection and "cursor4" in cursor._projection) + self.assertIsNotNone(cursor._projection) + self.assertNotIn("cursor4", cursor._projection.keys()) # Test memo when deepcopying queries query = {"hello": "world"} diff --git a/test/asynchronous/test_database.py b/test/asynchronous/test_database.py index 1e0f0c40d..3195c7498 100644 --- a/test/asynchronous/test_database.py +++ b/test/asynchronous/test_database.py @@ -163,13 +163,13 @@ class TestDatabase(AsyncIntegrationTest): await db.create_collection("coll..ection") # type: ignore[arg-type] test = await db.create_collection("test") - self.assertTrue("test" in await db.list_collection_names()) + self.assertIn("test", await db.list_collection_names()) await test.insert_one({"hello": "world"}) self.assertEqual((await db.test.find_one())["hello"], "world") await db.drop_collection("test.foo") await db.create_collection("test.foo") - self.assertTrue("test.foo" in await db.list_collection_names()) + self.assertIn("test.foo", await db.list_collection_names()) with self.assertRaises(CollectionInvalid): await db.create_collection("test.foo") @@ -179,10 +179,10 @@ class TestDatabase(AsyncIntegrationTest): await db.test.mike.insert_one({"dummy": "object"}) colls = await db.list_collection_names() - self.assertTrue("test" in colls) - self.assertTrue("test.mike" in colls) + self.assertIn("test", colls) + self.assertIn("test.mike", colls) for coll in colls: - self.assertTrue("$" not in coll) + self.assertNotIn("$", coll) await db.systemcoll.test.insert_one({}) no_system_collections = await db.list_collection_names( @@ -252,12 +252,12 @@ class TestDatabase(AsyncIntegrationTest): colls = [result["name"] async for result in results] # All the collections present. - self.assertTrue("test" in colls) - self.assertTrue("test.mike" in colls) + self.assertIn("test", colls) + self.assertIn("test.mike", colls) # No collection containing a '$'. for coll in colls: - self.assertTrue("$" not in coll) + self.assertNotIn("$", coll) # Duplicate check. coll_cnt: dict = {} @@ -294,12 +294,12 @@ class TestDatabase(AsyncIntegrationTest): colls = [result["name"] async for result in results] # Checking only capped collections are present - self.assertTrue("test" in colls) - self.assertFalse("test.mike" in colls) + self.assertIn("test", colls) + self.assertNotIn("test.mike", colls) # No collection containing a '$'. for coll in colls: - self.assertTrue("$" not in coll) + self.assertNotIn("$", coll) # Duplicate check. coll_cnt = {} @@ -339,24 +339,24 @@ class TestDatabase(AsyncIntegrationTest): await db.drop_collection(None) # type: ignore[arg-type] await db.test.insert_one({"dummy": "object"}) - self.assertTrue("test" in await db.list_collection_names()) + self.assertIn("test", await db.list_collection_names()) await db.drop_collection("test") - self.assertFalse("test" in await db.list_collection_names()) + self.assertNotIn("test", await db.list_collection_names()) await db.test.insert_one({"dummy": "object"}) - self.assertTrue("test" in await db.list_collection_names()) + self.assertIn("test", await db.list_collection_names()) await db.drop_collection("test") - self.assertFalse("test" in await db.list_collection_names()) + self.assertNotIn("test", await db.list_collection_names()) await db.test.insert_one({"dummy": "object"}) - self.assertTrue("test" in await db.list_collection_names()) + self.assertIn("test", await db.list_collection_names()) await db.drop_collection(db.test) - self.assertFalse("test" in await db.list_collection_names()) + self.assertNotIn("test", await db.list_collection_names()) await db.test.insert_one({"dummy": "object"}) - self.assertTrue("test" in await db.list_collection_names()) + self.assertIn("test", await db.list_collection_names()) await db.test.drop() - self.assertFalse("test" in await db.list_collection_names()) + self.assertNotIn("test", await db.list_collection_names()) await db.test.drop() await db.drop_collection(db.test.doesnotexist) diff --git a/test/asynchronous/test_examples.py b/test/asynchronous/test_examples.py index a334a3ed1..a4ebf72df 100644 --- a/test/asynchronous/test_examples.py +++ b/test/asynchronous/test_examples.py @@ -479,77 +479,77 @@ class TestSampleShellCommands(AsyncIntegrationTest): # End Example 44 async for doc in cursor: - self.assertTrue("_id" in doc) - self.assertTrue("item" in doc) - self.assertTrue("status" in doc) - self.assertFalse("size" in doc) - self.assertFalse("instock" in doc) + self.assertIn("_id", doc) + self.assertIn("item", doc) + self.assertIn("status", doc) + self.assertNotIn("size", doc) + self.assertNotIn("instock", doc) # Start Example 45 cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "_id": 0}) # End Example 45 async for doc in cursor: - self.assertFalse("_id" in doc) - self.assertTrue("item" in doc) - self.assertTrue("status" in doc) - self.assertFalse("size" in doc) - self.assertFalse("instock" in doc) + self.assertNotIn("_id", doc) + self.assertIn("item", doc) + self.assertIn("status", doc) + self.assertNotIn("size", doc) + self.assertNotIn("instock", doc) # Start Example 46 cursor = db.inventory.find({"status": "A"}, {"status": 0, "instock": 0}) # End Example 46 async for doc in cursor: - self.assertTrue("_id" in doc) - self.assertTrue("item" in doc) - self.assertFalse("status" in doc) - self.assertTrue("size" in doc) - self.assertFalse("instock" in doc) + self.assertIn("_id", doc) + self.assertIn("item", doc) + self.assertNotIn("status", doc) + self.assertIn("size", doc) + self.assertNotIn("instock", doc) # Start Example 47 cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "size.uom": 1}) # End Example 47 async for doc in cursor: - self.assertTrue("_id" in doc) - self.assertTrue("item" in doc) - self.assertTrue("status" in doc) - self.assertTrue("size" in doc) - self.assertFalse("instock" in doc) + self.assertIn("_id", doc) + self.assertIn("item", doc) + self.assertIn("status", doc) + self.assertIn("size", doc) + self.assertNotIn("instock", doc) size = doc["size"] - self.assertTrue("uom" in size) - self.assertFalse("h" in size) - self.assertFalse("w" in size) + self.assertIn("uom", size) + self.assertNotIn("h", size) + self.assertNotIn("w", size) # Start Example 48 cursor = db.inventory.find({"status": "A"}, {"size.uom": 0}) # End Example 48 async for doc in cursor: - self.assertTrue("_id" in doc) - self.assertTrue("item" in doc) - self.assertTrue("status" in doc) - self.assertTrue("size" in doc) - self.assertTrue("instock" in doc) + self.assertIn("_id", doc) + self.assertIn("item", doc) + self.assertIn("status", doc) + self.assertIn("size", doc) + self.assertIn("instock", doc) size = doc["size"] - self.assertFalse("uom" in size) - self.assertTrue("h" in size) - self.assertTrue("w" in size) + self.assertNotIn("uom", size) + self.assertIn("h", size) + self.assertIn("w", size) # Start Example 49 cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "instock.qty": 1}) # End Example 49 async for doc in cursor: - self.assertTrue("_id" in doc) - self.assertTrue("item" in doc) - self.assertTrue("status" in doc) - self.assertFalse("size" in doc) - self.assertTrue("instock" in doc) + self.assertIn("_id", doc) + self.assertIn("item", doc) + self.assertIn("status", doc) + self.assertNotIn("size", doc) + self.assertIn("instock", doc) for subdoc in doc["instock"]: - self.assertFalse("warehouse" in subdoc) - self.assertTrue("qty" in subdoc) + self.assertNotIn("warehouse", subdoc) + self.assertIn("qty", subdoc) # Start Example 50 cursor = db.inventory.find( @@ -558,11 +558,11 @@ class TestSampleShellCommands(AsyncIntegrationTest): # End Example 50 async for doc in cursor: - self.assertTrue("_id" in doc) - self.assertTrue("item" in doc) - self.assertTrue("status" in doc) - self.assertFalse("size" in doc) - self.assertTrue("instock" in doc) + self.assertIn("_id", doc) + self.assertIn("item", doc) + self.assertIn("status", doc) + self.assertNotIn("size", doc) + self.assertIn("instock", doc) self.assertEqual(len(doc["instock"]), 1) async def test_update_and_replace(self): @@ -645,7 +645,7 @@ class TestSampleShellCommands(AsyncIntegrationTest): async for doc in db.inventory.find({"item": "paper"}): self.assertEqual(doc["size"]["uom"], "cm") self.assertEqual(doc["status"], "P") - self.assertTrue("lastModified" in doc) + self.assertIn("lastModified", doc) # Start Example 53 await db.inventory.update_many( @@ -657,7 +657,7 @@ class TestSampleShellCommands(AsyncIntegrationTest): async for doc in db.inventory.find({"qty": {"$lt": 50}}): self.assertEqual(doc["size"]["uom"], "in") self.assertEqual(doc["status"], "P") - self.assertTrue("lastModified" in doc) + self.assertIn("lastModified", doc) # Start Example 54 await db.inventory.replace_one( @@ -671,8 +671,8 @@ class TestSampleShellCommands(AsyncIntegrationTest): async for doc in db.inventory.find({"item": "paper"}, {"_id": 0}): self.assertEqual(len(doc.keys()), 2) - self.assertTrue("item" in doc) - self.assertTrue("instock" in doc) + self.assertIn("item", doc) + self.assertIn("instock", doc) self.assertEqual(len(doc["instock"]), 2) async def test_delete(self): diff --git a/test/asynchronous/test_json_util_integration.py b/test/asynchronous/test_json_util_integration.py index 4c02792d8..32312cb9d 100644 --- a/test/asynchronous/test_json_util_integration.py +++ b/test/asynchronous/test_json_util_integration.py @@ -25,4 +25,4 @@ class TestJsonUtilRoundtrip(AsyncIntegrationTest): await db.test.insert_many(docs) reloaded_docs = json_util.loads(json_util.dumps(await (db.test.find()).to_list())) for doc in docs: - self.assertTrue(doc in reloaded_docs) + self.assertIn(doc, reloaded_docs) diff --git a/test/asynchronous/test_monitoring.py b/test/asynchronous/test_monitoring.py index b2ca1aaaa..a44223a72 100644 --- a/test/asynchronous/test_monitoring.py +++ b/test/asynchronous/test_monitoring.py @@ -1088,8 +1088,8 @@ class AsyncTestCommandMonitoring(AsyncIntegrationTest): self.assertEqual(started.command_name, succeeded.command_name) self.assertEqual(started.request_id, succeeded.request_id) self.assertEqual(started.connection_id, succeeded.connection_id) - self.assertTrue("cursor" in succeeded.reply) - self.assertTrue("ok" in succeeded.reply) + self.assertIn("cursor", succeeded.reply) + self.assertIn("ok", succeeded.reply) self.listener.reset() diff --git a/test/asynchronous/test_session.py b/test/asynchronous/test_session.py index 3655f49aa..1f6fb0d31 100644 --- a/test/asynchronous/test_session.py +++ b/test/asynchronous/test_session.py @@ -134,8 +134,9 @@ class TestSession(AsyncIntegrationTest): await f(*args, **kw) self.assertGreaterEqual(len(listener.started_events), 1) for event in listener.started_events: - self.assertTrue( - "lsid" in event.command, + self.assertIn( + "lsid", + event.command, f"{f.__name__} sent no lsid with {event.command_name}", ) @@ -170,8 +171,9 @@ class TestSession(AsyncIntegrationTest): self.assertGreaterEqual(len(listener.started_events), 1) lsids = [] for event in listener.started_events: - self.assertTrue( - "lsid" in event.command, + self.assertIn( + "lsid", + event.command, f"{f.__name__} sent no lsid with {event.command_name}", ) @@ -422,8 +424,9 @@ class TestSession(AsyncIntegrationTest): await f(session=s) self.assertGreaterEqual(len(listener.started_events), 1) for event in listener.started_events: - self.assertTrue( - "lsid" in event.command, + self.assertIn( + "lsid", + event.command, f"{name} sent no lsid with {event.command_name}", ) @@ -441,15 +444,13 @@ class TestSession(AsyncIntegrationTest): listener.reset() await f(session=None) event0 = listener.first_command_started() - self.assertTrue( - "lsid" in event0.command, f"{name} sent no lsid with {event0.command_name}" - ) + self.assertIn("lsid", event0.command, f"{name} sent no lsid with {event0.command_name}") lsid = event0.command["lsid"] for event in listener.started_events[1:]: - self.assertTrue( - "lsid" in event.command, f"{name} sent no lsid with {event.command_name}" + self.assertIn( + "lsid", event.command, f"{name} sent no lsid with {event.command_name}" ) self.assertEqual( @@ -1201,15 +1202,17 @@ class TestClusterTime(AsyncIntegrationTest): self.assertGreaterEqual(len(listener.started_events), 1) for i, event in enumerate(listener.started_events): - self.assertTrue( - "$clusterTime" in event.command, + self.assertIn( + "$clusterTime", + event.command, f"{f.__name__} sent no $clusterTime with {event.command_name}", ) if i > 0: succeeded = listener.succeeded_events[i - 1] - self.assertTrue( - "$clusterTime" in succeeded.reply, + self.assertIn( + "$clusterTime", + succeeded.reply, f"{f.__name__} received no $clusterTime with {succeeded.command_name}", ) diff --git a/test/test_bulk.py b/test/test_bulk.py index 00c6c5e64..77d0d6c06 100644 --- a/test/test_bulk.py +++ b/test/test_bulk.py @@ -94,7 +94,7 @@ class BulkTestBase(IntegrationTest): self.assertEqual(expected["index"], actual["index"]) if expected["_id"] == "...": # Unspecified value. - self.assertTrue("_id" in actual) + self.assertIn("_id", actual) else: self.assertEqual(expected["_id"], actual["_id"]) @@ -107,7 +107,7 @@ class BulkTestBase(IntegrationTest): self.assertEqual(expected["code"], actual["code"]) if expected["errmsg"] == "...": # Unspecified value. - self.assertTrue("errmsg" in actual) + self.assertIn("errmsg", actual) else: self.assertEqual(expected["errmsg"], actual["errmsg"]) @@ -115,7 +115,7 @@ class BulkTestBase(IntegrationTest): actual_op = actual["op"].copy() if expected_op.get("_id") == "...": # Unspecified _id. - self.assertTrue("_id" in actual_op) + self.assertIn("_id", actual_op) actual_op.pop("_id") expected_op.pop("_id") @@ -160,7 +160,7 @@ class TestBulk(BulkTestBase): result = self.coll.bulk_write([UpdateMany({}, update)]) self.assertEqualResponse(expected, result.bulk_api_result) self.assertEqual(2, result.matched_count) - self.assertTrue(result.modified_count in (2, None)) + self.assertIn(result.modified_count, (2, None)) def test_update_many(self): self._test_update_many({"$set": {"foo": "bar"}}) @@ -201,7 +201,7 @@ class TestBulk(BulkTestBase): result = self.coll.bulk_write([UpdateOne({}, update)]) self.assertEqualResponse(expected, result.bulk_api_result) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (1, None)) + self.assertIn(result.modified_count, (1, None)) def test_update_one(self): self._test_update_one({"$set": {"foo": "bar"}}) @@ -227,7 +227,7 @@ class TestBulk(BulkTestBase): result = self.coll.bulk_write([ReplaceOne({}, {"foo": "bar"})]) self.assertEqualResponse(expected, result.bulk_api_result) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (1, None)) + self.assertIn(result.modified_count, (1, None)) def test_remove(self): # Test removing all documents, ordered. @@ -1035,7 +1035,7 @@ class TestBulkWriteConcern(BulkTestBase): self.assertTrue(len(details["writeConcernErrors"]) > 1) failed = details["writeErrors"][0] - self.assertTrue("duplicate" in failed["errmsg"]) + self.assertIn("duplicate", failed["errmsg"]) @client_context.require_version_max(7, 1) # PYTHON-4560 @client_context.require_replica_set diff --git a/test/test_client.py b/test/test_client.py index 4f2e5751a..c50082797 100644 --- a/test/test_client.py +++ b/test/test_client.py @@ -665,7 +665,7 @@ class TestClient(IntegrationTest): with server._pool.checkout() as conn: pass self.assertEqual(1, len(server._pool.conns)) - self.assertTrue(conn in server._pool.conns) + self.assertIn(conn, server._pool.conns) def test_max_idle_time_reaper_removes_stale_minPoolSize(self): with client_knobs(kill_cursor_frequency=0.1): @@ -731,7 +731,7 @@ class TestClient(IntegrationTest): lambda: len(server._pool.conns) == 10, "a closed socket gets replaced from the pool", ) - self.assertFalse(conn in server._pool.conns) + self.assertNotIn(conn, server._pool.conns) def test_max_idle_time_checkout(self): # Use high frequency to test _get_socket_no_auth. @@ -746,8 +746,8 @@ class TestClient(IntegrationTest): with server._pool.checkout() as new_con: self.assertNotEqual(conn, new_con) self.assertEqual(1, len(server._pool.conns)) - self.assertFalse(conn in server._pool.conns) - self.assertTrue(new_con in server._pool.conns) + self.assertNotIn(conn, server._pool.conns) + self.assertIn(new_con, server._pool.conns) # Test that connections are reused if maxIdleTimeMS is not set. client = self.rs_or_single_client() @@ -1005,8 +1005,8 @@ class TestClient(IntegrationTest): cmd_names = [doc["name"] for doc in cmd_docs] db_names = self.client.list_database_names() - self.assertTrue("pymongo_test" in db_names) - self.assertTrue("pymongo_test_mike" in db_names) + self.assertIn("pymongo_test", db_names) + self.assertIn("pymongo_test_mike", db_names) self.assertEqual(db_names, cmd_names) def test_drop_database(self): @@ -1220,9 +1220,9 @@ class TestClient(IntegrationTest): client = self.rs_or_single_client(uri) client.pymongo_test.test.insert_one({"dummy": "object"}) dbs = client.list_database_names() - self.assertTrue("pymongo_test" in dbs) + self.assertIn("pymongo_test", dbs) - self.assertTrue(mongodb_socket in repr(client)) + self.assertIn(mongodb_socket, repr(client)) # Confirm it fails with a missing socket. with self.assertRaises(ConnectionFailure): @@ -1390,8 +1390,8 @@ class TestClient(IntegrationTest): client.pymongo_test_bernie.test.insert_one({"dummy": "object"}) dbs = client.list_database_names() - self.assertTrue("pymongo_test" in dbs) - self.assertTrue("pymongo_test_bernie" in dbs) + self.assertIn("pymongo_test", dbs) + self.assertIn("pymongo_test_bernie", dbs) def test_contextlib(self): client = self.rs_or_single_client() diff --git a/test/test_collection.py b/test/test_collection.py index 6d1b02f1a..5643a6202 100644 --- a/test/test_collection.py +++ b/test/test_collection.py @@ -212,7 +212,7 @@ class TestCollection(IntegrationTest): def test_drop_nonexistent_collection(self): self.db.drop_collection("test") - self.assertFalse("test" in self.db.list_collection_names()) + self.assertNotIn("test", self.db.list_collection_names()) # No exception self.db.drop_collection("test") @@ -248,7 +248,7 @@ class TestCollection(IntegrationTest): db.test.drop_indexes() self.assertEqual(len(db.test.index_information()), 1) db.test.create_indexes([IndexModel("hello")]) - self.assertTrue("hello_1" in db.test.index_information()) + self.assertIn("hello_1", db.test.index_information()) db.test.drop_indexes() self.assertEqual(len(db.test.index_information()), 1) @@ -257,7 +257,7 @@ class TestCollection(IntegrationTest): ) info = db.test.index_information() for name in names: - self.assertTrue(name in info) + self.assertIn(name, info) db.test.drop() db.test.insert_one({"a": 1}) @@ -309,16 +309,16 @@ class TestCollection(IntegrationTest): db.test.drop_indexes() self.assertEqual(len(db.test.index_information()), 1) db.test.create_index("hello") - self.assertTrue("hello_1" in db.test.index_information()) + self.assertIn("hello_1", db.test.index_information()) db.test.drop_indexes() self.assertEqual(len(db.test.index_information()), 1) db.test.create_index([("hello", DESCENDING), ("world", ASCENDING)]) - self.assertTrue("hello_-1_world_1" in db.test.index_information()) + self.assertIn("hello_-1_world_1", db.test.index_information()) db.test.drop_indexes() db.test.create_index([("hello", DESCENDING), ("world", ASCENDING)], name=None) - self.assertTrue("hello_-1_world_1" in db.test.index_information()) + self.assertIn("hello_-1_world_1", db.test.index_information()) db.test.drop() db.test.insert_one({"a": 1}) @@ -347,7 +347,7 @@ class TestCollection(IntegrationTest): with self.assertRaises(OperationFailure): db.test.drop_index(name) self.assertEqual(len(db.test.index_information()), 2) - self.assertTrue("hello_1" in db.test.index_information()) + self.assertIn("hello_1", db.test.index_information()) db.test.drop_indexes() db.test.create_index("hello") @@ -357,7 +357,7 @@ class TestCollection(IntegrationTest): self.assertEqual(name, "goodbye_1") db.test.drop_index([("goodbye", ASCENDING)]) self.assertEqual(len(db.test.index_information()), 2) - self.assertTrue("hello_1" in db.test.index_information()) + self.assertIn("hello_1", db.test.index_information()) with self.write_concern_collection() as coll: coll.drop_index("hello_1") @@ -389,7 +389,7 @@ class TestCollection(IntegrationTest): indexes = (db.test.list_indexes()).to_list() self.assertEqual(len(indexes), 1) - self.assertTrue("_id_" in map_indexes(indexes)) + self.assertIn("_id_", map_indexes(indexes)) db.test.create_index("hello") indexes = (db.test.list_indexes()).to_list() @@ -418,7 +418,7 @@ class TestCollection(IntegrationTest): db.test.drop() db.test.insert_one({}) # create collection self.assertEqual(len(db.test.index_information()), 1) - self.assertTrue("_id_" in db.test.index_information()) + self.assertIn("_id_", db.test.index_information()) db.test.create_index("hello") self.assertEqual(len(db.test.index_information()), 2) @@ -478,7 +478,7 @@ class TestCollection(IntegrationTest): db.test.drop_indexes() self.assertEqual("t_text", db.test.create_index([("t", TEXT)])) index_info = (db.test.index_information())["t_text"] - self.assertTrue("weights" in index_info) + self.assertIn("weights", index_info) db.test.insert_many( [{"t": "spam eggs and spam"}, {"t": "spam"}, {"t": "egg sausage and bacon"}] @@ -539,7 +539,7 @@ class TestCollection(IntegrationTest): db.test.create_index([("keya", ASCENDING)]) db.test.create_index([("keyb", ASCENDING)], background=False) db.test.create_index([("keyc", ASCENDING)], background=True) - self.assertFalse("background" in (db.test.index_information())["keya_1"]) + self.assertNotIn("background", (db.test.index_information())["keya_1"]) self.assertFalse((db.test.index_information())["keyb_1"]["background"]) self.assertTrue((db.test.index_information())["keyc_1"]["background"]) @@ -690,7 +690,7 @@ class TestCollection(IntegrationTest): doc = next(db.test.find({}, {"_id": False})) l = list(doc) - self.assertFalse("_id" in l) + self.assertNotIn("_id", l) def test_options(self): db = self.db @@ -752,7 +752,7 @@ class TestCollection(IntegrationTest): for doc in docs: _id = doc["_id"] self.assertIsInstance(_id, ObjectId) - self.assertTrue(_id in result.inserted_ids) + self.assertIn(_id, result.inserted_ids) self.assertEqual(1, db.test.count_documents({"_id": _id})) self.assertTrue(result.acknowledged) @@ -764,7 +764,7 @@ class TestCollection(IntegrationTest): for doc in docs: _id = doc["_id"] self.assertIsInstance(_id, int) - self.assertTrue(_id in result.inserted_ids) + self.assertIn(_id, result.inserted_ids) self.assertEqual(1, db.test.count_documents({"_id": _id})) self.assertTrue(result.acknowledged) @@ -931,7 +931,7 @@ class TestCollection(IntegrationTest): for doc in docs: _id = doc["_id"] self.assertIsInstance(_id, int) - self.assertTrue(_id in result.inserted_ids) + self.assertIn(_id, result.inserted_ids) self.assertEqual(1, db.test.count_documents({"x": doc["x"]})) self.assertTrue(result.acknowledged) docs = [{"_id": i, "a": 200 - i} for i in range(100, 200)] @@ -941,7 +941,7 @@ class TestCollection(IntegrationTest): for doc in docs: _id = doc["_id"] self.assertIsInstance(_id, int) - self.assertTrue(_id in result.inserted_ids) + self.assertIn(_id, result.inserted_ids) self.assertEqual(1, db.test.count_documents({"a": doc["a"]})) self.assertTrue(result.acknowledged) @@ -1117,23 +1117,23 @@ class TestCollection(IntegrationTest): db.test.insert_one({"x": 1, "mike": "awesome", "extra thing": "abcdefghijklmnopqrstuvwxyz"}) self.assertEqual(1, db.test.count_documents({})) doc = next(db.test.find({})) - self.assertTrue("x" in doc) + self.assertIn("x", doc) doc = next(db.test.find({})) - self.assertTrue("mike" in doc) + self.assertIn("mike", doc) doc = next(db.test.find({})) - self.assertTrue("extra thing" in doc) + self.assertIn("extra thing", doc) doc = next(db.test.find({}, ["x", "mike"])) - self.assertTrue("x" in doc) + self.assertIn("x", doc) doc = next(db.test.find({}, ["x", "mike"])) - self.assertTrue("mike" in doc) + self.assertIn("mike", doc) doc = next(db.test.find({}, ["x", "mike"])) - self.assertFalse("extra thing" in doc) + self.assertNotIn("extra thing", doc) doc = next(db.test.find({}, ["mike"])) - self.assertFalse("x" in doc) + self.assertNotIn("x", doc) doc = next(db.test.find({}, ["mike"])) - self.assertTrue("mike" in doc) + self.assertIn("mike", doc) doc = next(db.test.find({}, ["mike"])) - self.assertFalse("extra thing" in doc) + self.assertNotIn("extra thing", doc) @no_type_check def test_fields_specifier_as_dict(self): @@ -1144,8 +1144,8 @@ class TestCollection(IntegrationTest): self.assertEqual([1, 2, 3], (db.test.find_one())["x"]) self.assertEqual([2, 3], (db.test.find_one(projection={"x": {"$slice": -2}}))["x"]) - self.assertTrue("x" not in db.test.find_one(projection={"x": 0})) - self.assertTrue("mike" in db.test.find_one(projection={"x": 0})) + self.assertNotIn("x", db.test.find_one(projection={"x": 0})) + self.assertIn("mike", db.test.find_one(projection={"x": 0})) def test_find_w_regex(self): db = self.db @@ -1180,7 +1180,7 @@ class TestCollection(IntegrationTest): for x in db.test.find(): self.assertEqual(x["hello"], "world") - self.assertTrue("_id" in x) + self.assertIn("_id", x) def test_unique_index(self): db = self.db @@ -1300,7 +1300,7 @@ class TestCollection(IntegrationTest): try: self.db.test.update_many({}, {"$thismodifierdoesntexist": 1}) except OperationFailure as exc: - self.assertTrue(exc.code in (9, 10147, 16840, 17009)) + self.assertIn(exc.code, (9, 10147, 16840, 17009)) # Just check that we set the error document. Fields # vary by MongoDB version. self.assertTrue(exc.details is not None) @@ -1334,7 +1334,7 @@ class TestCollection(IntegrationTest): result = db.test.replace_one({"x": 1}, {"y": 1}) self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (None, 1)) + self.assertIn(result.modified_count, (None, 1)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual(1, db.test.count_documents({"y": 1})) @@ -1345,7 +1345,7 @@ class TestCollection(IntegrationTest): result = db.test.replace_one({"y": 1}, replacement, True) self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (None, 1)) + self.assertIn(result.modified_count, (None, 1)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual(1, db.test.count_documents({"z": 1})) @@ -1355,7 +1355,7 @@ class TestCollection(IntegrationTest): result = db.test.replace_one({"x": 2}, {"y": 2}, True) self.assertIsInstance(result, UpdateResult) self.assertEqual(0, result.matched_count) - self.assertTrue(result.modified_count in (None, 0)) + self.assertIn(result.modified_count, (None, 0)) self.assertIsInstance(result.upserted_id, ObjectId) self.assertTrue(result.acknowledged) self.assertEqual(1, db.test.count_documents({"y": 2})) @@ -1379,7 +1379,7 @@ class TestCollection(IntegrationTest): result = db.test.update_one({}, {"$inc": {"x": 1}}) self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (None, 1)) + self.assertIn(result.modified_count, (None, 1)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual((db.test.find_one(id1))["x"], 6) # type: ignore @@ -1388,7 +1388,7 @@ class TestCollection(IntegrationTest): result = db.test.update_one({"x": 6}, {"$inc": {"x": 1}}) self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (None, 1)) + self.assertIn(result.modified_count, (None, 1)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual((db.test.find_one(id1))["x"], 7) # type: ignore @@ -1397,7 +1397,7 @@ class TestCollection(IntegrationTest): result = db.test.update_one({"x": 2}, {"$set": {"y": 1}}, True) self.assertIsInstance(result, UpdateResult) self.assertEqual(0, result.matched_count) - self.assertTrue(result.modified_count in (None, 0)) + self.assertIn(result.modified_count, (None, 0)) self.assertIsInstance(result.upserted_id, ObjectId) self.assertTrue(result.acknowledged) @@ -1436,7 +1436,7 @@ class TestCollection(IntegrationTest): result = db.test.update_many({"x": 4}, {"$set": {"y": 5}}) self.assertIsInstance(result, UpdateResult) self.assertEqual(2, result.matched_count) - self.assertTrue(result.modified_count in (None, 2)) + self.assertIn(result.modified_count, (None, 2)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual(3, db.test.count_documents({"y": 5})) @@ -1444,7 +1444,7 @@ class TestCollection(IntegrationTest): result = db.test.update_many({"x": 5}, {"$set": {"y": 6}}) self.assertIsInstance(result, UpdateResult) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (None, 1)) + self.assertIn(result.modified_count, (None, 1)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual(1, db.test.count_documents({"y": 6})) @@ -1452,7 +1452,7 @@ class TestCollection(IntegrationTest): result = db.test.update_many({"x": 2}, {"$set": {"y": 1}}, True) self.assertIsInstance(result, UpdateResult) self.assertEqual(0, result.matched_count) - self.assertTrue(result.modified_count in (None, 0)) + self.assertIn(result.modified_count, (None, 0)) self.assertIsInstance(result.upserted_id, ObjectId) self.assertTrue(result.acknowledged) @@ -1707,21 +1707,21 @@ class TestCollection(IntegrationTest): self.assertEqual(db.test.find_one({}), db.test.find_one()) self.assertEqual(db.test.find_one({"hello": "world"}), db.test.find_one()) - self.assertTrue("hello" in db.test.find_one(projection=["hello"])) - self.assertTrue("hello" not in db.test.find_one(projection=["foo"])) + self.assertIn("hello", db.test.find_one(projection=["hello"])) + self.assertNotIn("hello", db.test.find_one(projection=["foo"])) - self.assertTrue("hello" in db.test.find_one(projection=("hello",))) - self.assertTrue("hello" not in db.test.find_one(projection=("foo",))) + self.assertIn("hello", db.test.find_one(projection=("hello",))) + self.assertNotIn("hello", db.test.find_one(projection=("foo",))) - self.assertTrue("hello" in db.test.find_one(projection={"hello"})) - self.assertTrue("hello" not in db.test.find_one(projection={"foo"})) + self.assertIn("hello", db.test.find_one(projection={"hello"})) + self.assertNotIn("hello", db.test.find_one(projection={"foo"})) - self.assertTrue("hello" in db.test.find_one(projection=frozenset(["hello"]))) - self.assertTrue("hello" not in db.test.find_one(projection=frozenset(["foo"]))) + self.assertIn("hello", db.test.find_one(projection=frozenset(["hello"]))) + self.assertNotIn("hello", db.test.find_one(projection=frozenset(["foo"]))) self.assertEqual(["_id"], list(db.test.find_one(projection={"_id": True}))) - self.assertTrue("hello" in list(db.test.find_one(projection={}))) - self.assertTrue("hello" in list(db.test.find_one(projection=[]))) + self.assertIn("hello", list(db.test.find_one(projection={}))) + self.assertIn("hello", list(db.test.find_one(projection=[]))) self.assertEqual(None, db.test.find_one({"hello": "foo"})) self.assertEqual(None, db.test.find_one(ObjectId())) diff --git a/test/test_cursor.py b/test/test_cursor.py index d5845e39b..c33f50956 100644 --- a/test/test_cursor.py +++ b/test/test_cursor.py @@ -174,8 +174,8 @@ class TestCursor(IntegrationTest): cursor = coll.find().max_time_ms(999) c2 = cursor.clone() self.assertEqual(999, c2._max_time_ms) - self.assertTrue("$maxTimeMS" in cursor._query_spec()) - self.assertTrue("$maxTimeMS" in c2._query_spec()) + self.assertIn("$maxTimeMS", cursor._query_spec()) + self.assertIn("$maxTimeMS", c2._query_spec()) self.assertTrue(coll.find_one(max_time_ms=1000)) @@ -236,19 +236,19 @@ class TestCursor(IntegrationTest): # Tailable_defaults. coll.find(cursor_type=CursorType.TAILABLE_AWAIT).to_list() # find - self.assertFalse("maxTimeMS" in listener.started_events[0].command) + self.assertNotIn("maxTimeMS", listener.started_events[0].command) # getMore - self.assertFalse("maxTimeMS" in listener.started_events[1].command) + self.assertNotIn("maxTimeMS", listener.started_events[1].command) listener.reset() # Tailable_with max_await_time_ms set. coll.find(cursor_type=CursorType.TAILABLE_AWAIT).max_await_time_ms(99).to_list() # find self.assertEqual("find", listener.started_events[0].command_name) - self.assertFalse("maxTimeMS" in listener.started_events[0].command) + self.assertNotIn("maxTimeMS", listener.started_events[0].command) # getMore self.assertEqual("getMore", listener.started_events[1].command_name) - self.assertTrue("maxTimeMS" in listener.started_events[1].command) + self.assertIn("maxTimeMS", listener.started_events[1].command) self.assertEqual(99, listener.started_events[1].command["maxTimeMS"]) listener.reset() @@ -259,11 +259,11 @@ class TestCursor(IntegrationTest): coll.find(cursor_type=CursorType.TAILABLE_AWAIT).max_time_ms(99).to_list() # find self.assertEqual("find", listener.started_events[0].command_name) - self.assertTrue("maxTimeMS" in listener.started_events[0].command) + self.assertIn("maxTimeMS", listener.started_events[0].command) self.assertEqual(99, listener.started_events[0].command["maxTimeMS"]) # getMore self.assertEqual("getMore", listener.started_events[1].command_name) - self.assertFalse("maxTimeMS" in listener.started_events[1].command) + self.assertNotIn("maxTimeMS", listener.started_events[1].command) listener.reset() # Tailable_with both max_time_ms and max_await_time_ms @@ -275,11 +275,11 @@ class TestCursor(IntegrationTest): ) # find self.assertEqual("find", listener.started_events[0].command_name) - self.assertTrue("maxTimeMS" in listener.started_events[0].command) + self.assertIn("maxTimeMS", listener.started_events[0].command) self.assertEqual(99, listener.started_events[0].command["maxTimeMS"]) # getMore self.assertEqual("getMore", listener.started_events[1].command_name) - self.assertTrue("maxTimeMS" in listener.started_events[1].command) + self.assertIn("maxTimeMS", listener.started_events[1].command) self.assertEqual(99, listener.started_events[1].command["maxTimeMS"]) listener.reset() @@ -287,31 +287,31 @@ class TestCursor(IntegrationTest): coll.find(batch_size=1).max_await_time_ms(99).to_list() # find self.assertEqual("find", listener.started_events[0].command_name) - self.assertFalse("maxTimeMS" in listener.started_events[0].command) + self.assertNotIn("maxTimeMS", listener.started_events[0].command) # getMore self.assertEqual("getMore", listener.started_events[1].command_name) - self.assertFalse("maxTimeMS" in listener.started_events[1].command) + self.assertNotIn("maxTimeMS", listener.started_events[1].command) listener.reset() # Non tailable_await with max_time_ms coll.find(batch_size=1).max_time_ms(99).to_list() # find self.assertEqual("find", listener.started_events[0].command_name) - self.assertTrue("maxTimeMS" in listener.started_events[0].command) + self.assertIn("maxTimeMS", listener.started_events[0].command) self.assertEqual(99, listener.started_events[0].command["maxTimeMS"]) # getMore self.assertEqual("getMore", listener.started_events[1].command_name) - self.assertFalse("maxTimeMS" in listener.started_events[1].command) + self.assertNotIn("maxTimeMS", listener.started_events[1].command) # Non tailable_await with both max_time_ms and max_await_time_ms coll.find(batch_size=1).max_time_ms(99).max_await_time_ms(88).to_list() # find self.assertEqual("find", listener.started_events[0].command_name) - self.assertTrue("maxTimeMS" in listener.started_events[0].command) + self.assertIn("maxTimeMS", listener.started_events[0].command) self.assertEqual(99, listener.started_events[0].command["maxTimeMS"]) # getMore self.assertEqual("getMore", listener.started_events[1].command_name) - self.assertFalse("maxTimeMS" in listener.started_events[1].command) + self.assertNotIn("maxTimeMS", listener.started_events[1].command) @client_context.require_test_commands @client_context.require_no_mongos @@ -924,16 +924,19 @@ class TestCursor(IntegrationTest): # Shallow copies can so can mutate cursor2 = copy.copy(cursor) cursor2._projection["cursor2"] = False - self.assertTrue(cursor._projection and "cursor2" in cursor._projection) + self.assertIsNotNone(cursor._projection) + self.assertIn("cursor2", cursor._projection.keys()) # Deepcopies and shouldn't mutate cursor3 = copy.deepcopy(cursor) cursor3._projection["cursor3"] = False - self.assertFalse(cursor._projection and "cursor3" in cursor._projection) + self.assertIsNotNone(cursor._projection) + self.assertNotIn("cursor3", cursor._projection.keys()) cursor4 = cursor.clone() cursor4._projection["cursor4"] = False - self.assertFalse(cursor._projection and "cursor4" in cursor._projection) + self.assertIsNotNone(cursor._projection) + self.assertNotIn("cursor4", cursor._projection.keys()) # Test memo when deepcopying queries query = {"hello": "world"} diff --git a/test/test_database.py b/test/test_database.py index 0cb016e26..0fe6c01a9 100644 --- a/test/test_database.py +++ b/test/test_database.py @@ -162,13 +162,13 @@ class TestDatabase(IntegrationTest): db.create_collection("coll..ection") # type: ignore[arg-type] test = db.create_collection("test") - self.assertTrue("test" in db.list_collection_names()) + self.assertIn("test", db.list_collection_names()) test.insert_one({"hello": "world"}) self.assertEqual((db.test.find_one())["hello"], "world") db.drop_collection("test.foo") db.create_collection("test.foo") - self.assertTrue("test.foo" in db.list_collection_names()) + self.assertIn("test.foo", db.list_collection_names()) with self.assertRaises(CollectionInvalid): db.create_collection("test.foo") @@ -178,10 +178,10 @@ class TestDatabase(IntegrationTest): db.test.mike.insert_one({"dummy": "object"}) colls = db.list_collection_names() - self.assertTrue("test" in colls) - self.assertTrue("test.mike" in colls) + self.assertIn("test", colls) + self.assertIn("test.mike", colls) for coll in colls: - self.assertTrue("$" not in coll) + self.assertNotIn("$", coll) db.systemcoll.test.insert_one({}) no_system_collections = db.list_collection_names( @@ -251,12 +251,12 @@ class TestDatabase(IntegrationTest): colls = [result["name"] for result in results] # All the collections present. - self.assertTrue("test" in colls) - self.assertTrue("test.mike" in colls) + self.assertIn("test", colls) + self.assertIn("test.mike", colls) # No collection containing a '$'. for coll in colls: - self.assertTrue("$" not in coll) + self.assertNotIn("$", coll) # Duplicate check. coll_cnt: dict = {} @@ -291,12 +291,12 @@ class TestDatabase(IntegrationTest): colls = [result["name"] for result in results] # Checking only capped collections are present - self.assertTrue("test" in colls) - self.assertFalse("test.mike" in colls) + self.assertIn("test", colls) + self.assertNotIn("test.mike", colls) # No collection containing a '$'. for coll in colls: - self.assertTrue("$" not in coll) + self.assertNotIn("$", coll) # Duplicate check. coll_cnt = {} @@ -336,24 +336,24 @@ class TestDatabase(IntegrationTest): db.drop_collection(None) # type: ignore[arg-type] db.test.insert_one({"dummy": "object"}) - self.assertTrue("test" in db.list_collection_names()) + self.assertIn("test", db.list_collection_names()) db.drop_collection("test") - self.assertFalse("test" in db.list_collection_names()) + self.assertNotIn("test", db.list_collection_names()) db.test.insert_one({"dummy": "object"}) - self.assertTrue("test" in db.list_collection_names()) + self.assertIn("test", db.list_collection_names()) db.drop_collection("test") - self.assertFalse("test" in db.list_collection_names()) + self.assertNotIn("test", db.list_collection_names()) db.test.insert_one({"dummy": "object"}) - self.assertTrue("test" in db.list_collection_names()) + self.assertIn("test", db.list_collection_names()) db.drop_collection(db.test) - self.assertFalse("test" in db.list_collection_names()) + self.assertNotIn("test", db.list_collection_names()) db.test.insert_one({"dummy": "object"}) - self.assertTrue("test" in db.list_collection_names()) + self.assertIn("test", db.list_collection_names()) db.test.drop() - self.assertFalse("test" in db.list_collection_names()) + self.assertNotIn("test", db.list_collection_names()) db.test.drop() db.drop_collection(db.test.doesnotexist) diff --git a/test/test_examples.py b/test/test_examples.py index 0585d1e05..bda540320 100644 --- a/test/test_examples.py +++ b/test/test_examples.py @@ -479,77 +479,77 @@ class TestSampleShellCommands(IntegrationTest): # End Example 44 for doc in cursor: - self.assertTrue("_id" in doc) - self.assertTrue("item" in doc) - self.assertTrue("status" in doc) - self.assertFalse("size" in doc) - self.assertFalse("instock" in doc) + self.assertIn("_id", doc) + self.assertIn("item", doc) + self.assertIn("status", doc) + self.assertNotIn("size", doc) + self.assertNotIn("instock", doc) # Start Example 45 cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "_id": 0}) # End Example 45 for doc in cursor: - self.assertFalse("_id" in doc) - self.assertTrue("item" in doc) - self.assertTrue("status" in doc) - self.assertFalse("size" in doc) - self.assertFalse("instock" in doc) + self.assertNotIn("_id", doc) + self.assertIn("item", doc) + self.assertIn("status", doc) + self.assertNotIn("size", doc) + self.assertNotIn("instock", doc) # Start Example 46 cursor = db.inventory.find({"status": "A"}, {"status": 0, "instock": 0}) # End Example 46 for doc in cursor: - self.assertTrue("_id" in doc) - self.assertTrue("item" in doc) - self.assertFalse("status" in doc) - self.assertTrue("size" in doc) - self.assertFalse("instock" in doc) + self.assertIn("_id", doc) + self.assertIn("item", doc) + self.assertNotIn("status", doc) + self.assertIn("size", doc) + self.assertNotIn("instock", doc) # Start Example 47 cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "size.uom": 1}) # End Example 47 for doc in cursor: - self.assertTrue("_id" in doc) - self.assertTrue("item" in doc) - self.assertTrue("status" in doc) - self.assertTrue("size" in doc) - self.assertFalse("instock" in doc) + self.assertIn("_id", doc) + self.assertIn("item", doc) + self.assertIn("status", doc) + self.assertIn("size", doc) + self.assertNotIn("instock", doc) size = doc["size"] - self.assertTrue("uom" in size) - self.assertFalse("h" in size) - self.assertFalse("w" in size) + self.assertIn("uom", size) + self.assertNotIn("h", size) + self.assertNotIn("w", size) # Start Example 48 cursor = db.inventory.find({"status": "A"}, {"size.uom": 0}) # End Example 48 for doc in cursor: - self.assertTrue("_id" in doc) - self.assertTrue("item" in doc) - self.assertTrue("status" in doc) - self.assertTrue("size" in doc) - self.assertTrue("instock" in doc) + self.assertIn("_id", doc) + self.assertIn("item", doc) + self.assertIn("status", doc) + self.assertIn("size", doc) + self.assertIn("instock", doc) size = doc["size"] - self.assertFalse("uom" in size) - self.assertTrue("h" in size) - self.assertTrue("w" in size) + self.assertNotIn("uom", size) + self.assertIn("h", size) + self.assertIn("w", size) # Start Example 49 cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "instock.qty": 1}) # End Example 49 for doc in cursor: - self.assertTrue("_id" in doc) - self.assertTrue("item" in doc) - self.assertTrue("status" in doc) - self.assertFalse("size" in doc) - self.assertTrue("instock" in doc) + self.assertIn("_id", doc) + self.assertIn("item", doc) + self.assertIn("status", doc) + self.assertNotIn("size", doc) + self.assertIn("instock", doc) for subdoc in doc["instock"]: - self.assertFalse("warehouse" in subdoc) - self.assertTrue("qty" in subdoc) + self.assertNotIn("warehouse", subdoc) + self.assertIn("qty", subdoc) # Start Example 50 cursor = db.inventory.find( @@ -558,11 +558,11 @@ class TestSampleShellCommands(IntegrationTest): # End Example 50 for doc in cursor: - self.assertTrue("_id" in doc) - self.assertTrue("item" in doc) - self.assertTrue("status" in doc) - self.assertFalse("size" in doc) - self.assertTrue("instock" in doc) + self.assertIn("_id", doc) + self.assertIn("item", doc) + self.assertIn("status", doc) + self.assertNotIn("size", doc) + self.assertIn("instock", doc) self.assertEqual(len(doc["instock"]), 1) def test_update_and_replace(self): @@ -645,7 +645,7 @@ class TestSampleShellCommands(IntegrationTest): for doc in db.inventory.find({"item": "paper"}): self.assertEqual(doc["size"]["uom"], "cm") self.assertEqual(doc["status"], "P") - self.assertTrue("lastModified" in doc) + self.assertIn("lastModified", doc) # Start Example 53 db.inventory.update_many( @@ -657,7 +657,7 @@ class TestSampleShellCommands(IntegrationTest): for doc in db.inventory.find({"qty": {"$lt": 50}}): self.assertEqual(doc["size"]["uom"], "in") self.assertEqual(doc["status"], "P") - self.assertTrue("lastModified" in doc) + self.assertIn("lastModified", doc) # Start Example 54 db.inventory.replace_one( @@ -671,8 +671,8 @@ class TestSampleShellCommands(IntegrationTest): for doc in db.inventory.find({"item": "paper"}, {"_id": 0}): self.assertEqual(len(doc.keys()), 2) - self.assertTrue("item" in doc) - self.assertTrue("instock" in doc) + self.assertIn("item", doc) + self.assertIn("instock", doc) self.assertEqual(len(doc["instock"]), 2) def test_delete(self): diff --git a/test/test_json_util_integration.py b/test/test_json_util_integration.py index acab4f318..4ef5f10fe 100644 --- a/test/test_json_util_integration.py +++ b/test/test_json_util_integration.py @@ -25,4 +25,4 @@ class TestJsonUtilRoundtrip(IntegrationTest): db.test.insert_many(docs) reloaded_docs = json_util.loads(json_util.dumps((db.test.find()).to_list())) for doc in docs: - self.assertTrue(doc in reloaded_docs) + self.assertIn(doc, reloaded_docs) diff --git a/test/test_monitoring.py b/test/test_monitoring.py index fc8be127e..8b54793a3 100644 --- a/test/test_monitoring.py +++ b/test/test_monitoring.py @@ -1086,8 +1086,8 @@ class TestCommandMonitoring(IntegrationTest): self.assertEqual(started.command_name, succeeded.command_name) self.assertEqual(started.request_id, succeeded.request_id) self.assertEqual(started.connection_id, succeeded.connection_id) - self.assertTrue("cursor" in succeeded.reply) - self.assertTrue("ok" in succeeded.reply) + self.assertIn("cursor", succeeded.reply) + self.assertIn("ok", succeeded.reply) self.listener.reset() diff --git a/test/test_session.py b/test/test_session.py index a6266884a..49cb9dba9 100644 --- a/test/test_session.py +++ b/test/test_session.py @@ -134,8 +134,9 @@ class TestSession(IntegrationTest): f(*args, **kw) self.assertGreaterEqual(len(listener.started_events), 1) for event in listener.started_events: - self.assertTrue( - "lsid" in event.command, + self.assertIn( + "lsid", + event.command, f"{f.__name__} sent no lsid with {event.command_name}", ) @@ -170,8 +171,9 @@ class TestSession(IntegrationTest): self.assertGreaterEqual(len(listener.started_events), 1) lsids = [] for event in listener.started_events: - self.assertTrue( - "lsid" in event.command, + self.assertIn( + "lsid", + event.command, f"{f.__name__} sent no lsid with {event.command_name}", ) @@ -422,8 +424,9 @@ class TestSession(IntegrationTest): f(session=s) self.assertGreaterEqual(len(listener.started_events), 1) for event in listener.started_events: - self.assertTrue( - "lsid" in event.command, + self.assertIn( + "lsid", + event.command, f"{name} sent no lsid with {event.command_name}", ) @@ -441,15 +444,13 @@ class TestSession(IntegrationTest): listener.reset() f(session=None) event0 = listener.first_command_started() - self.assertTrue( - "lsid" in event0.command, f"{name} sent no lsid with {event0.command_name}" - ) + self.assertIn("lsid", event0.command, f"{name} sent no lsid with {event0.command_name}") lsid = event0.command["lsid"] for event in listener.started_events[1:]: - self.assertTrue( - "lsid" in event.command, f"{name} sent no lsid with {event.command_name}" + self.assertIn( + "lsid", event.command, f"{name} sent no lsid with {event.command_name}" ) self.assertEqual( @@ -1187,15 +1188,17 @@ class TestClusterTime(IntegrationTest): self.assertGreaterEqual(len(listener.started_events), 1) for i, event in enumerate(listener.started_events): - self.assertTrue( - "$clusterTime" in event.command, + self.assertIn( + "$clusterTime", + event.command, f"{f.__name__} sent no $clusterTime with {event.command_name}", ) if i > 0: succeeded = listener.succeeded_events[i - 1] - self.assertTrue( - "$clusterTime" in succeeded.reply, + self.assertIn( + "$clusterTime", + succeeded.reply, f"{f.__name__} received no $clusterTime with {succeeded.command_name}", ) diff --git a/test/test_son.py b/test/test_son.py index a06d92bcb..36a683488 100644 --- a/test/test_son.py +++ b/test/test_son.py @@ -148,8 +148,8 @@ class TestSON(unittest.TestCase): """has_key and __contains__""" test_son = SON([(1, 100), (2, 200), (3, 300)]) self.assertIn(1, test_son) - self.assertTrue(2 in test_son, "in failed") - self.assertFalse(22 in test_son, "in succeeded when it shouldn't") + self.assertIn(2, test_son, "in failed") + self.assertNotIn(22, test_son, "in succeeded when it shouldn't") self.assertTrue(test_son.has_key(2), "has_key failed") self.assertFalse(test_son.has_key(22), "has_key succeeded when it shouldn't") From 27593796fb3deb7c219fddf861b1f62ab0f126ba Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Michael=20=C5=A0im=C3=A1=C4=8Dek?= Date: Fri, 23 May 2025 19:01:30 +0200 Subject: [PATCH 6/6] PYTHON-5391 Skip C extension build on GraalPy (#2349) Co-authored-by: Steven Silvester --- _setup.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/_setup.py b/_setup.py index 1a8b9e024..f99e9e7dc 100644 --- a/_setup.py +++ b/_setup.py @@ -130,7 +130,11 @@ if "--no_ext" in sys.argv or os.environ.get("NO_EXT"): except ValueError: pass ext_modules = [] -elif sys.platform.startswith("java") or sys.platform == "cli" or "PyPy" in sys.version: +elif ( + sys.platform.startswith("java") + or sys.platform == "cli" + or sys.implementation.name in ("pypy", "graalpy") +): sys.stdout.write( """ *****************************************************\n