From e6b0f3847d4135a46880592e033cf30e58ea5b24 Mon Sep 17 00:00:00 2001 From: Bernie Hackett Date: Mon, 18 Jun 2018 10:50:26 -0700 Subject: [PATCH] PYTHON-1581 - Deprecate Collection/Cursor count --- pymongo/collection.py | 5 + pymongo/cursor.py | 2 + test/atlas/test_connection.py | 2 +- test/test_auth.py | 2 +- test/test_binary.py | 16 ++-- test/test_bulk.py | 10 +- test/test_client.py | 14 +-- test/test_collation.py | 8 +- test/test_collection.py | 175 +++++++++++++++++----------------- test/test_common.py | 14 +-- test/test_cursor.py | 8 +- test/test_database.py | 14 +-- test/test_examples.py | 14 +-- test/test_grid_file.py | 20 ++-- test/test_gridfs.py | 44 +++++---- test/test_gridfs_bucket.py | 56 +++++------ test/test_monitoring.py | 4 +- test/test_read_preferences.py | 14 ++- test/test_session.py | 8 ++ 19 files changed, 234 insertions(+), 196 deletions(-) diff --git a/pymongo/collection.py b/pymongo/collection.py index 8b00881d3..1d68dda94 100644 --- a/pymongo/collection.py +++ b/pymongo/collection.py @@ -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: diff --git a/pymongo/cursor.py b/pymongo/cursor.py index 49d9de0ba..298e4e6f5 100644 --- a/pymongo/cursor.py +++ b/pymongo/cursor.py @@ -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)]) diff --git a/test/atlas/test_connection.py b/test/atlas/test_connection.py index 6f303520e..667660abd 100644 --- a/test/atlas/test_connection.py +++ b/test/atlas/test_connection.py @@ -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): diff --git a/test/test_auth.py b/test/test_auth.py index a9c69f371..f6c1a3f5b 100644 --- a/test/test_auth.py +++ b/test/test_auth.py @@ -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}) diff --git a/test/test_binary.py b/test/test_binary.py index e984881ee..7df3f5c68 100644 --- a/test/test_binary.py +++ b/test/test_binary.py @@ -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() diff --git a/test/test_bulk.py b/test/test_bulk.py index 75bd3aabe..dd62e7fea 100644 --- a/test/test_bulk.py +++ b/test/test_bulk.py @@ -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(): diff --git a/test/test_client.py b/test/test_client.py index 78c37247a..4a0dcb217 100644 --- a/test/test_client.py +++ b/test/test_client.py @@ -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) diff --git a/test/test_collation.py b/test/test_collation.py index 8366174c6..25158856c 100644 --- a/test/test_collation.py +++ b/test/test_collation.py @@ -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() diff --git a/test/test_collection.py b/test/test_collection.py index 5a77e5295..3f8d9b7d1 100644 --- a/test/test_collection.py +++ b/test/test_collection.py @@ -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): diff --git a/test/test_common.py b/test/test_common.py index 663afffac..5175dd8bf 100644 --- a/test/test_common.py +++ b/test/test_common.py @@ -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() diff --git a/test/test_cursor.py b/test/test_cursor.py index 04a174cb1..1a8fcff8b 100644 --- a/test/test_cursor.py +++ b/test/test_cursor.py @@ -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.") diff --git a/test/test_database.py b/test/test_database.py index cb297eb7f..ad862ca15 100644 --- a/test/test_database.py +++ b/test/test_database.py @@ -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 diff --git a/test/test_examples.py b/test/test_examples.py index 6d3999632..e83b68af8 100644 --- a/test/test_examples.py +++ b/test/test_examples.py @@ -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 diff --git a/test/test_grid_file.py b/test/test_grid_file.py index 2b49d3a25..8bd674e6a 100644 --- a/test/test_grid_file.py +++ b/test/test_grid_file.py @@ -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()) diff --git a/test/test_gridfs.py b/test/test_gridfs.py index 2a6a3c0ab..53d74f838 100644 --- a/test/test_gridfs.py +++ b/test/test_gridfs.py @@ -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) diff --git a/test/test_gridfs_bucket.py b/test/test_gridfs_bucket.py index e1505077f..2af334db3 100644 --- a/test/test_gridfs_bucket.py +++ b/test/test_gridfs_bucket.py @@ -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) diff --git a/test/test_monitoring.py b/test/test_monitoring.py index 40a611a92..a9bcda0ff 100644 --- a/test/test_monitoring.py +++ b/test/test_monitoring.py @@ -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. diff --git a/test/test_read_preferences.py b/test/test_read_preferences.py index da8b0259d..871fa7423 100644 --- a/test/test_read_preferences.py +++ b/test/test_read_preferences.py @@ -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') diff --git a/test/test_session.py b/test/test_session.py index 58cf72a78..4e02586b3 100644 --- a/test/test_session.py +++ b/test/test_session.py @@ -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