fix connecting to MongoReplicaSetClient

CONTRIBUTING.rst

@@ -20,7 +20,7 @@ post to the `user group <http://groups.google.com/group/mongoengine-users>`
 Supported Interpreters
 ----------------------
 
-MongoEngine supports CPython 2.7 and newer. Language
+MongoEngine supports CPython 2.6 and newer. Language
 features not supported by all interpreters can not be used.
 Please also ensure that your code is properly converted by
 `2to3 <http://docs.python.org/library/2to3.html>`_ for Python 3 support.

docs/changelog.rst

@@ -5,8 +5,6 @@ Changelog
 Development
 ===========
 - (Fill this out as you fix issues and develop you features).
-- Fixed connecting to a replica set with PyMongo 2.x #1436
-- Fixed an obscure error message when filtering by `field__in=non_iterable`. #1237
 
 Changes in 0.11.0
 =================

docs/guide/querying.rst

@@ -479,8 +479,6 @@ operators. To use a :class:`~mongoengine.queryset.Q` object, pass it in as the
 first positional argument to :attr:`Document.objects` when you filter it by
 calling it with keyword arguments::
 
-    from mongoengine.queryset.visitor import Q
-
     # Get published posts
     Post.objects(Q(published=True) | Q(publish_date__lte=datetime.now()))
 

mongoengine/base/datastructures.py

@@ -138,7 +138,10 @@ class BaseList(list):
         return super(BaseList, self).__setitem__(key, value)
 
     def __delitem__(self, key, *args, **kwargs):
-        self._mark_as_changed()
+        if isinstance(key, slice):
+            self._mark_as_changed()
+        else:
+            self._mark_as_changed(key)
         return super(BaseList, self).__delitem__(key)
 
     def __setslice__(self, *args, **kwargs):

mongoengine/base/document.py

@@ -675,9 +675,6 @@ class BaseDocument(object):
         if not only_fields:
             only_fields = []
 
-        if son and not isinstance(son, dict):
-            raise ValueError("The source SON object needs to be of type 'dict'")
-
         # Get the class name from the document, falling back to the given
         # class if unavailable
         class_name = son.get('_cls', cls._class_name)

mongoengine/common.py

@@ -34,10 +34,7 @@ def _import_class(cls_name):
     queryset_classes = ('OperationError',)
     deref_classes = ('DeReference',)
 
-    if cls_name == 'BaseDocument':
+    if cls_name in doc_classes:
-        from mongoengine.base import document as module
-        import_classes = ['BaseDocument']
-    elif cls_name in doc_classes:
         from mongoengine import document as module
         import_classes = doc_classes
     elif cls_name in field_classes:

mongoengine/connection.py

