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

Merge branch 'master' of github.com:mongodb/mongo-python-driver

Browse Source
This commit is contained in:
Steven Silvester 2025-05-27 18:49:49 -05:00
commit 2a80cda15d
No known key found for this signature in database
GPG Key ID: B1BF5EC3A8B32F91
41 changed files with 711 additions and 653 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.github/workflows/codeql.yml vendored
View File

@ -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}}"

2
.github/workflows/zizmor.yml vendored
View File

@ -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

9
CONTRIBUTING.md
View File

@ -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

6
_setup.py
View File

@ -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

10
bson/codec_options.py
View File

@ -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

7
doc/changelog.rst
View File

@ -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)
--------------------------------------

22
test/asynchronous/test_bulk.py
View File

@ -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.
@ -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)
@ -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
@ -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))

30
test/asynchronous/test_client.py
View File

@ -214,7 +214,7 @@ class AsyncClientUnitTest(AsyncUnitTest):
self.assertRaises(InvalidName, make_db, self.client, "te/t")
self.assertRaises(InvalidName, make_db, self.client, "te 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
@ -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):
@ -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(
@ -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()

198
test/asynchronous/test_collection.py
View File

@ -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"])
@ -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
@ -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.assertTrue(_id in result.inserted_ids)
self.assertIsInstance(_id, ObjectId)
self.assertIn(_id, 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.assertTrue(_id in result.inserted_ids)
self.assertIsInstance(_id, int)
self.assertIn(_id, 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,22 +938,22 @@ 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.assertTrue(_id in result.inserted_ids)
self.assertIsInstance(_id, int)
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)]
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.assertTrue(_id in result.inserted_ids)
self.assertIsInstance(_id, int)
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
@ -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)
@ -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)
@ -1346,9 +1346,9 @@ 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.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}))
@ -1357,9 +1357,9 @@ 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.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}))
@ -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.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}))
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,33 +1391,33 @@ 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.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
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.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
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.assertIn(result.modified_count, (None, 0))
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,31 +1448,31 @@ 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.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}))
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.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}))
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.assertIn(result.modified_count, (None, 0))
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
@ -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()))
@ -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(

43
test/asynchronous/test_cursor.py
View File

@ -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"}
@ -959,7 +962,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

11
test/asynchronous/test_custom_types.py
View File

@ -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)
@ -784,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)

46
test/asynchronous/test_database.py
View File

@ -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
@ -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)
@ -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))

8
test/asynchronous/test_encryption.py
View File

@ -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"})

94
test/asynchronous/test_examples.py
View File

@ -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):

10
test/asynchronous/test_grid_file.py
View File

@ -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)

2
test/asynchronous/test_gridfs.py
View File

@ -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)

2
test/asynchronous/test_gridfs_bucket.py
View File

@ -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)

2
test/asynchronous/test_json_util_integration.py
View File

@ -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)

146
test/asynchronous/test_monitoring.py
View File

@ -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
@ -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()
@ -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):

33
test/asynchronous/test_session.py
View File

@ -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}",
)

4
test/test_binary.py
View File

@ -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)

12
test/test_bson.py
View File

@ -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):

22
test/test_bulk.py
View File

@ -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.
@ -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)
@ -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
@ -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))

30
test/test_client.py
View File

@ -211,7 +211,7 @@ class ClientUnitTest(UnitTest):
self.assertRaises(InvalidName, make_db, self.client, "te/t")
self.assertRaises(InvalidName, make_db, self.client, "te 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
@ -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):
@ -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(
@ -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()

4
test/test_code.py
View File

@ -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)

198
test/test_collection.py
View File

@ -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"])
@ -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
@ -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.assertTrue(_id in result.inserted_ids)
self.assertIsInstance(_id, ObjectId)
self.assertIn(_id, 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.assertTrue(_id in result.inserted_ids)
self.assertIsInstance(_id, int)
self.assertIn(_id, 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,22 +926,22 @@ 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.assertTrue(_id in result.inserted_ids)
self.assertIsInstance(_id, int)
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)]
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.assertTrue(_id in result.inserted_ids)
self.assertIsInstance(_id, int)
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
@ -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)
@ -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)
@ -1332,9 +1332,9 @@ 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.assertIn(result.modified_count, (None, 1))
self.assertIsNone(result.upserted_id)
self.assertTrue(result.acknowledged)
self.assertEqual(1, db.test.count_documents({"y": 1}))
@ -1343,9 +1343,9 @@ 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.assertIn(result.modified_count, (None, 1))
self.assertIsNone(result.upserted_id)
self.assertTrue(result.acknowledged)
self.assertEqual(1, db.test.count_documents({"z": 1}))
@ -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.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}))
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,33 +1377,33 @@ 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.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
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.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
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.assertIn(result.modified_count, (None, 0))
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,31 +1434,31 @@ 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.assertIn(result.modified_count, (None, 2))
self.assertIsNone(result.upserted_id)
self.assertTrue(result.acknowledged)
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.assertIn(result.modified_count, (None, 1))
self.assertIsNone(result.upserted_id)
self.assertTrue(result.acknowledged)
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.assertIn(result.modified_count, (None, 0))
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
@ -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()))
@ -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(

43
test/test_cursor.py
View File

@ -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"}
@ -950,7 +953,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

11
test/test_custom_types.py
View File

@ -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)
@ -784,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)

46
test/test_database.py
View File

@ -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
@ -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)
@ -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))

8
test/test_encryption.py
View File

@ -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"})

94
test/test_examples.py
View File

@ -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):

10
test/test_grid_file.py
View File

@ -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)

2
test/test_gridfs.py
View File

@ -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)

2
test/test_gridfs_bucket.py
View File

@ -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)

2
test/test_json_util.py
View File

@ -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)

2
test/test_json_util_integration.py
View File

@ -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)

146
test/test_monitoring.py
View File

@ -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
@ -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()
@ -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):

33
test/test_session.py
View File

@ -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}",
)

4
test/test_son.py
View File

@ -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")

2
test/test_timestamp.py
View File

@ -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)

4
test/test_uri_parser.py
View File

@ -135,8 +135,8 @@ class TestURI(unittest.TestCase):
self.assertEqual({"connecttimeoutms": 0.3}, split_options("connectTimeoutMS=300"))
self.assertEqual({"connecttimeoutms": 0.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"))