From 0424723182c8d6799b9489c0b9d35e2896d239ca Mon Sep 17 00:00:00 2001 From: Iris Ho Date: Wed, 21 May 2025 14:57:41 -0700 Subject: [PATCH 1/5] better test assertions for in --- test/asynchronous/test_bulk.py | 14 +-- test/asynchronous/test_client.py | 16 ++-- test/asynchronous/test_collection.py | 86 +++++++++---------- test/asynchronous/test_cursor.py | 18 ++-- test/asynchronous/test_database.py | 28 +++--- test/asynchronous/test_examples.py | 66 +++++++------- .../test_json_util_integration.py | 2 +- test/asynchronous/test_monitoring.py | 4 +- test/test_bulk.py | 14 +-- test/test_client.py | 16 ++-- test/test_collection.py | 86 +++++++++---------- test/test_cursor.py | 18 ++-- test/test_database.py | 28 +++--- test/test_examples.py | 66 +++++++------- test/test_json_util_integration.py | 2 +- test/test_monitoring.py | 4 +- test/test_son.py | 2 +- 17 files changed, 235 insertions(+), 235 deletions(-) diff --git a/test/asynchronous/test_bulk.py b/test/asynchronous/test_bulk.py index 65ed6e236a..3da9c4ba3c 100644 --- a/test/asynchronous/test_bulk.py +++ b/test/asynchronous/test_bulk.py @@ -94,7 +94,7 @@ def assertEqualUpsert(self, expected, actual): self.assertEqual(expected["index"], actual["index"]) if expected["_id"] == "...": # Unspecified value. - self.assertTrue("_id" in actual) + self.assertIn("_id", actual) else: self.assertEqual(expected["_id"], actual["_id"]) @@ -107,7 +107,7 @@ def assertEqualWriteError(self, expected, actual): self.assertEqual(expected["code"], actual["code"]) if expected["errmsg"] == "...": # Unspecified value. - self.assertTrue("errmsg" in actual) + self.assertIn("errmsg", actual) else: self.assertEqual(expected["errmsg"], actual["errmsg"]) @@ -115,7 +115,7 @@ def assertEqualWriteError(self, expected, actual): actual_op = actual["op"].copy() if expected_op.get("_id") == "...": # Unspecified _id. - self.assertTrue("_id" in actual_op) + self.assertIn("_id", actual_op) actual_op.pop("_id") expected_op.pop("_id") @@ -160,7 +160,7 @@ async def _test_update_many(self, update): result = await self.coll.bulk_write([UpdateMany({}, update)]) self.assertEqualResponse(expected, result.bulk_api_result) self.assertEqual(2, result.matched_count) - self.assertTrue(result.modified_count in (2, None)) + self.assertIn(result.modified_count, (2, None)) async def test_update_many(self): await self._test_update_many({"$set": {"foo": "bar"}}) @@ -201,7 +201,7 @@ async def _test_update_one(self, update): result = await self.coll.bulk_write([UpdateOne({}, update)]) self.assertEqualResponse(expected, result.bulk_api_result) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (1, None)) + self.assertIn(result.modified_count, (1, None)) async def test_update_one(self): await self._test_update_one({"$set": {"foo": "bar"}}) @@ -227,7 +227,7 @@ async def test_replace_one(self): result = await self.coll.bulk_write([ReplaceOne({}, {"foo": "bar"})]) self.assertEqualResponse(expected, result.bulk_api_result) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (1, None)) + self.assertIn(result.modified_count, (1, None)) async def test_remove(self): # Test removing all documents, ordered. @@ -1037,7 +1037,7 @@ async def test_write_concern_failure_ordered(self): self.assertTrue(len(details["writeConcernErrors"]) > 1) failed = details["writeErrors"][0] - self.assertTrue("duplicate" in failed["errmsg"]) + self.assertIn("duplicate", failed["errmsg"]) @async_client_context.require_version_max(7, 1) # PYTHON-4560 @async_client_context.require_replica_set diff --git a/test/asynchronous/test_client.py b/test/asynchronous/test_client.py index 1e1faf0a2a..1fafa92189 100644 --- a/test/asynchronous/test_client.py +++ b/test/asynchronous/test_client.py @@ -674,7 +674,7 @@ async def test_max_idle_time_reaper_default(self): async with server._pool.checkout() as conn: pass self.assertEqual(1, len(server._pool.conns)) - self.assertTrue(conn in server._pool.conns) + self.assertIn(conn, server._pool.conns) async def test_max_idle_time_reaper_removes_stale_minPoolSize(self): with client_knobs(kill_cursor_frequency=0.1): @@ -770,7 +770,7 @@ async def test_max_idle_time_checkout(self): 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.assertIn(new_con, server._pool.conns) # Test that connections are reused if maxIdleTimeMS is not set. client = await self.async_rs_or_single_client() @@ -1032,8 +1032,8 @@ async def test_list_database_names(self): cmd_names = [doc["name"] for doc in cmd_docs] db_names = await self.client.list_database_names() - self.assertTrue("pymongo_test" in db_names) - self.assertTrue("pymongo_test_mike" in db_names) + self.assertIn("pymongo_test", db_names) + self.assertIn("pymongo_test_mike", db_names) self.assertEqual(db_names, cmd_names) async def test_drop_database(self): @@ -1257,9 +1257,9 @@ async def test_unix_socket(self): client = await self.async_rs_or_single_client(uri) await client.pymongo_test.test.insert_one({"dummy": "object"}) dbs = await client.list_database_names() - self.assertTrue("pymongo_test" in dbs) + self.assertIn("pymongo_test", dbs) - self.assertTrue(mongodb_socket in repr(client)) + self.assertIn(mongodb_socket, repr(client)) # Confirm it fails with a missing socket. with self.assertRaises(ConnectionFailure): @@ -1431,8 +1431,8 @@ async def test_ipv6(self): await client.pymongo_test_bernie.test.insert_one({"dummy": "object"}) dbs = await client.list_database_names() - self.assertTrue("pymongo_test" in dbs) - self.assertTrue("pymongo_test_bernie" in dbs) + self.assertIn("pymongo_test", dbs) + self.assertIn("pymongo_test_bernie", dbs) async def test_contextlib(self): client = await self.async_rs_or_single_client() diff --git a/test/asynchronous/test_collection.py b/test/asynchronous/test_collection.py index 00ed020d88..9a317f4bae 100644 --- a/test/asynchronous/test_collection.py +++ b/test/asynchronous/test_collection.py @@ -248,7 +248,7 @@ async def test_create_indexes(self): await db.test.drop_indexes() self.assertEqual(len(await db.test.index_information()), 1) await db.test.create_indexes([IndexModel("hello")]) - self.assertTrue("hello_1" in await db.test.index_information()) + self.assertIn("hello_1", await db.test.index_information()) await db.test.drop_indexes() self.assertEqual(len(await db.test.index_information()), 1) @@ -257,7 +257,7 @@ async def test_create_indexes(self): ) info = await db.test.index_information() for name in names: - self.assertTrue(name in info) + self.assertIn(name, info) await db.test.drop() await db.test.insert_one({"a": 1}) @@ -311,16 +311,16 @@ async def test_create_index(self): await db.test.drop_indexes() self.assertEqual(len(await db.test.index_information()), 1) await db.test.create_index("hello") - self.assertTrue("hello_1" in await db.test.index_information()) + self.assertIn("hello_1", await db.test.index_information()) await db.test.drop_indexes() self.assertEqual(len(await db.test.index_information()), 1) await db.test.create_index([("hello", DESCENDING), ("world", ASCENDING)]) - self.assertTrue("hello_-1_world_1" in await db.test.index_information()) + self.assertIn("hello_-1_world_1", await db.test.index_information()) await db.test.drop_indexes() await db.test.create_index([("hello", DESCENDING), ("world", ASCENDING)], name=None) - self.assertTrue("hello_-1_world_1" in await db.test.index_information()) + self.assertIn("hello_-1_world_1", await db.test.index_information()) await db.test.drop() await db.test.insert_one({"a": 1}) @@ -349,7 +349,7 @@ async def test_drop_index(self): with self.assertRaises(OperationFailure): await db.test.drop_index(name) self.assertEqual(len(await db.test.index_information()), 2) - self.assertTrue("hello_1" in await db.test.index_information()) + self.assertIn("hello_1", await db.test.index_information()) await db.test.drop_indexes() await db.test.create_index("hello") @@ -359,7 +359,7 @@ async def test_drop_index(self): self.assertEqual(name, "goodbye_1") await db.test.drop_index([("goodbye", ASCENDING)]) self.assertEqual(len(await db.test.index_information()), 2) - self.assertTrue("hello_1" in await db.test.index_information()) + self.assertIn("hello_1", await db.test.index_information()) with self.write_concern_collection() as coll: await coll.drop_index("hello_1") @@ -395,7 +395,7 @@ def map_indexes(indexes): indexes = await (await db.test.list_indexes()).to_list() self.assertEqual(len(indexes), 1) - self.assertTrue("_id_" in map_indexes(indexes)) + self.assertIn("_id_", map_indexes(indexes)) await db.test.create_index("hello") indexes = await (await db.test.list_indexes()).to_list() @@ -424,7 +424,7 @@ async def test_index_info(self): await db.test.drop() await db.test.insert_one({}) # create collection self.assertEqual(len(await db.test.index_information()), 1) - self.assertTrue("_id_" in await db.test.index_information()) + self.assertIn("_id_", await db.test.index_information()) await db.test.create_index("hello") self.assertEqual(len(await db.test.index_information()), 2) @@ -488,7 +488,7 @@ async def test_index_text(self): await db.test.drop_indexes() self.assertEqual("t_text", await db.test.create_index([("t", TEXT)])) index_info = (await db.test.index_information())["t_text"] - self.assertTrue("weights" in index_info) + self.assertIn("weights", index_info) await db.test.insert_many( [{"t": "spam eggs and spam"}, {"t": "spam"}, {"t": "egg sausage and bacon"}] @@ -764,7 +764,7 @@ async def test_insert_many(self): for doc in docs: _id = doc["_id"] self.assertTrue(isinstance(_id, ObjectId)) - self.assertTrue(_id in result.inserted_ids) + self.assertIn(_id, result.inserted_ids) self.assertEqual(1, await db.test.count_documents({"_id": _id})) self.assertTrue(result.acknowledged) @@ -776,7 +776,7 @@ async def test_insert_many(self): for doc in docs: _id = doc["_id"] self.assertTrue(isinstance(_id, int)) - self.assertTrue(_id in result.inserted_ids) + self.assertIn(_id, result.inserted_ids) self.assertEqual(1, await db.test.count_documents({"_id": _id})) self.assertTrue(result.acknowledged) @@ -943,7 +943,7 @@ async def async_lambda(): for doc in docs: _id = doc["_id"] self.assertTrue(isinstance(_id, int)) - self.assertTrue(_id in result.inserted_ids) + self.assertIn(_id, result.inserted_ids) self.assertEqual(1, await db.test.count_documents({"x": doc["x"]})) self.assertTrue(result.acknowledged) docs = [{"_id": i, "a": 200 - i} for i in range(100, 200)] @@ -953,7 +953,7 @@ async def async_lambda(): for doc in docs: _id = doc["_id"] self.assertTrue(isinstance(_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,21 +1131,21 @@ async def test_find_w_fields(self): ) self.assertEqual(1, await db.test.count_documents({})) doc = await anext(db.test.find({})) - self.assertTrue("x" in doc) + self.assertIn("x", doc) doc = await anext(db.test.find({})) - self.assertTrue("mike" in doc) + self.assertIn("mike", doc) doc = await anext(db.test.find({})) - self.assertTrue("extra thing" in doc) + self.assertIn("extra thing", doc) doc = await anext(db.test.find({}, ["x", "mike"])) - self.assertTrue("x" in doc) + self.assertIn("x", doc) doc = await anext(db.test.find({}, ["x", "mike"])) - self.assertTrue("mike" in doc) + self.assertIn("mike", doc) doc = await anext(db.test.find({}, ["x", "mike"])) self.assertFalse("extra thing" in doc) doc = await anext(db.test.find({}, ["mike"])) self.assertFalse("x" in 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) @@ -1158,8 +1158,8 @@ async def test_fields_specifier_as_dict(self): self.assertEqual([1, 2, 3], (await db.test.find_one())["x"]) self.assertEqual([2, 3], (await db.test.find_one(projection={"x": {"$slice": -2}}))["x"]) - self.assertTrue("x" not in await db.test.find_one(projection={"x": 0})) - self.assertTrue("mike" in await db.test.find_one(projection={"x": 0})) + self.assertNotIn("x", await db.test.find_one(projection={"x": 0})) + self.assertIn("mike", await db.test.find_one(projection={"x": 0})) async def test_find_w_regex(self): db = self.db @@ -1194,7 +1194,7 @@ async def test_id_can_be_anything(self): async for x in db.test.find(): self.assertEqual(x["hello"], "world") - self.assertTrue("_id" in x) + self.assertIn("_id", x) async def test_unique_index(self): db = self.db @@ -1314,7 +1314,7 @@ async def test_error_code(self): try: await self.db.test.update_many({}, {"$thismodifierdoesntexist": 1}) except OperationFailure as exc: - self.assertTrue(exc.code in (9, 10147, 16840, 17009)) + self.assertIn(exc.code, (9, 10147, 16840, 17009)) # Just check that we set the error document. Fields # vary by MongoDB version. self.assertTrue(exc.details is not None) @@ -1348,7 +1348,7 @@ async def test_replace_one(self): result = await db.test.replace_one({"x": 1}, {"y": 1}) self.assertTrue(isinstance(result, UpdateResult)) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (None, 1)) + self.assertIn(result.modified_count, (None, 1)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual(1, await db.test.count_documents({"y": 1})) @@ -1359,7 +1359,7 @@ async def test_replace_one(self): result = await db.test.replace_one({"y": 1}, replacement, True) self.assertTrue(isinstance(result, UpdateResult)) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (None, 1)) + self.assertIn(result.modified_count, (None, 1)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual(1, await db.test.count_documents({"z": 1})) @@ -1369,7 +1369,7 @@ async def test_replace_one(self): result = await db.test.replace_one({"x": 2}, {"y": 2}, True) self.assertTrue(isinstance(result, UpdateResult)) self.assertEqual(0, result.matched_count) - self.assertTrue(result.modified_count in (None, 0)) + self.assertIn(result.modified_count, (None, 0)) self.assertTrue(isinstance(result.upserted_id, ObjectId)) self.assertTrue(result.acknowledged) self.assertEqual(1, await db.test.count_documents({"y": 2})) @@ -1393,7 +1393,7 @@ async def test_update_one(self): result = await db.test.update_one({}, {"$inc": {"x": 1}}) self.assertTrue(isinstance(result, UpdateResult)) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (None, 1)) + self.assertIn(result.modified_count, (None, 1)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual((await db.test.find_one(id1))["x"], 6) # type: ignore @@ -1402,7 +1402,7 @@ async def test_update_one(self): result = await db.test.update_one({"x": 6}, {"$inc": {"x": 1}}) self.assertTrue(isinstance(result, UpdateResult)) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (None, 1)) + self.assertIn(result.modified_count, (None, 1)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual((await db.test.find_one(id1))["x"], 7) # type: ignore @@ -1411,7 +1411,7 @@ async def test_update_one(self): result = await db.test.update_one({"x": 2}, {"$set": {"y": 1}}, True) self.assertTrue(isinstance(result, UpdateResult)) self.assertEqual(0, result.matched_count) - self.assertTrue(result.modified_count in (None, 0)) + self.assertIn(result.modified_count, (None, 0)) self.assertTrue(isinstance(result.upserted_id, ObjectId)) self.assertTrue(result.acknowledged) @@ -1450,7 +1450,7 @@ async def test_update_many(self): result = await db.test.update_many({"x": 4}, {"$set": {"y": 5}}) self.assertTrue(isinstance(result, UpdateResult)) self.assertEqual(2, result.matched_count) - self.assertTrue(result.modified_count in (None, 2)) + self.assertIn(result.modified_count, (None, 2)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual(3, await db.test.count_documents({"y": 5})) @@ -1458,7 +1458,7 @@ async def test_update_many(self): result = await db.test.update_many({"x": 5}, {"$set": {"y": 6}}) self.assertTrue(isinstance(result, UpdateResult)) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (None, 1)) + self.assertIn(result.modified_count, (None, 1)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual(1, await db.test.count_documents({"y": 6})) @@ -1466,7 +1466,7 @@ async def test_update_many(self): result = await db.test.update_many({"x": 2}, {"$set": {"y": 1}}, True) self.assertTrue(isinstance(result, UpdateResult)) self.assertEqual(0, result.matched_count) - self.assertTrue(result.modified_count in (None, 0)) + self.assertIn(result.modified_count, (None, 0)) self.assertTrue(isinstance(result.upserted_id, ObjectId)) self.assertTrue(result.acknowledged) @@ -1725,21 +1725,21 @@ async def test_find_one(self): self.assertEqual(await db.test.find_one({}), await db.test.find_one()) self.assertEqual(await db.test.find_one({"hello": "world"}), await db.test.find_one()) - self.assertTrue("hello" in await db.test.find_one(projection=["hello"])) - self.assertTrue("hello" not in await db.test.find_one(projection=["foo"])) + self.assertIn("hello", await db.test.find_one(projection=["hello"])) + self.assertNotIn("hello", await db.test.find_one(projection=["foo"])) - self.assertTrue("hello" in await db.test.find_one(projection=("hello",))) - self.assertTrue("hello" not in await db.test.find_one(projection=("foo",))) + self.assertIn("hello", await db.test.find_one(projection=("hello",))) + self.assertNotIn("hello", await db.test.find_one(projection=("foo",))) - self.assertTrue("hello" in await db.test.find_one(projection={"hello"})) - self.assertTrue("hello" not in await db.test.find_one(projection={"foo"})) + self.assertIn("hello", await db.test.find_one(projection={"hello"})) + self.assertNotIn("hello", await db.test.find_one(projection={"foo"})) - self.assertTrue("hello" in await db.test.find_one(projection=frozenset(["hello"]))) - self.assertTrue("hello" not in await db.test.find_one(projection=frozenset(["foo"]))) + self.assertIn("hello", await db.test.find_one(projection=frozenset(["hello"]))) + self.assertNotIn("hello", await db.test.find_one(projection=frozenset(["foo"]))) self.assertEqual(["_id"], list(await db.test.find_one(projection={"_id": True}))) - self.assertTrue("hello" in list(await db.test.find_one(projection={}))) - self.assertTrue("hello" in list(await db.test.find_one(projection=[]))) + self.assertIn("hello", list(await db.test.find_one(projection={}))) + self.assertIn("hello", list(await db.test.find_one(projection=[]))) self.assertEqual(None, await db.test.find_one({"hello": "foo"})) self.assertEqual(None, await db.test.find_one(ObjectId())) diff --git a/test/asynchronous/test_cursor.py b/test/asynchronous/test_cursor.py index 3c8570f336..5ad7f9e4e8 100644 --- a/test/asynchronous/test_cursor.py +++ b/test/asynchronous/test_cursor.py @@ -174,8 +174,8 @@ async def test_max_time_ms(self): cursor = coll.find().max_time_ms(999) c2 = cursor.clone() self.assertEqual(999, c2._max_time_ms) - self.assertTrue("$maxTimeMS" in cursor._query_spec()) - self.assertTrue("$maxTimeMS" in c2._query_spec()) + self.assertIn("$maxTimeMS", cursor._query_spec()) + self.assertIn("$maxTimeMS", c2._query_spec()) self.assertTrue(await coll.find_one(max_time_ms=1000)) @@ -252,7 +252,7 @@ async def test_max_await_time_ms(self): self.assertFalse("maxTimeMS" in 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,7 +263,7 @@ async def test_max_await_time_ms(self): await coll.find(cursor_type=CursorType.TAILABLE_AWAIT).max_time_ms(99).to_list() # find self.assertEqual("find", listener.started_events[0].command_name) - self.assertTrue("maxTimeMS" in listener.started_events[0].command) + self.assertIn("maxTimeMS", listener.started_events[0].command) self.assertEqual(99, listener.started_events[0].command["maxTimeMS"]) # getMore self.assertEqual("getMore", listener.started_events[1].command_name) @@ -279,11 +279,11 @@ async def test_max_await_time_ms(self): ) # find self.assertEqual("find", listener.started_events[0].command_name) - self.assertTrue("maxTimeMS" in listener.started_events[0].command) + self.assertIn("maxTimeMS", listener.started_events[0].command) self.assertEqual(99, listener.started_events[0].command["maxTimeMS"]) # getMore self.assertEqual("getMore", listener.started_events[1].command_name) - self.assertTrue("maxTimeMS" in listener.started_events[1].command) + self.assertIn("maxTimeMS", listener.started_events[1].command) self.assertEqual(99, listener.started_events[1].command["maxTimeMS"]) listener.reset() @@ -301,7 +301,7 @@ async def test_max_await_time_ms(self): 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) @@ -311,7 +311,7 @@ async def test_max_await_time_ms(self): 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) @@ -933,7 +933,7 @@ async def test_clone(self): # Shallow copies can so can mutate cursor2 = copy.copy(cursor) cursor2._projection["cursor2"] = False - self.assertTrue(cursor._projection and "cursor2" in cursor._projection) + self.assertIn(cursor._projection and "cursor2", cursor._projection) # Deepcopies and shouldn't mutate cursor3 = copy.deepcopy(cursor) diff --git a/test/asynchronous/test_database.py b/test/asynchronous/test_database.py index b2ddd4122d..f6181555b8 100644 --- a/test/asynchronous/test_database.py +++ b/test/asynchronous/test_database.py @@ -163,13 +163,13 @@ async def test_create_collection(self): await db.create_collection("coll..ection") # type: ignore[arg-type] test = await db.create_collection("test") - self.assertTrue("test" in await db.list_collection_names()) + self.assertIn("test", await db.list_collection_names()) await test.insert_one({"hello": "world"}) self.assertEqual((await db.test.find_one())["hello"], "world") await db.drop_collection("test.foo") await db.create_collection("test.foo") - self.assertTrue("test.foo" in await db.list_collection_names()) + self.assertIn("test.foo", await db.list_collection_names()) with self.assertRaises(CollectionInvalid): await db.create_collection("test.foo") @@ -179,10 +179,10 @@ async def test_list_collection_names(self): await db.test.mike.insert_one({"dummy": "object"}) colls = await db.list_collection_names() - self.assertTrue("test" in colls) - self.assertTrue("test.mike" in colls) + self.assertIn("test", colls) + self.assertIn("test.mike", colls) for coll in colls: - self.assertTrue("$" not in coll) + self.assertNotIn("$", coll) await db.systemcoll.test.insert_one({}) no_system_collections = await db.list_collection_names( @@ -252,12 +252,12 @@ async def test_list_collections(self): colls = [result["name"] async for result in results] # All the collections present. - self.assertTrue("test" in colls) - self.assertTrue("test.mike" in colls) + self.assertIn("test", colls) + self.assertIn("test.mike", colls) # No collection containing a '$'. for coll in colls: - self.assertTrue("$" not in coll) + self.assertNotIn("$", coll) # Duplicate check. coll_cnt: dict = {} @@ -294,12 +294,12 @@ async def test_list_collections(self): colls = [result["name"] async for result in results] # Checking only capped collections are present - self.assertTrue("test" in colls) + self.assertIn("test", colls) self.assertFalse("test.mike" in colls) # No collection containing a '$'. for coll in colls: - self.assertTrue("$" not in coll) + self.assertNotIn("$", coll) # Duplicate check. coll_cnt = {} @@ -339,22 +339,22 @@ async def test_drop_collection(self): await db.drop_collection(None) # type: ignore[arg-type] await db.test.insert_one({"dummy": "object"}) - self.assertTrue("test" in await db.list_collection_names()) + self.assertIn("test", await db.list_collection_names()) await db.drop_collection("test") self.assertFalse("test" in await db.list_collection_names()) 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()) 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()) 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()) await db.test.drop() diff --git a/test/asynchronous/test_examples.py b/test/asynchronous/test_examples.py index a334a3ed1d..f7eaf2b385 100644 --- a/test/asynchronous/test_examples.py +++ b/test/asynchronous/test_examples.py @@ -479,9 +479,9 @@ async def test_projection(self): # End Example 44 async for doc in cursor: - self.assertTrue("_id" in doc) - self.assertTrue("item" in doc) - self.assertTrue("status" in doc) + self.assertIn("_id", doc) + self.assertIn("item", doc) + self.assertIn("status", doc) self.assertFalse("size" in doc) self.assertFalse("instock" in doc) @@ -491,8 +491,8 @@ async def test_projection(self): async for doc in cursor: self.assertFalse("_id" in doc) - self.assertTrue("item" in doc) - self.assertTrue("status" in doc) + self.assertIn("item", doc) + self.assertIn("status", doc) self.assertFalse("size" in doc) self.assertFalse("instock" in doc) @@ -501,10 +501,10 @@ async def test_projection(self): # End Example 46 async for doc in cursor: - self.assertTrue("_id" in doc) - self.assertTrue("item" in doc) + self.assertIn("_id", doc) + self.assertIn("item", doc) self.assertFalse("status" in doc) - self.assertTrue("size" in doc) + self.assertIn("size", doc) self.assertFalse("instock" in doc) # Start Example 47 @@ -512,13 +512,13 @@ async def test_projection(self): # 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.assertIn("_id", doc) + self.assertIn("item", doc) + self.assertIn("status", doc) + self.assertIn("size", doc) self.assertFalse("instock" in doc) size = doc["size"] - self.assertTrue("uom" in size) + self.assertIn("uom", size) self.assertFalse("h" in size) self.assertFalse("w" in size) @@ -527,29 +527,29 @@ async def test_projection(self): # 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.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.assertIn("_id", doc) + self.assertIn("item", doc) + self.assertIn("status", doc) self.assertFalse("size" in doc) - self.assertTrue("instock" in doc) + self.assertIn("instock", doc) for subdoc in doc["instock"]: self.assertFalse("warehouse" in subdoc) - self.assertTrue("qty" in subdoc) + self.assertIn("qty", subdoc) # Start Example 50 cursor = db.inventory.find( @@ -558,11 +558,11 @@ async def test_projection(self): # End Example 50 async for doc in cursor: - self.assertTrue("_id" in doc) - self.assertTrue("item" in doc) - self.assertTrue("status" in doc) + self.assertIn("_id", doc) + self.assertIn("item", doc) + self.assertIn("status", doc) self.assertFalse("size" in doc) - self.assertTrue("instock" in doc) + self.assertIn("instock", doc) self.assertEqual(len(doc["instock"]), 1) async def test_update_and_replace(self): @@ -645,7 +645,7 @@ async def test_update_and_replace(self): async for doc in db.inventory.find({"item": "paper"}): self.assertEqual(doc["size"]["uom"], "cm") self.assertEqual(doc["status"], "P") - self.assertTrue("lastModified" in doc) + self.assertIn("lastModified", doc) # Start Example 53 await db.inventory.update_many( @@ -657,7 +657,7 @@ async def test_update_and_replace(self): async for doc in db.inventory.find({"qty": {"$lt": 50}}): self.assertEqual(doc["size"]["uom"], "in") self.assertEqual(doc["status"], "P") - self.assertTrue("lastModified" in doc) + self.assertIn("lastModified", doc) # Start Example 54 await db.inventory.replace_one( @@ -671,8 +671,8 @@ async def test_update_and_replace(self): async for doc in db.inventory.find({"item": "paper"}, {"_id": 0}): self.assertEqual(len(doc.keys()), 2) - self.assertTrue("item" in doc) - self.assertTrue("instock" in doc) + self.assertIn("item", doc) + self.assertIn("instock", doc) self.assertEqual(len(doc["instock"]), 2) async def test_delete(self): diff --git a/test/asynchronous/test_json_util_integration.py b/test/asynchronous/test_json_util_integration.py index 4c02792d89..32312cb9d3 100644 --- a/test/asynchronous/test_json_util_integration.py +++ b/test/asynchronous/test_json_util_integration.py @@ -25,4 +25,4 @@ async def test_cursor(self): await db.test.insert_many(docs) reloaded_docs = json_util.loads(json_util.dumps(await (db.test.find()).to_list())) for doc in docs: - self.assertTrue(doc in reloaded_docs) + self.assertIn(doc, reloaded_docs) diff --git a/test/asynchronous/test_monitoring.py b/test/asynchronous/test_monitoring.py index a7d56a8cf7..343ad5cc65 100644 --- a/test/asynchronous/test_monitoring.py +++ b/test/asynchronous/test_monitoring.py @@ -1088,8 +1088,8 @@ async def test_first_batch_helper(self): self.assertEqual(started.command_name, succeeded.command_name) self.assertEqual(started.request_id, succeeded.request_id) self.assertEqual(started.connection_id, succeeded.connection_id) - self.assertTrue("cursor" in succeeded.reply) - self.assertTrue("ok" in succeeded.reply) + self.assertIn("cursor", succeeded.reply) + self.assertIn("ok", succeeded.reply) self.listener.reset() diff --git a/test/test_bulk.py b/test/test_bulk.py index 8a863cc49b..3f34d3b9ea 100644 --- a/test/test_bulk.py +++ b/test/test_bulk.py @@ -94,7 +94,7 @@ def assertEqualUpsert(self, expected, actual): self.assertEqual(expected["index"], actual["index"]) if expected["_id"] == "...": # Unspecified value. - self.assertTrue("_id" in actual) + self.assertIn("_id", actual) else: self.assertEqual(expected["_id"], actual["_id"]) @@ -107,7 +107,7 @@ def assertEqualWriteError(self, expected, actual): self.assertEqual(expected["code"], actual["code"]) if expected["errmsg"] == "...": # Unspecified value. - self.assertTrue("errmsg" in actual) + self.assertIn("errmsg", actual) else: self.assertEqual(expected["errmsg"], actual["errmsg"]) @@ -115,7 +115,7 @@ def assertEqualWriteError(self, expected, actual): actual_op = actual["op"].copy() if expected_op.get("_id") == "...": # Unspecified _id. - self.assertTrue("_id" in actual_op) + self.assertIn("_id", actual_op) actual_op.pop("_id") expected_op.pop("_id") @@ -160,7 +160,7 @@ def _test_update_many(self, update): result = self.coll.bulk_write([UpdateMany({}, update)]) self.assertEqualResponse(expected, result.bulk_api_result) self.assertEqual(2, result.matched_count) - self.assertTrue(result.modified_count in (2, None)) + self.assertIn(result.modified_count, (2, None)) def test_update_many(self): self._test_update_many({"$set": {"foo": "bar"}}) @@ -201,7 +201,7 @@ def _test_update_one(self, update): result = self.coll.bulk_write([UpdateOne({}, update)]) self.assertEqualResponse(expected, result.bulk_api_result) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (1, None)) + self.assertIn(result.modified_count, (1, None)) def test_update_one(self): self._test_update_one({"$set": {"foo": "bar"}}) @@ -227,7 +227,7 @@ def test_replace_one(self): result = self.coll.bulk_write([ReplaceOne({}, {"foo": "bar"})]) self.assertEqualResponse(expected, result.bulk_api_result) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (1, None)) + self.assertIn(result.modified_count, (1, None)) def test_remove(self): # Test removing all documents, ordered. @@ -1035,7 +1035,7 @@ def test_write_concern_failure_ordered(self): self.assertTrue(len(details["writeConcernErrors"]) > 1) failed = details["writeErrors"][0] - self.assertTrue("duplicate" in failed["errmsg"]) + self.assertIn("duplicate", failed["errmsg"]) @client_context.require_version_max(7, 1) # PYTHON-4560 @client_context.require_replica_set diff --git a/test/test_client.py b/test/test_client.py index 189e58e803..b3f259c50b 100644 --- a/test/test_client.py +++ b/test/test_client.py @@ -665,7 +665,7 @@ def test_max_idle_time_reaper_default(self): with server._pool.checkout() as conn: pass self.assertEqual(1, len(server._pool.conns)) - self.assertTrue(conn in server._pool.conns) + self.assertIn(conn, server._pool.conns) def test_max_idle_time_reaper_removes_stale_minPoolSize(self): with client_knobs(kill_cursor_frequency=0.1): @@ -747,7 +747,7 @@ def test_max_idle_time_checkout(self): 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.assertIn(new_con, server._pool.conns) # Test that connections are reused if maxIdleTimeMS is not set. client = self.rs_or_single_client() @@ -1005,8 +1005,8 @@ def test_list_database_names(self): cmd_names = [doc["name"] for doc in cmd_docs] db_names = self.client.list_database_names() - self.assertTrue("pymongo_test" in db_names) - self.assertTrue("pymongo_test_mike" in db_names) + self.assertIn("pymongo_test", db_names) + self.assertIn("pymongo_test_mike", db_names) self.assertEqual(db_names, cmd_names) def test_drop_database(self): @@ -1220,9 +1220,9 @@ def test_unix_socket(self): client = self.rs_or_single_client(uri) client.pymongo_test.test.insert_one({"dummy": "object"}) dbs = client.list_database_names() - self.assertTrue("pymongo_test" in dbs) + self.assertIn("pymongo_test", dbs) - self.assertTrue(mongodb_socket in repr(client)) + self.assertIn(mongodb_socket, repr(client)) # Confirm it fails with a missing socket. with self.assertRaises(ConnectionFailure): @@ -1390,8 +1390,8 @@ def test_ipv6(self): client.pymongo_test_bernie.test.insert_one({"dummy": "object"}) dbs = client.list_database_names() - self.assertTrue("pymongo_test" in dbs) - self.assertTrue("pymongo_test_bernie" in dbs) + self.assertIn("pymongo_test", dbs) + self.assertIn("pymongo_test_bernie", dbs) def test_contextlib(self): client = self.rs_or_single_client() diff --git a/test/test_collection.py b/test/test_collection.py index 75c11383d0..0e156d70bc 100644 --- a/test/test_collection.py +++ b/test/test_collection.py @@ -248,7 +248,7 @@ def test_create_indexes(self): db.test.drop_indexes() self.assertEqual(len(db.test.index_information()), 1) db.test.create_indexes([IndexModel("hello")]) - self.assertTrue("hello_1" in db.test.index_information()) + self.assertIn("hello_1", db.test.index_information()) db.test.drop_indexes() self.assertEqual(len(db.test.index_information()), 1) @@ -257,7 +257,7 @@ def test_create_indexes(self): ) info = db.test.index_information() for name in names: - self.assertTrue(name in info) + self.assertIn(name, info) db.test.drop() db.test.insert_one({"a": 1}) @@ -309,16 +309,16 @@ def test_create_index(self): db.test.drop_indexes() self.assertEqual(len(db.test.index_information()), 1) db.test.create_index("hello") - self.assertTrue("hello_1" in db.test.index_information()) + self.assertIn("hello_1", db.test.index_information()) db.test.drop_indexes() self.assertEqual(len(db.test.index_information()), 1) db.test.create_index([("hello", DESCENDING), ("world", ASCENDING)]) - self.assertTrue("hello_-1_world_1" in db.test.index_information()) + self.assertIn("hello_-1_world_1", db.test.index_information()) db.test.drop_indexes() db.test.create_index([("hello", DESCENDING), ("world", ASCENDING)], name=None) - self.assertTrue("hello_-1_world_1" in db.test.index_information()) + self.assertIn("hello_-1_world_1", db.test.index_information()) db.test.drop() db.test.insert_one({"a": 1}) @@ -347,7 +347,7 @@ def test_drop_index(self): with self.assertRaises(OperationFailure): db.test.drop_index(name) self.assertEqual(len(db.test.index_information()), 2) - self.assertTrue("hello_1" in db.test.index_information()) + self.assertIn("hello_1", db.test.index_information()) db.test.drop_indexes() db.test.create_index("hello") @@ -357,7 +357,7 @@ def test_drop_index(self): self.assertEqual(name, "goodbye_1") db.test.drop_index([("goodbye", ASCENDING)]) self.assertEqual(len(db.test.index_information()), 2) - self.assertTrue("hello_1" in db.test.index_information()) + self.assertIn("hello_1", db.test.index_information()) with self.write_concern_collection() as coll: coll.drop_index("hello_1") @@ -389,7 +389,7 @@ def map_indexes(indexes): indexes = (db.test.list_indexes()).to_list() self.assertEqual(len(indexes), 1) - self.assertTrue("_id_" in map_indexes(indexes)) + self.assertIn("_id_", map_indexes(indexes)) db.test.create_index("hello") indexes = (db.test.list_indexes()).to_list() @@ -418,7 +418,7 @@ def test_index_info(self): db.test.drop() db.test.insert_one({}) # create collection self.assertEqual(len(db.test.index_information()), 1) - self.assertTrue("_id_" in db.test.index_information()) + self.assertIn("_id_", db.test.index_information()) db.test.create_index("hello") self.assertEqual(len(db.test.index_information()), 2) @@ -478,7 +478,7 @@ def test_index_text(self): db.test.drop_indexes() self.assertEqual("t_text", db.test.create_index([("t", TEXT)])) index_info = (db.test.index_information())["t_text"] - self.assertTrue("weights" in index_info) + self.assertIn("weights", index_info) db.test.insert_many( [{"t": "spam eggs and spam"}, {"t": "spam"}, {"t": "egg sausage and bacon"}] @@ -752,7 +752,7 @@ def test_insert_many(self): for doc in docs: _id = doc["_id"] self.assertTrue(isinstance(_id, ObjectId)) - self.assertTrue(_id in result.inserted_ids) + self.assertIn(_id, result.inserted_ids) self.assertEqual(1, db.test.count_documents({"_id": _id})) self.assertTrue(result.acknowledged) @@ -764,7 +764,7 @@ def test_insert_many(self): for doc in docs: _id = doc["_id"] self.assertTrue(isinstance(_id, int)) - self.assertTrue(_id in result.inserted_ids) + self.assertIn(_id, result.inserted_ids) self.assertEqual(1, db.test.count_documents({"_id": _id})) self.assertTrue(result.acknowledged) @@ -931,7 +931,7 @@ def async_lambda(): for doc in docs: _id = doc["_id"] self.assertTrue(isinstance(_id, int)) - self.assertTrue(_id in result.inserted_ids) + self.assertIn(_id, result.inserted_ids) self.assertEqual(1, db.test.count_documents({"x": doc["x"]})) self.assertTrue(result.acknowledged) docs = [{"_id": i, "a": 200 - i} for i in range(100, 200)] @@ -941,7 +941,7 @@ def async_lambda(): for doc in docs: _id = doc["_id"] self.assertTrue(isinstance(_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,21 +1117,21 @@ def test_find_w_fields(self): db.test.insert_one({"x": 1, "mike": "awesome", "extra thing": "abcdefghijklmnopqrstuvwxyz"}) self.assertEqual(1, db.test.count_documents({})) doc = next(db.test.find({})) - self.assertTrue("x" in doc) + self.assertIn("x", doc) doc = next(db.test.find({})) - self.assertTrue("mike" in doc) + self.assertIn("mike", doc) doc = next(db.test.find({})) - self.assertTrue("extra thing" in doc) + self.assertIn("extra thing", doc) doc = next(db.test.find({}, ["x", "mike"])) - self.assertTrue("x" in doc) + self.assertIn("x", doc) doc = next(db.test.find({}, ["x", "mike"])) - self.assertTrue("mike" in doc) + self.assertIn("mike", doc) doc = next(db.test.find({}, ["x", "mike"])) self.assertFalse("extra thing" in doc) doc = next(db.test.find({}, ["mike"])) self.assertFalse("x" in 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) @@ -1144,8 +1144,8 @@ def test_fields_specifier_as_dict(self): self.assertEqual([1, 2, 3], (db.test.find_one())["x"]) self.assertEqual([2, 3], (db.test.find_one(projection={"x": {"$slice": -2}}))["x"]) - self.assertTrue("x" not in db.test.find_one(projection={"x": 0})) - self.assertTrue("mike" in db.test.find_one(projection={"x": 0})) + self.assertNotIn("x", db.test.find_one(projection={"x": 0})) + self.assertIn("mike", db.test.find_one(projection={"x": 0})) def test_find_w_regex(self): db = self.db @@ -1180,7 +1180,7 @@ def test_id_can_be_anything(self): for x in db.test.find(): self.assertEqual(x["hello"], "world") - self.assertTrue("_id" in x) + self.assertIn("_id", x) def test_unique_index(self): db = self.db @@ -1300,7 +1300,7 @@ def test_error_code(self): try: self.db.test.update_many({}, {"$thismodifierdoesntexist": 1}) except OperationFailure as exc: - self.assertTrue(exc.code in (9, 10147, 16840, 17009)) + self.assertIn(exc.code, (9, 10147, 16840, 17009)) # Just check that we set the error document. Fields # vary by MongoDB version. self.assertTrue(exc.details is not None) @@ -1334,7 +1334,7 @@ def test_replace_one(self): result = db.test.replace_one({"x": 1}, {"y": 1}) self.assertTrue(isinstance(result, UpdateResult)) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (None, 1)) + self.assertIn(result.modified_count, (None, 1)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual(1, db.test.count_documents({"y": 1})) @@ -1345,7 +1345,7 @@ def test_replace_one(self): result = db.test.replace_one({"y": 1}, replacement, True) self.assertTrue(isinstance(result, UpdateResult)) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (None, 1)) + self.assertIn(result.modified_count, (None, 1)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual(1, db.test.count_documents({"z": 1})) @@ -1355,7 +1355,7 @@ def test_replace_one(self): result = db.test.replace_one({"x": 2}, {"y": 2}, True) self.assertTrue(isinstance(result, UpdateResult)) self.assertEqual(0, result.matched_count) - self.assertTrue(result.modified_count in (None, 0)) + self.assertIn(result.modified_count, (None, 0)) self.assertTrue(isinstance(result.upserted_id, ObjectId)) self.assertTrue(result.acknowledged) self.assertEqual(1, db.test.count_documents({"y": 2})) @@ -1379,7 +1379,7 @@ def test_update_one(self): result = db.test.update_one({}, {"$inc": {"x": 1}}) self.assertTrue(isinstance(result, UpdateResult)) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (None, 1)) + self.assertIn(result.modified_count, (None, 1)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual((db.test.find_one(id1))["x"], 6) # type: ignore @@ -1388,7 +1388,7 @@ def test_update_one(self): result = db.test.update_one({"x": 6}, {"$inc": {"x": 1}}) self.assertTrue(isinstance(result, UpdateResult)) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (None, 1)) + self.assertIn(result.modified_count, (None, 1)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual((db.test.find_one(id1))["x"], 7) # type: ignore @@ -1397,7 +1397,7 @@ def test_update_one(self): result = db.test.update_one({"x": 2}, {"$set": {"y": 1}}, True) self.assertTrue(isinstance(result, UpdateResult)) self.assertEqual(0, result.matched_count) - self.assertTrue(result.modified_count in (None, 0)) + self.assertIn(result.modified_count, (None, 0)) self.assertTrue(isinstance(result.upserted_id, ObjectId)) self.assertTrue(result.acknowledged) @@ -1436,7 +1436,7 @@ def test_update_many(self): result = db.test.update_many({"x": 4}, {"$set": {"y": 5}}) self.assertTrue(isinstance(result, UpdateResult)) self.assertEqual(2, result.matched_count) - self.assertTrue(result.modified_count in (None, 2)) + self.assertIn(result.modified_count, (None, 2)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual(3, db.test.count_documents({"y": 5})) @@ -1444,7 +1444,7 @@ def test_update_many(self): result = db.test.update_many({"x": 5}, {"$set": {"y": 6}}) self.assertTrue(isinstance(result, UpdateResult)) self.assertEqual(1, result.matched_count) - self.assertTrue(result.modified_count in (None, 1)) + self.assertIn(result.modified_count, (None, 1)) self.assertIsNone(result.upserted_id) self.assertTrue(result.acknowledged) self.assertEqual(1, db.test.count_documents({"y": 6})) @@ -1452,7 +1452,7 @@ def test_update_many(self): result = db.test.update_many({"x": 2}, {"$set": {"y": 1}}, True) self.assertTrue(isinstance(result, UpdateResult)) self.assertEqual(0, result.matched_count) - self.assertTrue(result.modified_count in (None, 0)) + self.assertIn(result.modified_count, (None, 0)) self.assertTrue(isinstance(result.upserted_id, ObjectId)) self.assertTrue(result.acknowledged) @@ -1707,21 +1707,21 @@ def test_find_one(self): self.assertEqual(db.test.find_one({}), db.test.find_one()) self.assertEqual(db.test.find_one({"hello": "world"}), db.test.find_one()) - self.assertTrue("hello" in db.test.find_one(projection=["hello"])) - self.assertTrue("hello" not in db.test.find_one(projection=["foo"])) + self.assertIn("hello", db.test.find_one(projection=["hello"])) + self.assertNotIn("hello", db.test.find_one(projection=["foo"])) - self.assertTrue("hello" in db.test.find_one(projection=("hello",))) - self.assertTrue("hello" not in db.test.find_one(projection=("foo",))) + self.assertIn("hello", db.test.find_one(projection=("hello",))) + self.assertNotIn("hello", db.test.find_one(projection=("foo",))) - self.assertTrue("hello" in db.test.find_one(projection={"hello"})) - self.assertTrue("hello" not in db.test.find_one(projection={"foo"})) + self.assertIn("hello", db.test.find_one(projection={"hello"})) + self.assertNotIn("hello", db.test.find_one(projection={"foo"})) - self.assertTrue("hello" in db.test.find_one(projection=frozenset(["hello"]))) - self.assertTrue("hello" not in db.test.find_one(projection=frozenset(["foo"]))) + self.assertIn("hello", db.test.find_one(projection=frozenset(["hello"]))) + self.assertNotIn("hello", db.test.find_one(projection=frozenset(["foo"]))) self.assertEqual(["_id"], list(db.test.find_one(projection={"_id": True}))) - self.assertTrue("hello" in list(db.test.find_one(projection={}))) - self.assertTrue("hello" in list(db.test.find_one(projection=[]))) + self.assertIn("hello", list(db.test.find_one(projection={}))) + self.assertIn("hello", list(db.test.find_one(projection=[]))) self.assertEqual(None, db.test.find_one({"hello": "foo"})) self.assertEqual(None, db.test.find_one(ObjectId())) diff --git a/test/test_cursor.py b/test/test_cursor.py index 7b75f4ddc4..2f9f203ab9 100644 --- a/test/test_cursor.py +++ b/test/test_cursor.py @@ -174,8 +174,8 @@ def test_max_time_ms(self): cursor = coll.find().max_time_ms(999) c2 = cursor.clone() self.assertEqual(999, c2._max_time_ms) - self.assertTrue("$maxTimeMS" in cursor._query_spec()) - self.assertTrue("$maxTimeMS" in c2._query_spec()) + self.assertIn("$maxTimeMS", cursor._query_spec()) + self.assertIn("$maxTimeMS", c2._query_spec()) self.assertTrue(coll.find_one(max_time_ms=1000)) @@ -248,7 +248,7 @@ def test_max_await_time_ms(self): self.assertFalse("maxTimeMS" in 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,7 +259,7 @@ def test_max_await_time_ms(self): coll.find(cursor_type=CursorType.TAILABLE_AWAIT).max_time_ms(99).to_list() # find self.assertEqual("find", listener.started_events[0].command_name) - self.assertTrue("maxTimeMS" in listener.started_events[0].command) + self.assertIn("maxTimeMS", listener.started_events[0].command) self.assertEqual(99, listener.started_events[0].command["maxTimeMS"]) # getMore self.assertEqual("getMore", listener.started_events[1].command_name) @@ -275,11 +275,11 @@ def test_max_await_time_ms(self): ) # find self.assertEqual("find", listener.started_events[0].command_name) - self.assertTrue("maxTimeMS" in listener.started_events[0].command) + self.assertIn("maxTimeMS", listener.started_events[0].command) self.assertEqual(99, listener.started_events[0].command["maxTimeMS"]) # getMore self.assertEqual("getMore", listener.started_events[1].command_name) - self.assertTrue("maxTimeMS" in listener.started_events[1].command) + self.assertIn("maxTimeMS", listener.started_events[1].command) self.assertEqual(99, listener.started_events[1].command["maxTimeMS"]) listener.reset() @@ -297,7 +297,7 @@ def test_max_await_time_ms(self): 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) @@ -307,7 +307,7 @@ def test_max_await_time_ms(self): 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) @@ -924,7 +924,7 @@ def test_clone(self): # Shallow copies can so can mutate cursor2 = copy.copy(cursor) cursor2._projection["cursor2"] = False - self.assertTrue(cursor._projection and "cursor2" in cursor._projection) + self.assertIn(cursor._projection and "cursor2", cursor._projection) # Deepcopies and shouldn't mutate cursor3 = copy.deepcopy(cursor) diff --git a/test/test_database.py b/test/test_database.py index 4c09b421cf..d4d1a0a0fc 100644 --- a/test/test_database.py +++ b/test/test_database.py @@ -162,13 +162,13 @@ def test_create_collection(self): db.create_collection("coll..ection") # type: ignore[arg-type] test = db.create_collection("test") - self.assertTrue("test" in db.list_collection_names()) + self.assertIn("test", db.list_collection_names()) test.insert_one({"hello": "world"}) self.assertEqual((db.test.find_one())["hello"], "world") db.drop_collection("test.foo") db.create_collection("test.foo") - self.assertTrue("test.foo" in db.list_collection_names()) + self.assertIn("test.foo", db.list_collection_names()) with self.assertRaises(CollectionInvalid): db.create_collection("test.foo") @@ -178,10 +178,10 @@ def test_list_collection_names(self): db.test.mike.insert_one({"dummy": "object"}) colls = db.list_collection_names() - self.assertTrue("test" in colls) - self.assertTrue("test.mike" in colls) + self.assertIn("test", colls) + self.assertIn("test.mike", colls) for coll in colls: - self.assertTrue("$" not in coll) + self.assertNotIn("$", coll) db.systemcoll.test.insert_one({}) no_system_collections = db.list_collection_names( @@ -251,12 +251,12 @@ def test_list_collections(self): colls = [result["name"] for result in results] # All the collections present. - self.assertTrue("test" in colls) - self.assertTrue("test.mike" in colls) + self.assertIn("test", colls) + self.assertIn("test.mike", colls) # No collection containing a '$'. for coll in colls: - self.assertTrue("$" not in coll) + self.assertNotIn("$", coll) # Duplicate check. coll_cnt: dict = {} @@ -291,12 +291,12 @@ def test_list_collections(self): colls = [result["name"] for result in results] # Checking only capped collections are present - self.assertTrue("test" in colls) + self.assertIn("test", colls) self.assertFalse("test.mike" in colls) # No collection containing a '$'. for coll in colls: - self.assertTrue("$" not in coll) + self.assertNotIn("$", coll) # Duplicate check. coll_cnt = {} @@ -336,22 +336,22 @@ def test_drop_collection(self): db.drop_collection(None) # type: ignore[arg-type] db.test.insert_one({"dummy": "object"}) - self.assertTrue("test" in db.list_collection_names()) + self.assertIn("test", db.list_collection_names()) db.drop_collection("test") self.assertFalse("test" in db.list_collection_names()) 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()) 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()) 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()) db.test.drop() diff --git a/test/test_examples.py b/test/test_examples.py index 0585d1e057..b3d8eaa2e3 100644 --- a/test/test_examples.py +++ b/test/test_examples.py @@ -479,9 +479,9 @@ def test_projection(self): # End Example 44 for doc in cursor: - self.assertTrue("_id" in doc) - self.assertTrue("item" in doc) - self.assertTrue("status" in doc) + self.assertIn("_id", doc) + self.assertIn("item", doc) + self.assertIn("status", doc) self.assertFalse("size" in doc) self.assertFalse("instock" in doc) @@ -491,8 +491,8 @@ def test_projection(self): for doc in cursor: self.assertFalse("_id" in doc) - self.assertTrue("item" in doc) - self.assertTrue("status" in doc) + self.assertIn("item", doc) + self.assertIn("status", doc) self.assertFalse("size" in doc) self.assertFalse("instock" in doc) @@ -501,10 +501,10 @@ def test_projection(self): # End Example 46 for doc in cursor: - self.assertTrue("_id" in doc) - self.assertTrue("item" in doc) + self.assertIn("_id", doc) + self.assertIn("item", doc) self.assertFalse("status" in doc) - self.assertTrue("size" in doc) + self.assertIn("size", doc) self.assertFalse("instock" in doc) # Start Example 47 @@ -512,13 +512,13 @@ def test_projection(self): # 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.assertIn("_id", doc) + self.assertIn("item", doc) + self.assertIn("status", doc) + self.assertIn("size", doc) self.assertFalse("instock" in doc) size = doc["size"] - self.assertTrue("uom" in size) + self.assertIn("uom", size) self.assertFalse("h" in size) self.assertFalse("w" in size) @@ -527,29 +527,29 @@ def test_projection(self): # 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.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.assertIn("_id", doc) + self.assertIn("item", doc) + self.assertIn("status", doc) self.assertFalse("size" in doc) - self.assertTrue("instock" in doc) + self.assertIn("instock", doc) for subdoc in doc["instock"]: self.assertFalse("warehouse" in subdoc) - self.assertTrue("qty" in subdoc) + self.assertIn("qty", subdoc) # Start Example 50 cursor = db.inventory.find( @@ -558,11 +558,11 @@ def test_projection(self): # End Example 50 for doc in cursor: - self.assertTrue("_id" in doc) - self.assertTrue("item" in doc) - self.assertTrue("status" in doc) + self.assertIn("_id", doc) + self.assertIn("item", doc) + self.assertIn("status", doc) self.assertFalse("size" in doc) - self.assertTrue("instock" in doc) + self.assertIn("instock", doc) self.assertEqual(len(doc["instock"]), 1) def test_update_and_replace(self): @@ -645,7 +645,7 @@ def test_update_and_replace(self): for doc in db.inventory.find({"item": "paper"}): self.assertEqual(doc["size"]["uom"], "cm") self.assertEqual(doc["status"], "P") - self.assertTrue("lastModified" in doc) + self.assertIn("lastModified", doc) # Start Example 53 db.inventory.update_many( @@ -657,7 +657,7 @@ def test_update_and_replace(self): for doc in db.inventory.find({"qty": {"$lt": 50}}): self.assertEqual(doc["size"]["uom"], "in") self.assertEqual(doc["status"], "P") - self.assertTrue("lastModified" in doc) + self.assertIn("lastModified", doc) # Start Example 54 db.inventory.replace_one( @@ -671,8 +671,8 @@ def test_update_and_replace(self): for doc in db.inventory.find({"item": "paper"}, {"_id": 0}): self.assertEqual(len(doc.keys()), 2) - self.assertTrue("item" in doc) - self.assertTrue("instock" in doc) + self.assertIn("item", doc) + self.assertIn("instock", doc) self.assertEqual(len(doc["instock"]), 2) def test_delete(self): diff --git a/test/test_json_util_integration.py b/test/test_json_util_integration.py index acab4f3182..4ef5f10fe2 100644 --- a/test/test_json_util_integration.py +++ b/test/test_json_util_integration.py @@ -25,4 +25,4 @@ def test_cursor(self): db.test.insert_many(docs) reloaded_docs = json_util.loads(json_util.dumps((db.test.find()).to_list())) for doc in docs: - self.assertTrue(doc in reloaded_docs) + self.assertIn(doc, reloaded_docs) diff --git a/test/test_monitoring.py b/test/test_monitoring.py index ae3e50db77..d390ab8779 100644 --- a/test/test_monitoring.py +++ b/test/test_monitoring.py @@ -1086,8 +1086,8 @@ def test_first_batch_helper(self): self.assertEqual(started.command_name, succeeded.command_name) self.assertEqual(started.request_id, succeeded.request_id) self.assertEqual(started.connection_id, succeeded.connection_id) - self.assertTrue("cursor" in succeeded.reply) - self.assertTrue("ok" in succeeded.reply) + self.assertIn("cursor", succeeded.reply) + self.assertIn("ok", succeeded.reply) self.listener.reset() diff --git a/test/test_son.py b/test/test_son.py index a06d92bcb2..3875426a62 100644 --- a/test/test_son.py +++ b/test/test_son.py @@ -148,7 +148,7 @@ def test_contains_has(self): """has_key and __contains__""" test_son = SON([(1, 100), (2, 200), (3, 300)]) self.assertIn(1, test_son) - self.assertTrue(2 in test_son, "in failed") + self.assertIn(2, test_son, "in failed") self.assertFalse(22 in 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 f7cefa17833d96d1b219e42fa3015744e9c2fe2a Mon Sep 17 00:00:00 2001 From: Iris Ho Date: Wed, 21 May 2025 16:28:59 -0700 Subject: [PATCH 2/5] assertFalse(... in ...) -> assertNotIn --- test/asynchronous/test_client.py | 4 ++-- test/asynchronous/test_collection.py | 12 ++++++------ test/asynchronous/test_cursor.py | 25 ++++++++++++++----------- test/asynchronous/test_database.py | 10 +++++----- test/asynchronous/test_examples.py | 28 ++++++++++++++-------------- test/test_client.py | 4 ++-- test/test_collection.py | 12 ++++++------ test/test_cursor.py | 25 ++++++++++++++----------- test/test_database.py | 10 +++++----- test/test_examples.py | 28 ++++++++++++++-------------- test/test_son.py | 2 +- 11 files changed, 83 insertions(+), 77 deletions(-) diff --git a/test/asynchronous/test_client.py b/test/asynchronous/test_client.py index 1fafa92189..f546092e6b 100644 --- a/test/asynchronous/test_client.py +++ b/test/asynchronous/test_client.py @@ -752,7 +752,7 @@ async def test_min_pool_size(self): lambda: len(server._pool.conns) == 10, "a closed socket gets replaced from the pool", ) - self.assertFalse(conn in server._pool.conns) + self.assertNotIn(conn, server._pool.conns) async def test_max_idle_time_checkout(self): # Use high frequency to test _get_socket_no_auth. @@ -769,7 +769,7 @@ async def test_max_idle_time_checkout(self): async with server._pool.checkout() as new_con: self.assertNotEqual(conn, new_con) self.assertEqual(1, len(server._pool.conns)) - self.assertFalse(conn in server._pool.conns) + self.assertNotIn(conn, server._pool.conns) self.assertIn(new_con, server._pool.conns) # Test that connections are reused if maxIdleTimeMS is not set. diff --git a/test/asynchronous/test_collection.py b/test/asynchronous/test_collection.py index 9a317f4bae..113563ae56 100644 --- a/test/asynchronous/test_collection.py +++ b/test/asynchronous/test_collection.py @@ -212,7 +212,7 @@ async def lambda_test_2(): async def test_drop_nonexistent_collection(self): await self.db.drop_collection("test") - self.assertFalse("test" in await self.db.list_collection_names()) + self.assertNotIn("test", await self.db.list_collection_names()) # No exception await self.db.drop_collection("test") @@ -549,7 +549,7 @@ async def test_index_background(self): await db.test.create_index([("keya", ASCENDING)]) await db.test.create_index([("keyb", ASCENDING)], background=False) await db.test.create_index([("keyc", ASCENDING)], background=True) - self.assertFalse("background" in (await db.test.index_information())["keya_1"]) + self.assertNotIn("background", (await db.test.index_information())["keya_1"]) self.assertFalse((await db.test.index_information())["keyb_1"]["background"]) self.assertTrue((await db.test.index_information())["keyc_1"]["background"]) @@ -702,7 +702,7 @@ async def test_field_selection(self): doc = await anext(db.test.find({}, {"_id": False})) l = list(doc) - self.assertFalse("_id" in l) + self.assertNotIn("_id", l) async def test_options(self): db = self.db @@ -1141,13 +1141,13 @@ async def test_find_w_fields(self): doc = await anext(db.test.find({}, ["x", "mike"])) 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.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): diff --git a/test/asynchronous/test_cursor.py b/test/asynchronous/test_cursor.py index 5ad7f9e4e8..bf642739b9 100644 --- a/test/asynchronous/test_cursor.py +++ b/test/asynchronous/test_cursor.py @@ -240,16 +240,16 @@ async def test_max_await_time_ms(self): # Tailable_await defaults. await coll.find(cursor_type=CursorType.TAILABLE_AWAIT).to_list() # find - self.assertFalse("maxTimeMS" in listener.started_events[0].command) + self.assertNotIn("maxTimeMS", listener.started_events[0].command) # getMore - self.assertFalse("maxTimeMS" in listener.started_events[1].command) + self.assertNotIn("maxTimeMS", listener.started_events[1].command) listener.reset() # Tailable_await with max_await_time_ms set. await coll.find(cursor_type=CursorType.TAILABLE_AWAIT).max_await_time_ms(99).to_list() # find self.assertEqual("find", listener.started_events[0].command_name) - self.assertFalse("maxTimeMS" in listener.started_events[0].command) + self.assertNotIn("maxTimeMS", listener.started_events[0].command) # getMore self.assertEqual("getMore", listener.started_events[1].command_name) self.assertIn("maxTimeMS", listener.started_events[1].command) @@ -267,7 +267,7 @@ async def test_max_await_time_ms(self): 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 @@ -291,10 +291,10 @@ async def test_max_await_time_ms(self): await coll.find(batch_size=1).max_await_time_ms(99).to_list() # find self.assertEqual("find", listener.started_events[0].command_name) - self.assertFalse("maxTimeMS" in listener.started_events[0].command) + self.assertNotIn("maxTimeMS", listener.started_events[0].command) # getMore self.assertEqual("getMore", listener.started_events[1].command_name) - self.assertFalse("maxTimeMS" in listener.started_events[1].command) + self.assertNotIn("maxTimeMS", listener.started_events[1].command) listener.reset() # Non tailable_await with max_time_ms @@ -305,7 +305,7 @@ async def test_max_await_time_ms(self): 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() @@ -315,7 +315,7 @@ async def test_max_await_time_ms(self): self.assertEqual(99, listener.started_events[0].command["maxTimeMS"]) # getMore self.assertEqual("getMore", listener.started_events[1].command_name) - self.assertFalse("maxTimeMS" in listener.started_events[1].command) + self.assertNotIn("maxTimeMS", listener.started_events[1].command) @async_client_context.require_test_commands @async_client_context.require_no_mongos @@ -933,16 +933,19 @@ async def test_clone(self): # Shallow copies can so can mutate cursor2 = copy.copy(cursor) cursor2._projection["cursor2"] = False - self.assertIn(cursor._projection and "cursor2", cursor._projection) + self.assertIsNotNone(cursor._projection) + self.assertIn("cursor2", cursor._projection) # 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) 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) # Test memo when deepcopying queries query = {"hello": "world"} diff --git a/test/asynchronous/test_database.py b/test/asynchronous/test_database.py index f6181555b8..a14465f1a6 100644 --- a/test/asynchronous/test_database.py +++ b/test/asynchronous/test_database.py @@ -295,7 +295,7 @@ async def test_list_collections(self): # Checking only capped collections are present self.assertIn("test", colls) - self.assertFalse("test.mike" in colls) + self.assertNotIn("test.mike", colls) # No collection containing a '$'. for coll in colls: @@ -341,22 +341,22 @@ async def test_drop_collection(self): await db.test.insert_one({"dummy": "object"}) 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.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.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.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 f7eaf2b385..a4ebf72df9 100644 --- a/test/asynchronous/test_examples.py +++ b/test/asynchronous/test_examples.py @@ -482,19 +482,19 @@ async def test_projection(self): self.assertIn("_id", doc) self.assertIn("item", doc) self.assertIn("status", doc) - self.assertFalse("size" in doc) - self.assertFalse("instock" in 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.assertNotIn("_id", doc) self.assertIn("item", doc) self.assertIn("status", doc) - self.assertFalse("size" in doc) - self.assertFalse("instock" in doc) + self.assertNotIn("size", doc) + self.assertNotIn("instock", doc) # Start Example 46 cursor = db.inventory.find({"status": "A"}, {"status": 0, "instock": 0}) @@ -503,9 +503,9 @@ async def test_projection(self): async for doc in cursor: self.assertIn("_id", doc) self.assertIn("item", doc) - self.assertFalse("status" in doc) + self.assertNotIn("status", doc) self.assertIn("size", doc) - self.assertFalse("instock" in doc) + self.assertNotIn("instock", doc) # Start Example 47 cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "size.uom": 1}) @@ -516,11 +516,11 @@ async def test_projection(self): self.assertIn("item", doc) self.assertIn("status", doc) self.assertIn("size", doc) - self.assertFalse("instock" in doc) + self.assertNotIn("instock", doc) size = doc["size"] self.assertIn("uom", size) - self.assertFalse("h" in size) - self.assertFalse("w" in size) + self.assertNotIn("h", size) + self.assertNotIn("w", size) # Start Example 48 cursor = db.inventory.find({"status": "A"}, {"size.uom": 0}) @@ -533,7 +533,7 @@ async def test_projection(self): self.assertIn("size", doc) self.assertIn("instock", doc) size = doc["size"] - self.assertFalse("uom" in size) + self.assertNotIn("uom", size) self.assertIn("h", size) self.assertIn("w", size) @@ -545,10 +545,10 @@ async def test_projection(self): self.assertIn("_id", doc) self.assertIn("item", doc) self.assertIn("status", doc) - self.assertFalse("size" in doc) + self.assertNotIn("size", doc) self.assertIn("instock", doc) for subdoc in doc["instock"]: - self.assertFalse("warehouse" in subdoc) + self.assertNotIn("warehouse", subdoc) self.assertIn("qty", subdoc) # Start Example 50 @@ -561,7 +561,7 @@ async def test_projection(self): self.assertIn("_id", doc) self.assertIn("item", doc) self.assertIn("status", doc) - self.assertFalse("size" in doc) + self.assertNotIn("size", doc) self.assertIn("instock", doc) self.assertEqual(len(doc["instock"]), 1) diff --git a/test/test_client.py b/test/test_client.py index b3f259c50b..51866e7ecc 100644 --- a/test/test_client.py +++ b/test/test_client.py @@ -731,7 +731,7 @@ def test_min_pool_size(self): lambda: len(server._pool.conns) == 10, "a closed socket gets replaced from the pool", ) - self.assertFalse(conn in server._pool.conns) + self.assertNotIn(conn, server._pool.conns) def test_max_idle_time_checkout(self): # Use high frequency to test _get_socket_no_auth. @@ -746,7 +746,7 @@ def test_max_idle_time_checkout(self): with server._pool.checkout() as new_con: self.assertNotEqual(conn, new_con) self.assertEqual(1, len(server._pool.conns)) - self.assertFalse(conn in server._pool.conns) + self.assertNotIn(conn, server._pool.conns) self.assertIn(new_con, server._pool.conns) # Test that connections are reused if maxIdleTimeMS is not set. diff --git a/test/test_collection.py b/test/test_collection.py index 0e156d70bc..dad8ef6d1e 100644 --- a/test/test_collection.py +++ b/test/test_collection.py @@ -212,7 +212,7 @@ def lambda_test_2(): def test_drop_nonexistent_collection(self): self.db.drop_collection("test") - self.assertFalse("test" in self.db.list_collection_names()) + self.assertNotIn("test", self.db.list_collection_names()) # No exception self.db.drop_collection("test") @@ -539,7 +539,7 @@ def test_index_background(self): db.test.create_index([("keya", ASCENDING)]) db.test.create_index([("keyb", ASCENDING)], background=False) db.test.create_index([("keyc", ASCENDING)], background=True) - self.assertFalse("background" in (db.test.index_information())["keya_1"]) + self.assertNotIn("background", (db.test.index_information())["keya_1"]) self.assertFalse((db.test.index_information())["keyb_1"]["background"]) self.assertTrue((db.test.index_information())["keyc_1"]["background"]) @@ -690,7 +690,7 @@ def test_field_selection(self): doc = next(db.test.find({}, {"_id": False})) l = list(doc) - self.assertFalse("_id" in l) + self.assertNotIn("_id", l) def test_options(self): db = self.db @@ -1127,13 +1127,13 @@ def test_find_w_fields(self): doc = next(db.test.find({}, ["x", "mike"])) 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.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): diff --git a/test/test_cursor.py b/test/test_cursor.py index 2f9f203ab9..1331bd5bdf 100644 --- a/test/test_cursor.py +++ b/test/test_cursor.py @@ -236,16 +236,16 @@ def test_max_await_time_ms(self): # Tailable_defaults. coll.find(cursor_type=CursorType.TAILABLE_AWAIT).to_list() # find - self.assertFalse("maxTimeMS" in listener.started_events[0].command) + self.assertNotIn("maxTimeMS", listener.started_events[0].command) # getMore - self.assertFalse("maxTimeMS" in listener.started_events[1].command) + self.assertNotIn("maxTimeMS", listener.started_events[1].command) listener.reset() # Tailable_with max_await_time_ms set. coll.find(cursor_type=CursorType.TAILABLE_AWAIT).max_await_time_ms(99).to_list() # find self.assertEqual("find", listener.started_events[0].command_name) - self.assertFalse("maxTimeMS" in listener.started_events[0].command) + self.assertNotIn("maxTimeMS", listener.started_events[0].command) # getMore self.assertEqual("getMore", listener.started_events[1].command_name) self.assertIn("maxTimeMS", listener.started_events[1].command) @@ -263,7 +263,7 @@ def test_max_await_time_ms(self): 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 @@ -287,10 +287,10 @@ def test_max_await_time_ms(self): coll.find(batch_size=1).max_await_time_ms(99).to_list() # find self.assertEqual("find", listener.started_events[0].command_name) - self.assertFalse("maxTimeMS" in listener.started_events[0].command) + self.assertNotIn("maxTimeMS", listener.started_events[0].command) # getMore self.assertEqual("getMore", listener.started_events[1].command_name) - self.assertFalse("maxTimeMS" in listener.started_events[1].command) + self.assertNotIn("maxTimeMS", listener.started_events[1].command) listener.reset() # Non tailable_await with max_time_ms @@ -301,7 +301,7 @@ def test_max_await_time_ms(self): 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() @@ -311,7 +311,7 @@ def test_max_await_time_ms(self): self.assertEqual(99, listener.started_events[0].command["maxTimeMS"]) # getMore self.assertEqual("getMore", listener.started_events[1].command_name) - self.assertFalse("maxTimeMS" in listener.started_events[1].command) + self.assertNotIn("maxTimeMS", listener.started_events[1].command) @client_context.require_test_commands @client_context.require_no_mongos @@ -924,16 +924,19 @@ def test_clone(self): # Shallow copies can so can mutate cursor2 = copy.copy(cursor) cursor2._projection["cursor2"] = False - self.assertIn(cursor._projection and "cursor2", cursor._projection) + self.assertIsNotNone(cursor._projection) + self.assertIn("cursor2", cursor._projection) # 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) 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) # Test memo when deepcopying queries query = {"hello": "world"} diff --git a/test/test_database.py b/test/test_database.py index d4d1a0a0fc..e3303d4205 100644 --- a/test/test_database.py +++ b/test/test_database.py @@ -292,7 +292,7 @@ def test_list_collections(self): # Checking only capped collections are present self.assertIn("test", colls) - self.assertFalse("test.mike" in colls) + self.assertNotIn("test.mike", colls) # No collection containing a '$'. for coll in colls: @@ -338,22 +338,22 @@ def test_drop_collection(self): db.test.insert_one({"dummy": "object"}) 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.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.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.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 b3d8eaa2e3..bda5403200 100644 --- a/test/test_examples.py +++ b/test/test_examples.py @@ -482,19 +482,19 @@ def test_projection(self): self.assertIn("_id", doc) self.assertIn("item", doc) self.assertIn("status", doc) - self.assertFalse("size" in doc) - self.assertFalse("instock" in 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.assertNotIn("_id", doc) self.assertIn("item", doc) self.assertIn("status", doc) - self.assertFalse("size" in doc) - self.assertFalse("instock" in doc) + self.assertNotIn("size", doc) + self.assertNotIn("instock", doc) # Start Example 46 cursor = db.inventory.find({"status": "A"}, {"status": 0, "instock": 0}) @@ -503,9 +503,9 @@ def test_projection(self): for doc in cursor: self.assertIn("_id", doc) self.assertIn("item", doc) - self.assertFalse("status" in doc) + self.assertNotIn("status", doc) self.assertIn("size", doc) - self.assertFalse("instock" in doc) + self.assertNotIn("instock", doc) # Start Example 47 cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "size.uom": 1}) @@ -516,11 +516,11 @@ def test_projection(self): self.assertIn("item", doc) self.assertIn("status", doc) self.assertIn("size", doc) - self.assertFalse("instock" in doc) + self.assertNotIn("instock", doc) size = doc["size"] self.assertIn("uom", size) - self.assertFalse("h" in size) - self.assertFalse("w" in size) + self.assertNotIn("h", size) + self.assertNotIn("w", size) # Start Example 48 cursor = db.inventory.find({"status": "A"}, {"size.uom": 0}) @@ -533,7 +533,7 @@ def test_projection(self): self.assertIn("size", doc) self.assertIn("instock", doc) size = doc["size"] - self.assertFalse("uom" in size) + self.assertNotIn("uom", size) self.assertIn("h", size) self.assertIn("w", size) @@ -545,10 +545,10 @@ def test_projection(self): self.assertIn("_id", doc) self.assertIn("item", doc) self.assertIn("status", doc) - self.assertFalse("size" in doc) + self.assertNotIn("size", doc) self.assertIn("instock", doc) for subdoc in doc["instock"]: - self.assertFalse("warehouse" in subdoc) + self.assertNotIn("warehouse", subdoc) self.assertIn("qty", subdoc) # Start Example 50 @@ -561,7 +561,7 @@ def test_projection(self): self.assertIn("_id", doc) self.assertIn("item", doc) self.assertIn("status", doc) - self.assertFalse("size" in doc) + self.assertNotIn("size", doc) self.assertIn("instock", doc) self.assertEqual(len(doc["instock"]), 1) diff --git a/test/test_son.py b/test/test_son.py index 3875426a62..36a6834889 100644 --- a/test/test_son.py +++ b/test/test_son.py @@ -149,7 +149,7 @@ def test_contains_has(self): test_son = SON([(1, 100), (2, 200), (3, 300)]) self.assertIn(1, test_son) self.assertIn(2, test_son, "in failed") - self.assertFalse(22 in test_son, "in succeeded when it shouldn't") + 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 73278ba450436a3c9c21a734c468994f1283b367 Mon Sep 17 00:00:00 2001 From: Iris Ho Date: Wed, 21 May 2025 16:56:55 -0700 Subject: [PATCH 3/5] fix typing --- test/asynchronous/test_cursor.py | 7 ++++--- test/test_cursor.py | 7 ++++--- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/test/asynchronous/test_cursor.py b/test/asynchronous/test_cursor.py index bf642739b9..7129e70127 100644 --- a/test/asynchronous/test_cursor.py +++ b/test/asynchronous/test_cursor.py @@ -934,18 +934,19 @@ async def test_clone(self): cursor2 = copy.copy(cursor) cursor2._projection["cursor2"] = False self.assertIsNotNone(cursor._projection) - self.assertIn("cursor2", cursor._projection) + print(cursor._projection.keys()) + self.assertIn("cursor2", cursor._projection.keys()) # Deepcopies and shouldn't mutate cursor3 = copy.deepcopy(cursor) cursor3._projection["cursor3"] = False self.assertIsNotNone(cursor._projection) - self.assertNotIn("cursor3", cursor._projection) + self.assertNotIn("cursor3", cursor._projection.keys()) cursor4 = cursor.clone() cursor4._projection["cursor4"] = False self.assertIsNotNone(cursor._projection) - self.assertNotIn("cursor4", cursor._projection) + self.assertNotIn("cursor4", cursor._projection.keys()) # Test memo when deepcopying queries query = {"hello": "world"} diff --git a/test/test_cursor.py b/test/test_cursor.py index 1331bd5bdf..c79c9d742d 100644 --- a/test/test_cursor.py +++ b/test/test_cursor.py @@ -925,18 +925,19 @@ def test_clone(self): cursor2 = copy.copy(cursor) cursor2._projection["cursor2"] = False self.assertIsNotNone(cursor._projection) - self.assertIn("cursor2", cursor._projection) + print(cursor._projection.keys()) + self.assertIn("cursor2", cursor._projection.keys()) # Deepcopies and shouldn't mutate cursor3 = copy.deepcopy(cursor) cursor3._projection["cursor3"] = False self.assertIsNotNone(cursor._projection) - self.assertNotIn("cursor3", cursor._projection) + self.assertNotIn("cursor3", cursor._projection.keys()) cursor4 = cursor.clone() cursor4._projection["cursor4"] = False self.assertIsNotNone(cursor._projection) - self.assertNotIn("cursor4", cursor._projection) + self.assertNotIn("cursor4", cursor._projection.keys()) # Test memo when deepcopying queries query = {"hello": "world"} From 1f308bd7d0fe6d2a6e19ad3cc57ef0774335e3fc Mon Sep 17 00:00:00 2001 From: Iris Ho Date: Thu, 22 May 2025 10:13:03 -0700 Subject: [PATCH 4/5] oops accidentally left a print statement --- test/asynchronous/test_cursor.py | 1 - test/test_cursor.py | 1 - 2 files changed, 2 deletions(-) diff --git a/test/asynchronous/test_cursor.py b/test/asynchronous/test_cursor.py index 7129e70127..ebeb0b79dc 100644 --- a/test/asynchronous/test_cursor.py +++ b/test/asynchronous/test_cursor.py @@ -934,7 +934,6 @@ async def test_clone(self): cursor2 = copy.copy(cursor) cursor2._projection["cursor2"] = False self.assertIsNotNone(cursor._projection) - print(cursor._projection.keys()) self.assertIn("cursor2", cursor._projection.keys()) # Deepcopies and shouldn't mutate diff --git a/test/test_cursor.py b/test/test_cursor.py index c79c9d742d..d6ead7f003 100644 --- a/test/test_cursor.py +++ b/test/test_cursor.py @@ -925,7 +925,6 @@ def test_clone(self): cursor2 = copy.copy(cursor) cursor2._projection["cursor2"] = False self.assertIsNotNone(cursor._projection) - print(cursor._projection.keys()) self.assertIn("cursor2", cursor._projection.keys()) # Deepcopies and shouldn't mutate From fb041882841c1930f906334f88a680286f725c43 Mon Sep 17 00:00:00 2001 From: Iris Ho Date: Thu, 22 May 2025 12:31:52 -0700 Subject: [PATCH 5/5] oops my regex forgot to account for this whitespace --- test/asynchronous/test_session.py | 33 +++++++++++++++++-------------- test/test_session.py | 33 +++++++++++++++++-------------- 2 files changed, 36 insertions(+), 30 deletions(-) diff --git a/test/asynchronous/test_session.py b/test/asynchronous/test_session.py index 3655f49aab..1f6fb0d319 100644 --- a/test/asynchronous/test_session.py +++ b/test/asynchronous/test_session.py @@ -134,8 +134,9 @@ async def _test_ops(self, client, *ops): await f(*args, **kw) self.assertGreaterEqual(len(listener.started_events), 1) for event in listener.started_events: - self.assertTrue( - "lsid" in event.command, + self.assertIn( + "lsid", + event.command, f"{f.__name__} sent no lsid with {event.command_name}", ) @@ -170,8 +171,9 @@ async def _test_ops(self, client, *ops): self.assertGreaterEqual(len(listener.started_events), 1) lsids = [] for event in listener.started_events: - self.assertTrue( - "lsid" in event.command, + self.assertIn( + "lsid", + event.command, f"{f.__name__} sent no lsid with {event.command_name}", ) @@ -422,8 +424,9 @@ async def test_cursor(self): await f(session=s) self.assertGreaterEqual(len(listener.started_events), 1) for event in listener.started_events: - self.assertTrue( - "lsid" in event.command, + self.assertIn( + "lsid", + event.command, f"{name} sent no lsid with {event.command_name}", ) @@ -441,15 +444,13 @@ async def test_cursor(self): listener.reset() await f(session=None) event0 = listener.first_command_started() - self.assertTrue( - "lsid" in event0.command, f"{name} sent no lsid with {event0.command_name}" - ) + self.assertIn("lsid", event0.command, f"{name} sent no lsid with {event0.command_name}") lsid = event0.command["lsid"] for event in listener.started_events[1:]: - self.assertTrue( - "lsid" in event.command, f"{name} sent no lsid with {event.command_name}" + self.assertIn( + "lsid", event.command, f"{name} sent no lsid with {event.command_name}" ) self.assertEqual( @@ -1201,15 +1202,17 @@ async def aggregate(): self.assertGreaterEqual(len(listener.started_events), 1) for i, event in enumerate(listener.started_events): - self.assertTrue( - "$clusterTime" in event.command, + self.assertIn( + "$clusterTime", + event.command, f"{f.__name__} sent no $clusterTime with {event.command_name}", ) if i > 0: succeeded = listener.succeeded_events[i - 1] - self.assertTrue( - "$clusterTime" in succeeded.reply, + self.assertIn( + "$clusterTime", + succeeded.reply, f"{f.__name__} received no $clusterTime with {succeeded.command_name}", ) diff --git a/test/test_session.py b/test/test_session.py index a6266884aa..49cb9dba91 100644 --- a/test/test_session.py +++ b/test/test_session.py @@ -134,8 +134,9 @@ def _test_ops(self, client, *ops): f(*args, **kw) self.assertGreaterEqual(len(listener.started_events), 1) for event in listener.started_events: - self.assertTrue( - "lsid" in event.command, + self.assertIn( + "lsid", + event.command, f"{f.__name__} sent no lsid with {event.command_name}", ) @@ -170,8 +171,9 @@ def _test_ops(self, client, *ops): self.assertGreaterEqual(len(listener.started_events), 1) lsids = [] for event in listener.started_events: - self.assertTrue( - "lsid" in event.command, + self.assertIn( + "lsid", + event.command, f"{f.__name__} sent no lsid with {event.command_name}", ) @@ -422,8 +424,9 @@ def test_cursor(self): f(session=s) self.assertGreaterEqual(len(listener.started_events), 1) for event in listener.started_events: - self.assertTrue( - "lsid" in event.command, + self.assertIn( + "lsid", + event.command, f"{name} sent no lsid with {event.command_name}", ) @@ -441,15 +444,13 @@ def test_cursor(self): listener.reset() f(session=None) event0 = listener.first_command_started() - self.assertTrue( - "lsid" in event0.command, f"{name} sent no lsid with {event0.command_name}" - ) + self.assertIn("lsid", event0.command, f"{name} sent no lsid with {event0.command_name}") lsid = event0.command["lsid"] for event in listener.started_events[1:]: - self.assertTrue( - "lsid" in event.command, f"{name} sent no lsid with {event.command_name}" + self.assertIn( + "lsid", event.command, f"{name} sent no lsid with {event.command_name}" ) self.assertEqual( @@ -1187,15 +1188,17 @@ def aggregate(): self.assertGreaterEqual(len(listener.started_events), 1) for i, event in enumerate(listener.started_events): - self.assertTrue( - "$clusterTime" in event.command, + self.assertIn( + "$clusterTime", + event.command, f"{f.__name__} sent no $clusterTime with {event.command_name}", ) if i > 0: succeeded = listener.succeeded_events[i - 1] - self.assertTrue( - "$clusterTime" in succeeded.reply, + self.assertIn( + "$clusterTime", + succeeded.reply, f"{f.__name__} received no $clusterTime with {succeeded.command_name}", )