fix BaseQuerySet.fields when mixing exclusion/inclusion with complex values like $slice

mongoengine/base/fields.py

@@ -41,7 +41,7 @@ class BaseField(object):
         """
         :param db_field: The database field to store this field in
             (defaults to the name of the field)
-        :param name: Deprecated - use db_field
+        :param name: Depreciated - use db_field
         :param required: If the field is required. Whether it has to have a
             value or not. Defaults to False.
         :param default: (optional) The default value for this field if no value
@@ -81,17 +81,6 @@ class BaseField(object):
         self.sparse = sparse
         self._owner_document = None
 
-        # Validate the db_field
-        if isinstance(self.db_field, six.string_types) and (
-            '.' in self.db_field or
-            '\0' in self.db_field or
-            self.db_field.startswith('$')
-        ):
-            raise ValueError(
-                'field names cannot contain dots (".") or null characters '
-                '("\\0"), and they must not start with a dollar sign ("$").'
-            )
-
         # Detect and report conflicts between metadata and base properties.
         conflicts = set(dir(self)) & set(kwargs)
         if conflicts:

mongoengine/document.py

@@ -313,6 +313,9 @@ 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)
 
@@ -828,7 +831,6 @@ 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/queryset/base.py

@@ -933,7 +933,20 @@ class BaseQuerySet(object):
             key = '.'.join(parts)
             cleaned_fields.append((key, value))
 
-        fields = sorted(cleaned_fields, key=operator.itemgetter(1))
+        # Sort fields by their values, explicitly excluded fields first, then
+        # explicitly included, and then more complicated operators such as
+        # $slice.
+        def _sort_key(field_tuple):
+            key, value = field_tuple
+            if isinstance(value, (int)):
+                return value  # 0 for exclusion, 1 for inclusion
+            else:
+                return 2  # so that complex values appear last
+
+        fields = sorted(cleaned_fields, key=_sort_key)
+
+        # Clone the queryset, group all fields by their value, convert
+        # each of them to db_fields, and set the queryset's _loaded_fields
         queryset = self.clone()
         for value, group in itertools.groupby(fields, lambda x: x[1]):
             fields = [field for field, value in group]

mongoengine/queryset/transform.py

@@ -233,8 +233,7 @@ def update(_doc_cls=None, **update):
                 # Support decrement by flipping a positive value's sign
                 # and using 'inc'
                 op = 'inc'
-                if value > 0:
-                    value = -value
+                value = -value
             elif op == 'add_to_set':
                 op = 'addToSet'
             elif op == 'set_on_insert':

tests/document/instance.py

@@ -435,6 +435,15 @@ 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.
         """

tests/fields/fields.py

@@ -306,24 +306,6 @@ class FieldTest(unittest.TestCase):
         person.id = '497ce96f395f2f052a494fd4'
         person.validate()
 
-    def test_db_field_validation(self):
-        """Ensure that db_field doesn't accept invalid values."""
-
-        # dot in the name
-        with self.assertRaises(ValueError):
-            class User(Document):
-                name = StringField(db_field='user.name')
-
-        # name starting with $
-        with self.assertRaises(ValueError):
-            class User(Document):
-                name = StringField(db_field='$name')
-
-        # name containing a null character
-        with self.assertRaises(ValueError):
-            class User(Document):
-                name = StringField(db_field='name\0')
-
     def test_string_validation(self):
         """Ensure that invalid values cannot be assigned to string fields.
         """
@@ -3991,25 +3973,30 @@ class FieldTest(unittest.TestCase):
         """Tests if a `FieldDoesNotExist` exception is raised when trying to
         instanciate a document with a field that's not defined.
         """
-        class Doc(Document):
-            foo = StringField()
 
-        with self.assertRaises(FieldDoesNotExist):
+        class Doc(Document):
+            foo = StringField(db_field='f')
+
+        def test():
             Doc(bar='test')
 
+        self.assertRaises(FieldDoesNotExist, test)
 
     def test_undefined_field_exception_with_strict(self):
         """Tests if a `FieldDoesNotExist` exception is raised when trying to
         instanciate a document with a field that's not defined,
         even when strict is set to False.
         """
+
         class Doc(Document):
-            foo = StringField()
+            foo = StringField(db_field='f')
             meta = {'strict': False}
 
-        with self.assertRaises(FieldDoesNotExist):
+        def test():
             Doc(bar='test')
 
+        self.assertRaises(FieldDoesNotExist, test)
+
     def test_long_field_is_considered_as_int64(self):
         """
         Tests that long fields are stored as long in mongo, even if long value

tests/queryset/field_list.py

@@ -141,6 +141,16 @@ class OnlyExcludeAllTest(unittest.TestCase):
         self.assertEqual(qs._loaded_fields.as_dict(),
                          {'b': {'$slice': 5}})
 
+    def test_mix_slice_with_other_fields(self):
+        class MyDoc(Document):
+            a = ListField()
+            b = ListField()
+            c = ListField()
+
+        qs = MyDoc.objects.fields(a=1, b=0, slice__c=2)
+        self.assertEqual(qs._loaded_fields.as_dict(),
+                         {'c': {'$slice': 2}, 'a': 1})
+
     def test_only(self):
         """Ensure that QuerySet.only only returns the requested fields.
         """

tests/queryset/queryset.py

@@ -1826,6 +1826,11 @@ class QuerySetTest(unittest.TestCase):
         post.reload()
         self.assertEqual(post.hits, 10)
 
+        # Negative dec operator is equal to a positive inc operator
+        BlogPost.objects.update_one(dec__hits=-1)
+        post.reload()
+        self.assertEqual(post.hits, 11)
+
         BlogPost.objects.update(push__tags='mongo')
         post.reload()
         self.assertTrue('mongo' in post.tags)