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
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
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 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 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 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 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 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 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 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']))
