Merge remote-tracking branch 'mallard/master' into 0.9
Conflicts: AUTHORS mongoengine/document.py
This commit is contained in:
Ross Lawley
commit
061cee83a8
33 changed files with 1117 additions and 1119 deletions
90
tests/benchmark.py
Normal file
90
tests/benchmark.py
Normal file
|
|
@ -0,0 +1,90 @@
|
|||
from mongoengine import *
|
||||
from timeit import repeat
|
||||
import unittest
|
||||
|
||||
conn_settings = {
|
||||
'db': 'mongomallard-test',
|
||||
}
|
||||
|
||||
connect(**conn_settings)
|
||||
|
||||
def timeit(f, n=10000):
|
||||
return min(repeat(f, repeat=3, number=n))/float(n)
|
||||
|
||||
class BenchmarkTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
pass
|
||||
|
||||
def test_basic(self):
|
||||
class Book(Document):
|
||||
name = StringField()
|
||||
pages = IntField()
|
||||
tags = ListField(StringField())
|
||||
is_published = BooleanField()
|
||||
|
||||
Book.drop_collection()
|
||||
|
||||
create_book = lambda: Book(name='Always be closing', pages=100, tags=['self-help', 'sales'], is_published=True)
|
||||
print 'Doc initialization: %.3fus' % (timeit(create_book, 1000) * 10**6)
|
||||
|
||||
b = create_book()
|
||||
|
||||
print 'Doc getattr: %.3fus' % (timeit(lambda: b.name, 10000) * 10**6)
|
||||
|
||||
print 'Doc setattr: %.3fus' % (timeit(lambda: setattr(b, 'name', 'New name'), 10000) * 10**6)
|
||||
|
||||
print 'Doc to mongo: %.3fus' % (timeit(b.to_mongo, 1000) * 10**6)
|
||||
|
||||
def save_book():
|
||||
b._mark_as_changed('name')
|
||||
b._mark_as_changed('tags')
|
||||
b.save()
|
||||
|
||||
save_book()
|
||||
son = b.to_mongo()
|
||||
|
||||
print 'Load from SON: %.3fus' % (timeit(lambda: Book._from_son(son), 1000) * 10**6)
|
||||
|
||||
print 'Save to database: %.3fus' % (timeit(save_book, 100) * 10**6)
|
||||
|
||||
print 'Load from database: %.3fus' % (timeit(lambda: Book.objects[0], 100) * 10**6)
|
||||
|
||||
def test_embedded(self):
|
||||
class Contact(EmbeddedDocument):
|
||||
name = StringField()
|
||||
title = StringField()
|
||||
address = StringField()
|
||||
|
||||
class Company(Document):
|
||||
name = StringField()
|
||||
contacts = ListField(EmbeddedDocumentField(Contact))
|
||||
|
||||
Company.drop_collection()
|
||||
|
||||
def get_company():
|
||||
return Company(
|
||||
name='Elastic',
|
||||
contacts=[
|
||||
Contact(
|
||||
name='Contact %d' % x,
|
||||
title='CEO',
|
||||
address='Address %d' % x,
|
||||
)
|
||||
for x in range(1000)]
|
||||
)
|
||||
|
||||
def create_company():
|
||||
c = get_company()
|
||||
c.save()
|
||||
c.delete()
|
||||
|
||||
print 'Save/delete big object to database: %.3fms' % (timeit(create_company, 10) * 10**3)
|
||||
|
||||
c = get_company().save()
|
||||
|
||||
print 'Serialize big object from database: %.3fms' % (timeit(c.to_mongo, 100) * 10**3)
|
||||
print 'Load big object from database: %.3fms' % (timeit(lambda: Company.objects[0], 100) * 10**3)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
|
|
@ -48,41 +48,42 @@ class DeltaTest(unittest.TestCase):
|
|||
doc.save()
|
||||
|
||||
doc = Doc.objects.first()
|
||||
self.assertEqual(doc._get_changed_fields(), [])
|
||||
self.assertEqual(doc._get_changed_fields(), set())
|
||||
self.assertEqual(doc._delta(), ({}, {}))
|
||||
|
||||
doc.string_field = 'hello'
|
||||
self.assertEqual(doc._get_changed_fields(), ['string_field'])
|
||||
self.assertEqual(doc._get_changed_fields(), set(['string_field']))
|
||||
self.assertEqual(doc._delta(), ({'string_field': 'hello'}, {}))
|
||||
|
||||
doc._changed_fields = []
|
||||
doc._changed_fields = set()
|
||||
doc.int_field = 1
|
||||
self.assertEqual(doc._get_changed_fields(), ['int_field'])
|
||||
self.assertEqual(doc._get_changed_fields(), set(['int_field']))
|
||||
self.assertEqual(doc._delta(), ({'int_field': 1}, {}))
|
||||
|
||||
doc._changed_fields = []
|
||||
doc._changed_fields = set()
|
||||
dict_value = {'hello': 'world', 'ping': 'pong'}
|
||||
doc.dict_field = dict_value
|
||||
self.assertEqual(doc._get_changed_fields(), ['dict_field'])
|
||||
self.assertEqual(doc._get_changed_fields(), set(['dict_field']))
|
||||
self.assertEqual(doc._delta(), ({'dict_field': dict_value}, {}))
|
||||
|
||||
doc._changed_fields = []
|
||||
doc._changed_fields = set()
|
||||
list_value = ['1', 2, {'hello': 'world'}]
|
||||
doc.list_field = list_value
|
||||
self.assertEqual(doc._get_changed_fields(), ['list_field'])
|
||||
self.assertEqual(doc._get_changed_fields(), set(['list_field']))
|
||||
self.assertEqual(doc._delta(), ({'list_field': list_value}, {}))
|
||||
|
||||
# Test unsetting
|
||||
doc._changed_fields = []
|
||||
doc._changed_fields = set()
|
||||
doc.dict_field = {}
|
||||
self.assertEqual(doc._get_changed_fields(), ['dict_field'])
|
||||
self.assertEqual(doc._get_changed_fields(), set(['dict_field']))
|
||||
self.assertEqual(doc._delta(), ({}, {'dict_field': 1}))
|
||||
|
||||
doc._changed_fields = []
|
||||
doc._changed_fields = set()
|
||||
doc.list_field = []
|
||||
self.assertEqual(doc._get_changed_fields(), ['list_field'])
|
||||
self.assertEqual(doc._get_changed_fields(), set(['list_field']))
|
||||
self.assertEqual(doc._delta(), ({}, {'list_field': 1}))
|
||||
|
||||
@unittest.skip("not fully implemented")
|
||||
def test_delta_recursive(self):
|
||||
self.delta_recursive(Document, EmbeddedDocument)
|
||||
self.delta_recursive(DynamicDocument, EmbeddedDocument)
|
||||
|
|
@ -109,7 +110,7 @@ class DeltaTest(unittest.TestCase):
|
|||
doc.save()
|
||||
|
||||
doc = Doc.objects.first()
|
||||
self.assertEqual(doc._get_changed_fields(), [])
|
||||
self.assertEqual(doc._get_changed_fields(), set())
|
||||
self.assertEqual(doc._delta(), ({}, {}))
|
||||
|
||||
embedded_1 = Embedded()
|
||||
|
|
@ -119,7 +120,7 @@ class DeltaTest(unittest.TestCase):
|
|||
embedded_1.list_field = ['1', 2, {'hello': 'world'}]
|
||||
doc.embedded_field = embedded_1
|
||||
|
||||
self.assertEqual(doc._get_changed_fields(), ['embedded_field'])
|
||||
self.assertEqual(doc._get_changed_fields(), set(['embedded_field']))
|
||||
|
||||
embedded_delta = {
|
||||
'string_field': 'hello',
|
||||
|
|
@ -136,7 +137,7 @@ class DeltaTest(unittest.TestCase):
|
|||
|
||||
doc.embedded_field.dict_field = {}
|
||||
self.assertEqual(doc._get_changed_fields(),
|
||||
['embedded_field.dict_field'])
|
||||
set(['embedded_field.dict_field']))
|
||||
self.assertEqual(doc.embedded_field._delta(), ({}, {'dict_field': 1}))
|
||||
self.assertEqual(doc._delta(), ({}, {'embedded_field.dict_field': 1}))
|
||||
doc.save()
|
||||
|
|
@ -145,7 +146,7 @@ class DeltaTest(unittest.TestCase):
|
|||
|
||||
doc.embedded_field.list_field = []
|
||||
self.assertEqual(doc._get_changed_fields(),
|
||||
['embedded_field.list_field'])
|
||||
set(['embedded_field.list_field']))
|
||||
self.assertEqual(doc.embedded_field._delta(), ({}, {'list_field': 1}))
|
||||
self.assertEqual(doc._delta(), ({}, {'embedded_field.list_field': 1}))
|
||||
doc.save()
|
||||
|
|
@ -160,7 +161,7 @@ class DeltaTest(unittest.TestCase):
|
|||
|
||||
doc.embedded_field.list_field = ['1', 2, embedded_2]
|
||||
self.assertEqual(doc._get_changed_fields(),
|
||||
['embedded_field.list_field'])
|
||||
set(['embedded_field.list_field']))
|
||||
|
||||
self.assertEqual(doc.embedded_field._delta(), ({
|
||||
'list_field': ['1', 2, {
|
||||
|
|
@ -192,7 +193,7 @@ class DeltaTest(unittest.TestCase):
|
|||
|
||||
doc.embedded_field.list_field[2].string_field = 'world'
|
||||
self.assertEqual(doc._get_changed_fields(),
|
||||
['embedded_field.list_field.2.string_field'])
|
||||
set(['embedded_field.list_field.2.string_field']))
|
||||
self.assertEqual(doc.embedded_field._delta(),
|
||||
({'list_field.2.string_field': 'world'}, {}))
|
||||
self.assertEqual(doc._delta(),
|
||||
|
|
@ -206,7 +207,7 @@ class DeltaTest(unittest.TestCase):
|
|||
doc.embedded_field.list_field[2].string_field = 'hello world'
|
||||
doc.embedded_field.list_field[2] = doc.embedded_field.list_field[2]
|
||||
self.assertEqual(doc._get_changed_fields(),
|
||||
['embedded_field.list_field'])
|
||||
set(['embedded_field.list_field']))
|
||||
self.assertEqual(doc.embedded_field._delta(), ({
|
||||
'list_field': ['1', 2, {
|
||||
'_cls': 'Embedded',
|
||||
|
|
@ -269,7 +270,7 @@ class DeltaTest(unittest.TestCase):
|
|||
|
||||
doc.dict_field['Embedded'].string_field = 'Hello World'
|
||||
self.assertEqual(doc._get_changed_fields(),
|
||||
['dict_field.Embedded.string_field'])
|
||||
set(['dict_field.Embedded.string_field']))
|
||||
self.assertEqual(doc._delta(),
|
||||
({'dict_field.Embedded.string_field': 'Hello World'}, {}))
|
||||
|
||||
|
|
@ -371,39 +372,39 @@ class DeltaTest(unittest.TestCase):
|
|||
doc.save()
|
||||
|
||||
doc = Doc.objects.first()
|
||||
self.assertEqual(doc._get_changed_fields(), [])
|
||||
self.assertEqual(doc._get_changed_fields(), set())
|
||||
self.assertEqual(doc._delta(), ({}, {}))
|
||||
|
||||
doc.string_field = 'hello'
|
||||
self.assertEqual(doc._get_changed_fields(), ['db_string_field'])
|
||||
self.assertEqual(doc._get_changed_fields(), set(['string_field']))
|
||||
self.assertEqual(doc._delta(), ({'db_string_field': 'hello'}, {}))
|
||||
|
||||
doc._changed_fields = []
|
||||
doc._changed_fields = set()
|
||||
doc.int_field = 1
|
||||
self.assertEqual(doc._get_changed_fields(), ['db_int_field'])
|
||||
self.assertEqual(doc._get_changed_fields(), set(['int_field']))
|
||||
self.assertEqual(doc._delta(), ({'db_int_field': 1}, {}))
|
||||
|
||||
doc._changed_fields = []
|
||||
doc._changed_fields = set()
|
||||
dict_value = {'hello': 'world', 'ping': 'pong'}
|
||||
doc.dict_field = dict_value
|
||||
self.assertEqual(doc._get_changed_fields(), ['db_dict_field'])
|
||||
self.assertEqual(doc._get_changed_fields(), set(['dict_field']))
|
||||
self.assertEqual(doc._delta(), ({'db_dict_field': dict_value}, {}))
|
||||
|
||||
doc._changed_fields = []
|
||||
doc._changed_fields = set()
|
||||
list_value = ['1', 2, {'hello': 'world'}]
|
||||
doc.list_field = list_value
|
||||
self.assertEqual(doc._get_changed_fields(), ['db_list_field'])
|
||||
self.assertEqual(doc._get_changed_fields(), set(['list_field']))
|
||||
self.assertEqual(doc._delta(), ({'db_list_field': list_value}, {}))
|
||||
|
||||
# Test unsetting
|
||||
doc._changed_fields = []
|
||||
doc._changed_fields = set()
|
||||
doc.dict_field = {}
|
||||
self.assertEqual(doc._get_changed_fields(), ['db_dict_field'])
|
||||
self.assertEqual(doc._get_changed_fields(), set(['dict_field']))
|
||||
self.assertEqual(doc._delta(), ({}, {'db_dict_field': 1}))
|
||||
|
||||
doc._changed_fields = []
|
||||
doc._changed_fields = set()
|
||||
doc.list_field = []
|
||||
self.assertEqual(doc._get_changed_fields(), ['db_list_field'])
|
||||
self.assertEqual(doc._get_changed_fields(), set(['list_field']))
|
||||
self.assertEqual(doc._delta(), ({}, {'db_list_field': 1}))
|
||||
|
||||
# Test it saves that data
|
||||
|
|
@ -415,13 +416,15 @@ class DeltaTest(unittest.TestCase):
|
|||
doc.dict_field = {'hello': 'world'}
|
||||
doc.list_field = ['1', 2, {'hello': 'world'}]
|
||||
doc.save()
|
||||
doc = doc.reload(10)
|
||||
#doc = doc.reload(10)
|
||||
doc = doc.reload()
|
||||
|
||||
self.assertEqual(doc.string_field, 'hello')
|
||||
self.assertEqual(doc.int_field, 1)
|
||||
self.assertEqual(doc.dict_field, {'hello': 'world'})
|
||||
self.assertEqual(doc.list_field, ['1', 2, {'hello': 'world'}])
|
||||
|
||||
@unittest.skip("not fully implemented")
|
||||
def test_delta_recursive_db_field(self):
|
||||
self.delta_recursive_db_field(Document, EmbeddedDocument)
|
||||
self.delta_recursive_db_field(Document, DynamicEmbeddedDocument)
|
||||
|
|
@ -449,7 +452,7 @@ class DeltaTest(unittest.TestCase):
|
|||
doc.save()
|
||||
|
||||
doc = Doc.objects.first()
|
||||
self.assertEqual(doc._get_changed_fields(), [])
|
||||
self.assertEqual(doc._get_changed_fields(), set())
|
||||
self.assertEqual(doc._delta(), ({}, {}))
|
||||
|
||||
embedded_1 = Embedded()
|
||||
|
|
@ -459,7 +462,7 @@ class DeltaTest(unittest.TestCase):
|
|||
embedded_1.list_field = ['1', 2, {'hello': 'world'}]
|
||||
doc.embedded_field = embedded_1
|
||||
|
||||
self.assertEqual(doc._get_changed_fields(), ['db_embedded_field'])
|
||||
self.assertEqual(doc._get_changed_fields(), set(['embedded_field']))
|
||||
|
||||
embedded_delta = {
|
||||
'db_string_field': 'hello',
|
||||
|
|
@ -487,7 +490,7 @@ class DeltaTest(unittest.TestCase):
|
|||
|
||||
doc.embedded_field.list_field = []
|
||||
self.assertEqual(doc._get_changed_fields(),
|
||||
['db_embedded_field.db_list_field'])
|
||||
set(['db_embedded_field.db_list_field']))
|
||||
self.assertEqual(doc.embedded_field._delta(),
|
||||
({}, {'db_list_field': 1}))
|
||||
self.assertEqual(doc._delta(),
|
||||
|
|
@ -605,6 +608,7 @@ class DeltaTest(unittest.TestCase):
|
|||
self.assertEqual(doc._delta(), ({},
|
||||
{'db_embedded_field.db_list_field.2.db_list_field': 1}))
|
||||
|
||||
@unittest.skip("DynamicDocument not implemented")
|
||||
def test_delta_for_dynamic_documents(self):
|
||||
class Person(DynamicDocument):
|
||||
name = StringField()
|
||||
|
|
@ -640,6 +644,7 @@ class DeltaTest(unittest.TestCase):
|
|||
p.save()
|
||||
self.assertEqual(1, self.Person.objects(age=24).count())
|
||||
|
||||
@unittest.skip("DynamicDocument not implemented")
|
||||
def test_dynamic_delta(self):
|
||||
|
||||
class Doc(DynamicDocument):
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ from mongoengine.connection import get_db
|
|||
__all__ = ("DynamicTest", )
|
||||
|
||||
|
||||
@unittest.skip("DynamicDocument not implemented")
|
||||
class DynamicTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
|
|
|
|||
|
|
@ -632,6 +632,7 @@ class IndexesTest(unittest.TestCase):
|
|||
pass
|
||||
Customer.drop_collection()
|
||||
|
||||
@unittest.skip("behavior differs")
|
||||
def test_unique_and_primary(self):
|
||||
"""If you set a field as primary, then unexpected behaviour can occur.
|
||||
You won't create a duplicate but you will update an existing document.
|
||||
|
|
|
|||
|
|
@ -182,10 +182,10 @@ class InheritanceTest(unittest.TestCase):
|
|||
|
||||
self.assertEqual(['age', 'id', 'name', 'salary'],
|
||||
sorted(Employee._fields.keys()))
|
||||
self.assertEqual(Person(name="Bob", age=35).to_mongo().keys(),
|
||||
['_cls', 'name', 'age'])
|
||||
self.assertEqual(Employee(name="Bob", age=35, salary=0).to_mongo().keys(),
|
||||
['_cls', 'name', 'age', 'salary'])
|
||||
self.assertEqual(set(Person(name="Bob", age=35).to_mongo().keys()),
|
||||
set(['_cls', 'name', 'age']))
|
||||
self.assertEqual(set(Employee(name="Bob", age=35, salary=0).to_mongo().keys()),
|
||||
set(['_cls', 'name', 'age', 'salary']))
|
||||
self.assertEqual(Employee._get_collection_name(),
|
||||
Person._get_collection_name())
|
||||
|
||||
|
|
|
|||
|
|
@ -390,24 +390,25 @@ class InstanceTest(unittest.TestCase):
|
|||
doc.embedded_field = embedded_1
|
||||
doc.save()
|
||||
|
||||
doc = doc.reload(10)
|
||||
doc = doc.reload()
|
||||
doc.list_field.append(1)
|
||||
doc.dict_field['woot'] = "woot"
|
||||
doc.embedded_field.list_field.append(1)
|
||||
doc.embedded_field.dict_field['woot'] = "woot"
|
||||
|
||||
self.assertEqual(doc._get_changed_fields(), [
|
||||
self.assertEqual(doc._get_changed_fields(), set([
|
||||
'list_field', 'dict_field', 'embedded_field.list_field',
|
||||
'embedded_field.dict_field'])
|
||||
'embedded_field.dict_field']))
|
||||
doc.save()
|
||||
|
||||
doc = doc.reload(10)
|
||||
self.assertEqual(doc._get_changed_fields(), [])
|
||||
doc = doc.reload()
|
||||
self.assertEqual(doc._get_changed_fields(), set())
|
||||
self.assertEqual(len(doc.list_field), 4)
|
||||
self.assertEqual(len(doc.dict_field), 2)
|
||||
self.assertEqual(len(doc.embedded_field.list_field), 4)
|
||||
self.assertEqual(len(doc.embedded_field.dict_field), 2)
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_dictionary_access(self):
|
||||
"""Ensure that dictionary-style field access works properly.
|
||||
"""
|
||||
|
|
@ -438,10 +439,10 @@ class InstanceTest(unittest.TestCase):
|
|||
class Employee(Person):
|
||||
salary = IntField()
|
||||
|
||||
self.assertEqual(Person(name="Bob", age=35).to_mongo().keys(),
|
||||
['_cls', 'name', 'age'])
|
||||
self.assertEqual(Employee(name="Bob", age=35, salary=0).to_mongo().keys(),
|
||||
['_cls', 'name', 'age', 'salary'])
|
||||
self.assertEqual(set(Person(name="Bob", age=35).to_mongo().keys()),
|
||||
set(['_cls', 'name', 'age']))
|
||||
self.assertEqual(set(Employee(name="Bob", age=35, salary=0).to_mongo().keys()),
|
||||
set(['_cls', 'name', 'age', 'salary']))
|
||||
|
||||
def test_embedded_document(self):
|
||||
"""Ensure that embedded documents are set up correctly.
|
||||
|
|
@ -452,6 +453,7 @@ class InstanceTest(unittest.TestCase):
|
|||
self.assertTrue('content' in Comment._fields)
|
||||
self.assertFalse('id' in Comment._fields)
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_embedded_document_instance(self):
|
||||
"""Ensure that embedded documents can reference parent instance
|
||||
"""
|
||||
|
|
@ -460,6 +462,7 @@ class InstanceTest(unittest.TestCase):
|
|||
|
||||
class Doc(Document):
|
||||
embedded_field = EmbeddedDocumentField(Embedded)
|
||||
meta = { 'cascade': True }
|
||||
|
||||
Doc.drop_collection()
|
||||
Doc(embedded_field=Embedded(string="Hi")).save()
|
||||
|
|
@ -467,6 +470,7 @@ class InstanceTest(unittest.TestCase):
|
|||
doc = Doc.objects.get()
|
||||
self.assertEqual(doc, doc.embedded_field._instance)
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_embedded_document_complex_instance(self):
|
||||
"""Ensure that embedded documents in complex fields can reference
|
||||
parent instance"""
|
||||
|
|
@ -623,6 +627,7 @@ class InstanceTest(unittest.TestCase):
|
|||
p0.name = 'wpjunior'
|
||||
p0.save()
|
||||
|
||||
@unittest.skip("FileField not implemented")
|
||||
def test_save_max_recursion_not_hit_with_file_field(self):
|
||||
|
||||
class Foo(Document):
|
||||
|
|
@ -771,6 +776,7 @@ class InstanceTest(unittest.TestCase):
|
|||
p1.reload()
|
||||
self.assertEqual(p1.name, p.parent.name)
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_update(self):
|
||||
"""Ensure that an existing document is updated instead of be
|
||||
overwritten."""
|
||||
|
|
@ -885,7 +891,6 @@ class InstanceTest(unittest.TestCase):
|
|||
reference_field = ReferenceField(Simple, default=lambda:
|
||||
Simple().save())
|
||||
map_field = MapField(IntField(), default=lambda: {"simple": 1})
|
||||
decimal_field = DecimalField(default=1.0)
|
||||
complex_datetime_field = ComplexDateTimeField(default=datetime.now)
|
||||
url_field = URLField(default="http://mongoengine.org")
|
||||
dynamic_field = DynamicField(default=1)
|
||||
|
|
@ -1054,9 +1059,9 @@ class InstanceTest(unittest.TestCase):
|
|||
user = User.objects.first()
|
||||
# Even if stored as ObjectId's internally mongoengine uses DBRefs
|
||||
# As ObjectId's aren't automatically derefenced
|
||||
self.assertTrue(isinstance(user._data['orgs'][0], DBRef))
|
||||
#self.assertTrue(isinstance(user._data['orgs'][0], DBRef))
|
||||
self.assertTrue(isinstance(user.orgs[0], Organization))
|
||||
self.assertTrue(isinstance(user._data['orgs'][0], Organization))
|
||||
#self.assertTrue(isinstance(user._data['orgs'][0], Organization))
|
||||
|
||||
# Changing a value
|
||||
with query_counter() as q:
|
||||
|
|
@ -1136,6 +1141,7 @@ class InstanceTest(unittest.TestCase):
|
|||
foo.save()
|
||||
self.assertEqual(1, q)
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_save_only_changed_fields_recursive(self):
|
||||
"""Ensure save only sets / unsets changed fields
|
||||
"""
|
||||
|
|
@ -1433,8 +1439,8 @@ class InstanceTest(unittest.TestCase):
|
|||
post_obj = BlogPost.objects.first()
|
||||
|
||||
# Test laziness
|
||||
self.assertTrue(isinstance(post_obj._data['author'],
|
||||
bson.DBRef))
|
||||
#self.assertTrue(isinstance(post_obj._data['author'],
|
||||
# bson.DBRef))
|
||||
self.assertTrue(isinstance(post_obj.author, self.Person))
|
||||
self.assertEqual(post_obj.author.name, 'Test User')
|
||||
|
||||
|
|
@ -1458,6 +1464,7 @@ class InstanceTest(unittest.TestCase):
|
|||
|
||||
self.assertRaises(InvalidDocumentError, throw_invalid_document_error)
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_invalid_son(self):
|
||||
"""Raise an error if loading invalid data"""
|
||||
class Occurrence(EmbeddedDocument):
|
||||
|
|
@ -1801,6 +1808,7 @@ class InstanceTest(unittest.TestCase):
|
|||
|
||||
self.assertTrue(u1 in all_user_set)
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_picklable(self):
|
||||
|
||||
pickle_doc = PickleTest(number=1, string="One", lists=['1', '2'])
|
||||
|
|
@ -1827,6 +1835,7 @@ class InstanceTest(unittest.TestCase):
|
|||
self.assertEqual(pickle_doc.string, "Two")
|
||||
self.assertEqual(pickle_doc.lists, ["1", "2", "3"])
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_picklable_on_signals(self):
|
||||
pickle_doc = PickleSignalsTest(number=1, string="One", lists=['1', '2'])
|
||||
pickle_doc.embedded = PickleEmbedded()
|
||||
|
|
@ -1887,6 +1896,7 @@ class InstanceTest(unittest.TestCase):
|
|||
|
||||
self.assertEqual(Doc.objects(archived=False).count(), 1)
|
||||
|
||||
@unittest.skip("DynamicDocument not implemented")
|
||||
def test_can_save_false_values_dynamic(self):
|
||||
"""Ensures you can save False values on dynamic docs"""
|
||||
class Doc(DynamicDocument):
|
||||
|
|
@ -2026,6 +2036,7 @@ class InstanceTest(unittest.TestCase):
|
|||
|
||||
self.assertEqual('testdb-1', B._meta.get('db_alias'))
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_db_ref_usage(self):
|
||||
""" DB Ref usage in dict_fields"""
|
||||
|
||||
|
|
@ -2104,6 +2115,7 @@ class InstanceTest(unittest.TestCase):
|
|||
})]),
|
||||
"1,2")
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_switch_db_instance(self):
|
||||
register_connection('testdb-1', 'mongoenginetest2')
|
||||
|
||||
|
|
@ -2175,9 +2187,10 @@ class InstanceTest(unittest.TestCase):
|
|||
user = User.objects.first()
|
||||
self.assertEqual("Ross", user.username)
|
||||
self.assertEqual(True, user.foo)
|
||||
self.assertEqual("Bar", user._data["foo"])
|
||||
self.assertEqual([1, 2, 3], user._data["data"])
|
||||
self.assertEqual("Bar", user._db_data["foo"])
|
||||
self.assertEqual([1, 2, 3], user._db_data["data"])
|
||||
|
||||
@unittest.skip("DynamicDocument not implemented")
|
||||
def test_spaces_in_keys(self):
|
||||
|
||||
class Embedded(DynamicEmbeddedDocument):
|
||||
|
|
@ -2194,6 +2207,7 @@ class InstanceTest(unittest.TestCase):
|
|||
one = Doc.objects.filter(**{'hello world': 1}).count()
|
||||
self.assertEqual(1, one)
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_shard_key(self):
|
||||
class LogEntry(Document):
|
||||
machine = StringField()
|
||||
|
|
@ -2217,6 +2231,7 @@ class InstanceTest(unittest.TestCase):
|
|||
|
||||
self.assertRaises(OperationError, change_shard_key)
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_shard_key_primary(self):
|
||||
class LogEntry(Document):
|
||||
machine = StringField(primary_key=True)
|
||||
|
|
@ -2240,6 +2255,7 @@ class InstanceTest(unittest.TestCase):
|
|||
|
||||
self.assertRaises(OperationError, change_shard_key)
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_kwargs_simple(self):
|
||||
|
||||
class Embedded(EmbeddedDocument):
|
||||
|
|
@ -2254,8 +2270,9 @@ class InstanceTest(unittest.TestCase):
|
|||
"doc": {"name": "embedded doc"}})
|
||||
|
||||
self.assertEqual(classic_doc, dict_doc)
|
||||
self.assertEqual(classic_doc._data, dict_doc._data)
|
||||
self.assertEqual(classic_doc.to_dict(), dict_doc.to_dict())
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_kwargs_complex(self):
|
||||
|
||||
class Embedded(EmbeddedDocument):
|
||||
|
|
@ -2273,8 +2290,9 @@ class InstanceTest(unittest.TestCase):
|
|||
{"name": "embedded doc2"}]})
|
||||
|
||||
self.assertEqual(classic_doc, dict_doc)
|
||||
self.assertEqual(classic_doc._data, dict_doc._data)
|
||||
self.assertEqual(classic_doc.to_dict(), dict_doc.to_dict())
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_positional_creation(self):
|
||||
"""Ensure that document may be created using positional arguments.
|
||||
"""
|
||||
|
|
@ -2282,6 +2300,7 @@ class InstanceTest(unittest.TestCase):
|
|||
self.assertEqual(person.name, "Test User")
|
||||
self.assertEqual(person.age, 42)
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_mixed_creation(self):
|
||||
"""Ensure that document may be created using mixed arguments.
|
||||
"""
|
||||
|
|
@ -2307,8 +2326,8 @@ class InstanceTest(unittest.TestCase):
|
|||
Person(name="Harry Potter").save()
|
||||
|
||||
person = Person.objects.first()
|
||||
self.assertTrue('id' in person._data.keys())
|
||||
self.assertEqual(person._data.get('id'), person.id)
|
||||
self.assertTrue('id' in person.to_dict().keys())
|
||||
self.assertEqual(person.to_dict().get('id'), person.id)
|
||||
|
||||
def test_complex_nesting_document_and_embedded_document(self):
|
||||
|
||||
|
|
|
|||
|
|
@ -58,7 +58,6 @@ class TestJson(unittest.TestCase):
|
|||
reference_field = ReferenceField(Simple, default=lambda:
|
||||
Simple().save())
|
||||
map_field = MapField(IntField(), default=lambda: {"simple": 1})
|
||||
decimal_field = DecimalField(default=1.0)
|
||||
complex_datetime_field = ComplexDateTimeField(default=datetime.now)
|
||||
url_field = URLField(default="http://mongoengine.org")
|
||||
dynamic_field = DynamicField(default=1)
|
||||
|
|
|
|||
|
|
@ -53,11 +53,12 @@ class ValidatorErrorTest(unittest.TestCase):
|
|||
self.assertEqual(error.message, "root(2nd.3rd.4th.Inception: ['1st'])")
|
||||
|
||||
def test_model_validation(self):
|
||||
|
||||
class User(Document):
|
||||
username = StringField(primary_key=True)
|
||||
name = StringField(required=True)
|
||||
|
||||
User.drop_collection()
|
||||
|
||||
try:
|
||||
User().validate()
|
||||
except ValidationError, e:
|
||||
|
|
@ -128,18 +129,13 @@ class ValidatorErrorTest(unittest.TestCase):
|
|||
Doc(id="test", e=SubDoc(val=15)).save()
|
||||
|
||||
doc = Doc.objects.first()
|
||||
keys = doc._data.keys()
|
||||
keys = doc.to_dict().keys()
|
||||
self.assertEqual(2, len(keys))
|
||||
self.assertTrue('e' in keys)
|
||||
self.assertTrue('id' in keys)
|
||||
|
||||
doc.e.val = "OK"
|
||||
try:
|
||||
doc.save()
|
||||
except ValidationError, e:
|
||||
self.assertTrue("Doc:test" in e.message)
|
||||
self.assertEqual(e.to_dict(), {
|
||||
"e": {'val': 'OK could not be converted to int'}})
|
||||
with self.assertRaises(ValueError):
|
||||
doc.e.val = "OK"
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
|||
|
|
@ -56,10 +56,11 @@ class FieldTest(unittest.TestCase):
|
|||
self.assertEqual(person.userid, person.userid)
|
||||
self.assertEqual(person.created, person.created)
|
||||
|
||||
self.assertEqual(person._data['name'], person.name)
|
||||
self.assertEqual(person._data['age'], person.age)
|
||||
self.assertEqual(person._data['userid'], person.userid)
|
||||
self.assertEqual(person._data['created'], person.created)
|
||||
data = person.to_dict()
|
||||
self.assertEqual(data['name'], person.name)
|
||||
self.assertEqual(data['age'], person.age)
|
||||
self.assertEqual(data['userid'], person.userid)
|
||||
self.assertEqual(data['created'], person.created)
|
||||
|
||||
# Confirm introspection changes nothing
|
||||
data_to_be_saved = sorted(person.to_mongo().keys())
|
||||
|
|
@ -88,10 +89,11 @@ class FieldTest(unittest.TestCase):
|
|||
self.assertEqual(person.userid, person.userid)
|
||||
self.assertEqual(person.created, person.created)
|
||||
|
||||
self.assertEqual(person._data['name'], person.name)
|
||||
self.assertEqual(person._data['age'], person.age)
|
||||
self.assertEqual(person._data['userid'], person.userid)
|
||||
self.assertEqual(person._data['created'], person.created)
|
||||
data = person.to_dict()
|
||||
self.assertEqual(data['name'], person.name)
|
||||
self.assertEqual(data['age'], person.age)
|
||||
self.assertEqual(data['userid'], person.userid)
|
||||
self.assertEqual(data['created'], person.created)
|
||||
|
||||
# Confirm introspection changes nothing
|
||||
data_to_be_saved = sorted(person.to_mongo().keys())
|
||||
|
|
@ -123,10 +125,12 @@ class FieldTest(unittest.TestCase):
|
|||
self.assertEqual(person.userid, person.userid)
|
||||
self.assertEqual(person.created, person.created)
|
||||
|
||||
self.assertEqual(person._data['name'], person.name)
|
||||
self.assertEqual(person._data['age'], person.age)
|
||||
self.assertEqual(person._data['userid'], person.userid)
|
||||
self.assertEqual(person._data['created'], person.created)
|
||||
data = person.to_dict()
|
||||
|
||||
self.assertEqual(data['name'], person.name)
|
||||
self.assertEqual(data['age'], person.age)
|
||||
self.assertEqual(data['userid'], person.userid)
|
||||
self.assertEqual(data['created'], person.created)
|
||||
|
||||
# Confirm introspection changes nothing
|
||||
data_to_be_saved = sorted(person.to_mongo().keys())
|
||||
|
|
@ -157,10 +161,12 @@ class FieldTest(unittest.TestCase):
|
|||
self.assertEqual(person.userid, person.userid)
|
||||
self.assertEqual(person.created, person.created)
|
||||
|
||||
self.assertEqual(person._data['name'], person.name)
|
||||
self.assertEqual(person._data['age'], person.age)
|
||||
self.assertEqual(person._data['userid'], person.userid)
|
||||
self.assertEqual(person._data['created'], person.created)
|
||||
data = person.to_dict()
|
||||
|
||||
self.assertEqual(data['name'], person.name)
|
||||
self.assertEqual(data['age'], person.age)
|
||||
self.assertEqual(data['userid'], person.userid)
|
||||
self.assertEqual(data['created'], person.created)
|
||||
|
||||
# Confirm introspection changes nothing
|
||||
data_to_be_saved = sorted(person.to_mongo().keys())
|
||||
|
|
@ -266,17 +272,6 @@ class FieldTest(unittest.TestCase):
|
|||
self.assertEqual(1, TestDocument.objects(int_fld__ne=None).count())
|
||||
self.assertEqual(1, TestDocument.objects(float_fld__ne=None).count())
|
||||
|
||||
def test_long_ne_operator(self):
|
||||
class TestDocument(Document):
|
||||
long_fld = LongField()
|
||||
|
||||
TestDocument.drop_collection()
|
||||
|
||||
TestDocument(long_fld=None).save()
|
||||
TestDocument(long_fld=1).save()
|
||||
|
||||
self.assertEqual(1, TestDocument.objects(long_fld__ne=None).count())
|
||||
|
||||
def test_object_id_validation(self):
|
||||
"""Ensure that invalid values cannot be assigned to string fields.
|
||||
"""
|
||||
|
|
@ -347,25 +342,8 @@ class FieldTest(unittest.TestCase):
|
|||
self.assertRaises(ValidationError, person.validate)
|
||||
person.age = 120
|
||||
self.assertRaises(ValidationError, person.validate)
|
||||
person.age = 'ten'
|
||||
self.assertRaises(ValidationError, person.validate)
|
||||
|
||||
def test_long_validation(self):
|
||||
"""Ensure that invalid values cannot be assigned to long fields.
|
||||
"""
|
||||
class TestDocument(Document):
|
||||
value = LongField(min_value=0, max_value=110)
|
||||
|
||||
doc = TestDocument()
|
||||
doc.value = 50
|
||||
doc.validate()
|
||||
|
||||
doc.value = -1
|
||||
self.assertRaises(ValidationError, doc.validate)
|
||||
doc.age = 120
|
||||
self.assertRaises(ValidationError, doc.validate)
|
||||
doc.age = 'ten'
|
||||
self.assertRaises(ValidationError, doc.validate)
|
||||
with self.assertRaises(ValueError):
|
||||
person.age = 'ten'
|
||||
|
||||
def test_float_validation(self):
|
||||
"""Ensure that invalid values cannot be assigned to float fields.
|
||||
|
|
@ -384,69 +362,6 @@ class FieldTest(unittest.TestCase):
|
|||
person.height = 4.0
|
||||
self.assertRaises(ValidationError, person.validate)
|
||||
|
||||
def test_decimal_validation(self):
|
||||
"""Ensure that invalid values cannot be assigned to decimal fields.
|
||||
"""
|
||||
class Person(Document):
|
||||
height = DecimalField(min_value=Decimal('0.1'),
|
||||
max_value=Decimal('3.5'))
|
||||
|
||||
Person.drop_collection()
|
||||
|
||||
Person(height=Decimal('1.89')).save()
|
||||
person = Person.objects.first()
|
||||
self.assertEqual(person.height, Decimal('1.89'))
|
||||
|
||||
person.height = '2.0'
|
||||
person.save()
|
||||
person.height = 0.01
|
||||
self.assertRaises(ValidationError, person.validate)
|
||||
person.height = Decimal('0.01')
|
||||
self.assertRaises(ValidationError, person.validate)
|
||||
person.height = Decimal('4.0')
|
||||
self.assertRaises(ValidationError, person.validate)
|
||||
|
||||
Person.drop_collection()
|
||||
|
||||
def test_decimal_comparison(self):
|
||||
|
||||
class Person(Document):
|
||||
money = DecimalField()
|
||||
|
||||
Person.drop_collection()
|
||||
|
||||
Person(money=6).save()
|
||||
Person(money=8).save()
|
||||
Person(money=10).save()
|
||||
|
||||
self.assertEqual(2, Person.objects(money__gt=Decimal("7")).count())
|
||||
self.assertEqual(2, Person.objects(money__gt=7).count())
|
||||
self.assertEqual(2, Person.objects(money__gt="7").count())
|
||||
|
||||
def test_decimal_storage(self):
|
||||
class Person(Document):
|
||||
btc = DecimalField(precision=4)
|
||||
|
||||
Person.drop_collection()
|
||||
Person(btc=10).save()
|
||||
Person(btc=10.1).save()
|
||||
Person(btc=10.11).save()
|
||||
Person(btc="10.111").save()
|
||||
Person(btc=Decimal("10.1111")).save()
|
||||
Person(btc=Decimal("10.11111")).save()
|
||||
|
||||
# How its stored
|
||||
expected = [{'btc': 10.0}, {'btc': 10.1}, {'btc': 10.11},
|
||||
{'btc': 10.111}, {'btc': 10.1111}, {'btc': 10.1111}]
|
||||
actual = list(Person.objects.exclude('id').as_pymongo())
|
||||
self.assertEqual(expected, actual)
|
||||
|
||||
# How it comes out locally
|
||||
expected = [Decimal('10.0000'), Decimal('10.1000'), Decimal('10.1100'),
|
||||
Decimal('10.1110'), Decimal('10.1111'), Decimal('10.1111')]
|
||||
actual = list(Person.objects().scalar('btc'))
|
||||
self.assertEqual(expected, actual)
|
||||
|
||||
def test_boolean_validation(self):
|
||||
"""Ensure that invalid values cannot be assigned to boolean fields.
|
||||
"""
|
||||
|
|
@ -532,10 +447,10 @@ class FieldTest(unittest.TestCase):
|
|||
log.time = datetime.datetime.now().isoformat('T')
|
||||
log.validate()
|
||||
|
||||
log.time = -1
|
||||
self.assertRaises(ValidationError, log.validate)
|
||||
log.time = 'ABC'
|
||||
self.assertRaises(ValidationError, log.validate)
|
||||
#log.time = -1
|
||||
#self.assertRaises(ValidationError, log.validate)
|
||||
#log.time = 'ABC'
|
||||
#self.assertRaises(ValidationError, log.validate)
|
||||
|
||||
def test_datetime_tz_aware_mark_as_changed(self):
|
||||
from mongoengine import connection
|
||||
|
|
@ -556,7 +471,7 @@ class FieldTest(unittest.TestCase):
|
|||
|
||||
log = LogEntry.objects.first()
|
||||
log.time = datetime.datetime(2013, 1, 1, 0, 0, 0)
|
||||
self.assertEqual(['time'], log._changed_fields)
|
||||
self.assertEqual(set(['time']), log._changed_fields)
|
||||
|
||||
def test_datetime(self):
|
||||
"""Tests showing pymongo datetime fields handling of microseconds.
|
||||
|
|
@ -791,8 +706,8 @@ class FieldTest(unittest.TestCase):
|
|||
post = BlogPost(content='Went for a walk today...')
|
||||
post.validate()
|
||||
|
||||
post.tags = 'fun'
|
||||
self.assertRaises(ValidationError, post.validate)
|
||||
#post.tags = 'fun'
|
||||
#self.assertRaises(ValidationError, post.validate)
|
||||
post.tags = [1, 2]
|
||||
self.assertRaises(ValidationError, post.validate)
|
||||
|
||||
|
|
@ -903,11 +818,11 @@ class FieldTest(unittest.TestCase):
|
|||
BlogPost.drop_collection()
|
||||
|
||||
post = BlogPost()
|
||||
post.info = 'my post'
|
||||
self.assertRaises(ValidationError, post.validate)
|
||||
#post.info = 'my post'
|
||||
#self.assertRaises(ValidationError, post.validate)
|
||||
|
||||
post.info = {'title': 'test'}
|
||||
self.assertRaises(ValidationError, post.validate)
|
||||
#post.info = {'title': 'test'}
|
||||
#self.assertRaises(ValidationError, post.validate)
|
||||
|
||||
post.info = ['test']
|
||||
post.save()
|
||||
|
|
@ -956,14 +871,12 @@ class FieldTest(unittest.TestCase):
|
|||
e.mapping = [1]
|
||||
e.save()
|
||||
|
||||
def create_invalid_mapping():
|
||||
with self.assertRaises(ValueError):
|
||||
e.mapping = ["abc"]
|
||||
e.save()
|
||||
|
||||
self.assertRaises(ValidationError, create_invalid_mapping)
|
||||
|
||||
Simple.drop_collection()
|
||||
|
||||
@unittest.skip("different behavior")
|
||||
def test_list_field_rejects_strings(self):
|
||||
"""Strings aren't valid list field data types"""
|
||||
|
||||
|
|
@ -1008,7 +921,7 @@ class FieldTest(unittest.TestCase):
|
|||
Simple.drop_collection()
|
||||
e = Simple().save()
|
||||
e.mapping = []
|
||||
self.assertEqual([], e._changed_fields)
|
||||
self.assertEqual(set([]), e._changed_fields)
|
||||
|
||||
class Simple(Document):
|
||||
mapping = DictField()
|
||||
|
|
@ -1016,8 +929,9 @@ class FieldTest(unittest.TestCase):
|
|||
Simple.drop_collection()
|
||||
e = Simple().save()
|
||||
e.mapping = {}
|
||||
self.assertEqual([], e._changed_fields)
|
||||
self.assertEqual(set([]), e._changed_fields)
|
||||
|
||||
@unittest.skip("complex types not implemented")
|
||||
def test_list_field_complex(self):
|
||||
"""Ensure that the list fields can handle the complex types."""
|
||||
|
||||
|
|
@ -1074,11 +988,11 @@ class FieldTest(unittest.TestCase):
|
|||
BlogPost.drop_collection()
|
||||
|
||||
post = BlogPost()
|
||||
post.info = 'my post'
|
||||
self.assertRaises(ValidationError, post.validate)
|
||||
#post.info = 'my post'
|
||||
#self.assertRaises(ValidationError, post.validate)
|
||||
|
||||
post.info = ['test', 'test']
|
||||
self.assertRaises(ValidationError, post.validate)
|
||||
#post.info = ['test', 'test']
|
||||
#self.assertRaises(ValidationError, post.validate)
|
||||
|
||||
post.info = {'$title': 'test'}
|
||||
self.assertRaises(ValidationError, post.validate)
|
||||
|
|
@ -1136,6 +1050,7 @@ class FieldTest(unittest.TestCase):
|
|||
|
||||
Simple.drop_collection()
|
||||
|
||||
@unittest.skip("complex types not implemented")
|
||||
def test_dictfield_complex(self):
|
||||
"""Ensure that the dict field can handle the complex types."""
|
||||
|
||||
|
|
@ -1953,6 +1868,7 @@ class FieldTest(unittest.TestCase):
|
|||
|
||||
Shirt.drop_collection()
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_choices_get_field_display(self):
|
||||
"""Test dynamic helper for returning the display value of a choices
|
||||
field.
|
||||
|
|
@ -2005,6 +1921,7 @@ class FieldTest(unittest.TestCase):
|
|||
|
||||
Shirt.drop_collection()
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_simple_choices_get_field_display(self):
|
||||
"""Test dynamic helper for returning the display value of a choices
|
||||
field.
|
||||
|
|
@ -2084,6 +2001,7 @@ class FieldTest(unittest.TestCase):
|
|||
self.assertEqual(d2.data, {})
|
||||
self.assertEqual(d2.data2, {})
|
||||
|
||||
@unittest.skip("SequenceField not implemented")
|
||||
def test_sequence_field(self):
|
||||
class Person(Document):
|
||||
id = SequenceField(primary_key=True)
|
||||
|
|
@ -2109,6 +2027,7 @@ class FieldTest(unittest.TestCase):
|
|||
self.assertEqual(c['next'], 1000)
|
||||
|
||||
|
||||
@unittest.skip("SequenceField not implemented")
|
||||
def test_sequence_field_get_next_value(self):
|
||||
class Person(Document):
|
||||
id = SequenceField(primary_key=True)
|
||||
|
|
@ -2140,6 +2059,7 @@ class FieldTest(unittest.TestCase):
|
|||
|
||||
self.assertEqual(Person.id.get_next_value(), '1')
|
||||
|
||||
@unittest.skip("SequenceField not implemented")
|
||||
def test_sequence_field_sequence_name(self):
|
||||
class Person(Document):
|
||||
id = SequenceField(primary_key=True, sequence_name='jelly')
|
||||
|
|
@ -2164,6 +2084,7 @@ class FieldTest(unittest.TestCase):
|
|||
c = self.db['mongoengine.counters'].find_one({'_id': 'jelly.id'})
|
||||
self.assertEqual(c['next'], 1000)
|
||||
|
||||
@unittest.skip("SequenceField not implemented")
|
||||
def test_multiple_sequence_fields(self):
|
||||
class Person(Document):
|
||||
id = SequenceField(primary_key=True)
|
||||
|
|
@ -2196,6 +2117,7 @@ class FieldTest(unittest.TestCase):
|
|||
c = self.db['mongoengine.counters'].find_one({'_id': 'person.counter'})
|
||||
self.assertEqual(c['next'], 999)
|
||||
|
||||
@unittest.skip("SequenceField not implemented")
|
||||
def test_sequence_fields_reload(self):
|
||||
class Animal(Document):
|
||||
counter = SequenceField()
|
||||
|
|
@ -2221,6 +2143,7 @@ class FieldTest(unittest.TestCase):
|
|||
a.reload()
|
||||
self.assertEqual(a.counter, 2)
|
||||
|
||||
@unittest.skip("SequenceField not implemented")
|
||||
def test_multiple_sequence_fields_on_docs(self):
|
||||
|
||||
class Animal(Document):
|
||||
|
|
@ -2255,6 +2178,7 @@ class FieldTest(unittest.TestCase):
|
|||
c = self.db['mongoengine.counters'].find_one({'_id': 'animal.id'})
|
||||
self.assertEqual(c['next'], 10)
|
||||
|
||||
@unittest.skip("SequenceField not implemented")
|
||||
def test_sequence_field_value_decorator(self):
|
||||
class Person(Document):
|
||||
id = SequenceField(primary_key=True, value_decorator=str)
|
||||
|
|
@ -2276,6 +2200,7 @@ class FieldTest(unittest.TestCase):
|
|||
c = self.db['mongoengine.counters'].find_one({'_id': 'person.id'})
|
||||
self.assertEqual(c['next'], 10)
|
||||
|
||||
@unittest.skip("SequenceField not implemented")
|
||||
def test_embedded_sequence_field(self):
|
||||
class Comment(EmbeddedDocument):
|
||||
id = SequenceField()
|
||||
|
|
|
|||
|
|
@ -24,6 +24,7 @@ TEST_IMAGE_PATH = os.path.join(os.path.dirname(__file__), 'mongoengine.png')
|
|||
TEST_IMAGE2_PATH = os.path.join(os.path.dirname(__file__), 'mongodb_leaf.png')
|
||||
|
||||
|
||||
@unittest.skip("FileField not implemented")
|
||||
class FileTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@ from mongoengine.connection import get_db
|
|||
__all__ = ("GeoFieldTest", )
|
||||
|
||||
|
||||
@unittest.skip("geo fields not implemented")
|
||||
class GeoFieldTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
|
|
|
|||
|
|
@ -1,5 +1,4 @@
|
|||
from convert_to_new_inheritance_model import *
|
||||
from decimalfield_as_float import *
|
||||
from refrencefield_dbref_to_object_id import *
|
||||
from turn_off_inheritance import *
|
||||
from uuidfield_to_binary import *
|
||||
|
|
|
|||
|
|
@ -1,50 +0,0 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
import unittest
|
||||
import decimal
|
||||
from decimal import Decimal
|
||||
|
||||
from mongoengine import Document, connect
|
||||
from mongoengine.connection import get_db
|
||||
from mongoengine.fields import StringField, DecimalField, ListField
|
||||
|
||||
__all__ = ('ConvertDecimalField', )
|
||||
|
||||
|
||||
class ConvertDecimalField(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
connect(db='mongoenginetest')
|
||||
self.db = get_db()
|
||||
|
||||
def test_how_to_convert_decimal_fields(self):
|
||||
"""Demonstrates migrating from 0.7 to 0.8
|
||||
"""
|
||||
|
||||
# 1. Old definition - using dbrefs
|
||||
class Person(Document):
|
||||
name = StringField()
|
||||
money = DecimalField(force_string=True)
|
||||
monies = ListField(DecimalField(force_string=True))
|
||||
|
||||
Person.drop_collection()
|
||||
Person(name="Wilson Jr", money=Decimal("2.50"),
|
||||
monies=[Decimal("2.10"), Decimal("5.00")]).save()
|
||||
|
||||
# 2. Start the migration by changing the schema
|
||||
# Change DecimalField - add precision and rounding settings
|
||||
class Person(Document):
|
||||
name = StringField()
|
||||
money = DecimalField(precision=2, rounding=decimal.ROUND_HALF_UP)
|
||||
monies = ListField(DecimalField(precision=2,
|
||||
rounding=decimal.ROUND_HALF_UP))
|
||||
|
||||
# 3. Loop all the objects and mark parent as changed
|
||||
for p in Person.objects:
|
||||
p._mark_as_changed('money')
|
||||
p._mark_as_changed('monies')
|
||||
p.save()
|
||||
|
||||
# 4. Confirmation of the fix!
|
||||
wilson = Person.objects(name="Wilson Jr").as_pymongo()[0]
|
||||
self.assertTrue(isinstance(wilson['money'], float))
|
||||
self.assertTrue(all([isinstance(m, float) for m in wilson['monies']]))
|
||||
|
|
@ -8,6 +8,7 @@ from mongoengine import *
|
|||
__all__ = ("GeoQueriesTest",)
|
||||
|
||||
|
||||
@unittest.skip("geo queries not implemented")
|
||||
class GeoQueriesTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
|
|
|
|||
|
|
@ -777,10 +777,10 @@ class QuerySetTest(unittest.TestCase):
|
|||
self.assertEqual(q, 0)
|
||||
|
||||
fresh_o1 = Organization.objects.get(id=o1.id)
|
||||
fresh_o1.employees.append(p2) # Dereferences
|
||||
fresh_o1.employees.append(p2)
|
||||
fresh_o1.save(cascade=False) # Saves
|
||||
|
||||
self.assertEqual(q, 3)
|
||||
self.assertEqual(q, 2)
|
||||
|
||||
def test_slave_okay(self):
|
||||
"""Ensures that a query can take slave_okay syntax
|
||||
|
|
@ -2922,19 +2922,6 @@ class QuerySetTest(unittest.TestCase):
|
|||
(u'Wilson Jr', 19, u'Corumba-GO'),
|
||||
(u'Gabriel Falcao', 23, u'New York')])
|
||||
|
||||
def test_scalar_decimal(self):
|
||||
from decimal import Decimal
|
||||
class Person(Document):
|
||||
name = StringField()
|
||||
rating = DecimalField()
|
||||
|
||||
Person.drop_collection()
|
||||
Person(name="Wilson Jr", rating=Decimal('1.0')).save()
|
||||
|
||||
ulist = list(Person.objects.scalar('name', 'rating'))
|
||||
self.assertEqual(ulist, [(u'Wilson Jr', Decimal('1.0'))])
|
||||
|
||||
|
||||
def test_scalar_reference_field(self):
|
||||
class State(Document):
|
||||
name = StringField()
|
||||
|
|
@ -3190,7 +3177,6 @@ class QuerySetTest(unittest.TestCase):
|
|||
objectid_field = ObjectIdField(default=ObjectId)
|
||||
reference_field = ReferenceField(Simple, default=lambda: Simple().save())
|
||||
map_field = MapField(IntField(), default=lambda: {"simple": 1})
|
||||
decimal_field = DecimalField(default=1.0)
|
||||
complex_datetime_field = ComplexDateTimeField(default=datetime.now)
|
||||
url_field = URLField(default="http://mongoengine.org")
|
||||
dynamic_field = DynamicField(default=1)
|
||||
|
|
@ -3221,30 +3207,25 @@ class QuerySetTest(unittest.TestCase):
|
|||
id = ObjectIdField('_id')
|
||||
name = StringField()
|
||||
age = IntField()
|
||||
price = DecimalField()
|
||||
|
||||
User.drop_collection()
|
||||
User(name="Bob Dole", age=89, price=Decimal('1.11')).save()
|
||||
User(name="Barack Obama", age=51, price=Decimal('2.22')).save()
|
||||
User(name="Bob Dole", age=89).save()
|
||||
User(name="Barack Obama", age=51).save()
|
||||
|
||||
users = User.objects.only('name', 'price').as_pymongo()
|
||||
users = User.objects.only('name').as_pymongo()
|
||||
results = list(users)
|
||||
self.assertTrue(isinstance(results[0], dict))
|
||||
self.assertTrue(isinstance(results[1], dict))
|
||||
self.assertEqual(results[0]['name'], 'Bob Dole')
|
||||
self.assertEqual(results[0]['price'], 1.11)
|
||||
self.assertEqual(results[1]['name'], 'Barack Obama')
|
||||
self.assertEqual(results[1]['price'], 2.22)
|
||||
|
||||
# Test coerce_types
|
||||
users = User.objects.only('name', 'price').as_pymongo(coerce_types=True)
|
||||
users = User.objects.only('name').as_pymongo(coerce_types=True)
|
||||
results = list(users)
|
||||
self.assertTrue(isinstance(results[0], dict))
|
||||
self.assertTrue(isinstance(results[1], dict))
|
||||
self.assertEqual(results[0]['name'], 'Bob Dole')
|
||||
self.assertEqual(results[0]['price'], Decimal('1.11'))
|
||||
self.assertEqual(results[1]['name'], 'Barack Obama')
|
||||
self.assertEqual(results[1]['price'], Decimal('2.22'))
|
||||
|
||||
def test_as_pymongo_json_limit_fields(self):
|
||||
|
||||
|
|
@ -3268,6 +3249,7 @@ class QuerySetTest(unittest.TestCase):
|
|||
serialized_user = User.objects.exclude('password_salt').only('email').to_json()
|
||||
self.assertEqual('[{"email": "ross@example.com"}]', serialized_user)
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_no_dereference(self):
|
||||
|
||||
class Organization(Document):
|
||||
|
|
|
|||
|
|
@ -63,6 +63,7 @@ class TransformTest(unittest.TestCase):
|
|||
|
||||
BlogPost.drop_collection()
|
||||
|
||||
@unittest.skip("unsupported")
|
||||
def test_query_pk_field_name(self):
|
||||
"""Ensure that the correct "primary key" field name is used when
|
||||
querying
|
||||
|
|
|
|||
|
|
@ -16,6 +16,7 @@ class FieldTest(unittest.TestCase):
|
|||
connect(db='mongoenginetest')
|
||||
self.db = get_db()
|
||||
|
||||
@unittest.skip("select_related currently doesn't dereference lists")
|
||||
def test_list_item_dereference(self):
|
||||
"""Ensure that DBRef items in ListFields are dereferenced.
|
||||
"""
|
||||
|
|
@ -74,6 +75,7 @@ class FieldTest(unittest.TestCase):
|
|||
User.drop_collection()
|
||||
Group.drop_collection()
|
||||
|
||||
@unittest.skip("select_related currently doesn't dereference lists")
|
||||
def test_list_item_dereference_dref_false(self):
|
||||
"""Ensure that DBRef items in ListFields are dereferenced.
|
||||
"""
|
||||
|
|
@ -146,6 +148,7 @@ class FieldTest(unittest.TestCase):
|
|||
self.assertEqual(Group._get_collection().find_one()['members'], [1])
|
||||
self.assertEqual(group.members, [user])
|
||||
|
||||
@unittest.skip('currently not implemented')
|
||||
def test_handle_old_style_references(self):
|
||||
"""Ensure that DBRef items in ListFields are dereferenced.
|
||||
"""
|
||||
|
|
@ -179,6 +182,7 @@ class FieldTest(unittest.TestCase):
|
|||
self.assertEqual(group.members[0].name, 'user 1')
|
||||
self.assertEqual(group.members[-1].name, 'String!')
|
||||
|
||||
@unittest.skip('currently not implemented')
|
||||
def test_migrate_references(self):
|
||||
"""Example of migrating ReferenceField storage
|
||||
"""
|
||||
|
|
@ -225,6 +229,7 @@ class FieldTest(unittest.TestCase):
|
|||
self.assertTrue(isinstance(raw_data['author'], ObjectId))
|
||||
self.assertTrue(isinstance(raw_data['members'][0], ObjectId))
|
||||
|
||||
@unittest.skip("select_related currently doesn't dereference lists")
|
||||
def test_recursive_reference(self):
|
||||
"""Ensure that ReferenceFields can reference their own documents.
|
||||
"""
|
||||
|
|
@ -259,9 +264,15 @@ class FieldTest(unittest.TestCase):
|
|||
self.assertEqual(q, 1)
|
||||
|
||||
peter.boss
|
||||
self.assertEqual(q, 2)
|
||||
self.assertEqual(q, 1)
|
||||
|
||||
peter.friends
|
||||
self.assertEqual(q, 1)
|
||||
|
||||
peter.boss.name
|
||||
self.assertEqual(q, 2)
|
||||
|
||||
peter.friends[0].name
|
||||
self.assertEqual(q, 3)
|
||||
|
||||
# Document select_related
|
||||
|
|
@ -291,6 +302,32 @@ class FieldTest(unittest.TestCase):
|
|||
self.assertEqual(employee.friends, friends)
|
||||
self.assertEqual(q, 2)
|
||||
|
||||
def test_list_of_lists_of_references(self):
|
||||
|
||||
class User(Document):
|
||||
name = StringField()
|
||||
|
||||
class Post(Document):
|
||||
user_lists = ListField(ListField(ReferenceField(User)))
|
||||
|
||||
class SimpleList(Document):
|
||||
users = ListField(ReferenceField(User))
|
||||
|
||||
User.drop_collection()
|
||||
Post.drop_collection()
|
||||
SimpleList.drop_collection()
|
||||
|
||||
u1 = User.objects.create(name='u1')
|
||||
u2 = User.objects.create(name='u2')
|
||||
u3 = User.objects.create(name='u3')
|
||||
|
||||
SimpleList.objects.create(users=[u1, u2, u3])
|
||||
self.assertEqual(SimpleList.objects.all()[0].users, [u1, u2, u3])
|
||||
|
||||
Post.objects.create(user_lists=[[u1, u2], [u3]])
|
||||
self.assertEqual(Post.objects.all()[0].user_lists, [[u1, u2], [u3]])
|
||||
|
||||
|
||||
def test_circular_reference(self):
|
||||
"""Ensure you can handle circular references
|
||||
"""
|
||||
|
|
@ -391,6 +428,7 @@ class FieldTest(unittest.TestCase):
|
|||
"%s" % Person.objects()
|
||||
)
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_generic_reference(self):
|
||||
|
||||
class UserA(Document):
|
||||
|
|
@ -482,6 +520,7 @@ class FieldTest(unittest.TestCase):
|
|||
UserC.drop_collection()
|
||||
Group.drop_collection()
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_list_field_complex(self):
|
||||
|
||||
class UserA(Document):
|
||||
|
|
@ -573,6 +612,7 @@ class FieldTest(unittest.TestCase):
|
|||
UserC.drop_collection()
|
||||
Group.drop_collection()
|
||||
|
||||
@unittest.skip('MapField not fully implemented')
|
||||
def test_map_field_reference(self):
|
||||
|
||||
class User(Document):
|
||||
|
|
@ -638,6 +678,7 @@ class FieldTest(unittest.TestCase):
|
|||
User.drop_collection()
|
||||
Group.drop_collection()
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_dict_field(self):
|
||||
|
||||
class UserA(Document):
|
||||
|
|
@ -741,6 +782,7 @@ class FieldTest(unittest.TestCase):
|
|||
UserC.drop_collection()
|
||||
Group.drop_collection()
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_dict_field_no_field_inheritance(self):
|
||||
|
||||
class UserA(Document):
|
||||
|
|
@ -817,6 +859,7 @@ class FieldTest(unittest.TestCase):
|
|||
UserA.drop_collection()
|
||||
Group.drop_collection()
|
||||
|
||||
@unittest.skip("select_related currently doesn't dereference lists")
|
||||
def test_generic_reference_map_field(self):
|
||||
|
||||
class UserA(Document):
|
||||
|
|
@ -942,6 +985,7 @@ class FieldTest(unittest.TestCase):
|
|||
self.assertEqual(root.children, [company])
|
||||
self.assertEqual(company.parents, [root])
|
||||
|
||||
@unittest.skip("not implemented")
|
||||
def test_dict_in_dbref_instance(self):
|
||||
|
||||
class Person(Document):
|
||||
|
|
|
|||
|
|
@ -30,28 +30,10 @@ class SignalTests(unittest.TestCase):
|
|||
def __unicode__(self):
|
||||
return self.name
|
||||
|
||||
@classmethod
|
||||
def pre_init(cls, sender, document, *args, **kwargs):
|
||||
signal_output.append('pre_init signal, %s' % cls.__name__)
|
||||
signal_output.append(str(kwargs['values']))
|
||||
|
||||
@classmethod
|
||||
def post_init(cls, sender, document, **kwargs):
|
||||
signal_output.append('post_init signal, %s' % document)
|
||||
|
||||
@classmethod
|
||||
def pre_save(cls, sender, document, **kwargs):
|
||||
signal_output.append('pre_save signal, %s' % document)
|
||||
|
||||
@classmethod
|
||||
def pre_save_post_validation(cls, sender, document, **kwargs):
|
||||
signal_output.append('pre_save_post_validation signal, %s' % document)
|
||||
if 'created' in kwargs:
|
||||
if kwargs['created']:
|
||||
signal_output.append('Is created')
|
||||
else:
|
||||
signal_output.append('Is updated')
|
||||
|
||||
@classmethod
|
||||
def post_save(cls, sender, document, **kwargs):
|
||||
signal_output.append('post_save signal, %s' % document)
|
||||
|
|
@ -118,10 +100,7 @@ class SignalTests(unittest.TestCase):
|
|||
# Save up the number of connected signals so that we can check at the
|
||||
# end that all the signals we register get properly unregistered
|
||||
self.pre_signals = (
|
||||
len(signals.pre_init.receivers),
|
||||
len(signals.post_init.receivers),
|
||||
len(signals.pre_save.receivers),
|
||||
len(signals.pre_save_post_validation.receivers),
|
||||
len(signals.post_save.receivers),
|
||||
len(signals.pre_delete.receivers),
|
||||
len(signals.post_delete.receivers),
|
||||
|
|
@ -129,10 +108,7 @@ class SignalTests(unittest.TestCase):
|
|||
len(signals.post_bulk_insert.receivers),
|
||||
)
|
||||
|
||||
signals.pre_init.connect(Author.pre_init, sender=Author)
|
||||
signals.post_init.connect(Author.post_init, sender=Author)
|
||||
signals.pre_save.connect(Author.pre_save, sender=Author)
|
||||
signals.pre_save_post_validation.connect(Author.pre_save_post_validation, sender=Author)
|
||||
signals.post_save.connect(Author.post_save, sender=Author)
|
||||
signals.pre_delete.connect(Author.pre_delete, sender=Author)
|
||||
signals.post_delete.connect(Author.post_delete, sender=Author)
|
||||
|
|
@ -145,12 +121,9 @@ class SignalTests(unittest.TestCase):
|
|||
signals.post_save.connect(ExplicitId.post_save, sender=ExplicitId)
|
||||
|
||||
def tearDown(self):
|
||||
signals.pre_init.disconnect(self.Author.pre_init)
|
||||
signals.post_init.disconnect(self.Author.post_init)
|
||||
signals.post_delete.disconnect(self.Author.post_delete)
|
||||
signals.pre_delete.disconnect(self.Author.pre_delete)
|
||||
signals.post_save.disconnect(self.Author.post_save)
|
||||
signals.pre_save_post_validation.disconnect(self.Author.pre_save_post_validation)
|
||||
signals.pre_save.disconnect(self.Author.pre_save)
|
||||
signals.pre_bulk_insert.disconnect(self.Author.pre_bulk_insert)
|
||||
signals.post_bulk_insert.disconnect(self.Author.post_bulk_insert)
|
||||
|
|
@ -162,10 +135,7 @@ class SignalTests(unittest.TestCase):
|
|||
|
||||
# Check that all our signals got disconnected properly.
|
||||
post_signals = (
|
||||
len(signals.pre_init.receivers),
|
||||
len(signals.post_init.receivers),
|
||||
len(signals.pre_save.receivers),
|
||||
len(signals.pre_save_post_validation.receivers),
|
||||
len(signals.post_save.receivers),
|
||||
len(signals.pre_delete.receivers),
|
||||
len(signals.post_delete.receivers),
|
||||
|
|
@ -180,9 +150,6 @@ class SignalTests(unittest.TestCase):
|
|||
def test_model_signals(self):
|
||||
""" Model saves should throw some signals. """
|
||||
|
||||
def create_author():
|
||||
self.Author(name='Bill Shakespeare')
|
||||
|
||||
def bulk_create_author_with_load():
|
||||
a1 = self.Author(name='Bill Shakespeare')
|
||||
self.Author.objects.insert([a1], load_bulk=True)
|
||||
|
|
@ -191,17 +158,9 @@ class SignalTests(unittest.TestCase):
|
|||
a1 = self.Author(name='Bill Shakespeare')
|
||||
self.Author.objects.insert([a1], load_bulk=False)
|
||||
|
||||
self.assertEqual(self.get_signal_output(create_author), [
|
||||
"pre_init signal, Author",
|
||||
"{'name': 'Bill Shakespeare'}",
|
||||
"post_init signal, Bill Shakespeare",
|
||||
])
|
||||
|
||||
a1 = self.Author(name='Bill Shakespeare')
|
||||
self.assertEqual(self.get_signal_output(a1.save), [
|
||||
"pre_save signal, Bill Shakespeare",
|
||||
"pre_save_post_validation signal, Bill Shakespeare",
|
||||
"Is created",
|
||||
"post_save signal, Bill Shakespeare",
|
||||
"Is created"
|
||||
])
|
||||
|
|
@ -210,8 +169,6 @@ class SignalTests(unittest.TestCase):
|
|||
a1.name = 'William Shakespeare'
|
||||
self.assertEqual(self.get_signal_output(a1.save), [
|
||||
"pre_save signal, William Shakespeare",
|
||||
"pre_save_post_validation signal, William Shakespeare",
|
||||
"Is updated",
|
||||
"post_save signal, William Shakespeare",
|
||||
"Is updated"
|
||||
])
|
||||
|
|
@ -223,18 +180,13 @@ class SignalTests(unittest.TestCase):
|
|||
|
||||
signal_output = self.get_signal_output(bulk_create_author_with_load)
|
||||
|
||||
# The output of this signal is not entirely deterministic. The reloaded
|
||||
# object will have an object ID. Hence, we only check part of the output
|
||||
self.assertEqual(signal_output[3],
|
||||
"pre_bulk_insert signal, [<Author: Bill Shakespeare>]")
|
||||
self.assertEqual(signal_output[-2:],
|
||||
["post_bulk_insert signal, [<Author: Bill Shakespeare>]",
|
||||
"Is loaded",])
|
||||
self.assertEqual(self.get_signal_output(bulk_create_author_with_load), [
|
||||
"pre_bulk_insert signal, [<Author: Bill Shakespeare>]",
|
||||
"post_bulk_insert signal, [<Author: Bill Shakespeare>]",
|
||||
"Is loaded",
|
||||
])
|
||||
|
||||
self.assertEqual(self.get_signal_output(bulk_create_author_without_load), [
|
||||
"pre_init signal, Author",
|
||||
"{'name': 'Bill Shakespeare'}",
|
||||
"post_init signal, Bill Shakespeare",
|
||||
"pre_bulk_insert signal, [<Author: Bill Shakespeare>]",
|
||||
"post_bulk_insert signal, [<Author: Bill Shakespeare>]",
|
||||
"Not loaded",
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue