Added Doc class and pk to Validation messages (#69)

docs/changelog.rst

@@ -42,6 +42,7 @@ Changes in 0.8.X
 - Added no_dereference method for querysets (#82) (#61)
 - Undefined data should not override instance methods (#49)
 - Added Django Group and Permission (#142)
+- Added Doc class and pk to Validation messages (#69)
 
 Changes in 0.7.9
 ================

mongoengine/base/document.py

@@ -274,7 +274,13 @@ class BaseDocument(object):
                                                      field_name=field.name)
 
         if errors:
-            raise ValidationError('ValidationError', errors=errors)
+            pk = "None"
+            if hasattr(self, 'pk'):
+                pk = self.pk
+            elif self._instance:
+                pk = self._instance.pk
+            message = "ValidationError (%s:%s) " % (self._class_name, pk)
+            raise ValidationError(message, errors=errors)
 
     def to_json(self):
         """Converts a document to JSON"""

tests/document/instance.py

@@ -466,45 +466,6 @@ class InstanceTest(unittest.TestCase):
         doc = Doc.objects.get()
         self.assertEqual(doc, doc.embedded_field[0]._instance)
 
-    def test_embedded_document_validation(self):
-        """Ensure that embedded documents may be validated.
-        """
-        class Comment(EmbeddedDocument):
-            date = DateTimeField()
-            content = StringField(required=True)
-
-        comment = Comment()
-        self.assertRaises(ValidationError, comment.validate)
-
-        comment.content = 'test'
-        comment.validate()
-
-        comment.date = 4
-        self.assertRaises(ValidationError, comment.validate)
-
-        comment.date = datetime.now()
-        comment.validate()
-        self.assertEqual(comment._instance, None)
-
-    def test_embedded_db_field_validate(self):
-
-        class SubDoc(EmbeddedDocument):
-            val = IntField()
-
-        class Doc(Document):
-            e = EmbeddedDocumentField(SubDoc, db_field='eb')
-
-        Doc.drop_collection()
-
-        Doc(e=SubDoc(val=15)).save()
-
-        doc = Doc.objects.first()
-        doc.validate()
-        keys = doc._data.keys()
-        self.assertEqual(2, len(keys))
-        self.assertTrue('id' in keys)
-        self.assertTrue('e' in keys)
-
     def test_document_clean(self):
         class TestDocument(Document):
             status = StringField()
@@ -2001,5 +1962,103 @@ class InstanceTest(unittest.TestCase):
         self.assertEqual("Bar", user._data["foo"])
         self.assertEqual([1, 2, 3], user._data["data"])
 
+
+    def test_spaces_in_keys(self):
+
+        class Embedded(DynamicEmbeddedDocument):
+            pass
+
+        class Doc(DynamicDocument):
+            pass
+
+        Doc.drop_collection()
+        doc = Doc()
+        setattr(doc, 'hello world', 1)
+        doc.save()
+
+        one = Doc.objects.filter(**{'hello world': 1}).count()
+        self.assertEqual(1, one)
+
+    def test_shard_key(self):
+        class LogEntry(Document):
+            machine = StringField()
+            log = StringField()
+
+            meta = {
+                'shard_key': ('machine',)
+            }
+
+        LogEntry.drop_collection()
+
+        log = LogEntry()
+        log.machine = "Localhost"
+        log.save()
+
+        log.log = "Saving"
+        log.save()
+
+        def change_shard_key():
+            log.machine = "127.0.0.1"
+
+        self.assertRaises(OperationError, change_shard_key)
+
+    def test_shard_key_primary(self):
+        class LogEntry(Document):
+            machine = StringField(primary_key=True)
+            log = StringField()
+
+            meta = {
+                'shard_key': ('machine',)
+            }
+
+        LogEntry.drop_collection()
+
+        log = LogEntry()
+        log.machine = "Localhost"
+        log.save()
+
+        log.log = "Saving"
+        log.save()
+
+        def change_shard_key():
+            log.machine = "127.0.0.1"
+
+        self.assertRaises(OperationError, change_shard_key)
+
+    def test_kwargs_simple(self):
+
+        class Embedded(EmbeddedDocument):
+            name = StringField()
+
+        class Doc(Document):
+            doc_name = StringField()
+            doc = EmbeddedDocumentField(Embedded)
+
+        classic_doc = Doc(doc_name="my doc", doc=Embedded(name="embedded doc"))
+        dict_doc = Doc(**{"doc_name": "my doc",
+                          "doc": {"name": "embedded doc"}})
+
+        self.assertEqual(classic_doc, dict_doc)
+        self.assertEqual(classic_doc._data, dict_doc._data)
+
+    def test_kwargs_complex(self):
+
+        class Embedded(EmbeddedDocument):
+            name = StringField()
+
+        class Doc(Document):
+            doc_name = StringField()
+            docs = ListField(EmbeddedDocumentField(Embedded))
+
+        classic_doc = Doc(doc_name="my doc", docs=[
+                            Embedded(name="embedded doc1"),
+                            Embedded(name="embedded doc2")])
+        dict_doc = Doc(**{"doc_name": "my doc",
+                          "docs": [{"name": "embedded doc1"},
+                                   {"name": "embedded doc2"}]})
+
+        self.assertEqual(classic_doc, dict_doc)
+        self.assertEqual(classic_doc._data, dict_doc._data)
+
 if __name__ == '__main__':
     unittest.main()

tests/document/validation.py

@@ -3,6 +3,7 @@ import sys
 sys.path[0:0] = [""]
 
 import unittest
+from datetime import datetime
 
 from mongoengine import *
 
@@ -11,6 +12,9 @@ __all__ = ("ValidatorErrorTest",)
 
 class ValidatorErrorTest(unittest.TestCase):
 
+    def setUp(self):
+        connect(db='mongoenginetest')
+
     def test_to_dict(self):
         """Ensure a ValidationError handles error to_dict correctly.
         """
@@ -57,25 +61,19 @@ class ValidatorErrorTest(unittest.TestCase):
         try:
             User().validate()
         except ValidationError, e:
+            self.assertTrue("User:None" in e.message)
             self.assertEqual(e.to_dict(), {
                 'username': 'Field is required',
                 'name': 'Field is required'})
 
-    def test_spaces_in_keys(self):
+        user = User(username="RossC0", name="Ross").save()
-
+        user.name = None
-        class Embedded(DynamicEmbeddedDocument):
+        try:
-            pass
+            user.save()
-
+        except ValidationError, e:
-        class Doc(DynamicDocument):
+            self.assertTrue("User:RossC0" in e.message)
-            pass
+            self.assertEqual(e.to_dict(), {
-
+                'name': 'Field is required'})
-        Doc.drop_collection()
-        doc = Doc()
-        setattr(doc, 'hello world', 1)
-        doc.save()
-
-        one = Doc.objects.filter(**{'hello world': 1}).count()
-        self.assertEqual(1, one)
 
     def test_fields_rewrite(self):
         class BasePerson(Document):
@@ -89,107 +87,60 @@ class ValidatorErrorTest(unittest.TestCase):
         p = Person(age=15)
         self.assertRaises(ValidationError, p.validate)
 
-    def test_cascaded_save_wrong_reference(self):
+    def test_embedded_document_validation(self):
+        """Ensure that embedded documents may be validated.
+        """
+        class Comment(EmbeddedDocument):
+            date = DateTimeField()
+            content = StringField(required=True)
 
-        class ADocument(Document):
+        comment = Comment()
-            val = IntField()
+        self.assertRaises(ValidationError, comment.validate)
 
-        class BDocument(Document):
+        comment.content = 'test'
-            a = ReferenceField(ADocument)
+        comment.validate()
 
-        ADocument.drop_collection()
+        comment.date = 4
-        BDocument.drop_collection()
+        self.assertRaises(ValidationError, comment.validate)
 
-        a = ADocument()
+        comment.date = datetime.now()
-        a.val = 15
+        comment.validate()
-        a.save()
+        self.assertEqual(comment._instance, None)
 
-        b = BDocument()
+    def test_embedded_db_field_validate(self):
-        b.a = a
-        b.save()
 
-        a.delete()
+        class SubDoc(EmbeddedDocument):
-
+            val = IntField(required=True)
-        b = BDocument.objects.first()
-        b.save(cascade=True)
-
-    def test_shard_key(self):
-        class LogEntry(Document):
-            machine = StringField()
-            log = StringField()
-
-            meta = {
-                'shard_key': ('machine',)
-            }
-
-        LogEntry.drop_collection()
-
-        log = LogEntry()
-        log.machine = "Localhost"
-        log.save()
-
-        log.log = "Saving"
-        log.save()
-
-        def change_shard_key():
-            log.machine = "127.0.0.1"
-
-        self.assertRaises(OperationError, change_shard_key)
-
-    def test_shard_key_primary(self):
-        class LogEntry(Document):
-            machine = StringField(primary_key=True)
-            log = StringField()
-
-            meta = {
-                'shard_key': ('machine',)
-            }
-
-        LogEntry.drop_collection()
-
-        log = LogEntry()
-        log.machine = "Localhost"
-        log.save()
-
-        log.log = "Saving"
-        log.save()
-
-        def change_shard_key():
-            log.machine = "127.0.0.1"
-
-        self.assertRaises(OperationError, change_shard_key)
-
-    def test_kwargs_simple(self):
-
-        class Embedded(EmbeddedDocument):
-            name = StringField()
 
         class Doc(Document):
-            doc_name = StringField()
+            id = StringField(primary_key=True)
-            doc = EmbeddedDocumentField(Embedded)
+            e = EmbeddedDocumentField(SubDoc, db_field='eb')
 
-        classic_doc = Doc(doc_name="my doc", doc=Embedded(name="embedded doc"))
+        try:
-        dict_doc = Doc(**{"doc_name": "my doc",
+            Doc(id="bad").validate()
-                          "doc": {"name": "embedded doc"}})
+        except ValidationError, e:
+            self.assertTrue("SubDoc:None" in e.message)
+            self.assertEqual(e.to_dict(), {
+                'e.val': 'Field is required'})
 
-        self.assertEqual(classic_doc, dict_doc)
+        Doc.drop_collection()
-        self.assertEqual(classic_doc._data, dict_doc._data)
 
-    def test_kwargs_complex(self):
+        Doc(id="test", e=SubDoc(val=15)).save()
 
-        class Embedded(EmbeddedDocument):
+        doc = Doc.objects.first()
-            name = StringField()
+        keys = doc._data.keys()
+        self.assertEqual(2, len(keys))
+        self.assertTrue('id' in keys)
+        self.assertTrue('e' in keys)
 
-        class Doc(Document):
+        doc.e.val = "OK"
-            doc_name = StringField()
+        try:
-            docs = ListField(EmbeddedDocumentField(Embedded))
+            doc.save()
+        except ValidationError, e:
+            self.assertTrue("SubDoc:test" in e.message)
+            self.assertEqual(e.to_dict(), {
+                'e.val': 'Field is required'})
 
-        classic_doc = Doc(doc_name="my doc", docs=[
-                            Embedded(name="embedded doc1"),
-                            Embedded(name="embedded doc2")])
-        dict_doc = Doc(**{"doc_name": "my doc",
-                          "docs": [{"name": "embedded doc1"},
-                                   {"name": "embedded doc2"}]})
 
-        self.assertEqual(classic_doc, dict_doc)
+if __name__ == '__main__':
-        self.assertEqual(classic_doc._data, dict_doc._data)
+    unittest.main()