@@ -96,7 +96,7 @@ def register_connection(alias, name=None, host=None, port=None,
 
             uri_options = uri_dict['options']
             if 'replicaset' in uri_options:
-                conn_settings['replicaSet'] = uri_options['replicaset']
+                conn_settings['replicaSet'] = True
             if 'authsource' in uri_options:
                 conn_settings['authentication_source'] = uri_options['authsource']
             if 'authmechanism' in uri_options:

mongoengine/document.py

@@ -313,9 +313,6 @@ class Document(BaseDocument):
         .. versionchanged:: 0.10.7
             Add signal_kwargs argument
         """
-        if self._meta.get('abstract'):
-            raise InvalidDocumentError('Cannot save an abstract document.')
-
         signal_kwargs = signal_kwargs or {}
         signals.pre_save.send(self.__class__, document=self, **signal_kwargs)
 
@@ -831,6 +828,7 @@ class Document(BaseDocument):
         """ Lists all of the indexes that should be created for given
         collection. It includes all the indexes from super- and sub-classes.
         """
+
         if cls._meta.get('abstract'):
             return []
 

mongoengine/fields.py

@@ -28,7 +28,7 @@ from mongoengine.base import (BaseDocument, BaseField, ComplexBaseField,
                               GeoJsonBaseField, ObjectIdField, get_document)
 from mongoengine.connection import DEFAULT_CONNECTION_NAME, get_db
 from mongoengine.document import Document, EmbeddedDocument
-from mongoengine.errors import DoesNotExist, InvalidQueryError, ValidationError
+from mongoengine.errors import DoesNotExist, ValidationError
 from mongoengine.python_support import StringIO
 from mongoengine.queryset import DO_NOTHING, QuerySet
 
@@ -566,11 +566,7 @@ class EmbeddedDocumentField(BaseField):
 
     def prepare_query_value(self, op, value):
         if value is not None and not isinstance(value, self.document_type):
-            try:
+            value = self.document_type._from_son(value)
-                value = self.document_type._from_son(value)
-            except ValueError:
-                raise InvalidQueryError("Querying the embedded document '%s' failed, due to an invalid query value" %
-                                        (self.document_type._class_name,))
         super(EmbeddedDocumentField, self).prepare_query_value(op, value)
         return self.to_mongo(value)
 

mongoengine/queryset/base.py

@@ -900,24 +900,18 @@ class BaseQuerySet(object):
         return self.fields(**fields)
 
     def fields(self, _only_called=False, **kwargs):
-        """Manipulate how you load this document's fields. Used by `.only()`
+        """Manipulate how you load this document's fields.  Used by `.only()`
-        and `.exclude()` to manipulate which fields to retrieve. If called
+        and `.exclude()` to manipulate which fields to retrieve.  Fields also
-        directly, use a set of kwargs similar to the MongoDB projection
+        allows for a greater level of control for example:
-        document. For example:
 
-        Include only a subset of fields:
+        Retrieving a Subrange of Array Elements:
 
-            posts = BlogPost.objects(...).fields(author=1, title=1)
+        You can use the $slice operator to retrieve a subrange of elements in
+        an array. For example to get the first 5 comments::
 
-        Exclude a specific field:
+            post = BlogPost.objects(...).fields(slice__comments=5)
 
-            posts = BlogPost.objects(...).fields(comments=0)
+        :param kwargs: A dictionary identifying what to include
-
-        To retrieve a subrange of array elements:
-
-            posts = BlogPost.objects(...).fields(slice__comments=5)
-
-        :param kwargs: A set keywors arguments identifying what to include.
 
         .. versionadded:: 0.5
         """

mongoengine/queryset/transform.py

@@ -101,21 +101,8 @@ def query(_doc_cls=None, **kwargs):
                         value = value['_id']
 
             elif op in ('in', 'nin', 'all', 'near') and not isinstance(value, dict):
-                # Raise an error if the in/nin/all/near param is not iterable. We need a
+                # 'in', 'nin' and 'all' require a list of values
-                # special check for BaseDocument, because - although it's iterable - using
+                value = [field.prepare_query_value(op, v) for v in value]
-                # it as such in the context of this method is most definitely a mistake.
-                BaseDocument = _import_class('BaseDocument')
-                if isinstance(value, BaseDocument):
-                    raise TypeError("When using the `in`, `nin`, `all`, or "
-                                    "`near`-operators you can\'t use a "
-                                    "`Document`, you must wrap your object "
-                                    "in a list (object -> [object]).")
-                elif not hasattr(value, '__iter__'):
-                    raise TypeError("The `in`, `nin`, `all`, or "
-                                    "`near`-operators must be applied to an "
-                                    "iterable (e.g. a list).")
-                else:
-                    value = [field.prepare_query_value(op, v) for v in value]
 
             # If we're querying a GenericReferenceField, we need to alter the
             # key depending on the value:

setup.cfg

@@ -7,5 +7,5 @@ cover-package=mongoengine
 [flake8]
 ignore=E501,F401,F403,F405,I201
 exclude=build,dist,docs,venv,venv3,.tox,.eggs,tests
-max-complexity=47
+max-complexity=45
 application-import-names=mongoengine,tests

tests/document/instance.py

@@ -435,15 +435,6 @@ class InstanceTest(unittest.TestCase):
 
         person.to_dbref()
 
-    def test_save_abstract_document(self):
-        """Saving an abstract document should fail."""
-        class Doc(Document):
-            name = StringField()
-            meta = {'abstract': True}
-
-        with self.assertRaises(InvalidDocumentError):
-            Doc(name='aaa').save()
-
     def test_reload(self):
         """Ensure that attributes may be reloaded.
         """
@@ -1869,10 +1860,6 @@ class InstanceTest(unittest.TestCase):
                 'occurs': {"hello": None}
             })
 
