internally switch from ensure_index to create_index

ming/metadata.py

@@ -221,7 +221,7 @@ class _ClassManager(metaclass=_CurriedProxyClass):
     _proxy_args=('cls',)
     _proxy_methods = (
         'get', 'find', 'find_by', 'remove', 'count', 'update_partial',
-        'group', 'ensure_index', 'ensure_indexes', 'index_information',  'drop_indexes',
+        'group', 'create_index', 'ensure_index', 'ensure_indexes', 'index_information',  'drop_indexes',
         'find_one_and_update', 'find_one_and_replace', 'find_one_and_delete',
         'aggregate', 'distinct',
         )
@@ -359,7 +359,7 @@ def _ensure_indexes(self):
         try:
             with self._lock:
                 for idx in self.manager.indexes:
-                    collection.ensure_index(idx.index_spec, background=True,
+                    collection.create_index(idx.index_spec, background=True,
                                             **idx.index_options)
         except (MongoGone, ConnectionFailure) as e:
             if e.args[0] == 'not master':

ming/mim.py

@@ -567,7 +567,7 @@ def delete_many(self, filter, session=None):
     def list_indexes(self, session=None):
         return Cursor(self, lambda: self._indexes.values())
 
-    def ensure_index(self, key_or_list, unique=False, cache_for=300,
+    def create_index(self, key_or_list, unique=False, cache_for=300,
                      name=None, **kwargs):
         if isinstance(key_or_list, list):
             keys = tuple(tuple(k) for k in key_or_list)
@@ -590,9 +590,6 @@ def ensure_index(self, key_or_list, unique=False, cache_for=300,
 
         return index_name
 
-    def create_index(self, keys, **kwargs):
-        return self.ensure_index(keys, **kwargs)
-
     def index_information(self):
         return {
             index_name: fields

ming/session.py

@@ -107,13 +107,16 @@ def find_by(self, cls, **kwargs):
     def count(self, cls):
         return self._impl(cls).count()
 
-    def ensure_index(self, cls, fields, **kwargs):
+    def create_index(self, cls, fields, **kwargs):
         index_fields = fixup_index(fields)
-        return self._impl(cls).ensure_index(index_fields, **kwargs), fields
+        return self._impl(cls).create_index(index_fields, **kwargs)
+
+    def ensure_index(self, cls, fields, **kwargs):
+        return self.create_index(cls, fields, **kwargs)
 
     def ensure_indexes(self, cls):
         for idx in cls.m.indexes:
-            self.ensure_index(cls, idx.index_spec, background=True, **idx.index_options)
+            self.create_index(cls, idx.index_spec, background=True, **idx.index_options)
 
     def aggregate(self, cls, *args, **kwargs):
         return self._impl(cls).aggregate(*args, **kwargs)

ming/tests/test_declarative.py

@@ -160,11 +160,11 @@ class __mongometa__:
         self.MyDoc = MyDoc
 
     def test_ensure_indexes(self):
-        # make sure the manager constructor calls ensure_index with the right stuff
+        # make sure the manager constructor calls create_index with the right stuff
         self.MyDoc.m
         collection = self.MockSession.db[self.MyDoc.m.collection_name]
-        ensure_index = collection.ensure_index
-        args = ensure_index.call_args_list
+        create_index = collection.create_index
+        args = create_index.call_args_list
         for a in args:
             print(a)
         indexes = [
@@ -182,8 +182,8 @@ def test_ensure_indexes(self):
     def test_ensure_indexes_custom_options(self):
         self.MyDoc.m
         collection = self.MockSession.db[self.MyDoc.m.collection_name]
-        ensure_index = collection.ensure_index
-        args = ensure_index.call_args_list
+        create_index = collection.create_index
+        args = create_index.call_args_list
 
         custom_named_index = None
         for index in self.MyDoc.m.indexes:
@@ -200,29 +200,29 @@ def test_ensure_indexes_custom_options(self):
     def test_ensure_indexes_slave(self):
         # on a slave, an error will be thrown, but it should be swallowed
         collection = self.MockSession.db[self.MyDoc.__mongometa__.name]
-        ensure_index = collection.ensure_index
-        ensure_index.side_effect = AutoReconnect('not master')
+        create_index = collection.create_index
+        create_index.side_effect = AutoReconnect('not master')
         self.MyDoc.m
-        assert ensure_index.called
+        assert create_index.called
 
         # don't keep trying after it failed once
         self.MyDoc.m
-        assert ensure_index.call_count == 1, ensure_index.call_args_list
+        assert create_index.call_count == 1, create_index.call_args_list
 
     def test_auto_ensure_indexes_option(self):
-        ensure_index = self.MockSession.db[self.MyDoc.__mongometa__.name].ensure_index
+        create_index = self.MockSession.db[self.MyDoc.__mongometa__.name].create_index
         self.MockSession.bind.bind._auto_ensure_indexes = False
         self.MyDoc.m
-        assert not ensure_index.called
+        assert not create_index.called
 
     def test_ensure_indexes_other_error(self):
         # same as above, but no swallowing
         collection = self.MockSession.db[self.MyDoc.__mongometa__.name]
-        ensure_index = collection.ensure_index
-        ensure_index.side_effect = AutoReconnect('blah blah')
+        create_index = collection.create_index
+        create_index.side_effect = AutoReconnect('blah blah')
 
         self.assertRaises(AutoReconnect, lambda: self.MyDoc.m)
-        assert ensure_index.called
+        assert create_index.called
 
     def test_index_inheritance_child_none(self):
         class MyChild(self.MyDoc):

ming/tests/test_functional.py

@@ -100,14 +100,14 @@ def setUp(self):
             Index('test2'),
             Index('test1', 'test2', direction=pymongo.DESCENDING))
 
-    @mock.patch('ming.session.Session.ensure_index')
-    def test_ensure_indexes(self, ensure_index):
-        # make sure the manager constructor calls ensure_index with the right
+    @mock.patch('ming.session.Session.create_index')
+    def test_ensure_indexes(self, create_index):
+        # make sure the manager constructor calls create_index with the right
         # stuff
         self.MyDoc.m
         collection = self.MockSession.db[self.MyDoc.m.collection_name]
-        ensure_index = collection.ensure_index
-        args = ensure_index.call_args_list
+        create_index = collection.create_index
+        args = create_index.call_args_list
         indexes = [
             ( ([ ('test1', pymongo.DESCENDING), ('test2', pymongo.DESCENDING) ],),
               dict(unique=False, sparse=False, background=True) ),
@@ -117,13 +117,13 @@ def test_ensure_indexes(self, ensure_index):
             self.assertTrue(i in args, args)
 
 
-    @mock.patch('ming.session.Session.ensure_index')
-    def test_ensure_indexes_slave(self, ensure_index):
+    @mock.patch('ming.session.Session.create_index')
+    def test_ensure_indexes_slave(self, create_index):
         # on a slave, an error will be thrown, but it should be swallowed
         self.MyDoc.m
         collection = self.MockSession.db[self.MyDoc.m.collection_name]
-        ensure_index = collection.ensure_index
-        assert ensure_index.called
+        create_index = collection.create_index
+        assert create_index.called
 
     def test_index_inheritance_child_none(self):
         MyChild = collection(self.MyDoc, collection_name='my_child')

ming/tests/test_gridfs.py

@@ -98,6 +98,6 @@ def test_get_version(self):
             'jumped over the lazy dog')
 
     def test_custom_index(self):
-        self.ds.db[f'{self.fs_coll}.files'].ensure_index('custom_fld')
+        self.ds.db[f'{self.fs_coll}.files'].create_index('custom_fld')
         with self.TestFS.m.new_file('test.txt') as fp:
             fp.write('The quick brown fox')

ming/tests/test_mim.py

@@ -371,7 +371,7 @@ def test_upsert_simple(self):
 
     def test_upsert_duplicated(self):
         test = self.bind.db.test
-        test.ensure_index([('a', 1)], unique=True)
+        test.create_index([('a', 1)], unique=True)
 
         # Try with any index
         test.update_many({'x': 'NOT_FOUND1'}, {'$set': {'a': 0}}, upsert=True)
@@ -604,7 +604,7 @@ def test_find_one_and_delete_returns_projection(self):
         self.assertEqual(0, self.bind.db.col.estimated_document_count())
 
     def test_hint_simple(self):
-        self.bind.db.coll.ensure_index([('myindex', 1)])
+        self.bind.db.coll.create_index([('myindex', 1)])
 
         cursor = self.bind.db.coll.find().hint([('$natural', 1)])
         self.assertEqual(type(cursor), type(self.bind.db.coll.find()))
@@ -621,7 +621,7 @@ def test_hint_invalid(self):
         self.assertRaises(TypeError, self.bind.db.coll.find().hint, 123)
 
     def test_index_information(self):
-        self.bind.db.coll.ensure_index([('myfield', 1)],
+        self.bind.db.coll.create_index([('myfield', 1)],
                                        background=True,
                                        expireAfterSeconds=42,
                                        unique=True)
@@ -634,23 +634,23 @@ def test_index_information(self):
     def test_unique_index_subdocument(self):
         coll = self.bind.db.coll
 
-        coll.ensure_index([('x.y', 1)], unique=True)
+        coll.create_index([('x.y', 1)], unique=True)
         coll.insert_one({'x': {'y': 1}})
         coll.insert_one({'x': {'y': 2}})
         self.assertRaises(DuplicateKeyError, coll.insert_one, {'x': {'y': 2}})
 
     def test_unique_index_whole_sdoc(self):
         coll = self.bind.db.coll
 
-        coll.ensure_index([('x', 1)], unique=True)
+        coll.create_index([('x', 1)], unique=True)
         coll.insert_one({'x': {'y': 1}})
         coll.insert_one({'x': {'y': 2}})
         self.assertRaises(DuplicateKeyError, coll.insert_one, {'x': {'y': 2}})
 
     def test_unique_sparse_index_subdocument(self):
         coll = self.bind.db.coll
 
-        coll.ensure_index([('x.y', 1)], unique=True, sparse=True)
+        coll.create_index([('x.y', 1)], unique=True, sparse=True)
         coll.insert_one({'x': {'y': 1}})
 
         # no duplicate key error on these:
@@ -664,7 +664,7 @@ def test_unique_sparse_index_subdocument(self):
     def test_unique_sparse_index_whole_sdoc(self):
         coll = self.bind.db.coll
 
-        coll.ensure_index([('x', 1)], unique=True, sparse=True)
+        coll.create_index([('x', 1)], unique=True, sparse=True)
         coll.insert_one({'x': {'y': 1}})
         # no duplicate key error on these:
         coll.insert_one({'x': None})

ming/tests/test_session.py

@@ -105,12 +105,12 @@ def test_base_session(self):
         sess.ensure_index(self.TestDoc, 'a')
         impl.find.assert_called_with(dict(a=5))
         impl.count.assert_called_with()
-        impl.ensure_index.assert_called_with([ ('a', pymongo.ASCENDING) ])
-        impl.ensure_index.reset_mock()
+        impl.create_index.assert_called_with([ ('a', pymongo.ASCENDING) ])
+        impl.create_index.reset_mock()
 
         sess.ensure_indexes(self.TestDoc)
         self.assertEqual(
-            impl.ensure_index.call_args_list, [
+            impl.create_index.call_args_list, [
                 (
                     ([ ('b', pymongo.ASCENDING), ('c', pymongo.ASCENDING) ],),
                     {'unique':False, 'sparse':False, 'background': True} ),