def test_validate(self):
class MySchema(EmbeddedSchema):
with_max = fields.IntField(validate=validate.Range(max=99))
d = DataProxy(MySchema(), data={})
with pytest.raises(ValidationError) as exc:
DataProxy(MySchema(), data={'with_max': 100})
assert exc.value.args[0] == {'with_max': ['Must be at most 99.']}
with pytest.raises(ValidationError) as exc:
d.set('with_max', 100)
assert exc.value.args[0] == ['Must be at most 99.']
def test_validate(self):
class MySchema(EmbeddedSchema):
with_max = fields.IntField(validate=validate.Range(max=99))
d = DataProxy(MySchema(), data={})
with pytest.raises(ValidationError) as exc:
DataProxy(MySchema(), data={'with_max': 100})
assert exc.value.args[0] == {'with_max': ['Must be at most 99.']}
with pytest.raises(ValidationError) as exc:
d.set('with_max', 100)
assert exc.value.args[0] == ['Must be at most 99.']
def test_default(self):
class MySchema(EmbeddedSchema):
with_default = fields.StrField(default='default_value')
with_missing = fields.StrField(missing='missing_value')
d = DataProxy(MySchema(), data={})
assert d._data['with_default'] is missing
assert d._data['with_missing'] is 'missing_value'
assert d.get('with_default') == 'default_value'
assert d.get('with_missing') == 'missing_value'
assert d.to_mongo() == {'with_missing': 'missing_value'}
assert d.dump() == {'with_default': 'default_value', 'with_missing': 'missing_value'}
def test_equality(self):
class MySchema(EmbeddedSchema):
a = fields.IntField()
b = fields.IntField(attribute='in_mongo_b')
d1 = DataProxy(MySchema())
d1.load({'a': 1, 'b': 2})
assert d1 == {'a': 1, 'in_mongo_b': 2}
d2 = DataProxy(MySchema())
d2.load({'a': 1, 'b': 2})
assert d1 == d2
def test_repr(self):
class MySchema(EmbeddedSchema):
field_a = fields.IntField()
field_b = fields.StrField()
d = DataProxy(MySchema(), {'field_a': 1, 'field_b': 'value'})
repr_d = repr(d)
assert repr_d.startswith("<DataProxy(")
assert "'field_a': 1" in repr_d
assert "'field_b': 'value'" in repr_d
def test_complexe_list(self):
class MyEmbeddedDocument(EmbeddedDocument):
field = fields.IntField()
class ToRefDoc(Document):
pass
class MySchema(Schema):
embeds = fields.ListField(fields.EmbeddedField(MyEmbeddedDocument))
refs = fields.ListField(fields.ReferenceField(ToRefDoc))
obj_id1 = ObjectId()
obj_id2 = ObjectId()
to_ref_doc1 = ToRefDoc.build_from_mongo(data={'_id': obj_id1})
d = DataProxy(MySchema())
d.load({
'embeds': [MyEmbeddedDocument(field=1),
{'field': 2}],
'refs': [to_ref_doc1, Reference(ToRefDoc, obj_id2)]
})
assert d.to_mongo() == {
'embeds': [{'field': 1}, {'field': 2}],
'refs': [obj_id1, obj_id2]
}
assert isinstance(d.get('embeds'), List)
assert isinstance(d.get('refs'), List)
for e in d.get('refs'):
assert isinstance(e, Reference)
for e in d.get('embeds'):
assert isinstance(e, MyEmbeddedDocument)
# Test list modification as well
refs_list = d.get('refs')
refs_list.append(to_ref_doc1)
refs_list.extend([to_ref_doc1, Reference(ToRefDoc, obj_id2)])
for e in refs_list:
assert isinstance(e, Reference)
embeds_list = d.get('embeds')
embeds_list.append(MyEmbeddedDocument(field=3))
embeds_list.extend([{'field': 4}, {'field': 5}])
for e in embeds_list:
assert isinstance(e, MyEmbeddedDocument)
def test_from_mongo(self):
class MySchema(EmbeddedSchema):
in_front = fields.IntField(attribute='in_mongo')
d = DataProxy(MySchema())
with pytest.raises(KeyError):
d.from_mongo({'in_front': 42})
d.from_mongo({'in_mongo': 42})
assert d.get('in_front') == 42
def test_embedded_document_required(self):
# TODO
class MyEmbeddedDocument(EmbeddedDocument):
required_field = fields.IntField(required=True)
optional_field = fields.IntField()
@self.instance.register
class MyDoc(Document):
embedded = fields.EmbeddedField(MyEmbeddedDocument,
attribute='in_mongo_embedded')
MySchema = MyDoc.Schema
# with pytest.raises(ValidationError):
# MyEmbeddedDocument()
# with pytest.raises(ValidationError):
# MyEmbeddedDocument(optional_field=1)
# embedded = MyEmbeddedDocument(optional_field=1, required_field=2)
embedded = MyEmbeddedDocument()
d = DataProxy(MySchema())
d.set('embedded', embedded)
def test_from_mongo(self):
class MySchema(EmbeddedSchema):
in_front = fields.IntField(attribute='in_mongo')
d = DataProxy(MySchema())
with pytest.raises(KeyError):
d.from_mongo({'in_front': 42})
d.from_mongo({'in_mongo': 42})
assert d.get('in_front') == 42
def test_embedded_document_required(self):
class MyEmbeddedDocument(EmbeddedDocument):
required_field = fields.IntField(required=True)
optional_field = fields.IntField()
class MySchema(Schema):
embedded = fields.EmbeddedField(MyEmbeddedDocument,
attribute='in_mongo_embedded')
with pytest.raises(ValidationError):
MyEmbeddedDocument()
with pytest.raises(ValidationError):
MyEmbeddedDocument(optional_field=1)
embedded = MyEmbeddedDocument(optional_field=1, required_field=2)
d = DataProxy(MySchema())
def test_equality(self):
class MySchema(EmbeddedSchema):
a = fields.IntField()
b = fields.IntField(attribute='in_mongo_b')
d1 = DataProxy(MySchema())
d1.load({'a': 1, 'b': 2})
assert d1 == {'a': 1, 'in_mongo_b': 2}
d2 = DataProxy(MySchema())
d2.load({'a': 1, 'b': 2})
assert d1 == d2
def test_dict(self):
class MySchema(Schema):
dict = fields.DictField(attribute='in_mongo_dict')
d = DataProxy(MySchema())
d.load({'dict': {'a': 1, 'b': {'c': True}}})
with pytest.raises(KeyError):
d.get('in_mongo_dict')
assert d.dump() == {'dict': {'a': 1, 'b': {'c': True}}}
assert d.get('dict') == {'a': 1, 'b': {'c': True}}
assert d.to_mongo() == {'in_mongo_dict': {'a': 1, 'b': {'c': True}}}
# Must manually set_dirty to take the changes into account
dict_ = d.get('dict')
dict_['a'] = 1
assert d.to_mongo(update=True) is None
dict_.set_modified()
assert d.to_mongo(update=True) == {
'$set': {
'in_mongo_dict': {
'a': 1,
'b': {
'c': True
}
}
}
}
dict_.clear_modified()
assert d.to_mongo(update=True) is None
d2 = DataProxy(MySchema(), {'dict': {}})
d2.to_mongo() == {'dict': {}}
d3 = DataProxy(MySchema())
d3.from_mongo({})
assert isinstance(d3.get('dict'), Dict)
assert d3.to_mongo() == {}
assert d3.to_mongo(update=True) is None
d3.get('dict')['field'] = 'value'
assert d3.to_mongo(update=True) is None
d3.get('dict').set_modified()
assert d3.to_mongo(update=True) == {
'$set': {
'in_mongo_dict': {
'field': 'value'
}
}
}
assert d3.to_mongo() == {'in_mongo_dict': {'field': 'value'}}
def test_complexe_list(self):
@self.instance.register
class MyEmbeddedDocument(EmbeddedDocument):
field = fields.IntField()
@self.instance.register
class ToRefDoc(Document):
pass
@self.instance.register
class MyDoc(Document):
embeds = fields.ListField(fields.EmbeddedField(MyEmbeddedDocument))
refs = fields.ListField(fields.ReferenceField(ToRefDoc))
MySchema = MyDoc.Schema
obj_id1 = ObjectId()
obj_id2 = ObjectId()
to_ref_doc1 = ToRefDoc.build_from_mongo(data={'_id': obj_id1})
d = DataProxy(MySchema())
d.load({
'embeds': [MyEmbeddedDocument(field=1), {
'field': 2
}],
'refs': [to_ref_doc1, Reference(ToRefDoc, obj_id2)]
})
assert d.to_mongo() == {
'embeds': [{
'field': 1
}, {
'field': 2
}],
'refs': [obj_id1, obj_id2]
}
assert isinstance(d.get('embeds'), List)
assert isinstance(d.get('refs'), List)
for e in d.get('refs'):
assert isinstance(e, Reference)
for e in d.get('embeds'):
assert isinstance(e, MyEmbeddedDocument)
# Test list modification as well
refs_list = d.get('refs')
refs_list.append(to_ref_doc1)
refs_list.extend([to_ref_doc1, Reference(ToRefDoc, obj_id2)])
for e in refs_list:
assert isinstance(e, Reference)
embeds_list = d.get('embeds')
embeds_list.append(MyEmbeddedDocument(field=3))
embeds_list.extend([{'field': 4}, {'field': 5}])
for e in embeds_list:
assert isinstance(e, MyEmbeddedDocument)
# Modifying an EmbeddedDocument inside a list should count a list modification
d.clear_modified()
d.get('refs')[0] = obj_id2
assert d.to_mongo(update=True) == {
'$set': {
'refs': [obj_id2, obj_id2, obj_id1, obj_id1, obj_id2]
}
}
d.clear_modified()
d.get('embeds')[1].field = 42
assert d.to_mongo(update=True) == {
'$set': {
'embeds': [{
'field': 1
}, {
'field': 42
}, {
'field': 3
}, {
'field': 4
}, {
'field': 5
}]
}
}
def test_dict(self):
class MySchema(Schema):
dict = fields.DictField(attribute='in_mongo_dict')
d = DataProxy(MySchema())
d.load({'dict': {'a': 1, 'b': {'c': True}}})
with pytest.raises(KeyError):
d.get('in_mongo_dict')
assert d.dump() == {'dict': {'a': 1, 'b': {'c': True}}}
assert d.get('dict') == {'a': 1, 'b': {'c': True}}
assert d.to_mongo() == {'in_mongo_dict': {'a': 1, 'b': {'c': True}}}
# Must manually set_dirty to take the changes into account
dict_ = d.get('dict')
dict_['a'] = 1
assert d.to_mongo(update=True) is None
dict_.set_modified()
assert d.to_mongo(update=True) == {'$set': {'in_mongo_dict': {'a': 1, 'b': {'c': True}}}}
dict_.clear_modified()
assert d.to_mongo(update=True) is None
d2 = DataProxy(MySchema(), {'dict': {}})
d2.to_mongo() == {'dict': {}}
d3 = DataProxy(MySchema())
d3.from_mongo({})
assert isinstance(d3.get('dict'), Dict)
assert d3.to_mongo() == {}
assert d3.to_mongo(update=True) is None
d3.get('dict')['field'] = 'value'
assert d3.to_mongo(update=True) is None
d3.get('dict').set_modified()
assert d3.to_mongo(update=True) == {'$set': {'in_mongo_dict': {'field': 'value'}}}
assert d3.to_mongo() == {'in_mongo_dict': {'field': 'value'}}
def test_reference_lazy(self):
class MyReferencedDocLazy(Document):
pass
to_refer_doc = MyReferencedDocLazy.build_from_mongo(
{'_id': ObjectId("5672d47b1d41c88dcd37ef05")})
class MySchema(Schema):
ref = fields.ReferenceField("MyReferencedDocLazy",
attribute='in_mongo_ref')
d = DataProxy(MySchema())
d.load({'ref': ObjectId("5672d47b1d41c88dcd37ef05")})
d.load({'ref': "5672d47b1d41c88dcd37ef05"})
assert d.dump() == {'ref': "5672d47b1d41c88dcd37ef05"}
assert d.get('ref').document_cls == MyReferencedDocLazy
d.set('ref', to_refer_doc)
assert d.to_mongo(update=True) == {
'$set': {
'in_mongo_ref': to_refer_doc.pk
}
}
assert d.get('ref').document_cls == MyReferencedDocLazy
def test_objectid(self):
class MySchema(Schema):
objid = fields.ObjectIdField(attribute='in_mongo_objid')
d = DataProxy(MySchema())
d.load({'objid': ObjectId("5672d47b1d41c88dcd37ef05")})
assert d.dump() == {'objid': "5672d47b1d41c88dcd37ef05"}
assert d.to_mongo() == {
'in_mongo_objid': ObjectId("5672d47b1d41c88dcd37ef05")
}
d.load({'objid': "5672d47b1d41c88dcd37ef05"})
assert d.dump() == {'objid': "5672d47b1d41c88dcd37ef05"}
assert d.to_mongo() == {
'in_mongo_objid': ObjectId("5672d47b1d41c88dcd37ef05")
}
assert d.get('objid') == ObjectId("5672d47b1d41c88dcd37ef05")
d.set('objid', ObjectId("5672d5e71d41c88f914b77c4"))
d.to_mongo(update=True) == {
'$set': {
'in_mongo_objid': ObjectId("5672d5e71d41c88f914b77c4")
}
}
d.set('objid', ObjectId("5672d5e71d41c88f914b77c4"))
d.to_mongo(update=True) == {
'$set': {
'in_mongo_objid': ObjectId("5672d5e71d41c88f914b77c4")
}
}
d.set('objid', "5672d5e71d41c88f914b77c4")
assert d.get('objid') == ObjectId("5672d5e71d41c88f914b77c4")
with pytest.raises(ValidationError):
d.set('objid', 'notanid')
def test_list(self):
class MySchema(Schema):
list = fields.ListField(fields.IntField(),
attribute='in_mongo_list')
d = DataProxy(MySchema())
assert d.to_mongo() == {}
d.load({'list': [1, 2, 3]})
assert d.dump() == {'list': [1, 2, 3]}
assert d.to_mongo() == {'in_mongo_list': [1, 2, 3]}
assert d.get('list') == [1, 2, 3]
d.get('list').append(4)
assert d.to_mongo(update=True) == {
'$set': {
'in_mongo_list': [1, 2, 3, 4]
}
}
d.clear_modified()
d.set('list', [5, 6, 7])
assert d.dump() == {'list': [5, 6, 7]}
assert d.to_mongo(update=True) == {
'$set': {
'in_mongo_list': [5, 6, 7]
}
}
d.clear_modified()
d.get('list').pop()
assert d.dump() == {'list': [5, 6]}
assert d.to_mongo(update=True) == {'$set': {'in_mongo_list': [5, 6]}}
d.clear_modified()
d.get('list').clear()
assert d.dump() == {'list': []}
assert d.to_mongo(update=True) == {'$unset': ['in_mongo_list']}
d.set('list', [1, 2, 3])
d.clear_modified()
d.get('list').remove(1)
assert d.dump() == {'list': [2, 3]}
assert d.to_mongo(update=True) == {'$set': {'in_mongo_list': [2, 3]}}
d.clear_modified()
d.get('list').reverse()
assert d.dump() == {'list': [3, 2]}
assert d.to_mongo(update=True) == {'$set': {'in_mongo_list': [3, 2]}}
d.clear_modified()
d.get('list').sort()
assert d.dump() == {'list': [2, 3]}
assert d.to_mongo(update=True) == {'$set': {'in_mongo_list': [2, 3]}}
d.clear_modified()
d.get('list').extend([4, 5])
assert d.dump() == {'list': [2, 3, 4, 5]}
assert d.to_mongo(update=True) == {
'$set': {
'in_mongo_list': [2, 3, 4, 5]
}
}
d2 = DataProxy(MySchema())
d2.from_mongo({})
assert isinstance(d2.get('list'), List)
assert d2.to_mongo() == {}
d2.get('list').append(1)
assert d2.to_mongo() == {'in_mongo_list': [1]}
assert d2.to_mongo(update=True) == {'$set': {'in_mongo_list': [1]}}
# Test repr readability
repr_d = repr(d.get('list'))
assert repr_d == "<object umongo.data_objects.List([2, 3, 4, 5])>"
def test_load(self):
class MySchema(EmbeddedSchema):
a = fields.IntField()
b = fields.IntField(attribute='in_mongo_b')
d = DataProxy(MySchema())
d.load({'a': 1, 'b': 2})
assert d.to_mongo() == {'a': 1, 'in_mongo_b': 2}
d.set('a', 3)
assert d.to_mongo(update=True) == {'$set': {'a': 3}}
d.load({'a': 4, 'b': 5})
assert d.to_mongo(update=True) is None
assert d.to_mongo() == {'a': 4, 'in_mongo_b': 5}
d2 = DataProxy(MySchema(), data={'a': 4, 'b': 5})
assert d == d2
def test_set_to_missing_fields(self):
class MySchema(EmbeddedSchema):
a = fields.IntField()
b = fields.IntField(attribute='in_mongo_b')
d = DataProxy(MySchema(), data={'a': 1})
assert d.get('b') is missing
assert d.get_by_mongo_name('in_mongo_b') is missing
assert d._data['in_mongo_b'] is missing
d.set('b', 2)
assert d.get('b') == 2
d.delete('b')
# Can do it two time in a row without error
d.delete('b')
assert d._data['in_mongo_b'] is missing
def test_partial(self):
class MySchema(EmbeddedSchema):
with_default = fields.StrField(default='default_value')
with_missing = fields.StrField(missing='missing_value')
normal = fields.StrField()
loaded = fields.StrField()
loaded_but_empty = fields.StrField()
d = DataProxy(MySchema())
d.from_mongo({
'loaded': "foo",
'loaded_but_empty': missing
},
partial=True)
assert d.partial is True
for field in ('with_default', 'with_missing', 'normal'):
with pytest.raises(exceptions.FieldNotLoadedError):
d.get(field)
with pytest.raises(exceptions.FieldNotLoadedError):
d.set(field, "test")
with pytest.raises(exceptions.FieldNotLoadedError):
d.delete(field)
assert d.get('loaded') == "foo"
assert d.get('loaded_but_empty') is missing
d.set('loaded_but_empty', "bar")
assert d.get('loaded_but_empty') == "bar"
d.delete('loaded')
# Can still access the deleted field
assert d.get('loaded') is missing
# Same test, but using `load`
d = DataProxy(MySchema())
d.load({'loaded': "foo", 'loaded_but_empty': missing}, partial=True)
assert d.partial is True
for field in ('with_default', 'with_missing', 'normal'):
with pytest.raises(exceptions.FieldNotLoadedError):
d.get(field)
with pytest.raises(exceptions.FieldNotLoadedError):
d.set(field, "test")
with pytest.raises(exceptions.FieldNotLoadedError):
d.delete(field)
assert d.get('loaded') == "foo"
assert d.get('loaded_but_empty') is missing
d.set('loaded_but_empty', "bar")
assert d.get('loaded_but_empty') == "bar"
d.delete('loaded')
# Can still access the deleted field
assert d.get('loaded') is missing
# Not partial
d = DataProxy(MySchema())
d.from_mongo({'loaded': "foo", 'loaded_but_empty': missing})
assert d.partial is False
assert d.get('with_default') == 'default_value'
assert d.get('with_missing') == 'missing_value'
assert d.get('normal') is missing
assert d.get('loaded') == "foo"
assert d.get('loaded_but_empty') == missing
# Same test with load
d = DataProxy(MySchema())
d.load({'loaded': "foo", 'loaded_but_empty': missing})
assert d.partial is False
assert d.partial is False
assert d.get('with_default') == 'default_value'
assert d.get('with_missing') == 'missing_value'
assert d.get('normal') is missing
assert d.get('loaded') == "foo"
assert d.get('loaded_but_empty') == missing
def test_simple(self):
class MySchema(EmbeddedSchema):
a = fields.IntField()
b = fields.IntField()
d = DataProxy(MySchema())
d.load({'a': 1, 'b': 2})
assert d.get('a') == 1
d.set('b', 3)
assert d.get('b') == 3
assert d._data == {'a': 1, 'b': 3}
assert d.dump() == {'a': 1, 'b': 3}
d.delete('b')
assert d._data == {'a': 1, 'b': missing}
assert d.dump() == {'a': 1}
def test_set_to_missing_fields(self):
class MySchema(EmbeddedSchema):
a = fields.IntField()
b = fields.IntField(attribute='in_mongo_b')
d = DataProxy(MySchema(), data={'a': 1})
assert d.get('b') is None
assert d.get_by_mongo_name('in_mongo_b') is None
assert d._data['in_mongo_b'] is missing
with pytest.raises(KeyError):
d.delete('b')
d.set('b', 2)
assert d.get('b') == 2
d.delete('b')
assert d._data['in_mongo_b'] is missing
def test_access_by_mongo_name(self):
class MySchema(EmbeddedSchema):
a = fields.IntField()
b = fields.IntField(attribute='in_mongo_b')
d = DataProxy(MySchema(), data={'a': 1, 'b': 2})
assert d.get_by_mongo_name('in_mongo_b') == 2
assert d.get_by_mongo_name('a') == 1
with pytest.raises(KeyError):
d.get_by_mongo_name('b')
d.set_by_mongo_name('in_mongo_b', 3)
assert d.to_mongo(update=True) == {'$set': {'in_mongo_b': 3}}
assert d.get_by_mongo_name('in_mongo_b') == 3
d.delete_by_mongo_name('in_mongo_b')
assert d.to_mongo(update=True) == {'$unset': ['in_mongo_b']}
def test_embedded_document(self):
class MyEmbeddedDocument(EmbeddedDocument):
a = fields.IntField(attribute='in_mongo_a')
b = fields.IntField()
class MySchema(Schema):
embedded = fields.EmbeddedField(MyEmbeddedDocument,
attribute='in_mongo_embedded')
# Make sure embedded document doesn't have implicit _id field
assert '_id' not in MyEmbeddedDocument.Schema().fields
assert 'id' not in MyEmbeddedDocument.Schema().fields
d = DataProxy(MySchema())
d.load(data={'embedded': {'a': 1, 'b': 2}})
assert d.dump() == {'embedded': {'a': 1, 'b': 2}}
embedded = d.get('embedded')
assert type(embedded) == MyEmbeddedDocument
assert embedded.a == 1
assert embedded.b == 2
assert embedded.dump() == {'a': 1, 'b': 2}
assert embedded.to_mongo() == {'in_mongo_a': 1, 'b': 2}
assert d.to_mongo() == {'in_mongo_embedded': {'in_mongo_a': 1, 'b': 2}}
d2 = DataProxy(MySchema())
d2.from_mongo(data={'in_mongo_embedded': {'in_mongo_a': 1, 'b': 2}})
assert d == d2
embedded.a = 3
assert embedded.to_mongo(update=True) == {'$set': {'in_mongo_a': 3}}
assert d.to_mongo(update=True) == {
'$set': {
'in_mongo_embedded': {
'in_mongo_a': 3,
'b': 2
}
}
}
embedded.clear_modified()
assert embedded.to_mongo(update=True) == None
assert d.to_mongo(update=True) == None
del embedded.a
assert embedded.to_mongo(update=True) == {'$unset': ['in_mongo_a']}
assert d.to_mongo(update=True) == {
'$set': {
'in_mongo_embedded': {
'b': 2
}
}
}
d.set('embedded', MyEmbeddedDocument(a=4))
assert d.get('embedded').to_mongo(update=True) is None
assert d.to_mongo(update=True) == {
'$set': {
'in_mongo_embedded': {
'in_mongo_a': 4
}
}
}
embedded_doc = MyEmbeddedDocument(a=1, b=2)
assert embedded_doc.a == 1
assert embedded_doc.b == 2
assert embedded_doc == {'in_mongo_a': 1, 'b': 2}
assert embedded_doc == MyEmbeddedDocument(a=1, b=2)
assert embedded_doc['a'] == 1
assert embedded_doc['b'] == 2
with pytest.raises(ValidationError):
MyEmbeddedDocument(in_mongo_a=1, b=2)
embedded_doc['a'] = 1
assert embedded_doc.a == embedded_doc['a'] == 1
del embedded_doc['a']
assert embedded_doc.a == embedded_doc['a'] == None
# Test repr readability
repr_d = repr(MyEmbeddedDocument(a=1, b=2))
assert 'tests.test_fields.MyEmbeddedDocument' in repr_d
assert "'in_mongo_a': 1" in repr_d
assert "'b': 2" in repr_d
def test_modify(self):
class MySchema(EmbeddedSchema):
a = fields.IntField()
b = fields.IntField(attribute='in_mongo_b')
d = DataProxy(MySchema())
d.load({'a': 1, 'b': 2})
assert d.to_mongo() == {'a': 1, 'in_mongo_b': 2}
assert d.to_mongo(update=True) is None
d.set('a', 3)
d.delete('b')
assert d.to_mongo(update=True) == {'$set': {'a': 3}, '$unset': ['in_mongo_b']}
d.clear_modified()
assert d.to_mongo(update=True) is None
assert d.to_mongo() == {'a': 3}
def test_objectid(self):
class MySchema(Schema):
objid = fields.ObjectIdField(attribute='in_mongo_objid')
d = DataProxy(MySchema())
d.load({'objid': ObjectId("5672d47b1d41c88dcd37ef05")})
assert d.dump() == {'objid': "5672d47b1d41c88dcd37ef05"}
assert d.to_mongo() == {'in_mongo_objid': ObjectId("5672d47b1d41c88dcd37ef05")}
d.load({'objid': "5672d47b1d41c88dcd37ef05"})
assert d.dump() == {'objid': "5672d47b1d41c88dcd37ef05"}
assert d.to_mongo() == {'in_mongo_objid': ObjectId("5672d47b1d41c88dcd37ef05")}
assert d.get('objid') == ObjectId("5672d47b1d41c88dcd37ef05")
d.set('objid', ObjectId("5672d5e71d41c88f914b77c4"))
d.to_mongo(update=True) == {
'$set': {'in_mongo_objid': ObjectId("5672d5e71d41c88f914b77c4")}}
d.set('objid', ObjectId("5672d5e71d41c88f914b77c4"))
d.to_mongo(update=True) == {
'$set': {'in_mongo_objid': ObjectId("5672d5e71d41c88f914b77c4")}}
d.set('objid', "5672d5e71d41c88f914b77c4")
assert d.get('objid') == ObjectId("5672d5e71d41c88f914b77c4")
with pytest.raises(ValidationError):
d.set('objid', 'notanid')
def test_complexe_list(self):
class MyEmbeddedDocument(EmbeddedDocument):
field = fields.IntField()
class ToRefDoc(Document):
pass
class MySchema(Schema):
embeds = fields.ListField(fields.EmbeddedField(MyEmbeddedDocument))
refs = fields.ListField(fields.ReferenceField(ToRefDoc))
obj_id1 = ObjectId()
obj_id2 = ObjectId()
to_ref_doc1 = ToRefDoc.build_from_mongo(data={'_id': obj_id1})
d = DataProxy(MySchema())
d.load({
'embeds': [MyEmbeddedDocument(field=1), {
'field': 2
}],
'refs': [to_ref_doc1, Reference(ToRefDoc, obj_id2)]
})
assert d.to_mongo() == {
'embeds': [{
'field': 1
}, {
'field': 2
}],
'refs': [obj_id1, obj_id2]
}
assert isinstance(d.get('embeds'), List)
assert isinstance(d.get('refs'), List)
for e in d.get('refs'):
assert isinstance(e, Reference)
for e in d.get('embeds'):
assert isinstance(e, MyEmbeddedDocument)
# Test list modification as well
refs_list = d.get('refs')
refs_list.append(to_ref_doc1)
refs_list.extend([to_ref_doc1, Reference(ToRefDoc, obj_id2)])
for e in refs_list:
assert isinstance(e, Reference)
embeds_list = d.get('embeds')
embeds_list.append(MyEmbeddedDocument(field=3))
embeds_list.extend([{'field': 4}, {'field': 5}])
for e in embeds_list:
assert isinstance(e, MyEmbeddedDocument)
def test_reference_lazy(self):
class MyReferencedDocLazy(Document):
pass
to_refer_doc = MyReferencedDocLazy.build_from_mongo(
{'_id': ObjectId("5672d47b1d41c88dcd37ef05")})
class MySchema(Schema):
ref = fields.ReferenceField("MyReferencedDocLazy", attribute='in_mongo_ref')
d = DataProxy(MySchema())
d.load({'ref': ObjectId("5672d47b1d41c88dcd37ef05")})
d.load({'ref': "5672d47b1d41c88dcd37ef05"})
assert d.dump() == {'ref': "5672d47b1d41c88dcd37ef05"}
assert d.get('ref').document_cls == MyReferencedDocLazy
d.set('ref', to_refer_doc)
assert d.to_mongo(update=True) == {'$set': {'in_mongo_ref': to_refer_doc.pk}}
assert d.get('ref').document_cls == MyReferencedDocLazy
def test_reference(self, collection_moke):
class MyReferencedDoc(Document):
class Meta:
collection = collection_moke
class OtherDoc(Document):
pass
to_refer_doc = MyReferencedDoc.build_from_mongo(
{'_id': ObjectId("5672d47b1d41c88dcd37ef05")})
ref = Reference(MyReferencedDoc, to_refer_doc.pk)
dbref = DBRef(collection_moke.name, to_refer_doc.pk)
other_doc = OtherDoc.build_from_mongo(
{'_id': ObjectId("5672d47b1d41c88dcd37ef07")})
# Test reference equality
assert ref == to_refer_doc
assert ref == dbref
assert dbref == to_refer_doc
assert dbref == ref
assert to_refer_doc == ref
assert to_refer_doc == dbref
class MySchema(Schema):
ref = fields.ReferenceField(MyReferencedDoc,
attribute='in_mongo_ref')
d = DataProxy(MySchema())
d.load({'ref': ObjectId("5672d47b1d41c88dcd37ef05")})
d.load({'ref': "5672d47b1d41c88dcd37ef05"})
assert d.dump() == {'ref': "5672d47b1d41c88dcd37ef05"}
d.get('ref').document_cls == MyReferencedDoc
d.set('ref', to_refer_doc)
assert d.to_mongo(update=True) == {
'$set': {
'in_mongo_ref': to_refer_doc.pk
}
}
assert d.get('ref') == ref
d.set('ref', ref)
assert d.get('ref') == ref
d.set('ref', dbref)
assert d.get('ref') == ref
with pytest.raises(ValidationError):
d.set('ref', other_doc)
not_created_doc = MyReferencedDoc()
with pytest.raises(ValidationError):
d.set('ref', not_created_doc)
bad_ref = Reference(OtherDoc, other_doc.pk)
with pytest.raises(ValidationError):
d.set('ref', bad_ref)
def test_list(self):
class MySchema(Schema):
list = fields.ListField(fields.IntField(), attribute='in_mongo_list')
d = DataProxy(MySchema())
assert d.to_mongo() == {}
d.load({'list': [1, 2, 3]})
assert d.dump() == {'list': [1, 2, 3]}
assert d.to_mongo() == {'in_mongo_list': [1, 2, 3]}
assert d.get('list') == [1, 2, 3]
d.get('list').append(4)
assert d.to_mongo(update=True) == {'$set': {'in_mongo_list': [1, 2, 3, 4]}}
d.clear_modified()
d.set('list', [5, 6, 7])
assert d.dump() == {'list': [5, 6, 7]}
assert d.to_mongo(update=True) == {'$set': {'in_mongo_list': [5, 6, 7]}}
d.clear_modified()
d.get('list').pop()
assert d.dump() == {'list': [5, 6]}
assert d.to_mongo(update=True) == {'$set': {'in_mongo_list': [5, 6]}}
d.clear_modified()
d.get('list').clear()
assert d.dump() == {'list': []}
assert d.to_mongo(update=True) == {'$unset': ['in_mongo_list']}
d.set('list', [1, 2, 3])
d.clear_modified()
d.get('list').remove(1)
assert d.dump() == {'list': [2, 3]}
assert d.to_mongo(update=True) == {'$set': {'in_mongo_list': [2, 3]}}
d.clear_modified()
d.get('list').reverse()
assert d.dump() == {'list': [3, 2]}
assert d.to_mongo(update=True) == {'$set': {'in_mongo_list': [3, 2]}}
d.clear_modified()
d.get('list').sort()
assert d.dump() == {'list': [2, 3]}
assert d.to_mongo(update=True) == {'$set': {'in_mongo_list': [2, 3]}}
d.clear_modified()
d.get('list').extend([4, 5])
assert d.dump() == {'list': [2, 3, 4, 5]}
assert d.to_mongo(update=True) == {'$set': {'in_mongo_list': [2, 3, 4, 5]}}
d2 = DataProxy(MySchema())
d2.from_mongo({})
assert isinstance(d2.get('list'), List)
assert d2.to_mongo() == {}
d2.get('list').append(1)
assert d2.to_mongo() == {'in_mongo_list': [1]}
assert d2.to_mongo(update=True) == {'$set': {'in_mongo_list': [1]}}
# Test repr readability
repr_d = repr(d.get('list'))
assert repr_d == "<object umongo.data_objects.List([2, 3, 4, 5])>"
def test_generic_reference(self, db_moke):
class ToRef1(Document):
class Config:
collection = db_moke.col_ref1
class ToRef2(Document):
class Config:
collection = db_moke.col_ref2
doc1 = ToRef1.build_from_mongo({'_id': ObjectId()})
ref1 = Reference(ToRef1, doc1.pk)
class MySchema(Schema):
gref = fields.GenericReferenceField(attribute='in_mongo_gref')
d = DataProxy(MySchema())
d.load({
'gref': {
'id': ObjectId("5672d47b1d41c88dcd37ef05"),
'cls': ToRef2.__name__
}
})
assert d.dump() == {
'gref': {
'id': "5672d47b1d41c88dcd37ef05",
'cls': 'ToRef2'
}
}
d.get('gref').document_cls == ToRef2
d.set('gref', doc1)
assert d.to_mongo(update=True) == {
'$set': {
'in_mongo_gref': {
'_id': doc1.pk,
'_cls': 'ToRef1'
}
}
}
assert d.get('gref') == ref1
d.set('gref', ref1)
assert d.get('gref') == ref1
assert d.dump() == {'gref': {'id': str(doc1.pk), 'cls': 'ToRef1'}}
not_created_doc = ToRef1()
with pytest.raises(ValidationError):
d.set('gref', not_created_doc)
# Test invalid references
for v in [
{
'id': ObjectId()
}, # missing _cls
{
'cls': ToRef1.__name__
}, # missing _id
{
'id': ObjectId(),
'cls': 'dummy!'
}, # invalid _cls
{
'_id': ObjectId(),
'_cls': ToRef1.__name__
}, # bad field names
{
'id': ObjectId(),
'cls': ToRef1.__name__,
'e': '?'
}, # too much fields
ObjectId("5672d47b1d41c88dcd37ef05"), # missing cls info
42, # Are you kidding ?
'', # Please stop...
True # I'm outa of that !
]:
with pytest.raises(ValidationError) as exc:
d.set('gref', v)
def test_del(self):
class MySchema(EmbeddedSchema):
a = fields.IntField()
b = fields.IntField(attribute='in_mongo_b')
d = DataProxy(MySchema())
d.load({'a': 1, 'b': 2})
d.delete('b')
assert d.to_mongo() == {'a': 1}
assert d.to_mongo(update=True) == {'$unset': ['in_mongo_b']}
d.delete('a')
assert d.to_mongo(update=True) == {'$unset': ['a', 'in_mongo_b']}
with pytest.raises(KeyError):
d.delete('in_mongo_b')
def test_embedded_document(self):
class MyEmbeddedDocument(EmbeddedDocument):
a = fields.IntField(attribute='in_mongo_a')
b = fields.IntField()
class MySchema(Schema):
embedded = fields.EmbeddedField(MyEmbeddedDocument, attribute='in_mongo_embedded')
# Make sure embedded document doesn't have implicit _id field
assert '_id' not in MyEmbeddedDocument.Schema().fields
assert 'id' not in MyEmbeddedDocument.Schema().fields
d = DataProxy(MySchema())
d.load(data={'embedded': {'a': 1, 'b': 2}})
assert d.dump() == {'embedded': {'a': 1, 'b': 2}}
embedded = d.get('embedded')
assert type(embedded) == MyEmbeddedDocument
assert embedded.a == 1
assert embedded.b == 2
assert embedded.dump() == {'a': 1, 'b': 2}
assert embedded.to_mongo() == {'in_mongo_a': 1, 'b': 2}
assert d.to_mongo() == {'in_mongo_embedded': {'in_mongo_a': 1, 'b': 2}}
d2 = DataProxy(MySchema())
d2.from_mongo(data={'in_mongo_embedded': {'in_mongo_a': 1, 'b': 2}})
assert d == d2
embedded.a = 3
assert embedded.to_mongo(update=True) == {'$set': {'in_mongo_a': 3}}
assert d.to_mongo(update=True) == {'$set': {'in_mongo_embedded': {'in_mongo_a': 3, 'b': 2}}}
embedded.clear_modified()
assert embedded.to_mongo(update=True) == None
assert d.to_mongo(update=True) == None
del embedded.a
assert embedded.to_mongo(update=True) == {'$unset': ['in_mongo_a']}
assert d.to_mongo(update=True) == {'$set': {'in_mongo_embedded': {'b': 2}}}
d.set('embedded', MyEmbeddedDocument(a=4))
assert d.get('embedded').to_mongo(update=True) is None
assert d.to_mongo(update=True) == {'$set': {'in_mongo_embedded': {'in_mongo_a': 4}}}
embedded_doc = MyEmbeddedDocument(a=1, b=2)
assert embedded_doc.a == 1
assert embedded_doc.b == 2
assert embedded_doc == {'in_mongo_a': 1, 'b': 2}
assert embedded_doc == MyEmbeddedDocument(a=1, b=2)
assert embedded_doc['a'] == 1
assert embedded_doc['b'] == 2
with pytest.raises(ValidationError):
MyEmbeddedDocument(in_mongo_a=1, b=2)
embedded_doc['a'] = 1
assert embedded_doc.a == embedded_doc['a'] == 1
del embedded_doc['a']
assert embedded_doc.a == embedded_doc['a'] == None
# Test repr readability
repr_d = repr(MyEmbeddedDocument(a=1, b=2))
assert 'tests.test_fields.MyEmbeddedDocument' in repr_d
assert "'in_mongo_a': 1" in repr_d
assert "'b': 2" in repr_d
def test_route_naming(self):
class MySchema(EmbeddedSchema):
in_front = fields.IntField(attribute='in_mongo')
d = DataProxy(MySchema())
with pytest.raises(ValidationError):
d.load({'in_mongo': 42})
d.load({'in_front': 42})
with pytest.raises(KeyError):
d.get('in_mongo')
assert d.get('in_front') == 42
d.set('in_front', 24)
assert d._data == {'in_mongo': 24}
assert d.get('in_front') == 24
assert d.dump() == {'in_front': 24}
assert d.to_mongo() == {'in_mongo': 24}
def test_complexe_field_clear_modified(self):
class MyEmbedded(EmbeddedDocument):
aa = fields.IntField()
class MySchema(EmbeddedSchema):
a = fields.EmbeddedField(MyEmbedded)
b = fields.ListField(fields.IntField)
d = DataProxy(MySchema())
d.load({'a': {'aa': 1}, 'b': [2, 3]})
assert d.to_mongo() == {'a': {'aa': 1}, 'b': [2, 3]}
d.get('a').aa = 4
d.get('b').append(5)
assert d.to_mongo(update=True) == {'$set': {'a': {'aa': 4}, 'b': [2, 3, 5]}}
d.clear_modified()
assert d.to_mongo(update=True) is None
assert not d.get('a').is_modified()
assert not d.get('b').is_modified()
def test_complexe_field_clear_modified(self):
@self.instance.register
class MyEmbedded(EmbeddedDocument):
aa = fields.IntField()
class MySchema(EmbeddedSchema):
# EmbeddedField need instance to retrieve implementation
a = fields.EmbeddedField(MyEmbedded, instance=self.instance)
b = fields.ListField(fields.IntField)
d = DataProxy(MySchema())
d.load({'a': {'aa': 1}, 'b': [2, 3]})
assert d.to_mongo() == {'a': {'aa': 1}, 'b': [2, 3]}
d.get('a').aa = 4
d.get('b').append(5)
assert d.to_mongo(update=True) == {
'$set': {
'a': {
'aa': 4
},
'b': [2, 3, 5]
}
}
d.clear_modified()
assert d.to_mongo(update=True) is None
assert not d.get('a').is_modified()
assert not d.get('b').is_modified()
def test_reference(self, collection_moke):
class MyReferencedDoc(Document):
class Meta:
collection = collection_moke
class OtherDoc(Document):
pass
to_refer_doc = MyReferencedDoc.build_from_mongo(
{'_id': ObjectId("5672d47b1d41c88dcd37ef05")})
ref = Reference(MyReferencedDoc, to_refer_doc.pk)
dbref = DBRef(collection_moke.name, to_refer_doc.pk)
other_doc = OtherDoc.build_from_mongo(
{'_id': ObjectId("5672d47b1d41c88dcd37ef07")})
# Test reference equality
assert ref == to_refer_doc
assert ref == dbref
assert dbref == to_refer_doc
assert dbref == ref
assert to_refer_doc == ref
assert to_refer_doc == dbref
class MySchema(Schema):
ref = fields.ReferenceField(MyReferencedDoc, attribute='in_mongo_ref')
d = DataProxy(MySchema())
d.load({'ref': ObjectId("5672d47b1d41c88dcd37ef05")})
d.load({'ref': "5672d47b1d41c88dcd37ef05"})
assert d.dump() == {'ref': "5672d47b1d41c88dcd37ef05"}
d.get('ref').document_cls == MyReferencedDoc
d.set('ref', to_refer_doc)
assert d.to_mongo(update=True) == {'$set': {'in_mongo_ref': to_refer_doc.pk}}
assert d.get('ref') == ref
d.set('ref', ref)
assert d.get('ref') == ref
d.set('ref', dbref)
assert d.get('ref') == ref
with pytest.raises(ValidationError):
d.set('ref', other_doc)
not_created_doc = MyReferencedDoc()
with pytest.raises(ValidationError):
d.set('ref', not_created_doc)
bad_ref = Reference(OtherDoc, other_doc.pk)
with pytest.raises(ValidationError):
d.set('ref', bad_ref)
def test_set(self):
class MySchema(EmbeddedSchema):
a = fields.IntField()
b = fields.IntField(attribute='in_mongo_b')
d = DataProxy(MySchema())
d.load({'a': 1, 'b': 2})
d.set('a', 3)
assert d.to_mongo() == {'a': 3, 'in_mongo_b': 2}
assert d.to_mongo(update=True) == {'$set': {'a': 3}}
d.load({'a': 1, 'b': 2})
d.set('b', 3)
assert d.to_mongo() == {'a': 1, 'in_mongo_b': 3}
assert d.to_mongo(update=True) == {'$set': {'in_mongo_b': 3}}
with pytest.raises(KeyError):
d.set('in_mongo_b', 2)
def test_generic_reference(self, db_moke):
class ToRef1(Document):
class Config:
collection = db_moke.col_ref1
class ToRef2(Document):
class Config:
collection = db_moke.col_ref2
doc1 = ToRef1.build_from_mongo({'_id': ObjectId()})
ref1 = Reference(ToRef1, doc1.pk)
class MySchema(Schema):
gref = fields.GenericReferenceField(attribute='in_mongo_gref')
d = DataProxy(MySchema())
d.load({'gref': {'id': ObjectId("5672d47b1d41c88dcd37ef05"), 'cls': ToRef2.__name__}})
assert d.dump() == {'gref': {'id': "5672d47b1d41c88dcd37ef05", 'cls': 'ToRef2'}}
d.get('gref').document_cls == ToRef2
d.set('gref', doc1)
assert d.to_mongo(update=True) == {'$set': {'in_mongo_gref': {'_id': doc1.pk, '_cls': 'ToRef1'}}}
assert d.get('gref') == ref1
d.set('gref', ref1)
assert d.get('gref') == ref1
assert d.dump() == {'gref': {'id': str(doc1.pk), 'cls': 'ToRef1'}}
not_created_doc = ToRef1()
with pytest.raises(ValidationError):
d.set('gref', not_created_doc)
# Test invalid references
for v in [
{'id': ObjectId()}, # missing _cls
{'cls': ToRef1.__name__}, # missing _id
{'id': ObjectId(), 'cls': 'dummy!'}, # invalid _cls
{'_id': ObjectId(), '_cls': ToRef1.__name__}, # bad field names
{'id': ObjectId(), 'cls': ToRef1.__name__, 'e': '?'}, # too much fields
ObjectId("5672d47b1d41c88dcd37ef05"), # missing cls info
42, # Are you kidding ?
'', # Please stop...
True # I'm outa of that !
]:
with pytest.raises(ValidationError) as exc:
d.set('gref', v)
def test_embedded_document(self):
@self.instance.register
class MyEmbeddedDocument(EmbeddedDocument):
a = fields.IntField(attribute='in_mongo_a')
b = fields.IntField()
@self.instance.register
class MyDoc(Document):
embedded = fields.EmbeddedField(MyEmbeddedDocument,
attribute='in_mongo_embedded')
MySchema = MyDoc.Schema
modified_schema = MyDoc.Schema(load_only=('embedded', ))
modified_embedded_schema = MyEmbeddedDocument.Schema(load_only=('a', ))
# Make sure embedded document doesn't have implicit _id field
assert '_id' not in MyEmbeddedDocument.Schema().fields
assert 'id' not in MyEmbeddedDocument.Schema().fields
d = DataProxy(MySchema())
d.load(data={'embedded': {'a': 1, 'b': 2}})
assert d.dump() == {'embedded': {'a': 1, 'b': 2}}
assert d.dump(schema=modified_schema) == {}
embedded = d.get('embedded')
assert type(embedded) == MyEmbeddedDocument
assert embedded.a == 1
assert embedded.b == 2
assert embedded.dump() == {'a': 1, 'b': 2}
assert embedded.dump(schema=modified_embedded_schema) == {'b': 2}
assert embedded.to_mongo() == {'in_mongo_a': 1, 'b': 2}
assert d.to_mongo() == {'in_mongo_embedded': {'in_mongo_a': 1, 'b': 2}}
d2 = DataProxy(MySchema())
d2.from_mongo(data={'in_mongo_embedded': {'in_mongo_a': 1, 'b': 2}})
assert d == d2
embedded.a = 3
assert embedded.to_mongo(update=True) == {'$set': {'in_mongo_a': 3}}
assert d.to_mongo(update=True) == {
'$set': {
'in_mongo_embedded': {
'in_mongo_a': 3,
'b': 2
}
}
}
embedded.clear_modified()
assert embedded.to_mongo(update=True) is None
assert d.to_mongo(update=True) is None
del embedded.a
assert embedded.to_mongo(update=True) == {'$unset': {'in_mongo_a': ''}}
assert d.to_mongo(update=True) == {
'$set': {
'in_mongo_embedded': {
'b': 2
}
}
}
d.set('embedded', MyEmbeddedDocument(a=4))
assert d.get('embedded').to_mongo(update=True) is None
assert d.to_mongo(update=True) == {
'$set': {
'in_mongo_embedded': {
'in_mongo_a': 4
}
}
}
embedded_doc = MyEmbeddedDocument(a=1, b=2)
assert embedded_doc.a == 1
assert embedded_doc.b == 2
assert embedded_doc == {'in_mongo_a': 1, 'b': 2}
assert embedded_doc == MyEmbeddedDocument(a=1, b=2)
assert embedded_doc['a'] == 1
assert embedded_doc['b'] == 2
with pytest.raises(ValidationError):
MyEmbeddedDocument(in_mongo_a=1, b=2)
embedded_doc['a'] = 1
assert embedded_doc.a == embedded_doc['a'] == 1
del embedded_doc['a']
assert embedded_doc.a is embedded_doc['a'] is None
# Test repr readability
repr_d = repr(MyEmbeddedDocument(a=1, b=2))
assert 'tests.test_fields.MyEmbeddedDocument' in repr_d
assert "'in_mongo_a': 1" in repr_d
assert "'b': 2" in repr_d
# Test unknown fields
with pytest.raises(AttributeError):
embedded_doc.dummy
with pytest.raises(AttributeError):
embedded_doc.dummy = None
with pytest.raises(AttributeError):
del embedded_doc.dummy
with pytest.raises(KeyError):
embedded_doc['dummy']
with pytest.raises(KeyError):
embedded_doc['dummy'] = None
with pytest.raises(KeyError):
del embedded_doc['dummy']