-        # Tests for issue #1438: https://github.com/MongoEngine/mongoengine/issues/1438
-        with self.assertRaises(ValueError):
-            Word._from_son('this is not a valid SON dict')
-
     def test_reverse_delete_rule_cascade_and_nullify(self):
         """Ensure that a referenced document is also deleted upon deletion.
         """

tests/fields/fields.py

@@ -1042,7 +1042,6 @@ class FieldTest(unittest.TestCase):
         self.assertEqual(
             BlogPost.objects.filter(info__100__test__exact='test').count(), 0)
 
-        # test queries by list
         post = BlogPost()
         post.info = ['1', '2']
         post.save()
@@ -1054,248 +1053,6 @@ class FieldTest(unittest.TestCase):
         post.info *= 2
         post.save()
         self.assertEqual(BlogPost.objects(info=['1', '2', '3', '4', '1', '2', '3', '4']).count(), 1)
-
-        BlogPost.drop_collection()
-
-    def test_list_field_manipulative_operators(self):
-        """Ensure that ListField works with standard list operators that manipulate the list.
-        """
-        class BlogPost(Document):
-            ref = StringField()
-            info = ListField(StringField())
-
-        BlogPost.drop_collection()
-
-        post = BlogPost()
-        post.ref = "1234"
-        post.info = ['0', '1', '2', '3', '4', '5']
-        post.save()
-
-        def reset_post():
-            post.info = ['0', '1', '2', '3', '4', '5']
-            post.save()
-
-        # '__add__(listB)'
-        # listA+listB
-        # operator.add(listA, listB)
-        reset_post()
-        temp = ['a', 'b']
-        post.info = post.info + temp
-        self.assertEqual(post.info, ['0', '1', '2', '3', '4', '5', 'a', 'b'])
-        post.save()
-        post.reload()
-        self.assertEqual(post.info, ['0', '1', '2', '3', '4', '5', 'a', 'b'])
-
-        # '__delitem__(index)'
-        # aka 'del list[index]'
-        # aka 'operator.delitem(list, index)'
-        reset_post()
-        del post.info[2] # del from middle ('2')
-        self.assertEqual(post.info, ['0', '1', '3', '4', '5'])
-        post.save()
-        post.reload()
-        self.assertEqual(post.info, ['0', '1', '3', '4', '5'])
-
-        # '__delitem__(slice(i, j))'
-        # aka 'del list[i:j]'
-        # aka 'operator.delitem(list, slice(i,j))'
-        reset_post()
-        del post.info[1:3] # removes '1', '2'
-        self.assertEqual(post.info, ['0', '3', '4', '5'])
-        post.save()
-        post.reload()
-        self.assertEqual(post.info, ['0', '3', '4', '5'])
-
-        # '__iadd__'
-        # aka 'list += list'
-        reset_post()
-        temp = ['a', 'b']
-        post.info += temp
-        self.assertEqual(post.info, ['0', '1', '2', '3', '4', '5', 'a', 'b'])
-        post.save()
-        post.reload()
-        self.assertEqual(post.info, ['0', '1', '2', '3', '4', '5', 'a', 'b'])
-
-        # '__imul__'
-        # aka 'list *= number'
-        reset_post()
-        post.info *= 2
-        self.assertEqual(post.info, ['0', '1', '2', '3', '4', '5', '0', '1', '2', '3', '4', '5'])
-        post.save()
-        post.reload()
-        self.assertEqual(post.info, ['0', '1', '2', '3', '4', '5', '0', '1', '2', '3', '4', '5'])
-
-        # '__mul__'
-        # aka 'listA*listB'
-        reset_post()
-        post.info = post.info * 2
-        self.assertEqual(post.info, ['0', '1', '2', '3', '4', '5', '0', '1', '2', '3', '4', '5'])
-        post.save()
-        post.reload()
-        self.assertEqual(post.info, ['0', '1', '2', '3', '4', '5', '0', '1', '2', '3', '4', '5'])
-
-        # '__rmul__'
-        # aka 'listB*listA'
-        reset_post()
-        post.info = 2 * post.info
-        self.assertEqual(post.info, ['0', '1', '2', '3', '4', '5', '0', '1', '2', '3', '4', '5'])
-        post.save()
-        post.reload()
-        self.assertEqual(post.info, ['0', '1', '2', '3', '4', '5', '0', '1', '2', '3', '4', '5'])
-
-        # '__setitem__(index, value)'
-        # aka 'list[index]=value'
-        # aka 'setitem(list, value)'
-        reset_post()
-        post.info[4] = 'a'
-        self.assertEqual(post.info, ['0', '1', '2', '3', 'a', '5'])
-        post.save()
-        post.reload()
-        self.assertEqual(post.info, ['0', '1', '2', '3', 'a', '5'])
-
-        # '__setitem__(slice(i, j), listB)'
-        # aka 'listA[i:j] = listB'
-        # aka 'setitem(listA, slice(i, j), listB)'
-        reset_post()
-        post.info[1:3] = ['h', 'e', 'l', 'l', 'o']
-        self.assertEqual(post.info, ['0', 'h', 'e', 'l', 'l', 'o', '3', '4', '5'])
-        post.save()
-        post.reload()
-        self.assertEqual(post.info, ['0', 'h', 'e', 'l', 'l', 'o', '3', '4', '5'])
-
-        # 'append'
-        reset_post()
-        post.info.append('h')
-        self.assertEqual(post.info, ['0', '1', '2', '3', '4', '5', 'h'])
-        post.save()
-        post.reload()
-        self.assertEqual(post.info, ['0', '1', '2', '3', '4', '5', 'h'])
-
-        # 'extend'
-        reset_post()
-        post.info.extend(['h', 'e', 'l', 'l', 'o'])
-        self.assertEqual(post.info, ['0', '1', '2', '3', '4', '5', 'h', 'e', 'l', 'l', 'o'])
-        post.save()
-        post.reload()
-        self.assertEqual(post.info, ['0', '1', '2', '3', '4', '5', 'h', 'e', 'l', 'l', 'o'])
-        # 'insert'
-
-        # 'pop'
-        reset_post()
-        x = post.info.pop(2)
-        y = post.info.pop()
-        self.assertEqual(post.info, ['0', '1', '3', '4'])
-        self.assertEqual(x, '2')
-        self.assertEqual(y, '5')
-        post.save()
-        post.reload()
-        self.assertEqual(post.info, ['0', '1', '3', '4'])
-
-        # 'remove'
-        reset_post()
-        post.info.remove('2')
-        self.assertEqual(post.info, ['0', '1', '3', '4', '5'])
-        post.save()
-        post.reload()
-        self.assertEqual(post.info, ['0', '1', '3', '4', '5'])
-
-        # 'reverse'
-        reset_post()
-        post.info.reverse()
-        self.assertEqual(post.info, ['5', '4', '3', '2', '1', '0'])
-        post.save()
-        post.reload()
-        self.assertEqual(post.info, ['5', '4', '3', '2', '1', '0'])
-
-        # 'sort': though this operator method does manipulate the list, it is tested in
-        #     the 'test_list_field_lexicograpic_operators' function
-        BlogPost.drop_collection()
-
-    def test_list_field_invalid_operators(self):
-        class BlogPost(Document):
-            ref = StringField()
-            info = ListField(StringField())
-        post = BlogPost()
-        post.ref = "1234"
-        post.info = ['0', '1', '2', '3', '4', '5']
-        # '__hash__'
-        # aka 'hash(list)'
-        # # assert TypeError
-        self.assertRaises(TypeError, lambda: hash(post.info))
-
-    def test_list_field_lexicographic_operators(self):
-        """Ensure that ListField works with standard list operators that do lexigraphic ordering.
-        """
-        class BlogPost(Document):
-            ref = StringField()
-            text_info = ListField(StringField())
-            oid_info = ListField(ObjectIdField())
-            bool_info = ListField(BooleanField())
-        BlogPost.drop_collection()
-
-        blogSmall = BlogPost(ref="small")
-        blogSmall.text_info = ["a", "a", "a"]
-        blogSmall.bool_info = [False, False]
-        blogSmall.save()
-        blogSmall.reload()
-
-        blogLargeA = BlogPost(ref="big")
-        blogLargeA.text_info = ["a", "z", "j"]
-        blogLargeA.bool_info = [False, True]
-        blogLargeA.save()
-        blogLargeA.reload()
-
-        blogLargeB = BlogPost(ref="big2")
-        blogLargeB.text_info = ["a", "z", "j"]
-        blogLargeB.oid_info = [
-            "54495ad94c934721ede76f90",
-            "54495ad94c934721ede76d23",
-            "54495ad94c934721ede76d00"
-        ]
-        blogLargeB.bool_info = [False, True]
-        blogLargeB.save()
-        blogLargeB.reload()
-        # '__eq__' aka '=='
-        self.assertEqual(blogLargeA.text_info, blogLargeB.text_info)
-        self.assertEqual(blogLargeA.bool_info, blogLargeB.bool_info)
-        # '__ge__' aka '>='
-        self.assertGreaterEqual(blogLargeA.text_info, blogSmall.text_info)
-        self.assertGreaterEqual(blogLargeA.text_info, blogLargeB.text_info)
-        self.assertGreaterEqual(blogLargeA.bool_info, blogSmall.bool_info)
-        self.assertGreaterEqual(blogLargeA.bool_info, blogLargeB.bool_info)
-        # '__gt__' aka '>'
-        self.assertGreaterEqual(blogLargeA.text_info, blogSmall.text_info)
-        self.assertGreaterEqual(blogLargeA.bool_info, blogSmall.bool_info)
-        # '__le__' aka '<='
-        self.assertLessEqual(blogSmall.text_info, blogLargeB.text_info)
-        self.assertLessEqual(blogLargeA.text_info, blogLargeB.text_info)
-        self.assertLessEqual(blogSmall.bool_info, blogLargeB.bool_info)
-        self.assertLessEqual(blogLargeA.bool_info, blogLargeB.bool_info)
-        # '__lt__' aka '<'
-        self.assertLess(blogSmall.text_info, blogLargeB.text_info)
-        self.assertLess(blogSmall.bool_info, blogLargeB.bool_info)
-        # '__ne__' aka '!='
-        self.assertNotEqual(blogSmall.text_info, blogLargeB.text_info)
-        self.assertNotEqual(blogSmall.bool_info, blogLargeB.bool_info)
-        # 'sort'
-        blogLargeB.bool_info = [True, False, True, False]
-        blogLargeB.text_info.sort()
-        blogLargeB.oid_info.sort()
-        blogLargeB.bool_info.sort()
-        sorted_target_list = [
-            ObjectId("54495ad94c934721ede76d00"),
-            ObjectId("54495ad94c934721ede76d23"),
-            ObjectId("54495ad94c934721ede76f90")
-        ]
-        self.assertEqual(blogLargeB.text_info, ["a", "j", "z"])
-        self.assertEqual(blogLargeB.oid_info, sorted_target_list)
-        self.assertEqual(blogLargeB.bool_info, [False, False, True, True])
-        blogLargeB.save()
-        blogLargeB.reload()
-        self.assertEqual(blogLargeB.text_info, ["a", "j", "z"])
-        self.assertEqual(blogLargeB.oid_info, sorted_target_list)
-        self.assertEqual(blogLargeB.bool_info, [False, False, True, True])
-
         BlogPost.drop_collection()
 
     def test_list_assignment(self):
