From 48418d5a60fbf4daafb3fca7e83f99d6da98bd15 Mon Sep 17 00:00:00 2001 From: Harry Marr Date: Tue, 17 Nov 2009 01:12:52 +0000 Subject: [PATCH] Added required fields, StringFields may be '_id's Included tests for required fields (checks primary key is required as well). Switched from using SuperClass.__init__ to super(). Added constructor for EmbeddedDocumentField. --- mongomap/base.py | 37 +++++++++++++++++++++++++++---------- mongomap/fields.py | 15 +++++++++++---- tests/fields.py | 16 ++++++++++++++++ 3 files changed, 54 insertions(+), 14 deletions(-) diff --git a/mongomap/base.py b/mongomap/base.py index cbcb8b8f..f6c97faa 100644 --- a/mongomap/base.py +++ b/mongomap/base.py @@ -8,8 +8,9 @@ class BaseField(object): may be added to subclasses of `Document` to define a document's schema. """ - def __init__(self, name=None, default=None): + def __init__(self, name=None, required=False, default=None): self.name = name + self.required = required self.default = default def __get__(self, instance, owner): @@ -42,6 +43,8 @@ class BaseField(object): except ValueError: raise ValidationError('Invalid value for field of type "' + self.__class__.__name__ + '"') + elif self.required: + raise ValidationError('Field "%s" is required' % self.name) instance._data[self.name] = value def _to_python(self, value): @@ -66,8 +69,9 @@ class DocumentMetaclass(type): def __new__(cls, name, bases, attrs): metaclass = attrs.get('__metaclass__') + super_new = super(DocumentMetaclass, cls).__new__ if metaclass and issubclass(metaclass, DocumentMetaclass): - return type.__new__(cls, name, bases, attrs) + return super_new(cls, name, bases, attrs) doc_fields = {} @@ -77,14 +81,15 @@ class DocumentMetaclass(type): doc_fields.update(base._fields) # Add the document's fields to the _fields attribute - for attr_name, attr_val in attrs.items(): - if issubclass(attr_val.__class__, BaseField): - if not attr_val.name: - attr_val.name = attr_name - doc_fields[attr_name] = attr_val + for attr_name, attr_value in attrs.items(): + if issubclass(attr_value.__class__, BaseField): + #print attr_value.name + if not attr_value.name: + attr_value.name = attr_name + doc_fields[attr_name] = attr_value attrs['_fields'] = doc_fields - return type.__new__(cls, name, bases, attrs) + return super_new(cls, name, bases, attrs) class TopLevelDocumentMetaclass(DocumentMetaclass): @@ -95,21 +100,31 @@ class TopLevelDocumentMetaclass(DocumentMetaclass): def __new__(cls, name, bases, attrs): # Classes defined in this package are abstract and should not have # their own metadata with DB collection, etc. + super_new = super(TopLevelDocumentMetaclass, cls).__new__ if attrs.get('__metaclass__') == TopLevelDocumentMetaclass: - return DocumentMetaclass.__new__(cls, name, bases, attrs) + return super_new(cls, name, bases, attrs) collection = name.lower() # Subclassed documents inherit collection from superclass for base in bases: if hasattr(base, '_meta') and 'collection' in base._meta: collection = base._meta['collection'] + + # Get primary key field + object_id_field = None + for attr_name, attr_value in attrs.items(): + if issubclass(attr_value.__class__, BaseField): + if hasattr(attr_value, 'object_id') and attr_value.object_id: + object_id_field = attr_name + attr_value.required = True meta = { 'collection': collection, + 'object_id_field': object_id_field, } meta.update(attrs.get('meta', {})) attrs['_meta'] = meta - return DocumentMetaclass.__new__(cls, name, bases, attrs) + return super_new(cls, name, bases, attrs) class BaseDocument(object): @@ -121,6 +136,8 @@ class BaseDocument(object): if attr_name in values: setattr(self, attr_name, values.pop(attr_name)) else: + if attr_value.required: + raise ValidationError('Field "%s" is required' % self.name) # Use default value setattr(self, attr_name, getattr(self, attr_name)) diff --git a/mongomap/fields.py b/mongomap/fields.py index f642f80c..b8fe9693 100644 --- a/mongomap/fields.py +++ b/mongomap/fields.py @@ -11,10 +11,11 @@ class StringField(BaseField): """A unicode string field. """ - def __init__(self, regex=None, max_length=None, **kwargs): + def __init__(self, regex=None, max_length=None, object_id=False, **kwargs): self.regex = re.compile(regex) if regex else None + self.object_id = object_id self.max_length = max_length - BaseField.__init__(self, **kwargs) + super(StringField, self).__init__(**kwargs) def _validate(self, value): if self.max_length is not None and len(value) > self.max_length: @@ -31,7 +32,7 @@ class IntField(BaseField): def __init__(self, min_value=None, max_value=None, **kwargs): self.min_value, self.max_value = min_value, max_value - BaseField.__init__(self, **kwargs) + super(IntField, self).__init__(**kwargs) def _to_python(self, value): return int(value) @@ -48,4 +49,10 @@ class EmbeddedDocumentField(BaseField): """An embedded document field. Only valid values are subclasses of EmbeddedDocument. """ - pass + + def __init__(self, document, **kwargs): + if not issubclass(document, EmbeddedDocument): + raise ValidationError('Invalid embedded document provided to an ' + 'EmbeddedDocumentField') + self.document = document + super(EmbeddedDocumentField, self).__init__(**kwargs) diff --git a/tests/fields.py b/tests/fields.py index 1b2d6f72..973ee8db 100644 --- a/tests/fields.py +++ b/tests/fields.py @@ -17,6 +17,22 @@ class FieldTest(unittest.TestCase): self.assertEqual(person._data['age'], 30) self.assertEqual(person._data['userid'], 'test') + def test_required_values(self): + """Ensure that required field constraints are enforced. + """ + class Person(Document): + name = StringField(object_id=True) + age = IntField(required=True) + userid = StringField() + + self.assertRaises(ValidationError, Person, name="Test User") + self.assertRaises(ValidationError, Person, age=30) + + person = Person(name="Test User", age=30, userid="testuser") + self.assertRaises(ValidationError, person.__setattr__, 'name', None) + self.assertRaises(ValidationError, person.__setattr__, 'age', None) + person.userid = None + def test_string_validation(self): """Ensure that invalid values cannot be assigned to string fields. """