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

PYTHON-1581 - Deprecate Collection/Cursor count

Browse Source
This commit is contained in:
Bernie Hackett 2018-06-18 10:50:26 -07:00
parent 9d8024d9ea
commit e6b0f3847d
19 changed files with 234 additions and 196 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
pymongo/collection.py
View File

@ -1578,6 +1578,9 @@ class Collection(common.BaseObject):
.. versionadded:: 3.7
"""
if 'session' in kwargs:
raise ConfigurationError(
'estimated_document_count does not support sessions')
cmd = SON([('count', self.__name)])
cmd.update(kwargs)
return self._count(cmd)
@ -1678,6 +1681,8 @@ class Collection(common.BaseObject):
Support the `collation` option.
"""
warnings.warn("count is deprecated. Use estimated_document_count or "
"count_documents instead.", DeprecationWarning, stacklevel=2)
cmd = SON([("count", self.__name)])
if filter is not None:
if "query" in kwargs:

2
pymongo/cursor.py
View File

@ -746,6 +746,8 @@ class Cursor(object):
.. versionchanged:: 2.8
The :meth:`~count` method now supports :meth:`~hint`.
"""
warnings.warn("count is deprecated. Use Collection.count_documents "
"instead.", DeprecationWarning, stacklevel=2)
validate_boolean("with_limit_and_skip", with_limit_and_skip)
cmd = SON([("count", self.__collection.name),
("query", self.__spec)])

2
test/atlas/test_connection.py
View File

@ -42,7 +42,7 @@ def _connect(uri):
# No TLS error
client.admin.command('ismaster')
# No auth error
client.test.test.count()
client.test.test.count_documents({})
class TestAtlasConnect(unittest.TestCase):

2
test/test_auth.py
View File

@ -209,7 +209,7 @@ class TestGSSAPI(unittest.TestCase):
# multiple sockets from the pool concurrently, proving that
# auto-authentication works with GSSAPI.
collection = db.test
if collection.count() == 0:
if not collection.count_documents({}):
try:
collection.drop()
collection.insert_one({'_id': 1})

16
test/test_binary.py
View File

@ -27,8 +27,9 @@ import bson
from bson.binary import *
from bson.codec_options import CodecOptions
from bson.son import SON
from test import client_context, unittest
from pymongo.mongo_client import MongoClient
from test import client_context, unittest
from test.utils import ignore_deprecations
class TestBinary(unittest.TestCase):
@ -203,7 +204,7 @@ class TestBinary(unittest.TestCase):
'java_uuid', CodecOptions(uuid_representation=JAVA_LEGACY))
coll.insert_many(docs)
self.assertEqual(5, coll.count())
self.assertEqual(5, coll.count_documents({}))
for d in coll.find():
self.assertEqual(d['newguid'], uuid.UUID(d['newguidstring']))
@ -273,7 +274,7 @@ class TestBinary(unittest.TestCase):
'csharp_uuid', CodecOptions(uuid_representation=CSHARP_LEGACY))
coll.insert_many(docs)
self.assertEqual(5, coll.count())
self.assertEqual(5, coll.count_documents({}))
for d in coll.find():
self.assertEqual(d['newguid'], uuid.UUID(d['newguidstring']))
@ -292,6 +293,7 @@ class TestBinary(unittest.TestCase):
CSHARP_LEGACY)
@client_context.require_connection
@ignore_deprecations
def test_uuid_queries(self):
db = client_context.client.pymongo_test
@ -300,7 +302,7 @@ class TestBinary(unittest.TestCase):
uu = uuid.uuid4()
coll.insert_one({'uuid': Binary(uu.bytes, 3)})
self.assertEqual(1, coll.count())
self.assertEqual(1, coll.count_documents({}))
# Test UUIDLegacy queries.
coll = db.get_collection("test",
@ -313,14 +315,16 @@ class TestBinary(unittest.TestCase):
# Test regular UUID queries (using subtype 4).
coll.insert_one({'uuid': uu})
self.assertEqual(2, coll.count())
self.assertEqual(2, coll.count_documents({}))
cur = coll.find({'uuid': uu})
self.assertEqual(1, cur.count())
retrieved = next(cur)
self.assertEqual(uu, retrieved['uuid'])
# Test both.
cur = coll.find({'uuid': {'$in': [uu, UUIDLegacy(uu)]}})
predicate = {'uuid': {'$in': [uu, UUIDLegacy(uu)]}}
self.assertEqual(2, coll.count_documents(predicate))
cur = coll.find(predicate)
self.assertEqual(2, cur.count())
coll.drop()

10
test/test_bulk.py
View File

@ -137,7 +137,7 @@ class TestBulk(BulkTestBase):
result = self.coll.bulk_write([InsertOne({})])
self.assertEqualResponse(expected, result.bulk_api_result)
self.assertEqual(1, result.inserted_count)
self.assertEqual(1, self.coll.count())
self.assertEqual(1, self.coll.count_documents({}))
def test_update_many(self):
@ -260,7 +260,7 @@ class TestBulk(BulkTestBase):
result = self.coll.bulk_write([DeleteOne({})])
self.assertEqualResponse(expected, result.bulk_api_result)
self.assertEqual(1, result.deleted_count)
self.assertEqual(self.coll.count(), 1)
self.assertEqual(self.coll.count_documents({}), 1)
def test_upsert(self):
@ -281,7 +281,7 @@ class TestBulk(BulkTestBase):
self.assertEqual(1, len(result.upserted_ids))
self.assertTrue(isinstance(result.upserted_ids.get(0), ObjectId))
self.assertEqual(self.coll.find({'foo': 'bar'}).count(), 1)
self.assertEqual(self.coll.count_documents({'foo': 'bar'}), 1)
def test_numerous_inserts(self):
# Ensure we don't exceed server's 1000-document batch size limit.
@ -289,13 +289,13 @@ class TestBulk(BulkTestBase):
requests = [InsertOne({}) for _ in range(n_docs)]
result = self.coll.bulk_write(requests, ordered=False)
self.assertEqual(n_docs, result.inserted_count)
self.assertEqual(n_docs, self.coll.count())
self.assertEqual(n_docs, self.coll.count_documents({}))
# Same with ordered bulk.
self.coll.drop()
result = self.coll.bulk_write(requests)
self.assertEqual(n_docs, result.inserted_count)
self.assertEqual(n_docs, self.coll.count())
self.assertEqual(n_docs, self.coll.count_documents({}))
def test_generator_insert(self):
def gen():

14
test/test_client.py
View File

@ -598,12 +598,12 @@ class TestClient(IntegrationTest):
self.client.close()
self.client.close()
coll.count()
coll.count_documents({})
self.client.close()
self.client.close()
coll.count()
coll.count_documents({})
def test_close_kills_cursors(self):
if sys.platform.startswith('java'):
@ -1077,7 +1077,7 @@ class TestClient(IntegrationTest):
client = rs_or_single_client(connect=False, w=0)
client.test_lazy_connect_w0.test.insert_one({})
wait_until(
lambda: client.test_lazy_connect_w0.test.count() == 1,
lambda: client.test_lazy_connect_w0.test.count_documents({}) == 1,
"find one document")
client = rs_or_single_client(connect=False, w=0)
@ -1089,7 +1089,7 @@ class TestClient(IntegrationTest):
client = rs_or_single_client(connect=False, w=0)
client.test_lazy_connect_w0.test.delete_one({})
wait_until(
lambda: client.test_lazy_connect_w0.test.count() == 0,
lambda: client.test_lazy_connect_w0.test.count_documents({}) == 0,
"delete one document")
@client_context.require_no_mongos
@ -1348,7 +1348,7 @@ class TestExhaustCursor(IntegrationTest):
sock_info.receive_message = saved
# The socket is returned the pool and it still works.
self.assertEqual(200, collection.count())
self.assertEqual(200, collection.count_documents({}))
self.assertIn(sock_info, pool.sockets)
def test_exhaust_query_network_error(self):
@ -1413,7 +1413,7 @@ class TestClientLazyConnect(IntegrationTest):
collection.insert_one({})
def test(collection):
self.assertEqual(NTHREADS, collection.count())
self.assertEqual(NTHREADS, collection.count_documents({}))
lazy_client_trial(reset, insert_one, test, self._get_client)
@ -1440,7 +1440,7 @@ class TestClientLazyConnect(IntegrationTest):
collection.delete_one({'i': i})
def test(collection):
self.assertEqual(0, collection.count())
self.assertEqual(0, collection.count_documents({}))
lazy_client_trial(reset, delete_one, test, self._get_client)

8
test/test_collation.py
View File

@ -17,18 +17,17 @@
import functools
import warnings
from test import unittest, client_context
from test.utils import EventListener, rs_or_single_client
from pymongo import monitoring
from pymongo.collation import (
Collation,
CollationCaseFirst, CollationStrength, CollationAlternate,
CollationMaxVariable)
from pymongo.errors import ConfigurationError
from pymongo.write_concern import WriteConcern
from pymongo.operations import (DeleteMany, DeleteOne, IndexModel, ReplaceOne,
UpdateMany, UpdateOne)
from pymongo.write_concern import WriteConcern
from test import unittest, client_context
from test.utils import EventListener, ignore_deprecations, rs_or_single_client
class TestCollationObject(unittest.TestCase):
@ -161,6 +160,7 @@ class TestCollation(unittest.TestCase):
self.assertCollationInLastCommand()
@raisesConfigurationErrorForOldMongoDB
@ignore_deprecations
def test_count(self):
self.db.test.count(collation=self.collation)
self.assertCollationInLastCommand()

175
test/test_collection.py
View File

@ -61,12 +61,12 @@ from pymongo.results import (InsertOneResult,
UpdateResult,
DeleteResult)
from pymongo.write_concern import WriteConcern
from test import client_context, unittest
from test.test_client import IntegrationTest
from test.utils import (is_mongos, get_pool,
from test.utils import (get_pool, ignore_deprecations, is_mongos,
rs_or_single_client, single_client,
wait_until, EventListener,
IMPOSSIBLE_WRITE_CONCERN)
from test import client_context, unittest
class TestCollectionNoConnect(unittest.TestCase):
@ -555,7 +555,7 @@ class TestCollection(IntegrationTest):
db.test.create_index([('i', ASCENDING)], unique=True, dropDups=True)
# Duplicate was dropped
self.assertEqual(3, db.test.count())
self.assertEqual(3, db.test.count_documents({}))
# Index was created, plus the index on _id
self.assertEqual(2, len(db.test.index_information()))
@ -575,7 +575,7 @@ class TestCollection(IntegrationTest):
self.assertRaises(DuplicateKeyError, test_create)
# Duplicate wasn't dropped
self.assertEqual(4, db.test.count())
self.assertEqual(4, db.test.count_documents({}))
# Index wasn't created, only the default index on _id
self.assertEqual(1, len(db.test.index_information()))
@ -732,7 +732,7 @@ class TestCollection(IntegrationTest):
self.assertEqual(document["_id"], result.inserted_id)
self.assertTrue(result.acknowledged)
self.assertIsNotNone(db.test.find_one({"_id": document["_id"]}))
self.assertEqual(1, db.test.count())
self.assertEqual(1, db.test.count_documents({}))
document = {"foo": "bar"}
result = db.test.insert_one(document)
@ -741,7 +741,7 @@ class TestCollection(IntegrationTest):
self.assertEqual(document["_id"], result.inserted_id)
self.assertTrue(result.acknowledged)
self.assertIsNotNone(db.test.find_one({"_id": document["_id"]}))
self.assertEqual(2, db.test.count())
self.assertEqual(2, db.test.count_documents({}))
db = db.client.get_database(db.name,
write_concern=WriteConcern(w=0))
@ -751,7 +751,8 @@ class TestCollection(IntegrationTest):
self.assertEqual(document["_id"], result.inserted_id)
self.assertFalse(result.acknowledged)
# The insert failed duplicate key...
wait_until(lambda: 2 == db.test.count(), 'forcing duplicate key error')
wait_until(lambda: 2 == db.test.count_documents({}),
'forcing duplicate key error')
document = RawBSONDocument(
bson.BSON.encode({'_id': ObjectId(), 'foo': 'bar'}))
@ -772,7 +773,7 @@ class TestCollection(IntegrationTest):
_id = doc["_id"]
self.assertTrue(isinstance(_id, ObjectId))
self.assertTrue(_id in result.inserted_ids)
self.assertEqual(1, db.test.count({'_id': _id}))
self.assertEqual(1, db.test.count_documents({'_id': _id}))
self.assertTrue(result.acknowledged)
docs = [{"_id": i} for i in range(5)]
@ -784,7 +785,7 @@ class TestCollection(IntegrationTest):
_id = doc["_id"]
self.assertTrue(isinstance(_id, int))
self.assertTrue(_id in result.inserted_ids)
self.assertEqual(1, db.test.count({"_id": _id}))
self.assertEqual(1, db.test.count_documents({"_id": _id}))
self.assertTrue(result.acknowledged)
docs = [RawBSONDocument(bson.BSON.encode({"_id": i + 5}))
@ -800,7 +801,7 @@ class TestCollection(IntegrationTest):
result = db.test.insert_many(docs)
self.assertTrue(isinstance(result, InsertManyResult))
self.assertFalse(result.acknowledged)
self.assertEqual(20, db.test.count())
self.assertEqual(20, db.test.count_documents({}))
def test_delete_one(self):
self.db.test.drop()
@ -813,13 +814,13 @@ class TestCollection(IntegrationTest):
self.assertTrue(isinstance(result, DeleteResult))
self.assertEqual(1, result.deleted_count)
self.assertTrue(result.acknowledged)
self.assertEqual(2, self.db.test.count())
self.assertEqual(2, self.db.test.count_documents({}))
result = self.db.test.delete_one({"y": 1})
self.assertTrue(isinstance(result, DeleteResult))
self.assertEqual(1, result.deleted_count)
self.assertTrue(result.acknowledged)
self.assertEqual(1, self.db.test.count())
self.assertEqual(1, self.db.test.count_documents({}))
db = self.db.client.get_database(self.db.name,
write_concern=WriteConcern(w=0))
@ -827,7 +828,7 @@ class TestCollection(IntegrationTest):
self.assertTrue(isinstance(result, DeleteResult))
self.assertRaises(InvalidOperation, lambda: result.deleted_count)
self.assertFalse(result.acknowledged)
wait_until(lambda: 0 == db.test.count(), 'delete 1 documents')
wait_until(lambda: 0 == db.test.count_documents({}), 'delete 1 documents')
def test_delete_many(self):
self.db.test.drop()
@ -841,7 +842,7 @@ class TestCollection(IntegrationTest):
self.assertTrue(isinstance(result, DeleteResult))
self.assertEqual(2, result.deleted_count)
self.assertTrue(result.acknowledged)
self.assertEqual(0, self.db.test.count({"x": 1}))
self.assertEqual(0, self.db.test.count_documents({"x": 1}))
db = self.db.client.get_database(self.db.name,
write_concern=WriteConcern(w=0))
@ -849,7 +850,8 @@ class TestCollection(IntegrationTest):
self.assertTrue(isinstance(result, DeleteResult))
self.assertRaises(InvalidOperation, lambda: result.deleted_count)
self.assertFalse(result.acknowledged)
wait_until(lambda: 0 == db.test.count(), 'delete 2 documents')
wait_until(
lambda: 0 == db.test.count_documents({}), 'delete 2 documents')
def test_command_document_too_large(self):
large = '*' * (self.client.max_bson_size + _COMMAND_OVERHEAD)
@ -894,7 +896,7 @@ class TestCollection(IntegrationTest):
_id = doc["_id"]
self.assertTrue(isinstance(_id, int))
self.assertTrue(_id in result.inserted_ids)
self.assertEqual(1, db.test.count({"x": doc["x"]}))
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)
@ -904,7 +906,7 @@ class TestCollection(IntegrationTest):
_id = doc["_id"]
self.assertTrue(isinstance(_id, int))
self.assertTrue(_id in result.inserted_ids)
self.assertEqual(1, db.test.count({"a": doc["a"]}))
self.assertEqual(1, db.test.count_documents({"a": doc["a"]}))
self.assertTrue(result.acknowledged)
self.assertRaises(OperationFailure, db_w0.test.insert_many,
@ -923,30 +925,30 @@ class TestCollection(IntegrationTest):
db.test.insert_one({"a": 101})
self.assertRaises(OperationFailure, db.test.replace_one,
{"a": 101}, {"y": 1})
self.assertEqual(0, db.test.count({"y": 1}))
self.assertEqual(1, db.test.count({"a": 101}))
self.assertEqual(0, db.test.count_documents({"y": 1}))
self.assertEqual(1, db.test.count_documents({"a": 101}))
db.test.replace_one({"a": 101}, {"y": 1},
bypass_document_validation=True)
self.assertEqual(0, db.test.count({"a": 101}))
self.assertEqual(1, db.test.count({"y": 1}))
self.assertEqual(0, db.test.count_documents({"a": 101}))
self.assertEqual(1, db.test.count_documents({"y": 1}))
db.test.replace_one({"y": 1}, {"a": 102})
self.assertEqual(0, db.test.count({"y": 1}))
self.assertEqual(0, db.test.count({"a": 101}))
self.assertEqual(1, db.test.count({"a": 102}))
self.assertEqual(0, db.test.count_documents({"y": 1}))
self.assertEqual(0, db.test.count_documents({"a": 101}))
self.assertEqual(1, db.test.count_documents({"a": 102}))
db.test.insert_one({"y": 1}, bypass_document_validation=True)
self.assertRaises(OperationFailure, db.test.replace_one,
{"y": 1}, {"x": 101})
self.assertEqual(0, db.test.count({"x": 101}))
self.assertEqual(1, db.test.count({"y": 1}))
self.assertEqual(0, db.test.count_documents({"x": 101}))
self.assertEqual(1, db.test.count_documents({"y": 1}))
db.test.replace_one({"y": 1}, {"x": 101},
bypass_document_validation=True)
self.assertEqual(0, db.test.count({"y": 1}))
self.assertEqual(1, db.test.count({"x": 101}))
self.assertEqual(0, db.test.count_documents({"y": 1}))
self.assertEqual(1, db.test.count_documents({"x": 101}))
db.test.replace_one({"x": 101}, {"a": 103},
bypass_document_validation=False)
self.assertEqual(0, db.test.count({"x": 101}))
self.assertEqual(1, db.test.count({"a": 103}))
self.assertEqual(0, db.test.count_documents({"x": 101}))
self.assertEqual(1, db.test.count_documents({"a": 103}))
self.assertRaises(OperationFailure, db_w0.test.replace_one, {"y": 1},
{"x": 1}, bypass_document_validation=True)
@ -964,31 +966,31 @@ class TestCollection(IntegrationTest):
# Test update_one
self.assertRaises(OperationFailure, db.test.update_one,
{"z": 5}, {"$inc": {"z": -10}})
self.assertEqual(0, db.test.count({"z": -5}))
self.assertEqual(1, db.test.count({"z": 5}))
self.assertEqual(0, db.test.count_documents({"z": -5}))
self.assertEqual(1, db.test.count_documents({"z": 5}))
db.test.update_one({"z": 5}, {"$inc": {"z": -10}},
bypass_document_validation=True)
self.assertEqual(0, db.test.count({"z": 5}))
self.assertEqual(1, db.test.count({"z": -5}))
self.assertEqual(0, db.test.count_documents({"z": 5}))
self.assertEqual(1, db.test.count_documents({"z": -5}))
db.test.update_one({"z": -5}, {"$inc": {"z": 6}},
bypass_document_validation=False)
self.assertEqual(1, db.test.count({"z": 1}))
self.assertEqual(0, db.test.count({"z": -5}))
self.assertEqual(1, db.test.count_documents({"z": 1}))
self.assertEqual(0, db.test.count_documents({"z": -5}))
db.test.insert_one({"z": -10},
bypass_document_validation=True)
self.assertRaises(OperationFailure, db.test.update_one,
{"z": -10}, {"$inc": {"z": 1}})
self.assertEqual(0, db.test.count({"z": -9}))
self.assertEqual(1, db.test.count({"z": -10}))
self.assertEqual(0, db.test.count_documents({"z": -9}))
self.assertEqual(1, db.test.count_documents({"z": -10}))
db.test.update_one({"z": -10}, {"$inc": {"z": 1}},
bypass_document_validation=True)
self.assertEqual(1, db.test.count({"z": -9}))
self.assertEqual(0, db.test.count({"z": -10}))
self.assertEqual(1, db.test.count_documents({"z": -9}))
self.assertEqual(0, db.test.count_documents({"z": -10}))
db.test.update_one({"z": -9}, {"$inc": {"z": 9}},
bypass_document_validation=False)
self.assertEqual(0, db.test.count({"z": -9}))
self.assertEqual(1, db.test.count({"z": 0}))
self.assertEqual(0, db.test.count_documents({"z": -9}))
self.assertEqual(1, db.test.count_documents({"z": 0}))
self.assertRaises(OperationFailure, db_w0.test.update_one, {"y": 1},
{"$inc": {"x": 1}}, bypass_document_validation=True)
@ -999,32 +1001,32 @@ class TestCollection(IntegrationTest):
bypass_document_validation=True)
self.assertRaises(OperationFailure, db.test.update_many, {},
{"$inc": {"z": -100}})
self.assertEqual(100, db.test.count({"z": {"$gte": 0}}))
self.assertEqual(0, db.test.count({"z": {"$lt": 0}}))
self.assertEqual(0, db.test.count({"y": 0, "z": -100}))
self.assertEqual(100, db.test.count_documents({"z": {"$gte": 0}}))
self.assertEqual(0, db.test.count_documents({"z": {"$lt": 0}}))
self.assertEqual(0, db.test.count_documents({"y": 0, "z": -100}))
db.test.update_many({"z": {"$gte": 0}}, {"$inc": {"z": -100}},
bypass_document_validation=True)
self.assertEqual(0, db.test.count({"z": {"$gt": 0}}))
self.assertEqual(100, db.test.count({"z": {"$lte": 0}}))
self.assertEqual(0, db.test.count_documents({"z": {"$gt": 0}}))
self.assertEqual(100, db.test.count_documents({"z": {"$lte": 0}}))
db.test.update_many({"z": {"$gt": -50}}, {"$inc": {"z": 100}},
bypass_document_validation=False)
self.assertEqual(50, db.test.count({"z": {"$gt": 0}}))
self.assertEqual(50, db.test.count({"z": {"$lt": 0}}))
self.assertEqual(50, db.test.count_documents({"z": {"$gt": 0}}))
self.assertEqual(50, db.test.count_documents({"z": {"$lt": 0}}))
db.test.insert_many([{"z": -i} for i in range(50)],
bypass_document_validation=True)
self.assertRaises(OperationFailure, db.test.update_many,
{}, {"$inc": {"z": 1}})
self.assertEqual(100, db.test.count({"z": {"$lte": 0}}))
self.assertEqual(50, db.test.count({"z": {"$gt": 1}}))
self.assertEqual(100, db.test.count_documents({"z": {"$lte": 0}}))
self.assertEqual(50, db.test.count_documents({"z": {"$gt": 1}}))
db.test.update_many({"z": {"$gte": 0}}, {"$inc": {"z": -100}},
bypass_document_validation=True)
self.assertEqual(0, db.test.count({"z": {"$gt": 0}}))
self.assertEqual(150, db.test.count({"z": {"$lte": 0}}))
self.assertEqual(0, db.test.count_documents({"z": {"$gt": 0}}))
self.assertEqual(150, db.test.count_documents({"z": {"$lte": 0}}))
db.test.update_many({"z": {"$lte": 0}}, {"$inc": {"z": 100}},
bypass_document_validation=False)
self.assertEqual(150, db.test.count({"z": {"$gte": 0}}))
self.assertEqual(0, db.test.count({"z": {"$lt": 0}}))
self.assertEqual(150, db.test.count_documents({"z": {"$gte": 0}}))
self.assertEqual(0, db.test.count_documents({"z": {"$lt": 0}}))
self.assertRaises(OperationFailure, db_w0.test.update_many, {"y": 1},
{"$inc": {"x": 1}}, bypass_document_validation=True)
@ -1045,10 +1047,10 @@ class TestCollection(IntegrationTest):
ReplaceOne({"a": {"$lte": -10}}, {"a": -1})]
db.test.bulk_write(ops, bypass_document_validation=True)
self.assertEqual(3, db.test.count())
self.assertEqual(1, db.test.count({"a": -11}))
self.assertEqual(1, db.test.count({"a": -1}))
self.assertEqual(1, db.test.count({"a": -9}))
self.assertEqual(3, db.test.count_documents({}))
self.assertEqual(1, db.test.count_documents({"a": -11}))
self.assertEqual(1, db.test.count_documents({"a": -1}))
self.assertEqual(1, db.test.count_documents({"a": -9}))
# Assert that the operations would fail without bypass_doc_val
for op in ops:
@ -1070,7 +1072,7 @@ class TestCollection(IntegrationTest):
db.test.insert_one({"x": 1, "mike": "awesome",
"extra thing": "abcdefghijklmnopqrstuvwxyz"})
self.assertEqual(1, db.test.count())
self.assertEqual(1, db.test.count_documents({}))
doc = next(db.test.find({}))
self.assertTrue("x" in doc)
doc = next(db.test.find({}))
@ -1112,15 +1114,15 @@ class TestCollection(IntegrationTest):
db.test.insert_one({"x": "hello_mikey"})
db.test.insert_one({"x": "hello_test"})
self.assertEqual(db.test.find().count(), 4)
self.assertEqual(db.test.find({"x":
re.compile("^hello.*")}).count(), 4)
self.assertEqual(db.test.find({"x":
re.compile("ello")}).count(), 4)
self.assertEqual(db.test.find({"x":
re.compile("^hello$")}).count(), 0)
self.assertEqual(db.test.find({"x":
re.compile("^hello_mi.*$")}).count(), 2)
self.assertEqual(len(list(db.test.find())), 4)
self.assertEqual(len(list(db.test.find({"x":
re.compile("^hello.*")}))), 4)
self.assertEqual(len(list(db.test.find({"x":
re.compile("ello")}))), 4)
self.assertEqual(len(list(db.test.find({"x":
re.compile("^hello$")}))), 0)
self.assertEqual(len(list(db.test.find({"x":
re.compile("^hello_mi.*$")}))), 2)
def test_id_can_be_anything(self):
db = self.db
@ -1203,7 +1205,7 @@ class TestCollection(IntegrationTest):
db.test.insert_one({"x": 1})
self.assertIsNotNone(context.exception.details)
self.assertEqual(1, db.test.count())
self.assertEqual(1, db.test.count_documents({}))
def test_write_error_text_handling(self):
db = self.db
@ -1331,8 +1333,8 @@ class TestCollection(IntegrationTest):
self.assertTrue(result.modified_count in (None, 1))
self.assertIsNone(result.upserted_id)
self.assertTrue(result.acknowledged)
self.assertEqual(1, db.test.count({"y": 1}))
self.assertEqual(0, db.test.count({"x": 1}))
self.assertEqual(1, db.test.count_documents({"y": 1}))
self.assertEqual(0, db.test.count_documents({"x": 1}))
self.assertEqual(db.test.find_one(id1)["y"], 1)
replacement = RawBSONDocument(bson.BSON.encode({"_id": id1, "z": 1}))
@ -1342,8 +1344,8 @@ class TestCollection(IntegrationTest):
self.assertTrue(result.modified_count in (None, 1))
self.assertIsNone(result.upserted_id)
self.assertTrue(result.acknowledged)
self.assertEqual(1, db.test.count({"z": 1}))
self.assertEqual(0, db.test.count({"y": 1}))
self.assertEqual(1, db.test.count_documents({"z": 1}))
self.assertEqual(0, db.test.count_documents({"y": 1}))
self.assertEqual(db.test.find_one(id1)["z"], 1)
result = db.test.replace_one({"x": 2}, {"y": 2}, True)
@ -1352,7 +1354,7 @@ class TestCollection(IntegrationTest):
self.assertTrue(result.modified_count in (None, 0))
self.assertTrue(isinstance(result.upserted_id, ObjectId))
self.assertTrue(result.acknowledged)
self.assertEqual(1, db.test.count({"y": 2}))
self.assertEqual(1, db.test.count_documents({"y": 2}))
db = db.client.get_database(db.name,
write_concern=WriteConcern(w=0))
@ -1422,7 +1424,7 @@ class TestCollection(IntegrationTest):
self.assertTrue(result.modified_count in (None, 2))
self.assertIsNone(result.upserted_id)
self.assertTrue(result.acknowledged)
self.assertEqual(3, db.test.count({"y": 5}))
self.assertEqual(3, db.test.count_documents({"y": 5}))
result = db.test.update_many({"x": 5}, {"$set": {"y": 6}})
self.assertTrue(isinstance(result, UpdateResult))
@ -1430,7 +1432,7 @@ class TestCollection(IntegrationTest):
self.assertTrue(result.modified_count in (None, 1))
self.assertIsNone(result.upserted_id)
self.assertTrue(result.acknowledged)
self.assertEqual(1, db.test.count({"y": 6}))
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))
@ -1500,7 +1502,7 @@ class TestCollection(IntegrationTest):
db.create_collection("test", capped=True, size=1000)
db.test.insert_one({"x": 1})
self.assertEqual(1, db.test.count())
self.assertEqual(1, db.test.count_documents({}))
# Can't remove from capped collection.
self.assertRaises(OperationFailure, db.test.delete_one, {"x": 1})
@ -1515,6 +1517,7 @@ class TestCollection(IntegrationTest):
coll.insert_one({"x": 1})
self.db.command("getlasterror", w=1, wtimeout=1)
@ignore_deprecations
def test_count(self):
db = self.db
db.drop_collection("test")
@ -1724,7 +1727,7 @@ class TestCollection(IntegrationTest):
for i in range(10):
db.test.insert_one({"x": i})
self.assertEqual(10, db.test.count())
self.assertEqual(10, db.test.count_documents({}))
total = 0
for x in db.test.find({}, skip=4, limit=2):
@ -1744,18 +1747,18 @@ class TestCollection(IntegrationTest):
self.assertRaises(InvalidName, db.test.rename, "test.")
self.assertRaises(InvalidName, db.test.rename, "tes..t")
self.assertEqual(0, db.test.count())
self.assertEqual(0, db.foo.count())
self.assertEqual(0, db.test.count_documents({}))
self.assertEqual(0, db.foo.count_documents({}))
for i in range(10):
db.test.insert_one({"x": i})
self.assertEqual(10, db.test.count())
self.assertEqual(10, db.test.count_documents({}))
db.test.rename("foo")
self.assertEqual(0, db.test.count())
self.assertEqual(10, db.foo.count())
self.assertEqual(0, db.test.count_documents({}))
self.assertEqual(10, db.foo.count_documents({}))
x = 0
for doc in db.foo.find():
@ -1933,7 +1936,7 @@ class TestCollection(IntegrationTest):
self.db.test.insert_one({"bar": "foo"})
self.assertEqual(1,
self.db.test.find({"query": {"$ne": None}}).count())
self.db.test.count_documents({"query": {"$ne": None}}))
self.assertEqual(1,
len(list(self.db.test.find({"query": {"$ne": None}})))
)
@ -1953,7 +1956,7 @@ class TestCollection(IntegrationTest):
self.db.test.drop()
n_docs = 2100
self.db.test.insert_many([{} for _ in range(n_docs)])
self.assertEqual(n_docs, self.db.test.count())
self.assertEqual(n_docs, self.db.test.count_documents({}))
self.db.test.drop()
def test_map_reduce(self):

14
test/test_common.py
View File

@ -55,21 +55,21 @@ class TestCommon(IntegrationTest):
self.assertEqual(None, coll.find_one({'uu': uu}))
self.assertEqual(uu, coll.find_one({'uu': UUIDLegacy(uu)})['uu'])
# Test Cursor.count
self.assertEqual(0, coll.find({'uu': uu}).count())
# Test count_documents
self.assertEqual(0, coll.count_documents({'uu': uu}))
coll = self.db.get_collection(
"uuid", CodecOptions(uuid_representation=PYTHON_LEGACY))
self.assertEqual(1, coll.find({'uu': uu}).count())
self.assertEqual(1, coll.count_documents({'uu': uu}))
# Test delete
coll = self.db.get_collection(
"uuid", CodecOptions(uuid_representation=STANDARD))
coll.delete_one({'uu': uu})
self.assertEqual(1, coll.count())
self.assertEqual(1, coll.count_documents({}))
coll = self.db.get_collection(
"uuid", CodecOptions(uuid_representation=PYTHON_LEGACY))
coll.delete_one({'uu': uu})
self.assertEqual(0, coll.count())
self.assertEqual(0, coll.count_documents({}))
# Test update_one
coll.insert_one({'_id': uu, 'i': 1})
@ -133,7 +133,7 @@ class TestCommon(IntegrationTest):
self.assertEqual([], result)
result = coll.map_reduce(map, reduce, "results", query=q)
self.assertEqual(0, self.db.results.count())
self.assertEqual(0, self.db.results.count_documents({}))
coll = self.db.get_collection(
"uuid", CodecOptions(uuid_representation=PYTHON_LEGACY))
@ -142,7 +142,7 @@ class TestCommon(IntegrationTest):
self.assertEqual(2, len(result))
result = coll.map_reduce(map, reduce, "results", query=q)
self.assertEqual(2, self.db.results.count())
self.assertEqual(2, self.db.results.count_documents({}))
self.db.drop_collection("result")
coll.drop()

8
test/test_cursor.py
View File

@ -732,6 +732,7 @@ class TestCursor(IntegrationTest):
break
self.assertRaises(InvalidOperation, a.sort, "x", ASCENDING)
@ignore_deprecations
def test_count(self):
db = self.db
db.test.drop()
@ -756,6 +757,7 @@ class TestCursor(IntegrationTest):
self.assertEqual(0, db.test.acollectionthatdoesntexist.find().count())
@ignore_deprecations
def test_count_with_hint(self):
collection = self.db.test
collection.drop()
@ -785,6 +787,7 @@ class TestCursor(IntegrationTest):
self.assertEqual(2, collection.find().hint("x_1").count())
self.assertEqual(2, collection.find().hint([("x", 1)]).count())
@ignore_deprecations
def test_where(self):
db = self.db
db.test.drop()
@ -954,6 +957,7 @@ class TestCursor(IntegrationTest):
self.assertTrue(isinstance(cursor2._Cursor__hint, SON))
self.assertEqual(cursor._Cursor__hint, cursor2._Cursor__hint)
@ignore_deprecations
def test_count_with_fields(self):
self.db.test.drop()
self.db.test.insert_one({"x": 1})
@ -1045,6 +1049,7 @@ class TestCursor(IntegrationTest):
self.assertRaises(IndexError,
lambda x: self.db.test.find().skip(50)[x], 50)
@ignore_deprecations
def test_count_with_limit_and_skip(self):
self.assertRaises(TypeError, self.db.test.find().count, "foo")
@ -1122,7 +1127,7 @@ class TestCursor(IntegrationTest):
# and that the cursor doesn't think it's still alive.
self.assertFalse(cursor.alive)
self.assertEqual(3, db.test.count())
self.assertEqual(3, db.test.count_documents({}))
# __getitem__(index)
for cursor in (db.test.find(cursor_type=CursorType.TAILABLE),
@ -1213,6 +1218,7 @@ class TestCursor(IntegrationTest):
self.assertTrue(c1.alive)
@client_context.require_no_mongos
@ignore_deprecations
def test_comment(self):
if client_context.auth_enabled:
raise SkipTest("SERVER-4754 - This test uses profiling.")

14
test/test_database.py
View File

@ -644,7 +644,7 @@ class TestDatabase(IntegrationTest):
# Regular user should be able to query its own db, but
# no other.
users_db.authenticate('user', 'pass')
self.assertEqual(0, users_db.test.count())
self.assertEqual(0, users_db.test.count_documents({}))
self.assertRaises(OperationFailure, other_db.test.find_one)
# Admin read-only user should be able to query any db,
@ -661,7 +661,7 @@ class TestDatabase(IntegrationTest):
self.assertTrue(users_db.test.delete_many({}))
# And read from other dbs...
self.assertEqual(0, other_db.test.count())
self.assertEqual(0, other_db.test.count_documents({}))
# But still not write to other dbs.
self.assertRaises(OperationFailure,
@ -828,20 +828,20 @@ class TestDatabase(IntegrationTest):
db = self.client.pymongo_test
db.system.js.delete_many({})
self.assertEqual(0, db.system.js.count())
self.assertEqual(0, db.system.js.count_documents({}))
db.system_js.add = "function(a, b) { return a + b; }"
self.assertEqual('add', db.system.js.find_one()['_id'])
self.assertEqual(1, db.system.js.count())
self.assertEqual(1, db.system.js.count_documents({}))
self.assertEqual(6, db.system_js.add(1, 5))
del db.system_js.add
self.assertEqual(0, db.system.js.count())
self.assertEqual(0, db.system.js.count_documents({}))
db.system_js['add'] = "function(a, b) { return a + b; }"
self.assertEqual('add', db.system.js.find_one()['_id'])
self.assertEqual(1, db.system.js.count())
self.assertEqual(1, db.system.js.count_documents({}))
self.assertEqual(6, db.system_js['add'](1, 5))
del db.system_js['add']
self.assertEqual(0, db.system.js.count())
self.assertEqual(0, db.system.js.count_documents({}))
self.assertRaises(OperationFailure, db.system_js.add, 1, 5)
# TODO right now CodeWScope doesn't work w/ system js

14
test/test_examples.py
View File

@ -55,7 +55,7 @@ class TestSampleShellCommands(unittest.TestCase):
"size": {"h": 28, "w": 35.5, "uom": "cm"}})
# End Example 1
self.assertEqual(db.inventory.count(), 1)
self.assertEqual(db.inventory.count_documents({}), 1)
# Start Example 2
cursor = db.inventory.find({"item": "canvas"})
@ -79,7 +79,7 @@ class TestSampleShellCommands(unittest.TestCase):
"size": {"h": 19, "w": 22.85, "uom": "cm"}}])
# End Example 3
self.assertEqual(db.inventory.count(), 4)
self.assertEqual(db.inventory.count_documents({}), 4)
def test_query_top_level_fields(self):
db = client_context.client.pymongo_test
@ -107,7 +107,7 @@ class TestSampleShellCommands(unittest.TestCase):
"status": "A"}])
# End Example 6
self.assertEqual(db.inventory.count(), 5)
self.assertEqual(db.inventory.count_documents({}), 5)
# Start Example 7
cursor = db.inventory.find({})
@ -638,25 +638,25 @@ class TestSampleShellCommands(unittest.TestCase):
"status": "A"}])
# End Example 55
self.assertEqual(db.inventory.count(), 5)
self.assertEqual(db.inventory.count_documents({}), 5)
# Start Example 57
db.inventory.delete_many({"status": "A"})
# End Example 57
self.assertEqual(db.inventory.count(), 3)
self.assertEqual(db.inventory.count_documents({}), 3)
# Start Example 58
db.inventory.delete_one({"status": "D"})
# End Example 58
self.assertEqual(db.inventory.count(), 2)
self.assertEqual(db.inventory.count_documents({}), 2)
# Start Example 56
db.inventory.delete_many({})
# End Example 56
self.assertEqual(db.inventory.count(), 0)
self.assertEqual(db.inventory.count_documents({}), 0)
@client_context.require_version_min(3, 5, 11)
@client_context.require_replica_set

20
test/test_grid_file.py
View File

@ -82,8 +82,8 @@ class TestGridFile(IntegrationTest):
f = GridIn(self.db.fs, filename="test")
f.write(b"hello world")
f.close()
self.assertEqual(1, self.db.fs.files.find().count())
self.assertEqual(1, self.db.fs.chunks.find().count())
self.assertEqual(1, self.db.fs.files.count_documents({}))
self.assertEqual(1, self.db.fs.chunks.count_documents({}))
g = GridOut(self.db.fs, f._id)
self.assertEqual(b"hello world", g.read())
@ -94,8 +94,8 @@ class TestGridFile(IntegrationTest):
f = GridIn(self.db.fs, filename="test")
f.close()
self.assertEqual(2, self.db.fs.files.find().count())
self.assertEqual(1, self.db.fs.chunks.find().count())
self.assertEqual(2, self.db.fs.files.count_documents({}))
self.assertEqual(1, self.db.fs.chunks.count_documents({}))
g = GridOut(self.db.fs, f._id)
self.assertEqual(b"", g.read())
@ -117,8 +117,8 @@ class TestGridFile(IntegrationTest):
f.write(b"hello world")
f.close()
self.assertEqual(1, self.db.alt.files.find().count())
self.assertEqual(1, self.db.alt.chunks.find().count())
self.assertEqual(1, self.db.alt.files.count_documents({}))
self.assertEqual(1, self.db.alt.chunks.count_documents({}))
g = GridOut(self.db.alt, f._id)
self.assertEqual(b"hello world", g.read())
@ -326,8 +326,8 @@ class TestGridFile(IntegrationTest):
f.write(random_string)
f.close()
self.assertEqual(1, self.db.fs.files.find().count())
self.assertEqual(2, self.db.fs.chunks.find().count())
self.assertEqual(1, self.db.fs.files.count_documents({}))
self.assertEqual(2, self.db.fs.chunks.count_documents({}))
g = GridOut(self.db.fs, f._id)
self.assertEqual(random_string, g.read())
@ -344,8 +344,8 @@ class TestGridFile(IntegrationTest):
self.files += 1
self.chunks += len(data)
self.assertEqual(self.files, self.db.fs.files.find().count())
self.assertEqual(self.chunks, self.db.fs.chunks.find().count())
self.assertEqual(self.files, self.db.fs.files.count_documents({}))
self.assertEqual(self.chunks, self.db.fs.chunks.count_documents({}))
g = GridOut(self.db.fs, f._id)
self.assertEqual(data, g.read())

44
test/test_gridfs.py
View File

@ -36,11 +36,12 @@ from test.test_replica_set_client import TestReplicaSetClientBase
from test import (client_context,
unittest,
IntegrationTest)
from test.utils import (joinall,
single_client,
from test.utils import (ignore_deprecations,
joinall,
one,
rs_client,
rs_or_single_client)
rs_or_single_client,
single_client)
class JustWrite(threading.Thread):
@ -103,13 +104,13 @@ class TestGridfs(IntegrationTest):
def test_basic(self):
oid = self.fs.put(b"hello world")
self.assertEqual(b"hello world", self.fs.get(oid).read())
self.assertEqual(1, self.db.fs.files.count())
self.assertEqual(1, self.db.fs.chunks.count())
self.assertEqual(1, self.db.fs.files.count_documents({}))
self.assertEqual(1, self.db.fs.chunks.count_documents({}))
self.fs.delete(oid)
self.assertRaises(NoFile, self.fs.get, oid)
self.assertEqual(0, self.db.fs.files.count())
self.assertEqual(0, self.db.fs.chunks.count())
self.assertEqual(0, self.db.fs.files.count_documents({}))
self.assertEqual(0, self.db.fs.chunks.count_documents({}))
self.assertRaises(NoFile, self.fs.get, "foo")
oid = self.fs.put(b"hello world", _id="foo")
@ -118,15 +119,15 @@ class TestGridfs(IntegrationTest):
def test_multi_chunk_delete(self):
self.db.fs.drop()
self.assertEqual(0, self.db.fs.files.count())
self.assertEqual(0, self.db.fs.chunks.count())
self.assertEqual(0, self.db.fs.files.count_documents({}))
self.assertEqual(0, self.db.fs.chunks.count_documents({}))
gfs = gridfs.GridFS(self.db)
oid = gfs.put(b"hello", chunkSize=1)
self.assertEqual(1, self.db.fs.files.count())
self.assertEqual(5, self.db.fs.chunks.count())
self.assertEqual(1, self.db.fs.files.count_documents({}))
self.assertEqual(5, self.db.fs.chunks.count_documents({}))
gfs.delete(oid)
self.assertEqual(0, self.db.fs.files.count())
self.assertEqual(0, self.db.fs.chunks.count())
self.assertEqual(0, self.db.fs.files.count_documents({}))
self.assertEqual(0, self.db.fs.chunks.count_documents({}))
def test_list(self):
self.assertEqual([], self.fs.list())
@ -148,8 +149,8 @@ class TestGridfs(IntegrationTest):
def test_empty_file(self):
oid = self.fs.put(b"")
self.assertEqual(b"", self.fs.get(oid).read())
self.assertEqual(1, self.db.fs.files.count())
self.assertEqual(0, self.db.fs.chunks.count())
self.assertEqual(1, self.db.fs.files.count_documents({}))
self.assertEqual(0, self.db.fs.chunks.count_documents({}))
raw = self.db.fs.files.find_one()
self.assertEqual(0, raw["length"])
@ -190,13 +191,13 @@ class TestGridfs(IntegrationTest):
def test_alt_collection(self):
oid = self.alt.put(b"hello world")
self.assertEqual(b"hello world", self.alt.get(oid).read())
self.assertEqual(1, self.db.alt.files.count())
self.assertEqual(1, self.db.alt.chunks.count())
self.assertEqual(1, self.db.alt.files.count_documents({}))
self.assertEqual(1, self.db.alt.chunks.count_documents({}))
self.alt.delete(oid)
self.assertRaises(NoFile, self.alt.get, oid)
self.assertEqual(0, self.db.alt.files.count())
self.assertEqual(0, self.db.alt.chunks.count())
self.assertEqual(0, self.db.alt.files.count_documents({}))
self.assertEqual(0, self.db.alt.chunks.count_documents({}))
self.assertRaises(NoFile, self.alt.get, "foo")
oid = self.alt.put(b"hello world", _id="foo")
@ -240,7 +241,7 @@ class TestGridfs(IntegrationTest):
# Should have created 100 versions of 'test' file
self.assertEqual(
100,
self.db.fs.files.find({'filename': 'test'}).count()
self.db.fs.files.count_documents({'filename': 'test'})
)
def test_get_last_version(self):
@ -328,7 +329,7 @@ class TestGridfs(IntegrationTest):
def test_put_filelike(self):
oid = self.fs.put(StringIO(b"hello world"), chunk_size=1)
self.assertEqual(11, self.db.fs.chunks.count())
self.assertEqual(11, self.db.fs.chunks.count_documents({}))
self.assertEqual(b"hello world", self.fs.get(oid).read())
def test_file_exists(self):
@ -404,6 +405,7 @@ class TestGridfs(IntegrationTest):
f = fs.new_file()
self.assertRaises(ServerSelectionTimeoutError, f.close)
@ignore_deprecations
def test_gridfs_find(self):
self.fs.put(b"test2", filename="two")
time.sleep(0.01)

56
test/test_gridfs_bucket.py
View File

@ -35,11 +35,12 @@ from test import (client_context,
unittest,
IntegrationTest)
from test.test_replica_set_client import TestReplicaSetClientBase
from test.utils import (joinall,
single_client,
from test.utils import (ignore_deprecations,
joinall,
one,
rs_client,
rs_or_single_client)
rs_or_single_client,
single_client)
class JustWrite(threading.Thread):
@ -94,34 +95,34 @@ class TestGridfs(IntegrationTest):
b"hello world")
self.assertEqual(b"hello world",
self.fs.open_download_stream(oid).read())
self.assertEqual(1, self.db.fs.files.count())
self.assertEqual(1, self.db.fs.chunks.count())
self.assertEqual(1, self.db.fs.files.count_documents({}))
self.assertEqual(1, self.db.fs.chunks.count_documents({}))
self.fs.delete(oid)
self.assertRaises(NoFile, self.fs.open_download_stream, oid)
self.assertEqual(0, self.db.fs.files.count())
self.assertEqual(0, self.db.fs.chunks.count())
self.assertEqual(0, self.db.fs.files.count_documents({}))
self.assertEqual(0, self.db.fs.chunks.count_documents({}))
def test_multi_chunk_delete(self):
self.db.fs.drop()
self.assertEqual(0, self.db.fs.files.count())
self.assertEqual(0, self.db.fs.chunks.count())
self.assertEqual(0, self.db.fs.files.count_documents({}))
self.assertEqual(0, self.db.fs.chunks.count_documents({}))
gfs = gridfs.GridFSBucket(self.db)
oid = gfs.upload_from_stream("test_filename",
b"hello",
chunk_size_bytes=1)
self.assertEqual(1, self.db.fs.files.count())
self.assertEqual(5, self.db.fs.chunks.count())
self.assertEqual(1, self.db.fs.files.count_documents({}))
self.assertEqual(5, self.db.fs.chunks.count_documents({}))
gfs.delete(oid)
self.assertEqual(0, self.db.fs.files.count())
self.assertEqual(0, self.db.fs.chunks.count())
self.assertEqual(0, self.db.fs.files.count_documents({}))
self.assertEqual(0, self.db.fs.chunks.count_documents({}))
def test_empty_file(self):
oid = self.fs.upload_from_stream("test_filename",
b"")
self.assertEqual(b"", self.fs.open_download_stream(oid).read())
self.assertEqual(1, self.db.fs.files.count())
self.assertEqual(0, self.db.fs.chunks.count())
self.assertEqual(1, self.db.fs.files.count_documents({}))
self.assertEqual(0, self.db.fs.chunks.count_documents({}))
raw = self.db.fs.files.find_one()
self.assertEqual(0, raw["length"])
@ -165,13 +166,13 @@ class TestGridfs(IntegrationTest):
b"hello world")
self.assertEqual(b"hello world",
self.alt.open_download_stream(oid).read())
self.assertEqual(1, self.db.alt.files.count())
self.assertEqual(1, self.db.alt.chunks.count())
self.assertEqual(1, self.db.alt.files.count_documents({}))
self.assertEqual(1, self.db.alt.chunks.count_documents({}))
self.alt.delete(oid)
self.assertRaises(NoFile, self.alt.open_download_stream, oid)
self.assertEqual(0, self.db.alt.files.count())
self.assertEqual(0, self.db.alt.chunks.count())
self.assertEqual(0, self.db.alt.files.count_documents({}))
self.assertEqual(0, self.db.alt.chunks.count_documents({}))
self.assertRaises(NoFile, self.alt.open_download_stream, "foo")
self.alt.upload_from_stream("foo",
@ -217,7 +218,7 @@ class TestGridfs(IntegrationTest):
# Should have created 100 versions of 'test' file
self.assertEqual(
100,
self.db.fs.files.find({'filename': 'test'}).count()
self.db.fs.files.count_documents({'filename': 'test'})
)
def test_get_last_version(self):
@ -273,7 +274,7 @@ class TestGridfs(IntegrationTest):
oid = self.fs.upload_from_stream("test_file",
StringIO(b"hello world"),
chunk_size_bytes=1)
self.assertEqual(11, self.db.fs.chunks.count())
self.assertEqual(11, self.db.fs.chunks.count_documents({}))
self.assertEqual(b"hello world",
self.fs.open_download_stream(oid).read())
@ -328,6 +329,7 @@ class TestGridfs(IntegrationTest):
ServerSelectionTimeoutError,
gfs.upload_from_stream, "test", b"") # Still no connection.
@ignore_deprecations
def test_gridfs_find(self):
self.fs.upload_from_stream("two", b"test2")
time.sleep(0.01)
@ -384,19 +386,19 @@ class TestGridfs(IntegrationTest):
gin.write(b"test1")
gin.write(b"test2")
gin.write(b"test3")
self.assertEqual(3, self.db.fs.chunks.count(
self.assertEqual(3, self.db.fs.chunks.count_documents(
{"files_id": gin._id}))
gin.abort()
self.assertTrue(gin.closed)
self.assertRaises(ValueError, gin.write, b"test4")
self.assertEqual(0, self.db.fs.chunks.count(
self.assertEqual(0, self.db.fs.chunks.count_documents(
{"files_id": gin._id}))
def test_download_to_stream(self):
file1 = StringIO(b"hello world")
# Test with one chunk.
oid = self.fs.upload_from_stream("one_chunk", file1)
self.assertEqual(1, self.db.fs.chunks.count())
self.assertEqual(1, self.db.fs.chunks.count_documents({}))
file2 = StringIO()
self.fs.download_to_stream(oid, file2)
file1.seek(0)
@ -410,7 +412,7 @@ class TestGridfs(IntegrationTest):
oid = self.fs.upload_from_stream("many_chunks",
file1,
chunk_size_bytes=1)
self.assertEqual(11, self.db.fs.chunks.count())
self.assertEqual(11, self.db.fs.chunks.count_documents({}))
file2 = StringIO()
self.fs.download_to_stream(oid, file2)
file1.seek(0)
@ -421,7 +423,7 @@ class TestGridfs(IntegrationTest):
file1 = StringIO(b"hello world")
# Test with one chunk.
oid = self.fs.upload_from_stream("one_chunk", file1)
self.assertEqual(1, self.db.fs.chunks.count())
self.assertEqual(1, self.db.fs.chunks.count_documents({}))
file2 = StringIO()
self.fs.download_to_stream_by_name("one_chunk", file2)
file1.seek(0)
@ -433,7 +435,7 @@ class TestGridfs(IntegrationTest):
self.db.drop_collection("fs.chunks")
file1.seek(0)
self.fs.upload_from_stream("many_chunks", file1, chunk_size_bytes=1)
self.assertEqual(11, self.db.fs.chunks.count())
self.assertEqual(11, self.db.fs.chunks.count_documents({}))
file2 = StringIO()
self.fs.download_to_stream_by_name("many_chunks", file2)

4
test/test_monitoring.py
View File

@ -782,7 +782,7 @@ class TestCommandMonitoring(PyMongoTestCase):
self.assertEqual(1, reply.get('ok'))
self.assertEqual(1, reply.get('n'))
self.assertEqual(0, coll.count())
self.assertEqual(0, coll.count_documents({}))
# write errors
coll.insert_one({'_id': 1})
@ -1042,7 +1042,7 @@ class TestCommandMonitoring(PyMongoTestCase):
self.assertEqual(1, reply.get('ok'))
self.assertEqual(1, reply.get('n'))
self.assertEqual(0, coll.count())
self.assertEqual(0, coll.count_documents({}))
def test_insert_many(self):
# This always uses the bulk API.

14
test/test_read_preferences.py
View File

@ -37,13 +37,18 @@ from pymongo.server_selectors import readable_server_selector, Selection
from pymongo.server_type import SERVER_TYPE
from pymongo.write_concern import WriteConcern
from test.test_replica_set_client import TestReplicaSetClientBase
from test import (SkipTest,
client_context,
unittest,
db_user,
db_pwd)
from test.utils import connected, single_client, one, wait_until, rs_client
from test.test_replica_set_client import TestReplicaSetClientBase
from test.utils import (connected,
ignore_deprecations,
one,
rs_client,
single_client,
wait_until)
from test.version import Version
@ -156,10 +161,10 @@ class TestSingleSlaveOk(TestReadPreferencesBase):
# Test some database helpers.
self.assertIsNotNone(db.collection_names())
self.assertIsNotNone(db.validate_collection("test"))
self.assertIsNotNone(db.command("count", "test"))
self.assertIsNotNone(db.command("ping"))
# Test some collection helpers.
self.assertEqual(10, coll.count())
self.assertEqual(10, coll.count_documents({}))
self.assertEqual(10, len(coll.distinct("_id")))
self.assertIsNotNone(coll.aggregate([]))
self.assertIsNotNone(coll.index_information())
@ -433,6 +438,7 @@ class TestCommandAndReadPreference(TestReplicaSetClientBase):
'inline_map_reduce',
'function() { }', 'function() { }')
@ignore_deprecations
def test_count(self):
self._test_coll_helper(True, self.c.pymongo_test.test, 'count')

8
test/test_session.py
View File

@ -307,6 +307,7 @@ class TestSession(IntegrationTest):
(coll.distinct, ['a'], {}),
(coll.find_one, [], {}),
(coll.count, [], {}),
(coll.count_documents, [{}], {}),
(coll.create_indexes, [[IndexModel('a')]], {}),
(coll.create_index, ['a'], {}),
(coll.drop_index, ['a_1'], {}),
@ -759,6 +760,8 @@ class TestCausalConsistency(unittest.TestCase):
lambda coll, session: coll.find_one({}, session=session))
self._test_reads(
lambda coll, session: coll.count(session=session))
self._test_reads(
lambda coll, session: coll.count_documents({}, session=session))
self._test_reads(
lambda coll, session: coll.distinct('foo', session=session))
self._test_reads(
@ -785,6 +788,11 @@ class TestCausalConsistency(unittest.TestCase):
self._test_reads,
lambda coll, session: list(
coll.find_raw_batches({}, session=session)))
self.assertRaises(
ConfigurationError,
self._test_reads,
lambda coll, session: coll.estimated_document_count(
session=session))
def _test_writes(self, op):
coll = self.client.pymongo_test.test