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