def test_connection(self):
class DocA(Document):
skeleton = {
"doc_a": {
'foo': int
},
}
self.connection.register([DocA])
assertion = True
try:
DocA.connection
except AttributeError:
assertion = True
assert assertion
try:
DocA.db
except AttributeError:
assertion = True
assert assertion
try:
DocA.collection
except AttributeError:
assertion = True
assert assertion
assert self.col.DocA.connection == Connection("localhost", 27017)
assert self.col.DocA.collection == Connection(
"localhost", 27017)['test']['mongolite']
assert self.col.DocA.db == Connection("localhost", 27017)['test']
class TypesTestCase(unittest.TestCase):
def setUp(self):
self.connection = Connection()
self.col = self.connection['test']['mongolite']
def tearDown(self):
self.connection.drop_database('test')
def test_authorized_type(self):
for auth_type in SchemaDocument.authorized_types:
if auth_type is dict:
auth_type = {}
class MyDoc(SchemaDocument):
skeleton = {"foo": auth_type}
if type(auth_type) is dict:
self.assertEqual(MyDoc(), {"foo": {}})
elif auth_type is list:
self.assertEqual(MyDoc(), {"foo": []})
else:
assert MyDoc() == {"foo": None}, auth_type
def test_not_authorized_type(self):
for unauth_type in [set]:
failed = False
try:
class MyDoc(SchemaDocument):
skeleton = {"foo": [unauth_type]}
except StructureError, e:
self.assertEqual(
str(e),
"MyDoc: %s is not an authorized type" % unauth_type)
failed = True
self.assertEqual(failed, True)
failed = False
try:
class MyDoc(SchemaDocument):
skeleton = {"foo": (unauth_type)}
except StructureError, e:
self.assertEqual(
str(e),
"MyDoc: %s is not an authorized type" % unauth_type)
failed = True
self.assertEqual(failed, True)
failed = False
try:
class MyDoc2(SchemaDocument):
skeleton = {'foo': [{int: unauth_type}]}
except StructureError, e:
self.assertEqual(
str(e),
"MyDoc2: %s is not an authorized type" % unauth_type)
failed = True
def test_get_collection_with_connection(self):
class Section(Document):
skeleton = {"section":int}
connection = Connection('127.0.0.3')
connection.register([Section])
col = connection.test.mongolite
assert col.database.connection == col.Section.connection
assert col.database.name == 'test' == col.Section.db.name
assert col.name == 'mongolite' == col.Section.collection.name
def test_get_collection_with_connection(self):
class Section(Document):
skeleton = {"section": int}
connection = Connection('127.0.0.3')
connection.register([Section])
col = connection.test.mongolite
assert col.database.connection == col.Section.connection
assert col.database.name == 'test' == col.Section.db.name
assert col.name == 'mongolite' == col.Section.collection.name
def test_pass_connection_arguments_to_cursor(self):
class MyDoc(Document):
structure = {
"foo":int,
"bar":{"bla":int},
}
con = Connection(read_preference=ReadPreference.SECONDARY_PREFERRED,
secondary_acceptable_latency_ms=16)
con.register([MyDoc])
col = con['test']['mongokit']
assert col.MyDoc.find()._Cursor__read_preference == ReadPreference.SECONDARY_PREFERRED
assert col.MyDoc.find()._Cursor__secondary_acceptable_latency_ms == 16
con.close()
class TypesTestCase(unittest.TestCase):
def setUp(self):
self.connection = Connection()
self.col = self.connection['test']['mongolite']
def tearDown(self):
self.connection.drop_database('test')
def test_authorized_type(self):
for auth_type in SchemaDocument.authorized_types:
if auth_type is dict:
auth_type = {}
class MyDoc(SchemaDocument):
skeleton = { "foo":auth_type }
if type(auth_type) is dict:
self.assertEqual(MyDoc(), {"foo":{}})
elif auth_type is list:
self.assertEqual(MyDoc(), {"foo":[]})
else:
assert MyDoc() == {"foo":None}, auth_type
def test_not_authorized_type(self):
for unauth_type in [set]:
failed = False
try:
class MyDoc(SchemaDocument):
skeleton = { "foo":[unauth_type] }
except StructureError, e:
self.assertEqual(str(e), "MyDoc: %s is not an authorized type" % unauth_type)
failed = True
self.assertEqual(failed, True)
failed = False
try:
class MyDoc(SchemaDocument):
skeleton = { "foo":(unauth_type) }
except StructureError, e:
self.assertEqual(str(e), "MyDoc: %s is not an authorized type" % unauth_type)
failed = True
self.assertEqual(failed, True)
failed = False
try:
class MyDoc2(SchemaDocument):
skeleton = { 'foo':[{int:unauth_type }]}
except StructureError, e:
self.assertEqual(str(e), "MyDoc2: %s is not an authorized type" % unauth_type)
failed = True
def test_pass_connection_arguments_to_cursor(self):
class MyDoc(Document):
structure = {
"foo": int,
"bar": {
"bla": int
},
}
con = Connection(read_preference=ReadPreference.SECONDARY_PREFERRED,
secondary_acceptable_latency_ms=16)
con.register([MyDoc])
col = con['test']['mongokit']
assert col.MyDoc.find(
)._Cursor__read_preference == ReadPreference.SECONDARY_PREFERRED
assert col.MyDoc.find()._Cursor__secondary_acceptable_latency_ms == 16
con.close()
# -*- coding: utf-8 -*-
from mongolite import Connection, Document
from bson.objectid import ObjectId
from tornado.options import options as tornado_options_dict
import settings
import logging
connection = Connection()
logging.info(u'Работаем с базой данных %s.' % settings.get('db_name'))
class BaseDocument(Document):
__database__ = settings.get('db_name')
__title__ = u'Тайтл не установлен!'
__short_fields__ = []
@property
def name(self):
""" Имя сущности, по умолчанию выводится айдишник"""
return str(self['_id'])
@property
def for_select(self):
return (str(self['_id']), self.name)
@classmethod
def get_for_select(cls):
return [u.for_select for u in connection[cls.__name__].find()]
@classmethod
class ApiTestCase(unittest.TestCase):
def setUp(self):
self.connection = Connection()
self.col = self.connection['test']['mongolite']
def tearDown(self):
self.connection.drop_database('test')
self.connection.drop_database('othertest')
def test_save(self):
class MyDoc(Document):
skeleton = {
"bla":{
"foo":unicode,
"bar":int,
},
"spam":[],
}
self.connection.register([MyDoc])
mydoc = self.col.MyDoc()
mydoc["bla"]["foo"] = u"bar"
mydoc["bla"]["bar"] = 42
mydoc.save()
assert isinstance(mydoc['_id'], ObjectId)
saved_doc = self.col.find_one({"bla.bar":42})
for key, value in mydoc.iteritems():
assert saved_doc[key] == value
mydoc = self.col.MyDoc()
mydoc["bla"]["foo"] = u"bar"
mydoc["bla"]["bar"] = 43
mydoc.save()
saved_doc = self.col.find_one({"bla.bar":43})
for key, value in mydoc.iteritems():
assert saved_doc[key] == value
def test_save_without_collection(self):
class MyDoc(Document):
skeleton = {
"foo":int,
}
self.connection.register([MyDoc])
mydoc = MyDoc()
mydoc["foo"] = 1
self.assertRaises(ConnectionError, mydoc.save)
def test_delete(self):
class MyDoc(Document):
skeleton = {
"foo":int,
}
self.connection.register([MyDoc])
mydoc = self.col.MyDoc()
mydoc['_id'] = 'foo'
mydoc["foo"] = 1
mydoc.save()
assert self.col.MyDoc.find().count() == 1
mydoc = self.col.MyDoc.get_from_id('foo')
assert mydoc['foo'] == 1
mydoc.delete()
assert self.col.MyDoc.find().count() == 0
def test_generate_skeleton(self):
class A(SchemaDocument):
skeleton = {
"a":{"foo":int},
"bar":unicode
}
a = A(gen_skel=False)
assert a == {}
a.generate_skeleton()
assert a == {"a":{"foo":None}, "bar":None}, a
def test_generate_skeleton2(self):
class A(SchemaDocument):
skeleton = {
"a":{"foo":[int]},
"bar":{unicode:{"egg":int}}
}
a = A(gen_skel=False)
assert a == {}
a.generate_skeleton()
assert a == {"a":{"foo":[]}, "bar":{}}, a
def test_generate_skeleton3(self):
class A(SchemaDocument):
skeleton = {
"a":{"foo":[int], "spam":{"bla":unicode}},
"bar":{unicode:{"egg":int}}
}
a = A(gen_skel=False)
assert a == {}
a.generate_skeleton()
assert a == {"a":{"foo":[], "spam":{"bla":None}}, "bar":{}}, a
def test_get_from_id(self):
class MyDoc(Document):
skeleton = {
"foo":int,
}
self.connection.register([MyDoc])
mydoc = self.col.MyDoc()
mydoc["_id"] = "bar"
mydoc["foo"] = 3
mydoc.save()
fetched_doc = self.col.MyDoc.get_from_id("bar")
assert mydoc == fetched_doc
assert callable(fetched_doc) is False
assert isinstance(fetched_doc, MyDoc)
raw_doc = self.col.get_from_id('bar')
assert mydoc == raw_doc
assert not isinstance(raw_doc, MyDoc)
def test_find(self):
class MyDoc(Document):
skeleton = {
"foo":int,
"bar":{"bla":int},
}
self.connection.register([MyDoc])
for i in range(10):
mydoc = self.col.MyDoc()
mydoc["foo"] = i
mydoc["bar"]['bla'] = i
mydoc.save()
for i in self.col.MyDoc.find({"foo":{"$gt":4}}):
assert isinstance(i, MyDoc), (i, type(i))
docs_list = [i["foo"] for i in self.col.MyDoc.find({"foo":{"$gt":4}})]
assert docs_list == [5,6,7,8,9]
# using limit/count
assert self.col.MyDoc.find().count() == 10, self.col.MyDoc.find().count()
assert self.col.MyDoc.find().limit(1).count() == 10, self.col.MyDoc.find().limit(1).count()
assert self.col.MyDoc.find().where('this.foo').count() == 9 #{'foo':0} is not taken
assert self.col.MyDoc.find().where('this.bar.bla').count() == 9 #{'foo':0} is not taken
assert self.col.MyDoc.find().hint([('foo', 1)])
assert [i['foo'] for i in self.col.MyDoc.find().sort('foo', -1)] == [9,8,7,6,5,4,3,2,1,0]
allPlans = self.col.MyDoc.find().explain()['allPlans']
assert allPlans == [{u'cursor': u'BasicCursor', u'indexBounds': {}}]
next_doc = self.col.MyDoc.find().sort('foo',1).next()
assert callable(next_doc) is False
assert isinstance(next_doc, MyDoc)
assert next_doc['foo'] == 0
assert len(list(self.col.MyDoc.find().skip(3))) == 7, len(list(self.col.MyDoc.find().skip(3)))
from mongolite.cursor import Cursor
assert isinstance(self.col.MyDoc.find().skip(3), Cursor)
def test_find_one(self):
class MyDoc(Document):
skeleton = {
"foo":int
}
self.connection.register([MyDoc])
assert self.col.MyDoc.find_one() is None
mydoc = self.col.MyDoc()
mydoc['foo'] = 0
mydoc.save()
mydoc = self.col.MyDoc.find_one()
assert mydoc["foo"] == 0
assert isinstance(mydoc, MyDoc)
for i in range(10):
mydoc = self.col.MyDoc()
mydoc["foo"] = i
mydoc.save()
one_doc = self.col.MyDoc.find_one()
assert callable(one_doc) is False
raw_mydoc = self.col.find_one()
assert one_doc == raw_mydoc
def test_find_and_modify(self):
@self.connection.register
class DocA(Document):
__database__ = 'test'
__collection__ = 'doca'
structure = {'title': unicode, 'rank': int}
for i in range(10):
self.connection.DocA({'title': unicode(i), 'rank': i}).save()
doc = self.connection.DocA.find_and_modify({'rank':3}, {'$set':{'title': u'coucou'}})
new_doc = self.connection.DocA.find_one({'rank':3})
self.assertEqual(doc['title'], '3')
self.assertEqual(new_doc['title'], 'coucou')
self.assertEqual(isinstance(doc, DocA), True)
@self.connection.register
class DocA(Document):
structure = {'title': unicode, 'rank': int}
for i in range(10):
self.connection.test.doca2.save({'title': unicode(i), 'rank': i})
doc = self.connection.test.doca2.DocA.find_and_modify({'rank':3}, {'$set':{'title': u'coucou'}})
new_doc = self.connection.test.doca2.DocA.find_one({'rank':3})
self.assertEqual(doc['title'], '3')
self.assertEqual(new_doc['title'], 'coucou')
self.assertEqual(isinstance(doc, DocA), True)
def test_find_random(self):
class MyDoc(Document):
skeleton = {
"foo":int
}
self.connection.register([MyDoc])
assert self.col.find_random() is None
assert self.col.MyDoc.find_random() is None
for i in range(50):
mydoc = self.col.MyDoc()
mydoc["foo"] = i
mydoc.save()
raw_mydoc = self.col.find_random()
mydoc = self.col.MyDoc.find_random()
assert callable(mydoc) is False
assert isinstance(mydoc, MyDoc)
assert mydoc != raw_mydoc, (mydoc, raw_mydoc)
def test_query_with_passing_collection(self):
class MyDoc(Document):
skeleton = {
'foo':int,
}
self.connection.register([MyDoc])
mongolite = self.connection.test.mongolite
# boostraping
for i in range(10):
mydoc = mongolite.MyDoc()
mydoc['_id'] = unicode(i)
mydoc['foo'] = i
mydoc.save()
# get_from_id
fetched_doc = mongolite.MyDoc.get_from_id('4')
assert fetched_doc.collection == mongolite
# all
fetched_docs = mongolite.MyDoc.find({'foo':{'$gt':2}})
assert fetched_docs.count() == 7
for doc in fetched_docs:
assert doc.collection == mongolite
def test_connection(self):
class DocA(Document):
skeleton = {
"doc_a":{'foo':int},
}
self.connection.register([DocA])
assertion = True
try:
DocA.connection
except AttributeError:
assertion = True
assert assertion
try:
DocA.db
except AttributeError:
assertion = True
assert assertion
try:
DocA.collection
except AttributeError:
assertion = True
assert assertion
assert self.col.DocA.connection == Connection("localhost", 27017)
assert self.col.DocA.collection == Connection("localhost", 27017)['test']['mongolite']
assert self.col.DocA.db == Connection("localhost", 27017)['test']
def test_all_with_dynamic_collection(self):
class Section(Document):
skeleton = {"section":int}
self.connection.register([Section])
s = self.connection.test.section.Section()
s['section'] = 1
s.save()
s = self.connection.test.section.Section()
s['section'] = 2
s.save()
s = self.connection.test.other_section.Section()
s['section'] = 1
s.save()
s = self.connection.test.other_section.Section()
s['section'] = 2
s.save()
sect_col = self.connection.test.section
sects = [s.collection.name == 'section' and s.db.name == 'test' for s in sect_col.Section.find({})]
assert len(sects) == 2, len(sects)
assert any(sects)
sect_col = self.connection.test.other_section
sects = [s.collection.name == 'other_section' and s.db.name == 'test' for s in sect_col.Section.find({})]
assert len(sects) == 2
assert any(sects)
def test_get_collection_with_connection(self):
class Section(Document):
skeleton = {"section":int}
connection = Connection('127.0.0.3')
connection.register([Section])
col = connection.test.mongolite
assert col.database.connection == col.Section.connection
assert col.database.name == 'test' == col.Section.db.name
assert col.name == 'mongolite' == col.Section.collection.name
def test_get_size(self):
class MyDoc(Document):
skeleton = {
"doc":{"foo":int, "bla":unicode},
}
mydoc = MyDoc()
mydoc['doc']['foo'] = 3
mydoc['doc']['bla'] = u'bla bla'
assert len(mydoc.get_son_object()) == 41, len(mydoc.get_son_object())
mydoc['doc']['bla'] = u'bla bla'+'b'*12
assert len(mydoc.get_son_object()) == 41+12
def test_get_with_no_wrap(self):
class MyDoc(Document):
skeleton = {"foo":int}
self.connection.register([MyDoc])
for i in xrange(2000):
mydoc = self.col.MyDoc()
mydoc['foo'] = i
mydoc.save()
import time
start = time.time()
wrapped_mydocs = [i for i in self.col.MyDoc.find()]
end = time.time()
wrap_time = end-start
start = time.time()
mydocs = [i for i in self.col.find().sort('foo', -1)]
end = time.time()
no_wrap_time = end-start
assert no_wrap_time < wrap_time
assert isinstance(wrapped_mydocs[0], MyDoc)
assert not isinstance(mydocs[0], MyDoc), type(mydocs[0])
assert [i['foo'] for i in mydocs] == list(reversed(range(2000))), [i['foo'] for i in mydocs]
assert mydocs[0]['foo'] == 1999, mydocs[0]['foo']
assert not isinstance(self.col.find().sort('foo', -1).next(), MyDoc)
def test_get_dbref(self):
class MyDoc(Document):
skeleton = {"foo":int}
self.connection.register([MyDoc])
mydoc = self.col.MyDoc()
mydoc['_id'] = u'1'
mydoc['foo'] = 1
mydoc.save()
mydoc = self.connection.test.othercol.MyDoc()
mydoc['_id'] = u'2'
mydoc['foo'] = 2
mydoc.save()
mydoc = self.connection.othertest.mongolite.MyDoc()
mydoc['_id'] = u'3'
mydoc['foo'] = 3
mydoc.save()
mydoc = self.col.MyDoc.find_one({'foo':1})
assert mydoc.get_dbref(), DBRef(u'mongolite', u'1', u'test')
mydoc = self.connection.test.othercol.MyDoc.find_one({'foo':2})
assert mydoc.get_dbref() == DBRef(u'othercol', u'2', u'test')
mydoc = self.connection.othertest.mongolite.MyDoc.find_one({'foo':3})
assert mydoc.get_dbref() == DBRef(u'mongolite', u'3', u'othertest')
def test__hash__(self):
class MyDoc(Document):
skeleton = {"foo":int}
self.connection.register([MyDoc])
mydoc = self.col.MyDoc()
mydoc['foo'] = 1
self.assertRaises(TypeError, hash, mydoc)
mydoc.save()
hash(mydoc)
def test_non_callable(self):
class MyDoc(Document):
skeleton = {"foo":int}
self.connection.register([MyDoc])
mydoc = self.col.MyDoc()
self.assertRaises(TypeError, mydoc)
assert callable(mydoc) is False
def test_bad_call(self):
class MyDoc(Document):
skeleton = {"foo":int}
self.assertRaises(TypeError, self.connection.test.col.MyDoc)
self.connection.register([MyDoc])
self.connection.test.col.MyDoc()
self.assertRaises(TypeError, self.connection.test.col.Bla)
self.assertRaises(TypeError, self.connection.test.Bla)
def test_distinct(self):
class Doc(Document):
skeleton = {
"foo": unicode,
"bla": int
}
self.connection.register([Doc])
for i in range(15):
if i % 2 == 0:
foo = u"blo"
else:
foo = u"bla"
doc = self.col.Doc(doc={'foo':foo, 'bla':i})
doc.save()
self.assertEqual(self.col.find().distinct('foo'), [u'blo', u'bla'])
self.assertEqual(self.col.find().distinct('bla'), range(15))
def test_explain(self):
class MyDoc(Document):
skeleton = {
"foo":int,
"bar":{"bla":int},
}
self.connection.register([MyDoc])
for i in range(10):
mydoc = self.col.MyDoc()
mydoc["foo"] = i
mydoc["bar"]['bla'] = i
mydoc.save()
explain1 = self.col.MyDoc.find({"foo":{"$gt":4}}).explain()
explain2 = self.col.find({'foo':{'gt':4}}).explain()
explain1.pop('n')
explain2.pop('n')
assert explain1 == explain2, (explain1, explain2)
def test_with_long(self):
class Doc(Document):
skeleton = {
"foo":long,
"bar":unicode,
}
self.connection.register([Doc])
doc = self.col.Doc()
doc['foo'] = 12L
doc.save()
fetch_doc = self.col.Doc.find_one()
fetch_doc['bar'] = u'egg'
fetch_doc.save()
def test_passing_collection_in_argument(self):
class MyDoc(Document):
skeleton = {
'foo':unicode
}
doc = MyDoc(collection=self.col)
doc['foo'] = u'bla'
doc.save()
def test_reload(self):
class MyDoc(Document):
skeleton = {
'foo':{
'bar':unicode,
'eggs':{'spam':int},
},
'bla':unicode
}
self.connection.register([MyDoc])
doc = self.col.MyDoc()
self.assertRaises(KeyError, doc.reload)
doc['_id'] = 3
doc['foo']['bar'] = u'mybar'
doc['foo']['eggs']['spam'] = 4
doc['bla'] = u'ble'
self.assertRaises(OperationFailure, doc.reload)
doc.save()
doc['bla'] = u'bli'
self.col.update({'_id':doc['_id']}, {'$set':{'foo.eggs.spam':2}})
doc.reload()
assert doc == {'_id': 3, 'foo': {u'eggs': {u'spam': 2}, u'bar': u'mybar'}, 'bla': u'ble'}
def test_rewind(self):
class MyDoc(Document):
skeleton = {
'foo':int,
}
self.connection.register([MyDoc])
for i in range(10):
doc = self.col.MyDoc()
doc['foo'] = i
doc.save()
cur = self.col.MyDoc.find()
for i in cur:
assert isinstance(i, MyDoc), type(MyDoc)
try:
cur.next()
except StopIteration:
pass
cur.rewind()
for i in cur:
assert isinstance(i, MyDoc), type(MyDoc)
for i in cur.rewind():
assert isinstance(i, MyDoc), type(MyDoc)
def test_decorator(self):
@self.connection.register
class MyDoc(Document):
skeleton = {
'foo':int,
}
mydoc = self.col.MyDoc()
mydoc['foo'] = 3
mydoc.save()
raw_doc = self.col.MyDoc.find_one()
self.assertEqual(raw_doc['foo'], 3)
assert isinstance(raw_doc, MyDoc)
def test_collection_name_filled(self):
@self.connection.register
class MyDoc(Document):
__collection__ = 'mydoc'
skeleton = {
'foo':int,
}
mydoc = self.connection.test.MyDoc()
mydoc['foo'] = 3
mydoc.save()
self.assertEqual(mydoc.collection.name, 'mydoc')
raw_doc = self.connection.test.MyDoc.find_one()
self.assertEqual(self.col.MyDoc.find_one(), None)
self.assertEqual(raw_doc['foo'], 3)
self.assertEqual(raw_doc, mydoc)
assert isinstance(raw_doc, MyDoc)
mydoc = self.col.MyDoc()
mydoc['foo'] = 3
mydoc.save()
self.assertEqual(mydoc.collection.name, 'mongolite')
raw_doc = self.col.MyDoc.find_one()
self.assertEqual(raw_doc['foo'], 3)
self.assertEqual(raw_doc, mydoc)
assert isinstance(raw_doc, MyDoc)
def test_database_name_filled(self):
failed = False
@self.connection.register
class MyDoc(Document):
__database__ = 'mydoc'
skeleton = {
'foo':int,
}
try:
doc = self.connection.MyDoc()
except AttributeError, e:
failed = True
self.assertEqual(str(e), 'MyDoc: __collection__ attribute not '
'found. You cannot specify the `__database__` attribute '
'without the `__collection__` attribute')
self.assertEqual(failed, True)
@self.connection.register
class MyDoc(Document):
__database__ = 'test'
__collection__ = 'mydoc'
skeleton = {
'foo':int,
}
# test directly from a connection
mydoc = self.connection.MyDoc()
mydoc['foo'] = 3
mydoc.save()
self.assertEqual(mydoc.collection.name, 'mydoc')
self.assertEqual(mydoc.collection.database.name, 'test')
self.assertEqual(self.col.MyDoc.find_one(), None)
raw_doc = self.connection.MyDoc.find_one()
self.assertEqual(raw_doc['foo'], 3)
self.assertEqual(raw_doc, mydoc)
assert isinstance(raw_doc, MyDoc)
# test directly from a database
mydoc = self.connection.othertest.MyDoc()
mydoc['foo'] = 3
mydoc.save()
self.assertEqual(mydoc.collection.name, 'mydoc')
self.assertEqual(mydoc.collection.database.name, 'othertest')
self.assertEqual(self.col.MyDoc.find_one(), None)
raw_doc = self.connection.othertest.MyDoc.find_one()
self.assertEqual(raw_doc['foo'], 3)
self.assertEqual(raw_doc, mydoc)
assert isinstance(raw_doc, MyDoc)
# and still can use it via a collection
mydoc = self.col.MyDoc()
mydoc['foo'] = 3
mydoc.save()
self.assertEqual(mydoc.collection.name, 'mongolite')
self.assertEqual(mydoc.collection.database.name, 'test')
raw_doc = self.col.MyDoc.find_one()
self.assertEqual(raw_doc['foo'], 3)
self.assertEqual(raw_doc, mydoc)
assert isinstance(raw_doc, MyDoc)
class InheritanceTestCase(unittest.TestCase):
def setUp(self):
self.connection = Connection()
self.col = self.connection['test']['mongolite']
def tearDown(self):
self.connection['test'].drop_collection('mongolite')
def test_simple_inheritance(self):
class A(SchemaDocument):
skeleton = {"a": {"foo": int}}
class B(A):
skeleton = {"b": {"bar": unicode}}
assert B() == {"a": {"foo": None}, "b": {"bar": None}}, B()
def test_simple_inheritance_with_only_optional(self):
class A(SchemaDocument):
optional = {
'optfoo': int,
}
class B(A):
optional = {
'optbar': float,
}
self.assertEqual(B(), {'optfoo': None, 'optbar': None})
def test_simple_inheritance_with_optional(self):
class A(SchemaDocument):
skeleton = {
'reqfoo': unicode,
}
optional = {
'optfoo': int,
}
class B(A):
optional = {
'optbar': float,
}
self.assertEqual(B(), {'reqfoo': None, 'optfoo': None, 'optbar': None})
def test_gen_doc(self):
class A(SchemaDocument):
skeleton = {
'reqfoo': unicode,
}
optional = {
'optfoo': int,
}
class B(A):
"""this is a test doc"""
optional = {
'optbar': float,
}
self.assertEqual(
B.__doc__, """this is a test doc
required fields: {
reqfoo : <type 'unicode'>
}
optional fields: {
optbar : <type 'float'>
optfoo : <type 'int'>
}
""")
def test_default_values_inheritance(self):
class A(SchemaDocument):
skeleton = {"a": {"foo": int}}
default_values = {"a.foo": 3}
class B(A):
skeleton = {"b": {"bar": unicode}}
assert B() == {"a": {"foo": 3}, "b": {"bar": None}}
class C(A):
skeleton = {"c": {"spam": unicode}}
default_values = {"a.foo": 5}
assert C() == {"a": {"foo": 5}, "c": {"spam": None}}, C()
def test_default_values_inheritance_with_optional(self):
class A(SchemaDocument):
skeleton = {"a": {"foo": int}}
optional = {"bar": int}
default_values = {"a.foo": 3, "bar": 42}
class B(A):
skeleton = {"b": {"bar": unicode}}
assert B() == {"a": {"foo": 3}, "b": {"bar": None}, "bar": 42}
class C(A):
skeleton = {"c": {"spam": unicode}}
optional = {
"bla": unicode,
}
default_values = {"a.foo": 5, "bla": u"foo"}
assert C() == {
"a": {
"foo": 5
},
"c": {
"spam": None
},
"bar": 42,
"bla": u"foo"
}, C()
def test_default_values_inheritance_with_function(self):
from datetime import datetime
class A(SchemaDocument):
skeleton = {"a": {"foo": datetime}}
default_values = {"a.foo": datetime.utcnow}
class B(A):
skeleton = {"b": {"bar": unicode}}
assert isinstance(B()['a']['foo'], datetime)
class C(A):
skeleton = {"c": {"spam": unicode}}
default_values = {"a.foo": datetime(2008, 8, 8)}
assert C() == {
"a": {
"foo": datetime(2008, 8, 8)
},
"c": {
"spam": None
}
}, C()
def test_complete_inheritance(self):
class A(SchemaDocument):
skeleton = {"a": {"foo": int}}
default_values = {"a.foo": 3}
class B(A):
skeleton = {"b": {"bar": unicode}}
default_values = {"a.foo": 5}
b = B()
assert b == {"a": {"foo": 5}, "b": {"bar": None}}
class C(B):
skeleton = {"c": {"spam": unicode}}
c = C()
assert c == {
"a": {
"foo": 5
},
"b": {
"bar": None
},
"c": {
"spam": None
}
}, C()
def test_polymorphism(self):
class A(SchemaDocument):
skeleton = {"a": {"foo": int}}
default_values = {"a.foo": 3}
class B(SchemaDocument):
skeleton = {"b": {"bar": unicode}}
required_fields = ['b.bar']
b = B()
assert b == {"b": {"bar": None}}
class C(A, B):
skeleton = {"c": {"spam": unicode}}
default_values = {"a.foo": 5}
c = C()
assert c == {
"a": {
"foo": 5
},
"b": {
"bar": None
},
"c": {
"spam": None
}
}, C()
def test_simple_manual_inheritance(self):
class A(SchemaDocument):
auto_inheritance = False
skeleton = {"a": {"foo": int}}
class B(A):
skeleton = {"b": {"bar": unicode}}
skeleton.update(A.skeleton)
assert B() == {"a": {"foo": None}, "b": {"bar": None}}
def test_default_values_manual_inheritance(self):
class A(SchemaDocument):
auto_inheritance = False
skeleton = {"a": {"foo": int}}
default_values = {"a.foo": 3}
class B(A):
skeleton = {"b": {"bar": unicode}}
skeleton.update(A.skeleton)
default_values = A.default_values
assert B() == {"a": {"foo": 3}, "b": {"bar": None}}
class C(A):
skeleton = {"c": {"spam": unicode}}
skeleton.update(A.skeleton)
default_values = A.default_values
default_values.update({"a.foo": 5})
assert C() == {"a": {"foo": 5}, "c": {"spam": None}}, C()
def test_inheritance_with_document(self):
class Doc(Document):
skeleton = {
"doc": {
'bla': int
},
}
class DocA(Doc):
skeleton = {
"doc_a": {
'foo': int
},
}
class DocB(DocA):
skeleton = {
"doc_b": {
"bar": int
},
}
self.connection.register([Doc, DocA, DocB])
assert self.col.DocA() == {
'doc': {
'bla': None
},
'doc_a': {
'foo': None
}
}
assert self.col.DocB() == {
'doc': {
'bla': None
},
'doc_b': {
'bar': None
},
'doc_a': {
'foo': None
}
}
# creating DocA
for i in range(10):
mydoc = self.col.DocA()
mydoc['doc']["bla"] = i + 1
mydoc['doc_a']["foo"] = i
mydoc.save()
assert self.col.find_one({'_id': mydoc['_id']}) == {
u'doc': {
u'bla': 10
},
u'_id': mydoc['_id'],
u'doc_a': {
u'foo': 9
}
}
# creating DocB
for i in range(5):
mydoc = self.col.DocB()
mydoc['doc']["bla"] = i + 1
mydoc['doc_a']["foo"] = i
mydoc['doc_b']["bar"] = i + 2
mydoc.save()
assert self.col.find_one({'_id': mydoc['_id']}) == {
u'doc': {
u'bla': 5
},
u'_id': mydoc['_id'],
u'doc_b': {
u'bar': 6
},
u'doc_a': {
u'foo': 4
}
}
class InheritedQueriesTestCase(unittest.TestCase):
def setUp(self):
self.connection = Connection(safe=True)
self.col = self.connection['test']['mongolite']
def tearDown(self):
self.connection.drop_database('test')
def test_use_inherited_queries(self):
@self.connection.register
class A(Document):
__database__ = 'test'
__collection__ = 'mongolite'
skeleton = {
'_type': unicode,
'a':{
'foo': int,
'bar': unicode,
}
}
@self.connection.register
class B(A):
skeleton = {
'b': {
'eggs': float,
}
}
doc_a = self.connection.A()
self.assertEqual(doc_a['_type'], 'A')
doc_a['a']['foo'] = 3
doc_a['a']['bar'] = u'Hello World'
doc_a.save()
doc_b = self.connection.B()
self.assertEqual(doc_b['_type'], 'B')
doc_b['a']['foo'] = 42
doc_b['a']['bar'] = u'bye bye'
doc_b['b']['eggs'] = 3.14
doc_b.save()
self.assertTrue(isinstance(self.connection.A.find_one({'_id':doc_b['_id']}), B))
self.assertTrue(isinstance(self.connection.A.find({'_id':doc_b['_id']}).next(), B))
def test_inherited_queries_without___collection__(self):
@self.connection.register
class A(Document):
skeleton = {
'_type': unicode,
'a':{
'foo': int,
'bar': unicode,
}
}
@self.connection.register
class B(A):
skeleton = {
'b': {
'eggs': float,
}
}
doc_a = self.col.A()
self.assertEqual(doc_a['_type'], 'A')
doc_a['a']['foo'] = 3
doc_a['a']['bar'] = u'Hello World'
doc_a.save()
doc_b = self.col.B()
self.assertEqual(doc_b['_type'], 'B')
doc_b['a']['foo'] = 42
doc_b['a']['bar'] = u'bye bye'
doc_b['b']['eggs'] = 3.14
doc_b.save()
self.assertTrue(isinstance(self.col.A.find_one({'_id':doc_b['_id']}), B))
self.assertTrue(isinstance(self.col.A.find({'_id':doc_b['_id']}).next(), B))
def test_type_field_is_None(self):
@self.connection.register
class A(Document):
type_field = None
skeleton = {
'_type': unicode,
'a':{
'foo': int,
'bar': unicode,
}
}
@self.connection.register
class B(A):
skeleton = {
'b': {
'eggs': float,
}
}
doc_a = self.col.A()
self.assertEqual(doc_a['_type'], None)
doc_a['a']['foo'] = 3
doc_a['a']['bar'] = u'Hello World'
doc_a.save()
doc_b = self.col.B()
self.assertEqual(doc_b['_type'], None)
doc_b['a']['foo'] = 42
doc_b['a']['bar'] = u'bye bye'
doc_b['b']['eggs'] = 3.14
doc_b.save()
self.assertTrue(isinstance(self.col.A.find_one({'_id':doc_b['_id']}), A))
self.assertTrue(isinstance(self.col.A.find({'_id':doc_b['_id']}).next(), A))
self.assertFalse(isinstance(self.col.A.find_one({'_id':doc_b['_id']}), B))
self.assertFalse(isinstance(self.col.A.find({'_id':doc_b['_id']}).next(), B))
def test_no__type(self):
@self.connection.register
class A(Document):
skeleton = {
'a':{
'foo': int,
'bar': unicode,
}
}
@self.connection.register
class B(A):
skeleton = {
'b': {
'eggs': float,
}
}
doc_a = self.col.A()
self.assertTrue('_type' not in doc_a)
doc_a['a']['foo'] = 3
doc_a['a']['bar'] = u'Hello World'
doc_a.save()
doc_b = self.col.B()
self.assertTrue('_type' not in doc_b)
doc_b['a']['foo'] = 42
doc_b['a']['bar'] = u'bye bye'
doc_b['b']['eggs'] = 3.14
doc_b.save()
self.assertTrue(isinstance(self.col.A.find_one({'_id':doc_b['_id']}), A))
self.assertTrue(isinstance(self.col.A.find({'_id':doc_b['_id']}).next(), A))
self.assertFalse(isinstance(self.col.A.find_one({'_id':doc_b['_id']}), B))
self.assertFalse(isinstance(self.col.A.find({'_id':doc_b['_id']}).next(), B))
def test_change_type_field(self):
@self.connection.register
class A(Document):
type_field = '_t'
skeleton = {
'_type': unicode,
'_t': unicode,
'a':{
'foo': int,
'bar': unicode,
}
}
@self.connection.register
class B(A):
skeleton = {
'b': {
'eggs': float,
}
}
doc_a = self.col.A()
self.assertEqual(doc_a['_type'], None)
self.assertEqual(doc_a['_t'], 'A')
doc_a['a']['foo'] = 3
doc_a['a']['bar'] = u'Hello World'
doc_a.save()
doc_b = self.col.B()
self.assertEqual(doc_b['_type'], None)
self.assertEqual(doc_b['_t'], 'B')
doc_b['a']['foo'] = 42
doc_b['a']['bar'] = u'bye bye'
doc_b['b']['eggs'] = 3.14
doc_b.save()
self.assertTrue(isinstance(self.col.A.find_one({'_id':doc_b['_id']}), A))
self.assertTrue(isinstance(self.col.A.find({'_id':doc_b['_id']}).next(), A))
self.assertTrue(isinstance(self.col.A.find_one({'_id':doc_b['_id']}), B))
self.assertTrue(isinstance(self.col.A.find({'_id':doc_b['_id']}).next(), B))
def test_use_inherited_queries_without_updated_data(self):
@self.connection.register
class A(Document):
__database__ = 'test'
__collection__ = 'mongolite'
skeleton = {
'_type': unicode,
'a':{
'foo': int,
'bar': unicode,
}
}
@self.connection.register
class B(A):
skeleton = {
'b': {
'eggs': float,
}
}
doc_a = self.connection.A()
doc_a["_type"] = None
doc_a['a']['foo'] = 3
doc_a['a']['bar'] = u'Hello World'
doc_a.save()
doc_b = self.connection.B()
doc_a["_type"] = None
doc_b['a']['foo'] = 42
doc_b['a']['bar'] = u'bye bye'
doc_b['b']['eggs'] = 3.14
doc_b.save()
@self.connection.register
class A(Document):
__database__ = 'test'
__collection__ = 'mongolite'
skeleton = {
'_type': unicode,
'a':{
'foo': int,
'bar': unicode,
}
}
@self.connection.register
class B(A):
skeleton = {
'b': {
'eggs': float,
}
}
self.assertRaises(StructureError, self.connection.A.find_one)
def setUp(self):
self.connection = Connection()
self.col = self.connection['test']['mongolite']
class IndexTestCase(unittest.TestCase):
def setUp(self):
self.connection = Connection(safe=True)
self.col = self.connection['test']['mongolite']
def tearDown(self):
self.connection['test'].drop_collection('mongolite')
self.connection = None
def test_index_basic(self):
@self.connection.register
class Movie(Document):
skeleton = {
'other':{
'deep':unicode,
},
'notindexed':unicode,
}
optional = {
'standard':unicode,
}
indexes = [
{
'fields':[('standard',1),('other.deep',1)],
'unique':True,
},
]
self.col.Movie.generate_indexes()
movie = self.col.Movie()
movie['standard'] = u'test'
movie['other']['deep'] = u'testdeep'
movie['notindexed'] = u'notthere'
movie.save()
db = self.connection.test
item = db['system.indexes'].find_one({'ns':'test.mongolite', 'name': 'standard_1_other.deep_1', 'unique':True})
assert item is not None, 'No Index Found'
movie = self.col.Movie()
movie['standard'] = u'test'
movie['other']['deep'] = u'testdeep'
self.assertRaises(OperationFailure, movie.save)
def test_index_basic_dynamic_collection(self):
@self.connection.register
class Movie(Document):
skeleton = {
'other':{
'deep':unicode,
},
'notindexed':unicode,
}
optional = {
'standard':unicode,
}
indexes = [
{
'fields':[('standard',1),('other.deep',1)],
'unique':True,
},
]
self.col.Movie.generate_indexes()
movie = self.col.Movie()
movie['standard'] = u'test'
movie['other']['deep'] = u'testdeep'
movie['notindexed'] = u'notthere'
movie.save()
db = self.connection.test
item = db['system.indexes'].find_one({'ns':'test.mongolite', 'name': 'standard_1_other.deep_1', 'unique':True})
assert item is not None, 'No Index Found'
movie = self.col.Movie()
movie['standard'] = u'test'
movie['other']['deep'] = u'testdeep'
self.assertRaises(OperationFailure, movie.save)
self.connection.test.othercol.Movie.generate_indexes()
db = self.connection.test
item = db['system.indexes'].find_one({'ns':'test.othercol', 'name': 'standard_1_other.deep_1', 'unique':True})
assert item is not None, 'No Index Found'
def test_index_single_without_generation(self):
class Movie(Document):
skeleton = {
'standard':unicode,
}
indexes = [
{
'fields':'standard',
'unique':True,
},
]
self.connection.register([Movie])
movie = self.col.Movie()
movie['standard'] = u'test'
movie.save()
db = self.connection.test
item = db['system.indexes'].find_one({'ns':'test.mongolite', 'name':'standard_1', 'unique':True, 'key':{'standard':1}})
assert item is None, 'Index is found'
def test_index_single(self):
class Movie(Document):
skeleton = {
'standard':unicode,
}
indexes = [
{
'fields':'standard',
'unique':True,
},
]
self.connection.register([Movie])
self.col.Movie.generate_indexes()
movie = self.col.Movie()
movie['standard'] = u'test'
movie.save()
db = self.connection.test
item = db['system.indexes'].find_one({'ns':'test.mongolite', 'name':'standard_1', 'unique':True, 'key':{'standard':1}})
assert item is not None, 'No Index Found'
def test_index_multi(self):
class Movie(Document):
skeleton = {
'standard':unicode,
'other':{
'deep':unicode,
},
'notindexed':unicode,
'alsoindexed':unicode,
}
indexes = [
{
'fields':'standard',
'unique':True,
},
{
'fields':[('alsoindexed', 1), ('other.deep', -1)],
'unique':True,
},
]
self.connection.register([Movie])
self.col.Movie.generate_indexes()
movie = self.col.Movie()
movie['standard'] = u'test'
movie.save()
db = self.connection.test
item = db['system.indexes'].find_one({'ns':'test.mongolite', 'name':'standard_1', 'unique':True, 'key':{'standard':1}})
index2 = db['system.indexes'].find_one({'ns':'test.mongolite', 'name': 'alsoindexed_1_other.deep_-1', 'unique':True})
assert item is not None, 'No Index Found'
assert index2 is not None, 'Index not found'
movie = self.col.Movie()
movie['standard'] = u'test'
self.assertRaises(OperationFailure, movie.save)
def test_index_multi2(self):
class Movie(Document):
skeleton = {
'standard':unicode,
'other':{
'deep':unicode,
},
'notindexed':unicode,
'alsoindexed':unicode,
}
indexes = [
{
'fields':'standard',
'unique':True,
},
{
'fields':'other.deep',
'unique':True,
},
]
self.connection.register([Movie])
self.col.Movie.generate_indexes()
movie = self.col.Movie()
movie['standard'] = u'test'
movie['other']['deep'] = u'foo'
movie.save()
db = self.connection.test
item = db['system.indexes'].find_one({'ns':'test.mongolite', 'name':'standard_1', 'unique':True, 'key':{'standard':1}})
index2 = db['system.indexes'].find_one({'ns':'test.mongolite', 'name': 'other.deep_1', 'unique':True})
assert item is not None, 'No Index Found'
assert index2 is not None, 'Index not found'
movie = self.col.Movie()
movie['standard'] = u'test'
self.assertRaises(OperationFailure, movie.save)
movie = self.col.Movie()
movie['other']['deep'] = u'foo'
self.assertRaises(OperationFailure, movie.save)
def test_index_direction(self):
class Movie(Document):
skeleton = {
'standard':unicode,
'other':{
'deep':unicode,
},
'notindexed':unicode,
'alsoindexed':unicode,
}
indexes = [
{
'fields':[('standard',INDEX_DESCENDING)],
'unique':True,
},
{
'fields':[('alsoindexed',INDEX_ASCENDING), ('other.deep',INDEX_DESCENDING)],
'unique':True,
},
]
self.connection.register([Movie])
self.col.Movie.generate_indexes()
movie = self.col.Movie()
movie['standard'] = u'test'
movie.save()
db = self.connection.test
index1 = db['system.indexes'].find_one({'ns':'test.mongolite', 'name':'standard_-1', 'unique':True})
index2 = db['system.indexes'].find_one({'ns':'test.mongolite', 'name': 'alsoindexed_1_other.deep_-1', 'unique':True})
assert index1 is not None, 'No Index Found'
assert index2 is not None, 'Index not found'
def test_index_direction_GEO2D(self):
class Movie(Document):
skeleton = {
'standard':unicode,
'other':{
'deep':unicode,
},
'notindexed':unicode,
'alsoindexed':unicode,
}
indexes = [
{
'fields':[('standard',INDEX_GEO2D)],
'unique':True,
},
{
'fields':[('alsoindexed',INDEX_GEO2D), ('other.deep',INDEX_DESCENDING)],
'unique':True,
},
]
self.connection.register([Movie])
self.col.Movie.generate_indexes()
movie = self.col.Movie()
movie['standard'] = u'test'
movie.save()
db = self.connection.test
index1 = db['system.indexes'].find_one({'ns':'test.mongolite', 'name':'standard_2d', 'unique':True})
index2 = db['system.indexes'].find_one({'ns':'test.mongolite', 'name': 'alsoindexed_2d_other.deep_-1', 'unique':True})
assert index1 is not None, 'No Index Found'
assert index2 is not None, 'Index not found'
def test_bad_index_descriptor(self):
failed = False
try:
class Movie(Document):
skeleton = {'standard':unicode}
indexes = [{'unique':True}]
except BadIndexError, e:
self.assertEqual(str(e), "`fields` key must be specify in indexes")
failed = True
self.assertEqual(failed, True)
failed = False
try:
class Movie(Document):
skeleton = {
'standard':unicode,
}
indexes = [
{
'fields':'std',
},
]
except ValueError, e:
self.assertEqual(str(e), "Error in indexes: can't find std in skeleton or optional")
failed = True
class InheritedQueriesTestCase(unittest.TestCase):
def setUp(self):
self.connection = Connection(safe=True)
self.col = self.connection['test']['mongolite']
def tearDown(self):
self.connection.drop_database('test')
def test_use_inherited_queries(self):
@self.connection.register
class A(Document):
__database__ = 'test'
__collection__ = 'mongolite'
skeleton = {
'_type': unicode,
'a': {
'foo': int,
'bar': unicode,
}
}
@self.connection.register
class B(A):
skeleton = {
'b': {
'eggs': float,
}
}
doc_a = self.connection.A()
self.assertEqual(doc_a['_type'], 'A')
doc_a['a']['foo'] = 3
doc_a['a']['bar'] = u'Hello World'
doc_a.save()
doc_b = self.connection.B()
self.assertEqual(doc_b['_type'], 'B')
doc_b['a']['foo'] = 42
doc_b['a']['bar'] = u'bye bye'
doc_b['b']['eggs'] = 3.14
doc_b.save()
self.assertTrue(
isinstance(self.connection.A.find_one({'_id': doc_b['_id']}), B))
self.assertTrue(
isinstance(
self.connection.A.find({
'_id': doc_b['_id']
}).next(), B))
def test_inherited_queries_without___collection__(self):
@self.connection.register
class A(Document):
skeleton = {
'_type': unicode,
'a': {
'foo': int,
'bar': unicode,
}
}
@self.connection.register
class B(A):
skeleton = {
'b': {
'eggs': float,
}
}
doc_a = self.col.A()
self.assertEqual(doc_a['_type'], 'A')
doc_a['a']['foo'] = 3
doc_a['a']['bar'] = u'Hello World'
doc_a.save()
doc_b = self.col.B()
self.assertEqual(doc_b['_type'], 'B')
doc_b['a']['foo'] = 42
doc_b['a']['bar'] = u'bye bye'
doc_b['b']['eggs'] = 3.14
doc_b.save()
self.assertTrue(
isinstance(self.col.A.find_one({'_id': doc_b['_id']}), B))
self.assertTrue(
isinstance(self.col.A.find({
'_id': doc_b['_id']
}).next(), B))
def test_type_field_is_None(self):
@self.connection.register
class A(Document):
type_field = None
skeleton = {
'_type': unicode,
'a': {
'foo': int,
'bar': unicode,
}
}
@self.connection.register
class B(A):
skeleton = {
'b': {
'eggs': float,
}
}
doc_a = self.col.A()
self.assertEqual(doc_a['_type'], None)
doc_a['a']['foo'] = 3
doc_a['a']['bar'] = u'Hello World'
doc_a.save()
doc_b = self.col.B()
self.assertEqual(doc_b['_type'], None)
doc_b['a']['foo'] = 42
doc_b['a']['bar'] = u'bye bye'
doc_b['b']['eggs'] = 3.14
doc_b.save()
self.assertTrue(
isinstance(self.col.A.find_one({'_id': doc_b['_id']}), A))
self.assertTrue(
isinstance(self.col.A.find({
'_id': doc_b['_id']
}).next(), A))
self.assertFalse(
isinstance(self.col.A.find_one({'_id': doc_b['_id']}), B))
self.assertFalse(
isinstance(self.col.A.find({
'_id': doc_b['_id']
}).next(), B))
def test_no__type(self):
@self.connection.register
class A(Document):
skeleton = {
'a': {
'foo': int,
'bar': unicode,
}
}
@self.connection.register
class B(A):
skeleton = {
'b': {
'eggs': float,
}
}
doc_a = self.col.A()
self.assertTrue('_type' not in doc_a)
doc_a['a']['foo'] = 3
doc_a['a']['bar'] = u'Hello World'
doc_a.save()
doc_b = self.col.B()
self.assertTrue('_type' not in doc_b)
doc_b['a']['foo'] = 42
doc_b['a']['bar'] = u'bye bye'
doc_b['b']['eggs'] = 3.14
doc_b.save()
self.assertTrue(
isinstance(self.col.A.find_one({'_id': doc_b['_id']}), A))
self.assertTrue(
isinstance(self.col.A.find({
'_id': doc_b['_id']
}).next(), A))
self.assertFalse(
isinstance(self.col.A.find_one({'_id': doc_b['_id']}), B))
self.assertFalse(
isinstance(self.col.A.find({
'_id': doc_b['_id']
}).next(), B))
def test_change_type_field(self):
@self.connection.register
class A(Document):
type_field = '_t'
skeleton = {
'_type': unicode,
'_t': unicode,
'a': {
'foo': int,
'bar': unicode,
}
}
@self.connection.register
class B(A):
skeleton = {
'b': {
'eggs': float,
}
}
doc_a = self.col.A()
self.assertEqual(doc_a['_type'], None)
self.assertEqual(doc_a['_t'], 'A')
doc_a['a']['foo'] = 3
doc_a['a']['bar'] = u'Hello World'
doc_a.save()
doc_b = self.col.B()
self.assertEqual(doc_b['_type'], None)
self.assertEqual(doc_b['_t'], 'B')
doc_b['a']['foo'] = 42
doc_b['a']['bar'] = u'bye bye'
doc_b['b']['eggs'] = 3.14
doc_b.save()
self.assertTrue(
isinstance(self.col.A.find_one({'_id': doc_b['_id']}), A))
self.assertTrue(
isinstance(self.col.A.find({
'_id': doc_b['_id']
}).next(), A))
self.assertTrue(
isinstance(self.col.A.find_one({'_id': doc_b['_id']}), B))
self.assertTrue(
isinstance(self.col.A.find({
'_id': doc_b['_id']
}).next(), B))
def test_use_inherited_queries_without_updated_data(self):
@self.connection.register
class A(Document):
__database__ = 'test'
__collection__ = 'mongolite'
skeleton = {
'_type': unicode,
'a': {
'foo': int,
'bar': unicode,
}
}
@self.connection.register
class B(A):
skeleton = {
'b': {
'eggs': float,
}
}
doc_a = self.connection.A()
doc_a["_type"] = None
doc_a['a']['foo'] = 3
doc_a['a']['bar'] = u'Hello World'
doc_a.save()
doc_b = self.connection.B()
doc_a["_type"] = None
doc_b['a']['foo'] = 42
doc_b['a']['bar'] = u'bye bye'
doc_b['b']['eggs'] = 3.14
doc_b.save()
@self.connection.register
class A(Document):
__database__ = 'test'
__collection__ = 'mongolite'
skeleton = {
'_type': unicode,
'a': {
'foo': int,
'bar': unicode,
}
}
@self.connection.register
class B(A):
skeleton = {
'b': {
'eggs': float,
}
}
self.assertRaises(StructureError, self.connection.A.find_one)
class SerializeTestCase(unittest.TestCase):
def setUp(self):
self.connection = Connection()
self.col = self.connection['test']['mongolite']
def tearDown(self):
self.connection.drop_database('test')
self.connection.drop_database('othertest')
def test_simple_serialize(self):
@self.connection.register
class Foo(Document):
__database__ = 'test'
__collection__ = 'foo'
skeleton = {
"bar": int,
}
@self.connection.register
class MyDoc(Document):
__database__ = 'test'
__collection__ = 'mydocs'
skeleton = {
"foo": ObjectId,
}
@property
def foo(self):
return self.db.Foo.get_from_id(self['foo'])
foo = self.connection.Foo()
foo['bar'] = 42
foo.save()
mydoc = self.connection.MyDoc()
mydoc['foo'] = foo['_id']
mydoc.save()
mydoc = self.connection.MyDoc.get_from_id(mydoc['_id'])
self.assertEqual(mydoc.foo['_id'], foo['_id'])
self.assertEqual(mydoc, {'_id': mydoc['_id'], 'foo': foo['_id']})
self.assertEqual(mydoc.serialize(), {
'_id': mydoc['_id'],
'foo': {
'_id': foo['_id'],
'bar': 42
}
})
self.assertEqual(
json.dumps(mydoc, default=json_util.default),
'{"_id": {"$oid": "%s"}, "foo": {"$oid": "%s"}}' %
(mydoc['_id'], foo['_id']))
self.assertEqual(
json.dumps(mydoc.serialize(), default=json_util.default),
'{"_id": {"$oid": "%s"}, "foo": {"_id": {"$oid": "%s"}, "bar": 42}}'
% (mydoc['_id'], foo['_id']))
def test_simple_serialize_cursor(self):
@self.connection.register
class Foo(Document):
__database__ = 'test'
__collection__ = 'foos'
skeleton = {
"bar": int,
}
@self.connection.register
class MyDoc(Document):
__database__ = 'test'
__collection__ = 'mydocs'
skeleton = {
"foos": [ObjectId],
}
@property
def foos(self):
return self.db.Foo.find({'_id': {'$in': self['foos']}})
foo = self.connection.Foo()
foo['bar'] = 42
foo.save()
foo2 = self.connection.Foo()
foo2['bar'] = 3
foo2.save()
mydoc = self.connection.MyDoc()
mydoc['foos'] = [foo['_id'], foo2['_id']]
mydoc.save()
mydoc = self.connection.MyDoc.get_from_id(mydoc['_id'])
for _foo in mydoc.foos:
self.assertTrue(_foo['_id'] in [foo['_id'], foo2['_id']])
self.assertEqual(mydoc, {
'_id': mydoc['_id'],
'foos': [foo['_id'], foo2['_id']]
})
self.assertEqual(
mydoc.serialize(), {
'_id':
mydoc['_id'],
'foos': [{
'_id': foo['_id'],
'bar': 42
}, {
'_id': foo2['_id'],
'bar': 3
}]
})
self.assertEqual(
json.dumps(mydoc, default=json_util.default),
'{"_id": {"$oid": "%s"}, "foos": [{"$oid": "%s"}, {"$oid": "%s"}]}'
% (mydoc['_id'], foo['_id'], foo2['_id']))
self.assertEqual(
json.dumps(mydoc.serialize(), default=json_util.default),
'{"_id": {"$oid": "%s"}, "foos": [{"_id": {"$oid": "%s"}, "bar": 42}, {"_id": {"$oid": "%s"}, "bar": 3}]}'
% (mydoc['_id'], foo['_id'], foo2['_id']))
def test_simple_serialize_without_property(self):
@self.connection.register
class Foo(Document):
__database__ = 'test'
__collection__ = 'foo'
skeleton = {
"bar": int,
}
@self.connection.register
class MyDoc(Document):
__database__ = 'test'
__collection__ = 'mydocs'
skeleton = {
"foo": ObjectId,
}
foo = self.connection.Foo()
foo['bar'] = 42
foo.save()
mydoc = self.connection.MyDoc()
mydoc['foo'] = foo['_id']
mydoc.save()
mydoc = self.connection.MyDoc.get_from_id(mydoc['_id'])
self.assertEqual(mydoc, {'_id': mydoc['_id'], 'foo': foo['_id']})
self.assertEqual(mydoc.serialize(), {
'_id': mydoc['_id'],
'foo': foo['_id']
})
self.assertEqual(
json.dumps(mydoc, default=json_util.default),
'{"_id": {"$oid": "%s"}, "foo": {"$oid": "%s"}}' %
(mydoc['_id'], foo['_id']))
self.assertEqual(
json.dumps(mydoc.serialize(), default=json_util.default),
'{"_id": {"$oid": "%s"}, "foo": {"$oid": "%s"}}' %
(mydoc['_id'], foo['_id']))
def test_simple_serialize_default_property(self):
@self.connection.register
class Foo(Document):
__database__ = 'test'
__collection__ = 'foo'
skeleton = {
"bar": int,
}
@self.connection.register
class MyDoc(Document):
__database__ = 'test'
__collection__ = 'mydocs'
skeleton = {
"spam": {
"foo": ObjectId,
}
}
@property
def spam__foo(self):
return self.db.Foo.get_from_id(self['spam']['foo'])
foo = self.connection.Foo()
foo['bar'] = 42
foo.save()
mydoc = self.connection.MyDoc()
mydoc['spam']['foo'] = foo['_id']
mydoc.save()
mydoc = self.connection.MyDoc.get_from_id(mydoc['_id'])
self.assertEqual(mydoc.spam__foo['_id'], foo['_id'])
self.assertEqual(mydoc, {
'_id': mydoc['_id'],
'spam': {
'foo': foo['_id']
}
})
self.assertEqual(mydoc.serialize(), {
'_id': mydoc['_id'],
'spam': {
'foo': {
'_id': foo['_id'],
'bar': 42
}
}
})
self.assertEqual(
json.dumps(mydoc, default=json_util.default),
'{"_id": {"$oid": "%s"}, "spam": {"foo": {"$oid": "%s"}}}' %
(mydoc['_id'], foo['_id']))
self.assertEqual(
json.dumps(mydoc.serialize(), default=json_util.default),
'{"_id": {"$oid": "%s"}, "spam": {"foo": {"_id": {"$oid": "%s"}, "bar": 42}}}'
% (mydoc['_id'], foo['_id']))
def test_simple_serialize_mapping(self):
@self.connection.register
class Foo(Document):
__database__ = 'test'
__collection__ = 'foo'
skeleton = {
"bar": int,
}
@self.connection.register
class MyDoc(Document):
__database__ = 'test'
__collection__ = 'mydocs'
skeleton = {
"spam": {
"foo": ObjectId,
}
}
serialize_mapping = {'spam.foo': 'foo'}
@property
def foo(self):
return self.db.Foo.get_from_id(self['spam']['foo'])
foo = self.connection.Foo()
foo['bar'] = 42
foo.save()
mydoc = self.connection.MyDoc()
mydoc['spam']['foo'] = foo['_id']
mydoc.save()
mydoc = self.connection.MyDoc.get_from_id(mydoc['_id'])
self.assertEqual(mydoc.foo['_id'], foo['_id'])
self.assertEqual(mydoc, {
'_id': mydoc['_id'],
'spam': {
'foo': foo['_id']
}
})
self.assertEqual(mydoc.serialize(), {
'_id': mydoc['_id'],
'spam': {
'foo': {
'_id': foo['_id'],
'bar': 42
}
}
})
self.assertEqual(
json.dumps(mydoc, default=json_util.default),
'{"_id": {"$oid": "%s"}, "spam": {"foo": {"$oid": "%s"}}}' %
(mydoc['_id'], foo['_id']))
self.assertEqual(
json.dumps(mydoc.serialize(), default=json_util.default),
'{"_id": {"$oid": "%s"}, "spam": {"foo": {"_id": {"$oid": "%s"}, "bar": 42}}}'
% (mydoc['_id'], foo['_id']))
class GridFSTestCase(unittest.TestCase):
def setUp(self):
self.connection = Connection()
self.col = self.connection['test']['mongolite']
def tearDown(self):
self.connection.drop_database('test')
def test_simple_gridfs(self):
@self.connection.register
class Doc(Document):
use_gridfs = True
skeleton = {
'title':unicode,
}
doc = self.col.Doc()
doc['title'] = u'Hello'
doc.save()
self.assertEqual(doc.fs._GridFS__collection.name, 'mongolitefs')
self.assertEqual(doc.fs._GridFS__collection.name, self.col.name+'fs')
self.assertRaises(NoFile, doc.fs.get_last_version, 'source', doc_id=doc['_id'])
doc.fs.put("Hello World !", filename='source', doc_id=doc['_id'])
obj = doc.fs.get_last_version(filename="source", doc_id=doc['_id'])
self.assertTrue(doc.fs.exists(obj._id))
self.assertEqual(doc.fs.get_last_version('source', doc_id=doc['_id']).read(), "Hello World !")
doc = self.col.Doc.find_one({'title':'Hello'})
self.assertEqual(doc.fs.get_last_version('source', doc_id=doc['_id']).read(), u"Hello World !")
f = doc.fs.get_last_version('source', doc_id=doc['_id'])
self.assertEqual(f.name, 'source')
doc.fs.delete(f._id)
assertion = False
try:
doc.fs.get_last_version('source', doc_id=doc['_id'])
except NoFile:
assertion = True
self.assertTrue(assertion)
def test_simple_unique_shared_gridfs(self):
@self.connection.register
class DocA(Document):
use_gridfs = True
__gridfs_collection__ = 'fs'
skeleton = {
'title':unicode,
}
doc = self.col.DocA()
doc['title'] = u'Hello'
doc.save()
doc.fs.put('blah', filename='shared_file.txt')
@self.connection.register
class DocB(Document):
use_gridfs = True
__gridfs_collection__ = 'fs'
skeleton = {
'title':unicode,
}
doc = self.col.DocB()
doc['title'] = u'Hello'
doc.save()
self.assertEqual(doc.fs.get_last_version('shared_file.txt').read(), "blah")
def test_pymongo_compatibility(self):
class Doc(Document):
skeleton = {
'title':unicode,
}
use_gridfs = True
self.connection.register([Doc])
doc = self.col.Doc()
doc['title'] = u'Hello'
doc.save()
id = doc.fs.put("Hello World", filename="source")
assert doc.fs.get(id).read() == 'Hello World'
assert doc.fs.get_last_version("source").name == 'source'
assert doc.fs.get_last_version("source").read() == 'Hello World'
f = doc.fs.new_file(filename="source")
f.write("New Hello World!")
f.close()
self.assertEqual(doc.fs.get_last_version('source').read(), 'New Hello World!')
new_id = doc.fs.get_last_version("source")._id
doc.fs.delete(new_id)
self.assertEqual(doc.fs.get_last_version('source').read(), 'Hello World')
class GridFSTestCase(unittest.TestCase):
def setUp(self):
self.connection = Connection()
self.col = self.connection['test']['mongolite']
def tearDown(self):
self.connection.drop_database('test')
def test_simple_gridfs(self):
@self.connection.register
class Doc(Document):
use_gridfs = True
skeleton = {
'title': unicode,
}
doc = self.col.Doc()
doc['title'] = u'Hello'
doc.save()
self.assertEqual(doc.fs._GridFS__collection.name, 'mongolitefs')
self.assertEqual(doc.fs._GridFS__collection.name, self.col.name + 'fs')
self.assertRaises(NoFile,
doc.fs.get_last_version,
'source',
doc_id=doc['_id'])
doc.fs.put("Hello World !", filename='source', doc_id=doc['_id'])
obj = doc.fs.get_last_version(filename="source", doc_id=doc['_id'])
self.assertTrue(doc.fs.exists(obj._id))
self.assertEqual(
doc.fs.get_last_version('source', doc_id=doc['_id']).read(),
"Hello World !")
doc = self.col.Doc.find_one({'title': 'Hello'})
self.assertEqual(
doc.fs.get_last_version('source', doc_id=doc['_id']).read(),
u"Hello World !")
f = doc.fs.get_last_version('source', doc_id=doc['_id'])
self.assertEqual(f.name, 'source')
doc.fs.delete(f._id)
assertion = False
try:
doc.fs.get_last_version('source', doc_id=doc['_id'])
except NoFile:
assertion = True
self.assertTrue(assertion)
def test_simple_unique_shared_gridfs(self):
@self.connection.register
class DocA(Document):
use_gridfs = True
__gridfs_collection__ = 'fs'
skeleton = {
'title': unicode,
}
doc = self.col.DocA()
doc['title'] = u'Hello'
doc.save()
doc.fs.put('blah', filename='shared_file.txt')
@self.connection.register
class DocB(Document):
use_gridfs = True
__gridfs_collection__ = 'fs'
skeleton = {
'title': unicode,
}
doc = self.col.DocB()
doc['title'] = u'Hello'
doc.save()
self.assertEqual(
doc.fs.get_last_version('shared_file.txt').read(), "blah")
def test_pymongo_compatibility(self):
class Doc(Document):
skeleton = {
'title': unicode,
}
use_gridfs = True
self.connection.register([Doc])
doc = self.col.Doc()
doc['title'] = u'Hello'
doc.save()
id = doc.fs.put("Hello World", filename="source")
assert doc.fs.get(id).read() == 'Hello World'
assert doc.fs.get_last_version("source").name == 'source'
assert doc.fs.get_last_version("source").read() == 'Hello World'
f = doc.fs.new_file(filename="source")
f.write("New Hello World!")
f.close()
self.assertEqual(
doc.fs.get_last_version('source').read(), 'New Hello World!')
new_id = doc.fs.get_last_version("source")._id
doc.fs.delete(new_id)
self.assertEqual(
doc.fs.get_last_version('source').read(), 'Hello World')
class DescriptorsTestCase(unittest.TestCase):
def setUp(self):
self.connection = Connection()
self.col = self.connection['test']['mongolite']
def tearDown(self):
self.connection.drop_database('test')
def test_default_values(self):
class MyDoc(Document):
skeleton = {
"foo":int,
"bla":unicode,
}
default_values = {"foo":42}
mydoc = MyDoc()
assert mydoc["foo"] == 42
assert mydoc == {'foo':42, 'bla':None}, mydoc
def test_default_values_with_optional(self):
class MyDoc(Document):
skeleton = {
"foo":int,
"bla":unicode,
}
optional = {
"optfield": int,
}
default_values = {"foo":42, 'optfield':3}
mydoc = MyDoc()
self.assertEqual(mydoc["foo"], 42)
self.assertEqual(mydoc.get('optfield'), 3)
self.assertEqual(mydoc, {'foo':42, 'optfield': 3, 'bla':None})
def test_default_values_nested(self):
class MyDoc(Document):
skeleton = {
"bar":{
"foo":int,
"bla":unicode,
}
}
default_values = {"bar.foo":42}
mydoc = MyDoc()
assert mydoc['bar']["foo"] == 42
assert mydoc == {'bar':{'foo':42, 'bla':None}}, mydoc
def test_default_values_nested_inheritance(self):
import datetime
class Core(Document):
skeleton = {
"core":{
"creation_date":datetime.datetime,
}
}
default_values = {
"core.creation_date": datetime.datetime(2010, 1, 1),
}
class MyDoc(Core):
skeleton = {
"bar":{
"foo":int,
"bla":unicode,
}
}
default_values = {"bar.foo":42}
class MyDoc2(MyDoc):
skeleton = {
"mydoc2":{
"toto":int
}
}
mydoc = MyDoc2()
assert mydoc['bar']["foo"] == 42
assert mydoc == {'mydoc2': {'toto': None}, 'core': {'creation_date': datetime.datetime(2010, 1, 1, 0, 0)}, 'bar': {'foo': 42, 'bla': None}}
def test_default_values_from_function(self):
import time
class MyDoc(Document):
skeleton = {
"foo":float
}
default_values = {"foo":time.time}
mydoc = MyDoc()
self.assertTrue(isinstance(mydoc['foo'], float))
def test_default_values_from_function2(self):
import time
class Doc( Document ):
skeleton = {
"doc":{
"creation_date":float,
"updated_date": float,
}
}
default_values = {
"doc.creation_date": time.time,
"doc.updated_date": time.time
}
doc = Doc()
assert isinstance(doc['doc']['creation_date'], float), doc['doc']['creation_date']
assert isinstance(doc['doc']['updated_date'], float)
def test_default_values_from_function_nested(self):
import time
class MyDoc(Document):
skeleton = {
"foo":{"bar":float}
}
default_values = {"foo.bar":time.time}
mydoc = MyDoc()
self.assertTrue(isinstance(mydoc['foo']['bar'], float))
self.assertTrue(mydoc['foo']['bar'] > 0)
def test_default_list_values(self):
class MyDoc(Document):
skeleton = {
"foo":[int]
}
default_values = {"foo":[42,3]}
self.connection.register([MyDoc])
mydoc = self.col.MyDoc()
assert mydoc["foo"] == [42,3]
mydoc['foo'] = [1,2,3]
mydoc.save()
mydoc = self.col.MyDoc()
assert mydoc['foo'] == [42,3]
def test_default_list_values_empty(self):
class MyDoc(Document):
skeleton = {
"foo":list
}
default_values = {"foo":[3]}
self.connection.register([MyDoc])
mydoc = self.col.MyDoc()
assert mydoc["foo"] == [3]
mydoc['foo'].append(2)
mydoc.save()
mydoc = self.col.MyDoc()
assert mydoc['foo'] == [3], mydoc
def test_default_list_values_with_callable(self):
def get_truth():
return 42
class MyDoc(Document):
skeleton = {
"foo":[int]
}
default_values = {"foo":[get_truth,3]}
mydoc = MyDoc()
assert mydoc["foo"] == [42,3]
def test_default_list_nested_values(self):
class MyDoc(Document):
skeleton = {
"foo":{
"bar":[int]
}
}
default_values = {"foo.bar":[42,3]}
mydoc = MyDoc()
assert mydoc["foo"]["bar"] == [42,3]
def test_default_dict_values(self):
class MyDoc(Document):
skeleton = {
"foo":dict
}
default_values = {"foo":{"bar":42}}
self.connection.register([MyDoc])
mydoc = self.col.MyDoc()
assert mydoc["foo"] == {"bar":42}, mydoc
mydoc['foo'] = {'bar':1}
mydoc.save()
mydoc = self.col.MyDoc()
assert mydoc["foo"] == {"bar":42}, mydoc
def test_default_dict_values_empty(self):
class MyDoc(Document):
skeleton = {
"foo":dict
}
default_values = {"foo":{}}
self.connection.register([MyDoc])
mydoc = self.col.MyDoc()
print id(mydoc.skeleton['foo']), id(mydoc['foo']), id(mydoc.default_values['foo'])
assert mydoc["foo"] == {}, mydoc
mydoc['foo'][u'bar'] = 1
mydoc.save()
mydoc2 = self.col.MyDoc()
print id(mydoc2.skeleton['foo']), id(mydoc2['foo']), id(mydoc2.default_values['foo'])
assert mydoc2["foo"] == {}, mydoc
class MyDoc(Document):
skeleton = {
"foo":{unicode:int}
}
default_values = {"foo":{}}
self.connection.register([MyDoc])
mydoc = self.col.MyDoc()
assert mydoc["foo"] == {}, mydoc
mydoc['foo'][u'bar'] = 1
mydoc.save()
mydoc2 = self.col.MyDoc()
assert mydoc2["foo"] == {}, mydoc
def test_default_dict_values_with_callable(self):
def get_truth():
return {'bar':42}
class MyDoc(Document):
skeleton = {
"foo":{}
}
default_values = {"foo":get_truth}
mydoc = MyDoc()
assert mydoc["foo"] == {"bar":42}, mydoc
def test_default_dict_checked_values(self):
class MyDoc(Document):
skeleton = {
"foo":{unicode:int}
}
default_values = {"foo":{u"bar":42}}
mydoc = MyDoc()
assert mydoc["foo"] == {"bar":42}, mydoc
def test_default_dict_nested_checked_values(self):
class MyDoc(Document):
skeleton = {
"foo":{unicode:{"bla":int, "ble":unicode}}
}
default_values = {"foo":{u"bar":{"bla":42, "ble":u"arf"}}}
mydoc = MyDoc()
assert mydoc["foo"] == {u"bar":{"bla":42, "ble":u"arf"}}, mydoc
def test_default_values_with_dict_in_list(self):
@self.connection.register
class MyDoc(Document):
skeleton = {
'bar': [{'foo':unicode}]
}
default_values = {
'bar': [{'foo': u'bla'}]
}
doc = self.col.MyDoc()
assert doc['bar'] == [{'foo': u'bla'}]
def test_bad_default_values(self):
failed = False
try:
class MyDoc(Document):
skeleton = {
"foo":{"bar":int},
}
default_values = {"foo.bla":2}
except ValueError, e:
failed = True
self.assertEqual(str(e), "Error in default_values: can't find foo.bla in skeleton")
self.assertEqual(failed, True)
class ApiTestCase(unittest.TestCase):
def setUp(self):
self.connection = Connection()
self.col = self.connection['test']['mongolite']
def tearDown(self):
self.connection.drop_database('test')
self.connection.drop_database('othertest')
def test_save(self):
class MyDoc(Document):
skeleton = {
"bla": {
"foo": unicode,
"bar": int,
},
"spam": [],
}
self.connection.register([MyDoc])
mydoc = self.col.MyDoc()
mydoc["bla"]["foo"] = u"bar"
mydoc["bla"]["bar"] = 42
mydoc.save()
assert isinstance(mydoc['_id'], ObjectId)
saved_doc = self.col.find_one({"bla.bar": 42})
for key, value in mydoc.iteritems():
assert saved_doc[key] == value
mydoc = self.col.MyDoc()
mydoc["bla"]["foo"] = u"bar"
mydoc["bla"]["bar"] = 43
mydoc.save()
saved_doc = self.col.find_one({"bla.bar": 43})
for key, value in mydoc.iteritems():
assert saved_doc[key] == value
def test_save_without_collection(self):
class MyDoc(Document):
skeleton = {
"foo": int,
}
self.connection.register([MyDoc])
mydoc = MyDoc()
mydoc["foo"] = 1
self.assertRaises(ConnectionError, mydoc.save)
def test_delete(self):
class MyDoc(Document):
skeleton = {
"foo": int,
}
self.connection.register([MyDoc])
mydoc = self.col.MyDoc()
mydoc['_id'] = 'foo'
mydoc["foo"] = 1
mydoc.save()
assert self.col.MyDoc.find().count() == 1
mydoc = self.col.MyDoc.get_from_id('foo')
assert mydoc['foo'] == 1
mydoc.delete()
assert self.col.MyDoc.find().count() == 0
def test_generate_skeleton(self):
class A(SchemaDocument):
skeleton = {"a": {"foo": int}, "bar": unicode}
a = A(gen_skel=False)
assert a == {}
a.generate_skeleton()
assert a == {"a": {"foo": None}, "bar": None}, a
def test_generate_skeleton2(self):
class A(SchemaDocument):
skeleton = {"a": {"foo": [int]}, "bar": {unicode: {"egg": int}}}
a = A(gen_skel=False)
assert a == {}
a.generate_skeleton()
assert a == {"a": {"foo": []}, "bar": {}}, a
def test_generate_skeleton3(self):
class A(SchemaDocument):
skeleton = {
"a": {
"foo": [int],
"spam": {
"bla": unicode
}
},
"bar": {
unicode: {
"egg": int
}
}
}
a = A(gen_skel=False)
assert a == {}
a.generate_skeleton()
assert a == {"a": {"foo": [], "spam": {"bla": None}}, "bar": {}}, a
def test_get_from_id(self):
class MyDoc(Document):
skeleton = {
"foo": int,
}
self.connection.register([MyDoc])
mydoc = self.col.MyDoc()
mydoc["_id"] = "bar"
mydoc["foo"] = 3
mydoc.save()
fetched_doc = self.col.MyDoc.get_from_id("bar")
assert mydoc == fetched_doc
assert callable(fetched_doc) is False
assert isinstance(fetched_doc, MyDoc)
raw_doc = self.col.get_from_id('bar')
assert mydoc == raw_doc
assert not isinstance(raw_doc, MyDoc)
def test_find(self):
class MyDoc(Document):
skeleton = {
"foo": int,
"bar": {
"bla": int
},
}
self.connection.register([MyDoc])
for i in range(10):
mydoc = self.col.MyDoc()
mydoc["foo"] = i
mydoc["bar"]['bla'] = i
mydoc.save()
for i in self.col.MyDoc.find({"foo": {"$gt": 4}}):
assert isinstance(i, MyDoc), (i, type(i))
docs_list = [
i["foo"] for i in self.col.MyDoc.find({"foo": {
"$gt": 4
}})
]
assert docs_list == [5, 6, 7, 8, 9]
# using limit/count
assert self.col.MyDoc.find().count() == 10, self.col.MyDoc.find(
).count()
assert self.col.MyDoc.find().limit(
1).count() == 10, self.col.MyDoc.find().limit(1).count()
assert self.col.MyDoc.find().where(
'this.foo').count() == 9 #{'foo':0} is not taken
assert self.col.MyDoc.find().where(
'this.bar.bla').count() == 9 #{'foo':0} is not taken
assert self.col.MyDoc.find().hint([('foo', 1)])
assert [i['foo'] for i in self.col.MyDoc.find().sort('foo', -1)
] == [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
allPlans = self.col.MyDoc.find().explain()['allPlans']
assert allPlans == [{u'cursor': u'BasicCursor', u'indexBounds': {}}]
next_doc = self.col.MyDoc.find().sort('foo', 1).next()
assert callable(next_doc) is False
assert isinstance(next_doc, MyDoc)
assert next_doc['foo'] == 0
assert len(list(self.col.MyDoc.find().skip(3))) == 7, len(
list(self.col.MyDoc.find().skip(3)))
from mongolite.cursor import Cursor
assert isinstance(self.col.MyDoc.find().skip(3), Cursor)
def test_find_one(self):
class MyDoc(Document):
skeleton = {"foo": int}
self.connection.register([MyDoc])
assert self.col.MyDoc.find_one() is None
mydoc = self.col.MyDoc()
mydoc['foo'] = 0
mydoc.save()
mydoc = self.col.MyDoc.find_one()
assert mydoc["foo"] == 0
assert isinstance(mydoc, MyDoc)
for i in range(10):
mydoc = self.col.MyDoc()
mydoc["foo"] = i
mydoc.save()
one_doc = self.col.MyDoc.find_one()
assert callable(one_doc) is False
raw_mydoc = self.col.find_one()
assert one_doc == raw_mydoc
def test_find_and_modify(self):
@self.connection.register
class DocA(Document):
__database__ = 'test'
__collection__ = 'doca'
structure = {'title': unicode, 'rank': int}
for i in range(10):
self.connection.DocA({'title': unicode(i), 'rank': i}).save()
doc = self.connection.DocA.find_and_modify(
{'rank': 3}, {'$set': {
'title': u'coucou'
}})
new_doc = self.connection.DocA.find_one({'rank': 3})
self.assertEqual(doc['title'], '3')
self.assertEqual(new_doc['title'], 'coucou')
self.assertEqual(isinstance(doc, DocA), True)
@self.connection.register
class DocA(Document):
structure = {'title': unicode, 'rank': int}
for i in range(10):
self.connection.test.doca2.save({'title': unicode(i), 'rank': i})
doc = self.connection.test.doca2.DocA.find_and_modify(
{'rank': 3}, {'$set': {
'title': u'coucou'
}})
new_doc = self.connection.test.doca2.DocA.find_one({'rank': 3})
self.assertEqual(doc['title'], '3')
self.assertEqual(new_doc['title'], 'coucou')
self.assertEqual(isinstance(doc, DocA), True)
def test_find_random(self):
class MyDoc(Document):
skeleton = {"foo": int}
self.connection.register([MyDoc])
assert self.col.find_random() is None
assert self.col.MyDoc.find_random() is None
for i in range(50):
mydoc = self.col.MyDoc()
mydoc["foo"] = i
mydoc.save()
raw_mydoc = self.col.find_random()
mydoc = self.col.MyDoc.find_random()
assert callable(mydoc) is False
assert isinstance(mydoc, MyDoc)
assert mydoc != raw_mydoc, (mydoc, raw_mydoc)
def test_query_with_passing_collection(self):
class MyDoc(Document):
skeleton = {
'foo': int,
}
self.connection.register([MyDoc])
mongolite = self.connection.test.mongolite
# boostraping
for i in range(10):
mydoc = mongolite.MyDoc()
mydoc['_id'] = unicode(i)
mydoc['foo'] = i
mydoc.save()
# get_from_id
fetched_doc = mongolite.MyDoc.get_from_id('4')
assert fetched_doc.collection == mongolite
# all
fetched_docs = mongolite.MyDoc.find({'foo': {'$gt': 2}})
assert fetched_docs.count() == 7
for doc in fetched_docs:
assert doc.collection == mongolite
def test_connection(self):
class DocA(Document):
skeleton = {
"doc_a": {
'foo': int
},
}
self.connection.register([DocA])
assertion = True
try:
DocA.connection
except AttributeError:
assertion = True
assert assertion
try:
DocA.db
except AttributeError:
assertion = True
assert assertion
try:
DocA.collection
except AttributeError:
assertion = True
assert assertion
assert self.col.DocA.connection == Connection("localhost", 27017)
assert self.col.DocA.collection == Connection(
"localhost", 27017)['test']['mongolite']
assert self.col.DocA.db == Connection("localhost", 27017)['test']
def test_all_with_dynamic_collection(self):
class Section(Document):
skeleton = {"section": int}
self.connection.register([Section])
s = self.connection.test.section.Section()
s['section'] = 1
s.save()
s = self.connection.test.section.Section()
s['section'] = 2
s.save()
s = self.connection.test.other_section.Section()
s['section'] = 1
s.save()
s = self.connection.test.other_section.Section()
s['section'] = 2
s.save()
sect_col = self.connection.test.section
sects = [
s.collection.name == 'section' and s.db.name == 'test'
for s in sect_col.Section.find({})
]
assert len(sects) == 2, len(sects)
assert any(sects)
sect_col = self.connection.test.other_section
sects = [
s.collection.name == 'other_section' and s.db.name == 'test'
for s in sect_col.Section.find({})
]
assert len(sects) == 2
assert any(sects)
def test_get_collection_with_connection(self):
class Section(Document):
skeleton = {"section": int}
connection = Connection('127.0.0.3')
connection.register([Section])
col = connection.test.mongolite
assert col.database.connection == col.Section.connection
assert col.database.name == 'test' == col.Section.db.name
assert col.name == 'mongolite' == col.Section.collection.name
def test_get_size(self):
class MyDoc(Document):
skeleton = {
"doc": {
"foo": int,
"bla": unicode
},
}
mydoc = MyDoc()
mydoc['doc']['foo'] = 3
mydoc['doc']['bla'] = u'bla bla'
assert len(mydoc.get_son_object()) == 41, len(mydoc.get_son_object())
mydoc['doc']['bla'] = u'bla bla' + 'b' * 12
assert len(mydoc.get_son_object()) == 41 + 12
def test_get_with_no_wrap(self):
class MyDoc(Document):
skeleton = {"foo": int}
self.connection.register([MyDoc])
for i in xrange(2000):
mydoc = self.col.MyDoc()
mydoc['foo'] = i
mydoc.save()
import time
start = time.time()
wrapped_mydocs = [i for i in self.col.MyDoc.find()]
end = time.time()
wrap_time = end - start
start = time.time()
mydocs = [i for i in self.col.find().sort('foo', -1)]
end = time.time()
no_wrap_time = end - start
assert no_wrap_time < wrap_time
assert isinstance(wrapped_mydocs[0], MyDoc)
assert not isinstance(mydocs[0], MyDoc), type(mydocs[0])
assert [i['foo'] for i in mydocs
] == list(reversed(range(2000))), [i['foo'] for i in mydocs]
assert mydocs[0]['foo'] == 1999, mydocs[0]['foo']
assert not isinstance(self.col.find().sort('foo', -1).next(), MyDoc)
def test_get_dbref(self):
class MyDoc(Document):
skeleton = {"foo": int}
self.connection.register([MyDoc])
mydoc = self.col.MyDoc()
mydoc['_id'] = u'1'
mydoc['foo'] = 1
mydoc.save()
mydoc = self.connection.test.othercol.MyDoc()
mydoc['_id'] = u'2'
mydoc['foo'] = 2
mydoc.save()
mydoc = self.connection.othertest.mongolite.MyDoc()
mydoc['_id'] = u'3'
mydoc['foo'] = 3
mydoc.save()
mydoc = self.col.MyDoc.find_one({'foo': 1})
assert mydoc.get_dbref(), DBRef(u'mongolite', u'1', u'test')
mydoc = self.connection.test.othercol.MyDoc.find_one({'foo': 2})
assert mydoc.get_dbref() == DBRef(u'othercol', u'2', u'test')
mydoc = self.connection.othertest.mongolite.MyDoc.find_one({'foo': 3})
assert mydoc.get_dbref() == DBRef(u'mongolite', u'3', u'othertest')
def test__hash__(self):
class MyDoc(Document):
skeleton = {"foo": int}
self.connection.register([MyDoc])
mydoc = self.col.MyDoc()
mydoc['foo'] = 1
self.assertRaises(TypeError, hash, mydoc)
mydoc.save()
hash(mydoc)
def test_non_callable(self):
class MyDoc(Document):
skeleton = {"foo": int}
self.connection.register([MyDoc])
mydoc = self.col.MyDoc()
self.assertRaises(TypeError, mydoc)
assert callable(mydoc) is False
def test_bad_call(self):
class MyDoc(Document):
skeleton = {"foo": int}
self.assertRaises(TypeError, self.connection.test.col.MyDoc)
self.connection.register([MyDoc])
self.connection.test.col.MyDoc()
self.assertRaises(TypeError, self.connection.test.col.Bla)
self.assertRaises(TypeError, self.connection.test.Bla)
def test_distinct(self):
class Doc(Document):
skeleton = {"foo": unicode, "bla": int}
self.connection.register([Doc])
for i in range(15):
if i % 2 == 0:
foo = u"blo"
else:
foo = u"bla"
doc = self.col.Doc(doc={'foo': foo, 'bla': i})
doc.save()
self.assertEqual(self.col.find().distinct('foo'), [u'blo', u'bla'])
self.assertEqual(self.col.find().distinct('bla'), range(15))
def test_explain(self):
class MyDoc(Document):
skeleton = {
"foo": int,
"bar": {
"bla": int
},
}
self.connection.register([MyDoc])
for i in range(10):
mydoc = self.col.MyDoc()
mydoc["foo"] = i
mydoc["bar"]['bla'] = i
mydoc.save()
explain1 = self.col.MyDoc.find({"foo": {"$gt": 4}}).explain()
explain2 = self.col.find({'foo': {'gt': 4}}).explain()
explain1.pop('n')
explain2.pop('n')
assert explain1 == explain2, (explain1, explain2)
def test_with_long(self):
class Doc(Document):
skeleton = {
"foo": long,
"bar": unicode,
}
self.connection.register([Doc])
doc = self.col.Doc()
doc['foo'] = 12L
doc.save()
fetch_doc = self.col.Doc.find_one()
fetch_doc['bar'] = u'egg'
fetch_doc.save()
def test_passing_collection_in_argument(self):
class MyDoc(Document):
skeleton = {'foo': unicode}
doc = MyDoc(collection=self.col)
doc['foo'] = u'bla'
doc.save()
def test_reload(self):
class MyDoc(Document):
skeleton = {
'foo': {
'bar': unicode,
'eggs': {
'spam': int
},
},
'bla': unicode
}
self.connection.register([MyDoc])
doc = self.col.MyDoc()
self.assertRaises(KeyError, doc.reload)
doc['_id'] = 3
doc['foo']['bar'] = u'mybar'
doc['foo']['eggs']['spam'] = 4
doc['bla'] = u'ble'
self.assertRaises(OperationFailure, doc.reload)
doc.save()
doc['bla'] = u'bli'
self.col.update({'_id': doc['_id']}, {'$set': {'foo.eggs.spam': 2}})
doc.reload()
assert doc == {
'_id': 3,
'foo': {
u'eggs': {
u'spam': 2
},
u'bar': u'mybar'
},
'bla': u'ble'
}
def test_rewind(self):
class MyDoc(Document):
skeleton = {
'foo': int,
}
self.connection.register([MyDoc])
for i in range(10):
doc = self.col.MyDoc()
doc['foo'] = i
doc.save()
cur = self.col.MyDoc.find()
for i in cur:
assert isinstance(i, MyDoc), type(MyDoc)
try:
cur.next()
except StopIteration:
pass
cur.rewind()
for i in cur:
assert isinstance(i, MyDoc), type(MyDoc)
for i in cur.rewind():
assert isinstance(i, MyDoc), type(MyDoc)
def test_decorator(self):
@self.connection.register
class MyDoc(Document):
skeleton = {
'foo': int,
}
mydoc = self.col.MyDoc()
mydoc['foo'] = 3
mydoc.save()
raw_doc = self.col.MyDoc.find_one()
self.assertEqual(raw_doc['foo'], 3)
assert isinstance(raw_doc, MyDoc)
def test_collection_name_filled(self):
@self.connection.register
class MyDoc(Document):
__collection__ = 'mydoc'
skeleton = {
'foo': int,
}
mydoc = self.connection.test.MyDoc()
mydoc['foo'] = 3
mydoc.save()
self.assertEqual(mydoc.collection.name, 'mydoc')
raw_doc = self.connection.test.MyDoc.find_one()
self.assertEqual(self.col.MyDoc.find_one(), None)
self.assertEqual(raw_doc['foo'], 3)
self.assertEqual(raw_doc, mydoc)
assert isinstance(raw_doc, MyDoc)
mydoc = self.col.MyDoc()
mydoc['foo'] = 3
mydoc.save()
self.assertEqual(mydoc.collection.name, 'mongolite')
raw_doc = self.col.MyDoc.find_one()
self.assertEqual(raw_doc['foo'], 3)
self.assertEqual(raw_doc, mydoc)
assert isinstance(raw_doc, MyDoc)
def test_database_name_filled(self):
failed = False
@self.connection.register
class MyDoc(Document):
__database__ = 'mydoc'
skeleton = {
'foo': int,
}
try:
doc = self.connection.MyDoc()
except AttributeError, e:
failed = True
self.assertEqual(
str(e), 'MyDoc: __collection__ attribute not '
'found. You cannot specify the `__database__` attribute '
'without the `__collection__` attribute')
self.assertEqual(failed, True)
@self.connection.register
class MyDoc(Document):
__database__ = 'test'
__collection__ = 'mydoc'
skeleton = {
'foo': int,
}
# test directly from a connection
mydoc = self.connection.MyDoc()
mydoc['foo'] = 3
mydoc.save()
self.assertEqual(mydoc.collection.name, 'mydoc')
self.assertEqual(mydoc.collection.database.name, 'test')
self.assertEqual(self.col.MyDoc.find_one(), None)
raw_doc = self.connection.MyDoc.find_one()
self.assertEqual(raw_doc['foo'], 3)
self.assertEqual(raw_doc, mydoc)
assert isinstance(raw_doc, MyDoc)
# test directly from a database
mydoc = self.connection.othertest.MyDoc()
mydoc['foo'] = 3
mydoc.save()
self.assertEqual(mydoc.collection.name, 'mydoc')
self.assertEqual(mydoc.collection.database.name, 'othertest')
self.assertEqual(self.col.MyDoc.find_one(), None)
raw_doc = self.connection.othertest.MyDoc.find_one()
self.assertEqual(raw_doc['foo'], 3)
self.assertEqual(raw_doc, mydoc)
assert isinstance(raw_doc, MyDoc)
# and still can use it via a collection
mydoc = self.col.MyDoc()
mydoc['foo'] = 3
mydoc.save()
self.assertEqual(mydoc.collection.name, 'mongolite')
self.assertEqual(mydoc.collection.database.name, 'test')
raw_doc = self.col.MyDoc.find_one()
self.assertEqual(raw_doc['foo'], 3)
self.assertEqual(raw_doc, mydoc)
assert isinstance(raw_doc, MyDoc)
class IndexTestCase(unittest.TestCase):
def setUp(self):
self.connection = Connection(safe=True)
self.col = self.connection['test']['mongolite']
def tearDown(self):
self.connection['test'].drop_collection('mongolite')
self.connection = None
def test_index_basic(self):
@self.connection.register
class Movie(Document):
skeleton = {
'other': {
'deep': unicode,
},
'notindexed': unicode,
}
optional = {
'standard': unicode,
}
indexes = [
{
'fields': [('standard', 1), ('other.deep', 1)],
'unique': True,
},
]
self.col.Movie.generate_indexes()
movie = self.col.Movie()
movie['standard'] = u'test'
movie['other']['deep'] = u'testdeep'
movie['notindexed'] = u'notthere'
movie.save()
db = self.connection.test
item = db['system.indexes'].find_one({
'ns': 'test.mongolite',
'name': 'standard_1_other.deep_1',
'unique': True
})
assert item is not None, 'No Index Found'
movie = self.col.Movie()
movie['standard'] = u'test'
movie['other']['deep'] = u'testdeep'
self.assertRaises(OperationFailure, movie.save)
def test_index_basic_dynamic_collection(self):
@self.connection.register
class Movie(Document):
skeleton = {
'other': {
'deep': unicode,
},
'notindexed': unicode,
}
optional = {
'standard': unicode,
}
indexes = [
{
'fields': [('standard', 1), ('other.deep', 1)],
'unique': True,
},
]
self.col.Movie.generate_indexes()
movie = self.col.Movie()
movie['standard'] = u'test'
movie['other']['deep'] = u'testdeep'
movie['notindexed'] = u'notthere'
movie.save()
db = self.connection.test
item = db['system.indexes'].find_one({
'ns': 'test.mongolite',
'name': 'standard_1_other.deep_1',
'unique': True
})
assert item is not None, 'No Index Found'
movie = self.col.Movie()
movie['standard'] = u'test'
movie['other']['deep'] = u'testdeep'
self.assertRaises(OperationFailure, movie.save)
self.connection.test.othercol.Movie.generate_indexes()
db = self.connection.test
item = db['system.indexes'].find_one({
'ns': 'test.othercol',
'name': 'standard_1_other.deep_1',
'unique': True
})
assert item is not None, 'No Index Found'
def test_index_single_without_generation(self):
class Movie(Document):
skeleton = {
'standard': unicode,
}
indexes = [
{
'fields': 'standard',
'unique': True,
},
]
self.connection.register([Movie])
movie = self.col.Movie()
movie['standard'] = u'test'
movie.save()
db = self.connection.test
item = db['system.indexes'].find_one({
'ns': 'test.mongolite',
'name': 'standard_1',
'unique': True,
'key': {
'standard': 1
}
})
assert item is None, 'Index is found'
def test_index_single(self):
class Movie(Document):
skeleton = {
'standard': unicode,
}
indexes = [
{
'fields': 'standard',
'unique': True,
},
]
self.connection.register([Movie])
self.col.Movie.generate_indexes()
movie = self.col.Movie()
movie['standard'] = u'test'
movie.save()
db = self.connection.test
item = db['system.indexes'].find_one({
'ns': 'test.mongolite',
'name': 'standard_1',
'unique': True,
'key': {
'standard': 1
}
})
assert item is not None, 'No Index Found'
def test_index_multi(self):
class Movie(Document):
skeleton = {
'standard': unicode,
'other': {
'deep': unicode,
},
'notindexed': unicode,
'alsoindexed': unicode,
}
indexes = [
{
'fields': 'standard',
'unique': True,
},
{
'fields': [('alsoindexed', 1), ('other.deep', -1)],
'unique': True,
},
]
self.connection.register([Movie])
self.col.Movie.generate_indexes()
movie = self.col.Movie()
movie['standard'] = u'test'
movie.save()
db = self.connection.test
item = db['system.indexes'].find_one({
'ns': 'test.mongolite',
'name': 'standard_1',
'unique': True,
'key': {
'standard': 1
}
})
index2 = db['system.indexes'].find_one({
'ns': 'test.mongolite',
'name': 'alsoindexed_1_other.deep_-1',
'unique': True
})
assert item is not None, 'No Index Found'
assert index2 is not None, 'Index not found'
movie = self.col.Movie()
movie['standard'] = u'test'
self.assertRaises(OperationFailure, movie.save)
def test_index_multi2(self):
class Movie(Document):
skeleton = {
'standard': unicode,
'other': {
'deep': unicode,
},
'notindexed': unicode,
'alsoindexed': unicode,
}
indexes = [
{
'fields': 'standard',
'unique': True,
},
{
'fields': 'other.deep',
'unique': True,
},
]
self.connection.register([Movie])
self.col.Movie.generate_indexes()
movie = self.col.Movie()
movie['standard'] = u'test'
movie['other']['deep'] = u'foo'
movie.save()
db = self.connection.test
item = db['system.indexes'].find_one({
'ns': 'test.mongolite',
'name': 'standard_1',
'unique': True,
'key': {
'standard': 1
}
})
index2 = db['system.indexes'].find_one({
'ns': 'test.mongolite',
'name': 'other.deep_1',
'unique': True
})
assert item is not None, 'No Index Found'
assert index2 is not None, 'Index not found'
movie = self.col.Movie()
movie['standard'] = u'test'
self.assertRaises(OperationFailure, movie.save)
movie = self.col.Movie()
movie['other']['deep'] = u'foo'
self.assertRaises(OperationFailure, movie.save)
def test_index_direction(self):
class Movie(Document):
skeleton = {
'standard': unicode,
'other': {
'deep': unicode,
},
'notindexed': unicode,
'alsoindexed': unicode,
}
indexes = [
{
'fields': [('standard', INDEX_DESCENDING)],
'unique': True,
},
{
'fields': [('alsoindexed', INDEX_ASCENDING),
('other.deep', INDEX_DESCENDING)],
'unique':
True,
},
]
self.connection.register([Movie])
self.col.Movie.generate_indexes()
movie = self.col.Movie()
movie['standard'] = u'test'
movie.save()
db = self.connection.test
index1 = db['system.indexes'].find_one({
'ns': 'test.mongolite',
'name': 'standard_-1',
'unique': True
})
index2 = db['system.indexes'].find_one({
'ns': 'test.mongolite',
'name': 'alsoindexed_1_other.deep_-1',
'unique': True
})
assert index1 is not None, 'No Index Found'
assert index2 is not None, 'Index not found'
def test_index_direction_GEO2D(self):
class Movie(Document):
skeleton = {
'standard': unicode,
'other': {
'deep': unicode,
},
'notindexed': unicode,
'alsoindexed': unicode,
}
indexes = [
{
'fields': [('standard', INDEX_GEO2D)],
'unique': True,
},
{
'fields': [('alsoindexed', INDEX_GEO2D),
('other.deep', INDEX_DESCENDING)],
'unique':
True,
},
]
self.connection.register([Movie])
self.col.Movie.generate_indexes()
movie = self.col.Movie()
movie['standard'] = u'test'
movie.save()
db = self.connection.test
index1 = db['system.indexes'].find_one({
'ns': 'test.mongolite',
'name': 'standard_2d',
'unique': True
})
index2 = db['system.indexes'].find_one({
'ns': 'test.mongolite',
'name': 'alsoindexed_2d_other.deep_-1',
'unique': True
})
assert index1 is not None, 'No Index Found'
assert index2 is not None, 'Index not found'
def test_bad_index_descriptor(self):
failed = False
try:
class Movie(Document):
skeleton = {'standard': unicode}
indexes = [{'unique': True}]
except BadIndexError, e:
self.assertEqual(str(e), "`fields` key must be specify in indexes")
failed = True
self.assertEqual(failed, True)
failed = False
try:
class Movie(Document):
skeleton = {
'standard': unicode,
}
indexes = [
{
'fields': 'std',
},
]
except ValueError, e:
self.assertEqual(
str(e),
"Error in indexes: can't find std in skeleton or optional")
failed = True
class InheritanceTestCase(unittest.TestCase):
def setUp(self):
self.connection = Connection()
self.col = self.connection['test']['mongolite']
def tearDown(self):
self.connection['test'].drop_collection('mongolite')
def test_simple_inheritance(self):
class A(SchemaDocument):
skeleton = {
"a":{"foo":int}
}
class B(A):
skeleton = {
"b":{"bar":unicode}
}
assert B() == {"a":{"foo":None}, "b":{"bar":None}}, B()
def test_simple_inheritance_with_only_optional(self):
class A(SchemaDocument):
optional = {
'optfoo': int,
}
class B(A):
optional = {
'optbar': float,
}
self.assertEqual(B(), {'optfoo':None, 'optbar':None})
def test_simple_inheritance_with_optional(self):
class A(SchemaDocument):
skeleton = {
'reqfoo': unicode,
}
optional = {
'optfoo': int,
}
class B(A):
optional = {
'optbar': float,
}
self.assertEqual(B(), {'reqfoo':None, 'optfoo':None, 'optbar':None})
def test_gen_doc(self):
class A(SchemaDocument):
skeleton = {
'reqfoo': unicode,
}
optional = {
'optfoo': int,
}
class B(A):
"""this is a test doc"""
optional = {
'optbar': float,
}
self.assertEqual(B.__doc__, """this is a test doc
required fields: {
reqfoo : <type 'unicode'>
}
optional fields: {
optbar : <type 'float'>
optfoo : <type 'int'>
}
""")
def test_default_values_inheritance(self):
class A(SchemaDocument):
skeleton = {
"a":{"foo":int}
}
default_values = {"a.foo":3}
class B(A):
skeleton = {
"b":{"bar":unicode}
}
assert B() == {"a":{"foo":3}, "b":{"bar":None}}
class C(A):
skeleton = {
"c":{"spam":unicode}
}
default_values = {"a.foo":5}
assert C() == {"a":{"foo":5}, "c":{"spam":None}}, C()
def test_default_values_inheritance_with_optional(self):
class A(SchemaDocument):
skeleton = {
"a":{"foo":int}
}
optional = {
"bar": int
}
default_values = {"a.foo":3, "bar": 42}
class B(A):
skeleton = {
"b":{"bar":unicode}
}
assert B() == {"a":{"foo":3}, "b":{"bar":None}, "bar": 42}
class C(A):
skeleton = {
"c":{"spam":unicode}
}
optional = {
"bla": unicode,
}
default_values = {"a.foo":5, "bla": u"foo"}
assert C() == {"a":{"foo":5}, "c":{"spam":None}, "bar": 42, "bla": u"foo"}, C()
def test_default_values_inheritance_with_function(self):
from datetime import datetime
class A(SchemaDocument):
skeleton = {
"a":{"foo":datetime}
}
default_values = {"a.foo":datetime.utcnow}
class B(A):
skeleton = {
"b":{"bar":unicode}
}
assert isinstance(B()['a']['foo'], datetime)
class C(A):
skeleton = {
"c":{"spam":unicode}
}
default_values = {"a.foo":datetime(2008,8,8)}
assert C() == {"a":{"foo":datetime(2008, 8, 8)}, "c":{"spam":None}}, C()
def test_complete_inheritance(self):
class A(SchemaDocument):
skeleton = {
"a":{"foo":int}
}
default_values = {"a.foo":3}
class B(A):
skeleton = {
"b":{"bar":unicode}
}
default_values = {"a.foo":5}
b = B()
assert b == {"a":{"foo":5}, "b":{"bar":None}}
class C(B):
skeleton = {
"c":{"spam":unicode}
}
c = C()
assert c == {"a":{"foo":5}, "b":{"bar":None}, "c":{"spam":None}}, C()
def test_polymorphism(self):
class A(SchemaDocument):
skeleton = {
"a":{"foo":int}
}
default_values = {"a.foo":3}
class B(SchemaDocument):
skeleton = {
"b":{"bar":unicode}
}
required_fields = ['b.bar']
b = B()
assert b == {"b":{"bar":None}}
class C(A,B):
skeleton = {
"c":{"spam":unicode}
}
default_values = {"a.foo":5}
c = C()
assert c == {"a":{"foo":5}, "b":{"bar":None}, "c":{"spam":None}}, C()
def test_simple_manual_inheritance(self):
class A(SchemaDocument):
auto_inheritance = False
skeleton = {
"a":{"foo":int}
}
class B(A):
skeleton = {
"b":{"bar":unicode}
}
skeleton.update(A.skeleton)
assert B() == {"a":{"foo":None}, "b":{"bar":None}}
def test_default_values_manual_inheritance(self):
class A(SchemaDocument):
auto_inheritance = False
skeleton = {
"a":{"foo":int}
}
default_values = {"a.foo":3}
class B(A):
skeleton = {
"b":{"bar":unicode}
}
skeleton.update(A.skeleton)
default_values = A.default_values
assert B() == {"a":{"foo":3}, "b":{"bar":None}}
class C(A):
skeleton = {
"c":{"spam":unicode}
}
skeleton.update(A.skeleton)
default_values = A.default_values
default_values.update({"a.foo":5})
assert C() == {"a":{"foo":5}, "c":{"spam":None}}, C()
def test_inheritance_with_document(self):
class Doc(Document):
skeleton = {
"doc":{'bla':int},
}
class DocA(Doc):
skeleton = {
"doc_a":{'foo':int},
}
class DocB(DocA):
skeleton = {
"doc_b":{"bar":int},
}
self.connection.register([Doc, DocA, DocB])
assert self.col.DocA() == {'doc': {'bla': None}, 'doc_a': {'foo': None}}
assert self.col.DocB() == {'doc': {'bla': None}, 'doc_b': {'bar': None}, 'doc_a': {'foo': None}}
# creating DocA
for i in range(10):
mydoc = self.col.DocA()
mydoc['doc']["bla"] = i+1
mydoc['doc_a']["foo"] = i
mydoc.save()
assert self.col.find_one({'_id':mydoc['_id']}) == {u'doc': {u'bla': 10}, u'_id': mydoc['_id'], u'doc_a': {u'foo': 9}}
# creating DocB
for i in range(5):
mydoc = self.col.DocB()
mydoc['doc']["bla"] = i+1
mydoc['doc_a']["foo"] = i
mydoc['doc_b']["bar"] = i+2
mydoc.save()
assert self.col.find_one({'_id':mydoc['_id']}) == {u'doc': {u'bla': 5}, u'_id': mydoc['_id'], u'doc_b': {u'bar': 6}, u'doc_a': {u'foo': 4}}
class StructureTestCase(unittest.TestCase):
def setUp(self):
self.connection = Connection()
self.col = self.connection['test']['mongolite']
def tearDown(self):
self.connection['test'].drop_collection('mongolite')
def test_no_skeleton(self):
class MyDoc(SchemaDocument):
pass
doc = MyDoc()
self.assertEqual(doc, {})
def test_empty_skeleton(self):
class MyDoc(SchemaDocument):
skeleton = {}
self.assertEqual(MyDoc(), {})
def test_skeleton_not_dict(self):
failed = False
try:
class MyDoc(SchemaDocument):
skeleton = 3
except StructureError:
failed = True
self.assertEqual(failed, True)
def test_load_with_dict(self):
doc = {"foo":1, "bla":{"bar":u"spam"}}
class MyDoc(SchemaDocument):
skeleton = {"foo":int, "bla":{"bar":unicode}}
mydoc = MyDoc(doc)
self.assertEqual(mydoc, doc)
def test_simple_skeleton(self):
class MyDoc(SchemaDocument):
skeleton = {
"foo":unicode,
"bar":int
}
self.assertEqual(MyDoc(), {"foo":None, "bar":None})
def test_simple_skeleton_and_optional(self):
class MyDoc(SchemaDocument):
skeleton = {
'reqfoo': unicode,
}
optional = {
'optfoo': int,
}
self.assertEqual(MyDoc(), {'reqfoo':None, 'optfoo':None})
def test_missed_field(self):
doc = {"foo":u"arf"}
class MyDoc(SchemaDocument):
skeleton = {
"foo":unicode,
"bar":{"bla":int}
}
mydoc = MyDoc(doc)
self.assertEqual(mydoc, {'foo': u'arf'})
def test_unknown_field(self):
class MyDoc(SchemaDocument):
skeleton = {
"foo":unicode,
}
mydoc = MyDoc()
self.assertEqual(mydoc, {'foo':None})
def test_None(self):
class MyDoc(SchemaDocument):
skeleton = {
"foo":None,
"bar":{
"bla":None
}
}
mydoc = MyDoc()
self.assertEqual(mydoc, {'foo': None, 'bar': {'bla': None}})
def test_big_nested_skeleton(self):
class MyDoc(SchemaDocument):
skeleton = {
"1":{
"2":{
"3":{
"4":{
"5":{
"6":{
"7":int,
"8":{
unicode:{int:int}
}
}
}
}
}
}
}
}
mydoc = MyDoc()
self.assertEqual(mydoc._namespaces, ['1', '1.2', '1.2.3', '1.2.3.4', '1.2.3.4.5', '1.2.3.4.5.6', '1.2.3.4.5.6.8', '1.2.3.4.5.6.8.$unicode', '1.2.3.4.5.6.8.$unicode.$int', '1.2.3.4.5.6.7'])
self.assertEqual(mydoc, {'1': {'2': {'3': {'4': {'5': {'6': {'8': {}, '7': None}}}}}}})
def test_big_nested_skeleton_mongo_document(self):
class MyDoc(Document):
skeleton = {
"1":{
"2":{
"3":{
"4":{
"5":{
"6":{
"7":int,
"8":{
unicode:{unicode:int}
}
}
}
}
}
}
}
}
self.connection.register([MyDoc])
mydoc = self.col.MyDoc()
self.assertEqual(mydoc, {'1': {'2': {'3': {'4': {'5': {'6': {'8': {}, '7': None}}}}}}})
self.assertEqual(mydoc._namespaces, ['1', '1.2', '1.2.3', '1.2.3.4', '1.2.3.4.5', '1.2.3.4.5.6', '1.2.3.4.5.6.8', '1.2.3.4.5.6.8.$unicode', '1.2.3.4.5.6.8.$unicode.$unicode', '1.2.3.4.5.6.7'])
mydoc['1']['2']['3']['4']['5']['6']['7'] = 8
mydoc['1']['2']['3']['4']['5']['6']['8'] = {u"bla":{"3":u"bla"}}
mydoc.save()
def test_field_changed(self):
class MyDoc(Document):
skeleton = {
'foo':int,
'bar':unicode,
}
self.connection.register([MyDoc])
doc = self.col.MyDoc()
doc['foo'] = 3
doc.save()
class MyDoc(Document):
skeleton = {
'foo':int,
'arf': unicode,
}
self.connection.register([MyDoc])
fetched_doc = self.col.MyDoc.find_one()
fetched_doc['foo'] = 2
fetched_doc.save()
def test_exception_bad_skeleton(self):
import datetime
failed = False
try:
class MyDoc(SchemaDocument):
skeleton = {
'topic': unicode,
'when': datetime.datetime.utcnow,
}
except TypeError, e:
assert str(e).startswith("MyDoc: <built-in method utcnow of type object at "), str(e)
assert str(e).endswith("is not a type")
failed = True
self.assertEqual(failed, True)
def setUp(self):
self.connection = Connection()
self.col = self.connection['test']['mongolite']
class SerializeTestCase(unittest.TestCase):
def setUp(self):
self.connection = Connection()
self.col = self.connection['test']['mongolite']
def tearDown(self):
self.connection.drop_database('test')
self.connection.drop_database('othertest')
def test_simple_serialize(self):
@self.connection.register
class Foo(Document):
__database__ = 'test'
__collection__ = 'foo'
skeleton = {
"bar":int,
}
@self.connection.register
class MyDoc(Document):
__database__ = 'test'
__collection__ = 'mydocs'
skeleton = {
"foo":ObjectId,
}
@property
def foo(self):
return self.db.Foo.get_from_id(self['foo'])
foo = self.connection.Foo()
foo['bar'] = 42
foo.save()
mydoc = self.connection.MyDoc()
mydoc['foo'] = foo['_id']
mydoc.save()
mydoc = self.connection.MyDoc.get_from_id(mydoc['_id'])
self.assertEqual(mydoc.foo['_id'], foo['_id'])
self.assertEqual(mydoc, {'_id':mydoc['_id'], 'foo': foo['_id']})
self.assertEqual(mydoc.serialize(), {'_id': mydoc['_id'], 'foo': {'_id':foo['_id'], 'bar':42}})
self.assertEqual(json.dumps(mydoc, default=json_util.default),
'{"_id": {"$oid": "%s"}, "foo": {"$oid": "%s"}}' % (mydoc['_id'], foo['_id']))
self.assertEqual(json.dumps(mydoc.serialize(), default=json_util.default),
'{"_id": {"$oid": "%s"}, "foo": {"_id": {"$oid": "%s"}, "bar": 42}}' % (mydoc['_id'], foo['_id']))
def test_simple_serialize_cursor(self):
@self.connection.register
class Foo(Document):
__database__ = 'test'
__collection__ = 'foos'
skeleton = {
"bar":int,
}
@self.connection.register
class MyDoc(Document):
__database__ = 'test'
__collection__ = 'mydocs'
skeleton = {
"foos":[ObjectId],
}
@property
def foos(self):
return self.db.Foo.find({'_id':{'$in':self['foos']}})
foo = self.connection.Foo()
foo['bar'] = 42
foo.save()
foo2 = self.connection.Foo()
foo2['bar'] = 3
foo2.save()
mydoc = self.connection.MyDoc()
mydoc['foos'] = [foo['_id'], foo2['_id']]
mydoc.save()
mydoc = self.connection.MyDoc.get_from_id(mydoc['_id'])
for _foo in mydoc.foos:
self.assertTrue(_foo['_id'] in [foo['_id'], foo2['_id']])
self.assertEqual(mydoc, {'_id':mydoc['_id'], 'foos': [foo['_id'], foo2['_id']]})
self.assertEqual(mydoc.serialize(), {'_id': mydoc['_id'],
'foos': [{'_id':foo['_id'], 'bar':42}, {'_id':foo2['_id'], 'bar': 3}]
})
self.assertEqual(json.dumps(mydoc, default=json_util.default),
'{"_id": {"$oid": "%s"}, "foos": [{"$oid": "%s"}, {"$oid": "%s"}]}' % (
mydoc['_id'], foo['_id'], foo2['_id']))
self.assertEqual(json.dumps(mydoc.serialize(), default=json_util.default),
'{"_id": {"$oid": "%s"}, "foos": [{"_id": {"$oid": "%s"}, "bar": 42}, {"_id": {"$oid": "%s"}, "bar": 3}]}' % (
mydoc['_id'], foo['_id'], foo2['_id']))
def test_simple_serialize_without_property(self):
@self.connection.register
class Foo(Document):
__database__ = 'test'
__collection__ = 'foo'
skeleton = {
"bar":int,
}
@self.connection.register
class MyDoc(Document):
__database__ = 'test'
__collection__ = 'mydocs'
skeleton = {
"foo":ObjectId,
}
foo = self.connection.Foo()
foo['bar'] = 42
foo.save()
mydoc = self.connection.MyDoc()
mydoc['foo'] = foo['_id']
mydoc.save()
mydoc = self.connection.MyDoc.get_from_id(mydoc['_id'])
self.assertEqual(mydoc, {'_id':mydoc['_id'], 'foo': foo['_id']})
self.assertEqual(mydoc.serialize(), {'_id': mydoc['_id'], 'foo': foo['_id']})
self.assertEqual(json.dumps(mydoc, default=json_util.default),
'{"_id": {"$oid": "%s"}, "foo": {"$oid": "%s"}}' % (mydoc['_id'], foo['_id']))
self.assertEqual(json.dumps(mydoc.serialize(), default=json_util.default),
'{"_id": {"$oid": "%s"}, "foo": {"$oid": "%s"}}' % (mydoc['_id'], foo['_id']))
def test_simple_serialize_default_property(self):
@self.connection.register
class Foo(Document):
__database__ = 'test'
__collection__ = 'foo'
skeleton = {
"bar":int,
}
@self.connection.register
class MyDoc(Document):
__database__ = 'test'
__collection__ = 'mydocs'
skeleton = {
"spam":{
"foo":ObjectId,
}
}
@property
def spam__foo(self):
return self.db.Foo.get_from_id(self['spam']['foo'])
foo = self.connection.Foo()
foo['bar'] = 42
foo.save()
mydoc = self.connection.MyDoc()
mydoc['spam']['foo'] = foo['_id']
mydoc.save()
mydoc = self.connection.MyDoc.get_from_id(mydoc['_id'])
self.assertEqual(mydoc.spam__foo['_id'], foo['_id'])
self.assertEqual(mydoc, {'_id':mydoc['_id'], 'spam':{'foo': foo['_id']}})
self.assertEqual(mydoc.serialize(), {'_id': mydoc['_id'], 'spam':{'foo': {'_id':foo['_id'], 'bar':42}}})
self.assertEqual(json.dumps(mydoc, default=json_util.default),
'{"_id": {"$oid": "%s"}, "spam": {"foo": {"$oid": "%s"}}}' % (mydoc['_id'], foo['_id']))
self.assertEqual(json.dumps(mydoc.serialize(), default=json_util.default),
'{"_id": {"$oid": "%s"}, "spam": {"foo": {"_id": {"$oid": "%s"}, "bar": 42}}}' % (mydoc['_id'], foo['_id']))
def test_simple_serialize_mapping(self):
@self.connection.register
class Foo(Document):
__database__ = 'test'
__collection__ = 'foo'
skeleton = {
"bar":int,
}
@self.connection.register
class MyDoc(Document):
__database__ = 'test'
__collection__ = 'mydocs'
skeleton = {
"spam":{
"foo":ObjectId,
}
}
serialize_mapping = {'spam.foo': 'foo'}
@property
def foo(self):
return self.db.Foo.get_from_id(self['spam']['foo'])
foo = self.connection.Foo()
foo['bar'] = 42
foo.save()
mydoc = self.connection.MyDoc()
mydoc['spam']['foo'] = foo['_id']
mydoc.save()
mydoc = self.connection.MyDoc.get_from_id(mydoc['_id'])
self.assertEqual(mydoc.foo['_id'], foo['_id'])
self.assertEqual(mydoc, {'_id':mydoc['_id'], 'spam':{'foo': foo['_id']}})
self.assertEqual(mydoc.serialize(), {'_id': mydoc['_id'], 'spam':{'foo': {'_id':foo['_id'], 'bar':42}}})
self.assertEqual(json.dumps(mydoc, default=json_util.default),
'{"_id": {"$oid": "%s"}, "spam": {"foo": {"$oid": "%s"}}}' % (mydoc['_id'], foo['_id']))
self.assertEqual(json.dumps(mydoc.serialize(), default=json_util.default),
'{"_id": {"$oid": "%s"}, "spam": {"foo": {"_id": {"$oid": "%s"}, "bar": 42}}}' % (mydoc['_id'], foo['_id']))