@@ -1345,6 +1102,7 @@ class FieldTest(unittest.TestCase):
         post.reload()
         self.assertEqual(post.info, [1, 2, 3, 4, 'n5'])
 
+
     def test_list_field_passed_in_value(self):
         class Foo(Document):
             bars = ListField(ReferenceField("Bar"))

tests/queryset/queryset.py

@@ -1266,7 +1266,7 @@ class QuerySetTest(unittest.TestCase):
 
     def test_find_embedded(self):
         """Ensure that an embedded document is properly returned from
-        different manners of querying.
+        a query.
         """
         class User(EmbeddedDocument):
             name = StringField()
@@ -1277,9 +1277,8 @@ class QuerySetTest(unittest.TestCase):
 
         BlogPost.drop_collection()
 
-        user = User(name='Test User')
         BlogPost.objects.create(
-            author=user,
+            author=User(name='Test User'),
             content='Had a good coffee today...'
         )
 
@@ -1287,19 +1286,6 @@ class QuerySetTest(unittest.TestCase):
         self.assertTrue(isinstance(result.author, User))
         self.assertEqual(result.author.name, 'Test User')
 
-        result = BlogPost.objects.get(author__name=user.name)
-        self.assertTrue(isinstance(result.author, User))
-        self.assertEqual(result.author.name, 'Test User')
-
-        result = BlogPost.objects.get(author={'name': user.name})
-        self.assertTrue(isinstance(result.author, User))
-        self.assertEqual(result.author.name, 'Test User')
-
-        # Fails, since the string is not a type that is able to represent the
-        # author's document structure (should be dict)
-        with self.assertRaises(InvalidQueryError):
-            BlogPost.objects.get(author=user.name)
-
     def test_find_empty_embedded(self):
         """Ensure that you can save and find an empty embedded document."""
         class User(EmbeddedDocument):
@@ -4977,35 +4963,6 @@ class QuerySetTest(unittest.TestCase):
         self.assertEqual(i, 249)
         self.assertEqual(j, 249)
 
-    def test_in_operator_on_non_iterable(self):
-        """Ensure that using the `__in` operator on a non-iterable raises an
-        error.
-        """
-        class User(Document):
-            name = StringField()
-
-        class BlogPost(Document):
-            content = StringField()
-            authors = ListField(ReferenceField(User))
-
-        User.drop_collection()
-        BlogPost.drop_collection()
-
-        author = User.objects.create(name='Test User')
-        post = BlogPost.objects.create(content='Had a good coffee today...',
-                                       authors=[author])
-
-        # Make sure using `__in` with a list works
-        blog_posts = BlogPost.objects(authors__in=[author])
-        self.assertEqual(list(blog_posts), [post])
-
-        # Using `__in` with a non-iterable should raise a TypeError
-        self.assertRaises(TypeError, BlogPost.objects(authors__in=author.pk).count)
-
-        # Using `__in` with a `Document` (which is seemingly iterable but not
-        # in a way we'd expect) should raise a TypeError, too
-        self.assertRaises(TypeError, BlogPost.objects(authors__in=author).count)
-
 
 if __name__ == '__main__':
     unittest.main()

tests/test_connection.py

@@ -200,19 +200,6 @@ class ConnectionTest(unittest.TestCase):
         self.assertTrue(isinstance(db, pymongo.database.Database))
         self.assertEqual(db.name, 'test')
 
-    def test_connect_uri_with_replicaset(self):
-        """Ensure connect() works when specifying a replicaSet."""
-        if IS_PYMONGO_3:
-            c = connect(host='mongodb://localhost/test?replicaSet=local-rs')
-            db = get_db()
-            self.assertTrue(isinstance(db, pymongo.database.Database))
-            self.assertEqual(db.name, 'test')
-        else:
-            # PyMongo < v3.x raises an exception:
-            # "localhost:27017 is not a member of replica set local-rs"
-            with self.assertRaises(MongoEngineConnectionError):
-                c = connect(host='mongodb://localhost/test?replicaSet=local-rs')
-
     def test_uri_without_credentials_doesnt_override_conn_settings(self):
         """Ensure connect() uses the username & password params if the URI
         doesn't explicitly specify them.