def test_get_collection_with_connection(self): class Section(Document): skeleton = {"section":int} connection = Connection('127.0.0.3') connection.register([Section]) col = connection.test.mongolite assert col.database.connection == col.Section.connection assert col.database.name == 'test' == col.Section.db.name assert col.name == 'mongolite' == col.Section.collection.name
def test_get_collection_with_connection(self): class Section(Document): skeleton = {"section": int} connection = Connection('127.0.0.3') connection.register([Section]) col = connection.test.mongolite assert col.database.connection == col.Section.connection assert col.database.name == 'test' == col.Section.db.name assert col.name == 'mongolite' == col.Section.collection.name
def test_pass_connection_arguments_to_cursor(self): class MyDoc(Document): structure = { "foo":int, "bar":{"bla":int}, } con = Connection(read_preference=ReadPreference.SECONDARY_PREFERRED, secondary_acceptable_latency_ms=16) con.register([MyDoc]) col = con['test']['mongokit'] assert col.MyDoc.find()._Cursor__read_preference == ReadPreference.SECONDARY_PREFERRED assert col.MyDoc.find()._Cursor__secondary_acceptable_latency_ms == 16 con.close()
def test_pass_connection_arguments_to_cursor(self): class MyDoc(Document): structure = { "foo": int, "bar": { "bla": int }, } con = Connection(read_preference=ReadPreference.SECONDARY_PREFERRED, secondary_acceptable_latency_ms=16) con.register([MyDoc]) col = con['test']['mongokit'] assert col.MyDoc.find( )._Cursor__read_preference == ReadPreference.SECONDARY_PREFERRED assert col.MyDoc.find()._Cursor__secondary_acceptable_latency_ms == 16 con.close()
class ApiTestCase(unittest.TestCase): def setUp(self): self.connection = Connection() self.col = self.connection['test']['mongolite'] def tearDown(self): self.connection.drop_database('test') self.connection.drop_database('othertest') def test_save(self): class MyDoc(Document): skeleton = { "bla":{ "foo":unicode, "bar":int, }, "spam":[], } self.connection.register([MyDoc]) mydoc = self.col.MyDoc() mydoc["bla"]["foo"] = u"bar" mydoc["bla"]["bar"] = 42 mydoc.save() assert isinstance(mydoc['_id'], ObjectId) saved_doc = self.col.find_one({"bla.bar":42}) for key, value in mydoc.iteritems(): assert saved_doc[key] == value mydoc = self.col.MyDoc() mydoc["bla"]["foo"] = u"bar" mydoc["bla"]["bar"] = 43 mydoc.save() saved_doc = self.col.find_one({"bla.bar":43}) for key, value in mydoc.iteritems(): assert saved_doc[key] == value def test_save_without_collection(self): class MyDoc(Document): skeleton = { "foo":int, } self.connection.register([MyDoc]) mydoc = MyDoc() mydoc["foo"] = 1 self.assertRaises(ConnectionError, mydoc.save) def test_delete(self): class MyDoc(Document): skeleton = { "foo":int, } self.connection.register([MyDoc]) mydoc = self.col.MyDoc() mydoc['_id'] = 'foo' mydoc["foo"] = 1 mydoc.save() assert self.col.MyDoc.find().count() == 1 mydoc = self.col.MyDoc.get_from_id('foo') assert mydoc['foo'] == 1 mydoc.delete() assert self.col.MyDoc.find().count() == 0 def test_generate_skeleton(self): class A(SchemaDocument): skeleton = { "a":{"foo":int}, "bar":unicode } a = A(gen_skel=False) assert a == {} a.generate_skeleton() assert a == {"a":{"foo":None}, "bar":None}, a def test_generate_skeleton2(self): class A(SchemaDocument): skeleton = { "a":{"foo":[int]}, "bar":{unicode:{"egg":int}} } a = A(gen_skel=False) assert a == {} a.generate_skeleton() assert a == {"a":{"foo":[]}, "bar":{}}, a def test_generate_skeleton3(self): class A(SchemaDocument): skeleton = { "a":{"foo":[int], "spam":{"bla":unicode}}, "bar":{unicode:{"egg":int}} } a = A(gen_skel=False) assert a == {} a.generate_skeleton() assert a == {"a":{"foo":[], "spam":{"bla":None}}, "bar":{}}, a def test_get_from_id(self): class MyDoc(Document): skeleton = { "foo":int, } self.connection.register([MyDoc]) mydoc = self.col.MyDoc() mydoc["_id"] = "bar" mydoc["foo"] = 3 mydoc.save() fetched_doc = self.col.MyDoc.get_from_id("bar") assert mydoc == fetched_doc assert callable(fetched_doc) is False assert isinstance(fetched_doc, MyDoc) raw_doc = self.col.get_from_id('bar') assert mydoc == raw_doc assert not isinstance(raw_doc, MyDoc) def test_find(self): class MyDoc(Document): skeleton = { "foo":int, "bar":{"bla":int}, } self.connection.register([MyDoc]) for i in range(10): mydoc = self.col.MyDoc() mydoc["foo"] = i mydoc["bar"]['bla'] = i mydoc.save() for i in self.col.MyDoc.find({"foo":{"$gt":4}}): assert isinstance(i, MyDoc), (i, type(i)) docs_list = [i["foo"] for i in self.col.MyDoc.find({"foo":{"$gt":4}})] assert docs_list == [5,6,7,8,9] # using limit/count assert self.col.MyDoc.find().count() == 10, self.col.MyDoc.find().count() assert self.col.MyDoc.find().limit(1).count() == 10, self.col.MyDoc.find().limit(1).count() assert self.col.MyDoc.find().where('this.foo').count() == 9 #{'foo':0} is not taken assert self.col.MyDoc.find().where('this.bar.bla').count() == 9 #{'foo':0} is not taken assert self.col.MyDoc.find().hint([('foo', 1)]) assert [i['foo'] for i in self.col.MyDoc.find().sort('foo', -1)] == [9,8,7,6,5,4,3,2,1,0] allPlans = self.col.MyDoc.find().explain()['allPlans'] assert allPlans == [{u'cursor': u'BasicCursor', u'indexBounds': {}}] next_doc = self.col.MyDoc.find().sort('foo',1).next() assert callable(next_doc) is False assert isinstance(next_doc, MyDoc) assert next_doc['foo'] == 0 assert len(list(self.col.MyDoc.find().skip(3))) == 7, len(list(self.col.MyDoc.find().skip(3))) from mongolite.cursor import Cursor assert isinstance(self.col.MyDoc.find().skip(3), Cursor) def test_find_one(self): class MyDoc(Document): skeleton = { "foo":int } self.connection.register([MyDoc]) assert self.col.MyDoc.find_one() is None mydoc = self.col.MyDoc() mydoc['foo'] = 0 mydoc.save() mydoc = self.col.MyDoc.find_one() assert mydoc["foo"] == 0 assert isinstance(mydoc, MyDoc) for i in range(10): mydoc = self.col.MyDoc() mydoc["foo"] = i mydoc.save() one_doc = self.col.MyDoc.find_one() assert callable(one_doc) is False raw_mydoc = self.col.find_one() assert one_doc == raw_mydoc def test_find_and_modify(self): @self.connection.register class DocA(Document): __database__ = 'test' __collection__ = 'doca' structure = {'title': unicode, 'rank': int} for i in range(10): self.connection.DocA({'title': unicode(i), 'rank': i}).save() doc = self.connection.DocA.find_and_modify({'rank':3}, {'$set':{'title': u'coucou'}}) new_doc = self.connection.DocA.find_one({'rank':3}) self.assertEqual(doc['title'], '3') self.assertEqual(new_doc['title'], 'coucou') self.assertEqual(isinstance(doc, DocA), True) @self.connection.register class DocA(Document): structure = {'title': unicode, 'rank': int} for i in range(10): self.connection.test.doca2.save({'title': unicode(i), 'rank': i}) doc = self.connection.test.doca2.DocA.find_and_modify({'rank':3}, {'$set':{'title': u'coucou'}}) new_doc = self.connection.test.doca2.DocA.find_one({'rank':3}) self.assertEqual(doc['title'], '3') self.assertEqual(new_doc['title'], 'coucou') self.assertEqual(isinstance(doc, DocA), True) def test_find_random(self): class MyDoc(Document): skeleton = { "foo":int } self.connection.register([MyDoc]) assert self.col.find_random() is None assert self.col.MyDoc.find_random() is None for i in range(50): mydoc = self.col.MyDoc() mydoc["foo"] = i mydoc.save() raw_mydoc = self.col.find_random() mydoc = self.col.MyDoc.find_random() assert callable(mydoc) is False assert isinstance(mydoc, MyDoc) assert mydoc != raw_mydoc, (mydoc, raw_mydoc) def test_query_with_passing_collection(self): class MyDoc(Document): skeleton = { 'foo':int, } self.connection.register([MyDoc]) mongolite = self.connection.test.mongolite # boostraping for i in range(10): mydoc = mongolite.MyDoc() mydoc['_id'] = unicode(i) mydoc['foo'] = i mydoc.save() # get_from_id fetched_doc = mongolite.MyDoc.get_from_id('4') assert fetched_doc.collection == mongolite # all fetched_docs = mongolite.MyDoc.find({'foo':{'$gt':2}}) assert fetched_docs.count() == 7 for doc in fetched_docs: assert doc.collection == mongolite def test_connection(self): class DocA(Document): skeleton = { "doc_a":{'foo':int}, } self.connection.register([DocA]) assertion = True try: DocA.connection except AttributeError: assertion = True assert assertion try: DocA.db except AttributeError: assertion = True assert assertion try: DocA.collection except AttributeError: assertion = True assert assertion assert self.col.DocA.connection == Connection("localhost", 27017) assert self.col.DocA.collection == Connection("localhost", 27017)['test']['mongolite'] assert self.col.DocA.db == Connection("localhost", 27017)['test'] def test_all_with_dynamic_collection(self): class Section(Document): skeleton = {"section":int} self.connection.register([Section]) s = self.connection.test.section.Section() s['section'] = 1 s.save() s = self.connection.test.section.Section() s['section'] = 2 s.save() s = self.connection.test.other_section.Section() s['section'] = 1 s.save() s = self.connection.test.other_section.Section() s['section'] = 2 s.save() sect_col = self.connection.test.section sects = [s.collection.name == 'section' and s.db.name == 'test' for s in sect_col.Section.find({})] assert len(sects) == 2, len(sects) assert any(sects) sect_col = self.connection.test.other_section sects = [s.collection.name == 'other_section' and s.db.name == 'test' for s in sect_col.Section.find({})] assert len(sects) == 2 assert any(sects) def test_get_collection_with_connection(self): class Section(Document): skeleton = {"section":int} connection = Connection('127.0.0.3') connection.register([Section]) col = connection.test.mongolite assert col.database.connection == col.Section.connection assert col.database.name == 'test' == col.Section.db.name assert col.name == 'mongolite' == col.Section.collection.name def test_get_size(self): class MyDoc(Document): skeleton = { "doc":{"foo":int, "bla":unicode}, } mydoc = MyDoc() mydoc['doc']['foo'] = 3 mydoc['doc']['bla'] = u'bla bla' assert len(mydoc.get_son_object()) == 41, len(mydoc.get_son_object()) mydoc['doc']['bla'] = u'bla bla'+'b'*12 assert len(mydoc.get_son_object()) == 41+12 def test_get_with_no_wrap(self): class MyDoc(Document): skeleton = {"foo":int} self.connection.register([MyDoc]) for i in xrange(2000): mydoc = self.col.MyDoc() mydoc['foo'] = i mydoc.save() import time start = time.time() wrapped_mydocs = [i for i in self.col.MyDoc.find()] end = time.time() wrap_time = end-start start = time.time() mydocs = [i for i in self.col.find().sort('foo', -1)] end = time.time() no_wrap_time = end-start assert no_wrap_time < wrap_time assert isinstance(wrapped_mydocs[0], MyDoc) assert not isinstance(mydocs[0], MyDoc), type(mydocs[0]) assert [i['foo'] for i in mydocs] == list(reversed(range(2000))), [i['foo'] for i in mydocs] assert mydocs[0]['foo'] == 1999, mydocs[0]['foo'] assert not isinstance(self.col.find().sort('foo', -1).next(), MyDoc) def test_get_dbref(self): class MyDoc(Document): skeleton = {"foo":int} self.connection.register([MyDoc]) mydoc = self.col.MyDoc() mydoc['_id'] = u'1' mydoc['foo'] = 1 mydoc.save() mydoc = self.connection.test.othercol.MyDoc() mydoc['_id'] = u'2' mydoc['foo'] = 2 mydoc.save() mydoc = self.connection.othertest.mongolite.MyDoc() mydoc['_id'] = u'3' mydoc['foo'] = 3 mydoc.save() mydoc = self.col.MyDoc.find_one({'foo':1}) assert mydoc.get_dbref(), DBRef(u'mongolite', u'1', u'test') mydoc = self.connection.test.othercol.MyDoc.find_one({'foo':2}) assert mydoc.get_dbref() == DBRef(u'othercol', u'2', u'test') mydoc = self.connection.othertest.mongolite.MyDoc.find_one({'foo':3}) assert mydoc.get_dbref() == DBRef(u'mongolite', u'3', u'othertest') def test__hash__(self): class MyDoc(Document): skeleton = {"foo":int} self.connection.register([MyDoc]) mydoc = self.col.MyDoc() mydoc['foo'] = 1 self.assertRaises(TypeError, hash, mydoc) mydoc.save() hash(mydoc) def test_non_callable(self): class MyDoc(Document): skeleton = {"foo":int} self.connection.register([MyDoc]) mydoc = self.col.MyDoc() self.assertRaises(TypeError, mydoc) assert callable(mydoc) is False def test_bad_call(self): class MyDoc(Document): skeleton = {"foo":int} self.assertRaises(TypeError, self.connection.test.col.MyDoc) self.connection.register([MyDoc]) self.connection.test.col.MyDoc() self.assertRaises(TypeError, self.connection.test.col.Bla) self.assertRaises(TypeError, self.connection.test.Bla) def test_distinct(self): class Doc(Document): skeleton = { "foo": unicode, "bla": int } self.connection.register([Doc]) for i in range(15): if i % 2 == 0: foo = u"blo" else: foo = u"bla" doc = self.col.Doc(doc={'foo':foo, 'bla':i}) doc.save() self.assertEqual(self.col.find().distinct('foo'), [u'blo', u'bla']) self.assertEqual(self.col.find().distinct('bla'), range(15)) def test_explain(self): class MyDoc(Document): skeleton = { "foo":int, "bar":{"bla":int}, } self.connection.register([MyDoc]) for i in range(10): mydoc = self.col.MyDoc() mydoc["foo"] = i mydoc["bar"]['bla'] = i mydoc.save() explain1 = self.col.MyDoc.find({"foo":{"$gt":4}}).explain() explain2 = self.col.find({'foo':{'gt':4}}).explain() explain1.pop('n') explain2.pop('n') assert explain1 == explain2, (explain1, explain2) def test_with_long(self): class Doc(Document): skeleton = { "foo":long, "bar":unicode, } self.connection.register([Doc]) doc = self.col.Doc() doc['foo'] = 12L doc.save() fetch_doc = self.col.Doc.find_one() fetch_doc['bar'] = u'egg' fetch_doc.save() def test_passing_collection_in_argument(self): class MyDoc(Document): skeleton = { 'foo':unicode } doc = MyDoc(collection=self.col) doc['foo'] = u'bla' doc.save() def test_reload(self): class MyDoc(Document): skeleton = { 'foo':{ 'bar':unicode, 'eggs':{'spam':int}, }, 'bla':unicode } self.connection.register([MyDoc]) doc = self.col.MyDoc() self.assertRaises(KeyError, doc.reload) doc['_id'] = 3 doc['foo']['bar'] = u'mybar' doc['foo']['eggs']['spam'] = 4 doc['bla'] = u'ble' self.assertRaises(OperationFailure, doc.reload) doc.save() doc['bla'] = u'bli' self.col.update({'_id':doc['_id']}, {'$set':{'foo.eggs.spam':2}}) doc.reload() assert doc == {'_id': 3, 'foo': {u'eggs': {u'spam': 2}, u'bar': u'mybar'}, 'bla': u'ble'} def test_rewind(self): class MyDoc(Document): skeleton = { 'foo':int, } self.connection.register([MyDoc]) for i in range(10): doc = self.col.MyDoc() doc['foo'] = i doc.save() cur = self.col.MyDoc.find() for i in cur: assert isinstance(i, MyDoc), type(MyDoc) try: cur.next() except StopIteration: pass cur.rewind() for i in cur: assert isinstance(i, MyDoc), type(MyDoc) for i in cur.rewind(): assert isinstance(i, MyDoc), type(MyDoc) def test_decorator(self): @self.connection.register class MyDoc(Document): skeleton = { 'foo':int, } mydoc = self.col.MyDoc() mydoc['foo'] = 3 mydoc.save() raw_doc = self.col.MyDoc.find_one() self.assertEqual(raw_doc['foo'], 3) assert isinstance(raw_doc, MyDoc) def test_collection_name_filled(self): @self.connection.register class MyDoc(Document): __collection__ = 'mydoc' skeleton = { 'foo':int, } mydoc = self.connection.test.MyDoc() mydoc['foo'] = 3 mydoc.save() self.assertEqual(mydoc.collection.name, 'mydoc') raw_doc = self.connection.test.MyDoc.find_one() self.assertEqual(self.col.MyDoc.find_one(), None) self.assertEqual(raw_doc['foo'], 3) self.assertEqual(raw_doc, mydoc) assert isinstance(raw_doc, MyDoc) mydoc = self.col.MyDoc() mydoc['foo'] = 3 mydoc.save() self.assertEqual(mydoc.collection.name, 'mongolite') raw_doc = self.col.MyDoc.find_one() self.assertEqual(raw_doc['foo'], 3) self.assertEqual(raw_doc, mydoc) assert isinstance(raw_doc, MyDoc) def test_database_name_filled(self): failed = False @self.connection.register class MyDoc(Document): __database__ = 'mydoc' skeleton = { 'foo':int, } try: doc = self.connection.MyDoc() except AttributeError, e: failed = True self.assertEqual(str(e), 'MyDoc: __collection__ attribute not ' 'found. You cannot specify the `__database__` attribute ' 'without the `__collection__` attribute') self.assertEqual(failed, True) @self.connection.register class MyDoc(Document): __database__ = 'test' __collection__ = 'mydoc' skeleton = { 'foo':int, } # test directly from a connection mydoc = self.connection.MyDoc() mydoc['foo'] = 3 mydoc.save() self.assertEqual(mydoc.collection.name, 'mydoc') self.assertEqual(mydoc.collection.database.name, 'test') self.assertEqual(self.col.MyDoc.find_one(), None) raw_doc = self.connection.MyDoc.find_one() self.assertEqual(raw_doc['foo'], 3) self.assertEqual(raw_doc, mydoc) assert isinstance(raw_doc, MyDoc) # test directly from a database mydoc = self.connection.othertest.MyDoc() mydoc['foo'] = 3 mydoc.save() self.assertEqual(mydoc.collection.name, 'mydoc') self.assertEqual(mydoc.collection.database.name, 'othertest') self.assertEqual(self.col.MyDoc.find_one(), None) raw_doc = self.connection.othertest.MyDoc.find_one() self.assertEqual(raw_doc['foo'], 3) self.assertEqual(raw_doc, mydoc) assert isinstance(raw_doc, MyDoc) # and still can use it via a collection mydoc = self.col.MyDoc() mydoc['foo'] = 3 mydoc.save() self.assertEqual(mydoc.collection.name, 'mongolite') self.assertEqual(mydoc.collection.database.name, 'test') raw_doc = self.col.MyDoc.find_one() self.assertEqual(raw_doc['foo'], 3) self.assertEqual(raw_doc, mydoc) assert isinstance(raw_doc, MyDoc)
class IndexTestCase(unittest.TestCase): def setUp(self): self.connection = Connection(safe=True) self.col = self.connection['test']['mongolite'] def tearDown(self): self.connection['test'].drop_collection('mongolite') self.connection = None def test_index_basic(self): @self.connection.register class Movie(Document): skeleton = { 'other':{ 'deep':unicode, }, 'notindexed':unicode, } optional = { 'standard':unicode, } indexes = [ { 'fields':[('standard',1),('other.deep',1)], 'unique':True, }, ] self.col.Movie.generate_indexes() movie = self.col.Movie() movie['standard'] = u'test' movie['other']['deep'] = u'testdeep' movie['notindexed'] = u'notthere' movie.save() db = self.connection.test item = db['system.indexes'].find_one({'ns':'test.mongolite', 'name': 'standard_1_other.deep_1', 'unique':True}) assert item is not None, 'No Index Found' movie = self.col.Movie() movie['standard'] = u'test' movie['other']['deep'] = u'testdeep' self.assertRaises(OperationFailure, movie.save) def test_index_basic_dynamic_collection(self): @self.connection.register class Movie(Document): skeleton = { 'other':{ 'deep':unicode, }, 'notindexed':unicode, } optional = { 'standard':unicode, } indexes = [ { 'fields':[('standard',1),('other.deep',1)], 'unique':True, }, ] self.col.Movie.generate_indexes() movie = self.col.Movie() movie['standard'] = u'test' movie['other']['deep'] = u'testdeep' movie['notindexed'] = u'notthere' movie.save() db = self.connection.test item = db['system.indexes'].find_one({'ns':'test.mongolite', 'name': 'standard_1_other.deep_1', 'unique':True}) assert item is not None, 'No Index Found' movie = self.col.Movie() movie['standard'] = u'test' movie['other']['deep'] = u'testdeep' self.assertRaises(OperationFailure, movie.save) self.connection.test.othercol.Movie.generate_indexes() db = self.connection.test item = db['system.indexes'].find_one({'ns':'test.othercol', 'name': 'standard_1_other.deep_1', 'unique':True}) assert item is not None, 'No Index Found' def test_index_single_without_generation(self): class Movie(Document): skeleton = { 'standard':unicode, } indexes = [ { 'fields':'standard', 'unique':True, }, ] self.connection.register([Movie]) movie = self.col.Movie() movie['standard'] = u'test' movie.save() db = self.connection.test item = db['system.indexes'].find_one({'ns':'test.mongolite', 'name':'standard_1', 'unique':True, 'key':{'standard':1}}) assert item is None, 'Index is found' def test_index_single(self): class Movie(Document): skeleton = { 'standard':unicode, } indexes = [ { 'fields':'standard', 'unique':True, }, ] self.connection.register([Movie]) self.col.Movie.generate_indexes() movie = self.col.Movie() movie['standard'] = u'test' movie.save() db = self.connection.test item = db['system.indexes'].find_one({'ns':'test.mongolite', 'name':'standard_1', 'unique':True, 'key':{'standard':1}}) assert item is not None, 'No Index Found' def test_index_multi(self): class Movie(Document): skeleton = { 'standard':unicode, 'other':{ 'deep':unicode, }, 'notindexed':unicode, 'alsoindexed':unicode, } indexes = [ { 'fields':'standard', 'unique':True, }, { 'fields':[('alsoindexed', 1), ('other.deep', -1)], 'unique':True, }, ] self.connection.register([Movie]) self.col.Movie.generate_indexes() movie = self.col.Movie() movie['standard'] = u'test' movie.save() db = self.connection.test item = db['system.indexes'].find_one({'ns':'test.mongolite', 'name':'standard_1', 'unique':True, 'key':{'standard':1}}) index2 = db['system.indexes'].find_one({'ns':'test.mongolite', 'name': 'alsoindexed_1_other.deep_-1', 'unique':True}) assert item is not None, 'No Index Found' assert index2 is not None, 'Index not found' movie = self.col.Movie() movie['standard'] = u'test' self.assertRaises(OperationFailure, movie.save) def test_index_multi2(self): class Movie(Document): skeleton = { 'standard':unicode, 'other':{ 'deep':unicode, }, 'notindexed':unicode, 'alsoindexed':unicode, } indexes = [ { 'fields':'standard', 'unique':True, }, { 'fields':'other.deep', 'unique':True, }, ] self.connection.register([Movie]) self.col.Movie.generate_indexes() movie = self.col.Movie() movie['standard'] = u'test' movie['other']['deep'] = u'foo' movie.save() db = self.connection.test item = db['system.indexes'].find_one({'ns':'test.mongolite', 'name':'standard_1', 'unique':True, 'key':{'standard':1}}) index2 = db['system.indexes'].find_one({'ns':'test.mongolite', 'name': 'other.deep_1', 'unique':True}) assert item is not None, 'No Index Found' assert index2 is not None, 'Index not found' movie = self.col.Movie() movie['standard'] = u'test' self.assertRaises(OperationFailure, movie.save) movie = self.col.Movie() movie['other']['deep'] = u'foo' self.assertRaises(OperationFailure, movie.save) def test_index_direction(self): class Movie(Document): skeleton = { 'standard':unicode, 'other':{ 'deep':unicode, }, 'notindexed':unicode, 'alsoindexed':unicode, } indexes = [ { 'fields':[('standard',INDEX_DESCENDING)], 'unique':True, }, { 'fields':[('alsoindexed',INDEX_ASCENDING), ('other.deep',INDEX_DESCENDING)], 'unique':True, }, ] self.connection.register([Movie]) self.col.Movie.generate_indexes() movie = self.col.Movie() movie['standard'] = u'test' movie.save() db = self.connection.test index1 = db['system.indexes'].find_one({'ns':'test.mongolite', 'name':'standard_-1', 'unique':True}) index2 = db['system.indexes'].find_one({'ns':'test.mongolite', 'name': 'alsoindexed_1_other.deep_-1', 'unique':True}) assert index1 is not None, 'No Index Found' assert index2 is not None, 'Index not found' def test_index_direction_GEO2D(self): class Movie(Document): skeleton = { 'standard':unicode, 'other':{ 'deep':unicode, }, 'notindexed':unicode, 'alsoindexed':unicode, } indexes = [ { 'fields':[('standard',INDEX_GEO2D)], 'unique':True, }, { 'fields':[('alsoindexed',INDEX_GEO2D), ('other.deep',INDEX_DESCENDING)], 'unique':True, }, ] self.connection.register([Movie]) self.col.Movie.generate_indexes() movie = self.col.Movie() movie['standard'] = u'test' movie.save() db = self.connection.test index1 = db['system.indexes'].find_one({'ns':'test.mongolite', 'name':'standard_2d', 'unique':True}) index2 = db['system.indexes'].find_one({'ns':'test.mongolite', 'name': 'alsoindexed_2d_other.deep_-1', 'unique':True}) assert index1 is not None, 'No Index Found' assert index2 is not None, 'Index not found' def test_bad_index_descriptor(self): failed = False try: class Movie(Document): skeleton = {'standard':unicode} indexes = [{'unique':True}] except BadIndexError, e: self.assertEqual(str(e), "`fields` key must be specify in indexes") failed = True self.assertEqual(failed, True) failed = False try: class Movie(Document): skeleton = { 'standard':unicode, } indexes = [ { 'fields':'std', }, ] except ValueError, e: self.assertEqual(str(e), "Error in indexes: can't find std in skeleton or optional") failed = True
class 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 InheritanceTestCase(unittest.TestCase): def setUp(self): self.connection = Connection() self.col = self.connection['test']['mongolite'] def tearDown(self): self.connection['test'].drop_collection('mongolite') def test_simple_inheritance(self): class A(SchemaDocument): skeleton = { "a":{"foo":int} } class B(A): skeleton = { "b":{"bar":unicode} } assert B() == {"a":{"foo":None}, "b":{"bar":None}}, B() def test_simple_inheritance_with_only_optional(self): class A(SchemaDocument): optional = { 'optfoo': int, } class B(A): optional = { 'optbar': float, } self.assertEqual(B(), {'optfoo':None, 'optbar':None}) def test_simple_inheritance_with_optional(self): class A(SchemaDocument): skeleton = { 'reqfoo': unicode, } optional = { 'optfoo': int, } class B(A): optional = { 'optbar': float, } self.assertEqual(B(), {'reqfoo':None, 'optfoo':None, 'optbar':None}) def test_gen_doc(self): class A(SchemaDocument): skeleton = { 'reqfoo': unicode, } optional = { 'optfoo': int, } class B(A): """this is a test doc""" optional = { 'optbar': float, } self.assertEqual(B.__doc__, """this is a test doc required fields: { reqfoo : <type 'unicode'> } optional fields: { optbar : <type 'float'> optfoo : <type 'int'> } """) def test_default_values_inheritance(self): class A(SchemaDocument): skeleton = { "a":{"foo":int} } default_values = {"a.foo":3} class B(A): skeleton = { "b":{"bar":unicode} } assert B() == {"a":{"foo":3}, "b":{"bar":None}} class C(A): skeleton = { "c":{"spam":unicode} } default_values = {"a.foo":5} assert C() == {"a":{"foo":5}, "c":{"spam":None}}, C() def test_default_values_inheritance_with_optional(self): class A(SchemaDocument): skeleton = { "a":{"foo":int} } optional = { "bar": int } default_values = {"a.foo":3, "bar": 42} class B(A): skeleton = { "b":{"bar":unicode} } assert B() == {"a":{"foo":3}, "b":{"bar":None}, "bar": 42} class C(A): skeleton = { "c":{"spam":unicode} } optional = { "bla": unicode, } default_values = {"a.foo":5, "bla": u"foo"} assert C() == {"a":{"foo":5}, "c":{"spam":None}, "bar": 42, "bla": u"foo"}, C() def test_default_values_inheritance_with_function(self): from datetime import datetime class A(SchemaDocument): skeleton = { "a":{"foo":datetime} } default_values = {"a.foo":datetime.utcnow} class B(A): skeleton = { "b":{"bar":unicode} } assert isinstance(B()['a']['foo'], datetime) class C(A): skeleton = { "c":{"spam":unicode} } default_values = {"a.foo":datetime(2008,8,8)} assert C() == {"a":{"foo":datetime(2008, 8, 8)}, "c":{"spam":None}}, C() def test_complete_inheritance(self): class A(SchemaDocument): skeleton = { "a":{"foo":int} } default_values = {"a.foo":3} class B(A): skeleton = { "b":{"bar":unicode} } default_values = {"a.foo":5} b = B() assert b == {"a":{"foo":5}, "b":{"bar":None}} class C(B): skeleton = { "c":{"spam":unicode} } c = C() assert c == {"a":{"foo":5}, "b":{"bar":None}, "c":{"spam":None}}, C() def test_polymorphism(self): class A(SchemaDocument): skeleton = { "a":{"foo":int} } default_values = {"a.foo":3} class B(SchemaDocument): skeleton = { "b":{"bar":unicode} } required_fields = ['b.bar'] b = B() assert b == {"b":{"bar":None}} class C(A,B): skeleton = { "c":{"spam":unicode} } default_values = {"a.foo":5} c = C() assert c == {"a":{"foo":5}, "b":{"bar":None}, "c":{"spam":None}}, C() def test_simple_manual_inheritance(self): class A(SchemaDocument): auto_inheritance = False skeleton = { "a":{"foo":int} } class B(A): skeleton = { "b":{"bar":unicode} } skeleton.update(A.skeleton) assert B() == {"a":{"foo":None}, "b":{"bar":None}} def test_default_values_manual_inheritance(self): class A(SchemaDocument): auto_inheritance = False skeleton = { "a":{"foo":int} } default_values = {"a.foo":3} class B(A): skeleton = { "b":{"bar":unicode} } skeleton.update(A.skeleton) default_values = A.default_values assert B() == {"a":{"foo":3}, "b":{"bar":None}} class C(A): skeleton = { "c":{"spam":unicode} } skeleton.update(A.skeleton) default_values = A.default_values default_values.update({"a.foo":5}) assert C() == {"a":{"foo":5}, "c":{"spam":None}}, C() def test_inheritance_with_document(self): class Doc(Document): skeleton = { "doc":{'bla':int}, } class DocA(Doc): skeleton = { "doc_a":{'foo':int}, } class DocB(DocA): skeleton = { "doc_b":{"bar":int}, } self.connection.register([Doc, DocA, DocB]) assert self.col.DocA() == {'doc': {'bla': None}, 'doc_a': {'foo': None}} assert self.col.DocB() == {'doc': {'bla': None}, 'doc_b': {'bar': None}, 'doc_a': {'foo': None}} # creating DocA for i in range(10): mydoc = self.col.DocA() mydoc['doc']["bla"] = i+1 mydoc['doc_a']["foo"] = i mydoc.save() assert self.col.find_one({'_id':mydoc['_id']}) == {u'doc': {u'bla': 10}, u'_id': mydoc['_id'], u'doc_a': {u'foo': 9}} # creating DocB for i in range(5): mydoc = self.col.DocB() mydoc['doc']["bla"] = i+1 mydoc['doc_a']["foo"] = i mydoc['doc_b']["bar"] = i+2 mydoc.save() assert self.col.find_one({'_id':mydoc['_id']}) == {u'doc': {u'bla': 5}, u'_id': mydoc['_id'], u'doc_b': {u'bar': 6}, u'doc_a': {u'foo': 4}}
class 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 StructureTestCase(unittest.TestCase): def setUp(self): self.connection = Connection() self.col = self.connection['test']['mongolite'] def tearDown(self): self.connection['test'].drop_collection('mongolite') def test_no_skeleton(self): class MyDoc(SchemaDocument): pass doc = MyDoc() self.assertEqual(doc, {}) def test_empty_skeleton(self): class MyDoc(SchemaDocument): skeleton = {} self.assertEqual(MyDoc(), {}) def test_skeleton_not_dict(self): failed = False try: class MyDoc(SchemaDocument): skeleton = 3 except StructureError: failed = True self.assertEqual(failed, True) def test_load_with_dict(self): doc = {"foo":1, "bla":{"bar":u"spam"}} class MyDoc(SchemaDocument): skeleton = {"foo":int, "bla":{"bar":unicode}} mydoc = MyDoc(doc) self.assertEqual(mydoc, doc) def test_simple_skeleton(self): class MyDoc(SchemaDocument): skeleton = { "foo":unicode, "bar":int } self.assertEqual(MyDoc(), {"foo":None, "bar":None}) def test_simple_skeleton_and_optional(self): class MyDoc(SchemaDocument): skeleton = { 'reqfoo': unicode, } optional = { 'optfoo': int, } self.assertEqual(MyDoc(), {'reqfoo':None, 'optfoo':None}) def test_missed_field(self): doc = {"foo":u"arf"} class MyDoc(SchemaDocument): skeleton = { "foo":unicode, "bar":{"bla":int} } mydoc = MyDoc(doc) self.assertEqual(mydoc, {'foo': u'arf'}) def test_unknown_field(self): class MyDoc(SchemaDocument): skeleton = { "foo":unicode, } mydoc = MyDoc() self.assertEqual(mydoc, {'foo':None}) def test_None(self): class MyDoc(SchemaDocument): skeleton = { "foo":None, "bar":{ "bla":None } } mydoc = MyDoc() self.assertEqual(mydoc, {'foo': None, 'bar': {'bla': None}}) def test_big_nested_skeleton(self): class MyDoc(SchemaDocument): skeleton = { "1":{ "2":{ "3":{ "4":{ "5":{ "6":{ "7":int, "8":{ unicode:{int:int} } } } } } } } } mydoc = MyDoc() self.assertEqual(mydoc._namespaces, ['1', '1.2', '1.2.3', '1.2.3.4', '1.2.3.4.5', '1.2.3.4.5.6', '1.2.3.4.5.6.8', '1.2.3.4.5.6.8.$unicode', '1.2.3.4.5.6.8.$unicode.$int', '1.2.3.4.5.6.7']) self.assertEqual(mydoc, {'1': {'2': {'3': {'4': {'5': {'6': {'8': {}, '7': None}}}}}}}) def test_big_nested_skeleton_mongo_document(self): class MyDoc(Document): skeleton = { "1":{ "2":{ "3":{ "4":{ "5":{ "6":{ "7":int, "8":{ unicode:{unicode:int} } } } } } } } } self.connection.register([MyDoc]) mydoc = self.col.MyDoc() self.assertEqual(mydoc, {'1': {'2': {'3': {'4': {'5': {'6': {'8': {}, '7': None}}}}}}}) self.assertEqual(mydoc._namespaces, ['1', '1.2', '1.2.3', '1.2.3.4', '1.2.3.4.5', '1.2.3.4.5.6', '1.2.3.4.5.6.8', '1.2.3.4.5.6.8.$unicode', '1.2.3.4.5.6.8.$unicode.$unicode', '1.2.3.4.5.6.7']) mydoc['1']['2']['3']['4']['5']['6']['7'] = 8 mydoc['1']['2']['3']['4']['5']['6']['8'] = {u"bla":{"3":u"bla"}} mydoc.save() def test_field_changed(self): class MyDoc(Document): skeleton = { 'foo':int, 'bar':unicode, } self.connection.register([MyDoc]) doc = self.col.MyDoc() doc['foo'] = 3 doc.save() class MyDoc(Document): skeleton = { 'foo':int, 'arf': unicode, } self.connection.register([MyDoc]) fetched_doc = self.col.MyDoc.find_one() fetched_doc['foo'] = 2 fetched_doc.save() def test_exception_bad_skeleton(self): import datetime failed = False try: class MyDoc(SchemaDocument): skeleton = { 'topic': unicode, 'when': datetime.datetime.utcnow, } except TypeError, e: assert str(e).startswith("MyDoc: <built-in method utcnow of type object at "), str(e) assert str(e).endswith("is not a type") failed = True self.assertEqual(failed, True)
class IndexTestCase(unittest.TestCase): def setUp(self): self.connection = Connection(safe=True) self.col = self.connection['test']['mongolite'] def tearDown(self): self.connection['test'].drop_collection('mongolite') self.connection = None def test_index_basic(self): @self.connection.register class Movie(Document): skeleton = { 'other': { 'deep': unicode, }, 'notindexed': unicode, } optional = { 'standard': unicode, } indexes = [ { 'fields': [('standard', 1), ('other.deep', 1)], 'unique': True, }, ] self.col.Movie.generate_indexes() movie = self.col.Movie() movie['standard'] = u'test' movie['other']['deep'] = u'testdeep' movie['notindexed'] = u'notthere' movie.save() db = self.connection.test item = db['system.indexes'].find_one({ 'ns': 'test.mongolite', 'name': 'standard_1_other.deep_1', 'unique': True }) assert item is not None, 'No Index Found' movie = self.col.Movie() movie['standard'] = u'test' movie['other']['deep'] = u'testdeep' self.assertRaises(OperationFailure, movie.save) def test_index_basic_dynamic_collection(self): @self.connection.register class Movie(Document): skeleton = { 'other': { 'deep': unicode, }, 'notindexed': unicode, } optional = { 'standard': unicode, } indexes = [ { 'fields': [('standard', 1), ('other.deep', 1)], 'unique': True, }, ] self.col.Movie.generate_indexes() movie = self.col.Movie() movie['standard'] = u'test' movie['other']['deep'] = u'testdeep' movie['notindexed'] = u'notthere' movie.save() db = self.connection.test item = db['system.indexes'].find_one({ 'ns': 'test.mongolite', 'name': 'standard_1_other.deep_1', 'unique': True }) assert item is not None, 'No Index Found' movie = self.col.Movie() movie['standard'] = u'test' movie['other']['deep'] = u'testdeep' self.assertRaises(OperationFailure, movie.save) self.connection.test.othercol.Movie.generate_indexes() db = self.connection.test item = db['system.indexes'].find_one({ 'ns': 'test.othercol', 'name': 'standard_1_other.deep_1', 'unique': True }) assert item is not None, 'No Index Found' def test_index_single_without_generation(self): class Movie(Document): skeleton = { 'standard': unicode, } indexes = [ { 'fields': 'standard', 'unique': True, }, ] self.connection.register([Movie]) movie = self.col.Movie() movie['standard'] = u'test' movie.save() db = self.connection.test item = db['system.indexes'].find_one({ 'ns': 'test.mongolite', 'name': 'standard_1', 'unique': True, 'key': { 'standard': 1 } }) assert item is None, 'Index is found' def test_index_single(self): class Movie(Document): skeleton = { 'standard': unicode, } indexes = [ { 'fields': 'standard', 'unique': True, }, ] self.connection.register([Movie]) self.col.Movie.generate_indexes() movie = self.col.Movie() movie['standard'] = u'test' movie.save() db = self.connection.test item = db['system.indexes'].find_one({ 'ns': 'test.mongolite', 'name': 'standard_1', 'unique': True, 'key': { 'standard': 1 } }) assert item is not None, 'No Index Found' def test_index_multi(self): class Movie(Document): skeleton = { 'standard': unicode, 'other': { 'deep': unicode, }, 'notindexed': unicode, 'alsoindexed': unicode, } indexes = [ { 'fields': 'standard', 'unique': True, }, { 'fields': [('alsoindexed', 1), ('other.deep', -1)], 'unique': True, }, ] self.connection.register([Movie]) self.col.Movie.generate_indexes() movie = self.col.Movie() movie['standard'] = u'test' movie.save() db = self.connection.test item = db['system.indexes'].find_one({ 'ns': 'test.mongolite', 'name': 'standard_1', 'unique': True, 'key': { 'standard': 1 } }) index2 = db['system.indexes'].find_one({ 'ns': 'test.mongolite', 'name': 'alsoindexed_1_other.deep_-1', 'unique': True }) assert item is not None, 'No Index Found' assert index2 is not None, 'Index not found' movie = self.col.Movie() movie['standard'] = u'test' self.assertRaises(OperationFailure, movie.save) def test_index_multi2(self): class Movie(Document): skeleton = { 'standard': unicode, 'other': { 'deep': unicode, }, 'notindexed': unicode, 'alsoindexed': unicode, } indexes = [ { 'fields': 'standard', 'unique': True, }, { 'fields': 'other.deep', 'unique': True, }, ] self.connection.register([Movie]) self.col.Movie.generate_indexes() movie = self.col.Movie() movie['standard'] = u'test' movie['other']['deep'] = u'foo' movie.save() db = self.connection.test item = db['system.indexes'].find_one({ 'ns': 'test.mongolite', 'name': 'standard_1', 'unique': True, 'key': { 'standard': 1 } }) index2 = db['system.indexes'].find_one({ 'ns': 'test.mongolite', 'name': 'other.deep_1', 'unique': True }) assert item is not None, 'No Index Found' assert index2 is not None, 'Index not found' movie = self.col.Movie() movie['standard'] = u'test' self.assertRaises(OperationFailure, movie.save) movie = self.col.Movie() movie['other']['deep'] = u'foo' self.assertRaises(OperationFailure, movie.save) def test_index_direction(self): class Movie(Document): skeleton = { 'standard': unicode, 'other': { 'deep': unicode, }, 'notindexed': unicode, 'alsoindexed': unicode, } indexes = [ { 'fields': [('standard', INDEX_DESCENDING)], 'unique': True, }, { 'fields': [('alsoindexed', INDEX_ASCENDING), ('other.deep', INDEX_DESCENDING)], 'unique': True, }, ] self.connection.register([Movie]) self.col.Movie.generate_indexes() movie = self.col.Movie() movie['standard'] = u'test' movie.save() db = self.connection.test index1 = db['system.indexes'].find_one({ 'ns': 'test.mongolite', 'name': 'standard_-1', 'unique': True }) index2 = db['system.indexes'].find_one({ 'ns': 'test.mongolite', 'name': 'alsoindexed_1_other.deep_-1', 'unique': True }) assert index1 is not None, 'No Index Found' assert index2 is not None, 'Index not found' def test_index_direction_GEO2D(self): class Movie(Document): skeleton = { 'standard': unicode, 'other': { 'deep': unicode, }, 'notindexed': unicode, 'alsoindexed': unicode, } indexes = [ { 'fields': [('standard', INDEX_GEO2D)], 'unique': True, }, { 'fields': [('alsoindexed', INDEX_GEO2D), ('other.deep', INDEX_DESCENDING)], 'unique': True, }, ] self.connection.register([Movie]) self.col.Movie.generate_indexes() movie = self.col.Movie() movie['standard'] = u'test' movie.save() db = self.connection.test index1 = db['system.indexes'].find_one({ 'ns': 'test.mongolite', 'name': 'standard_2d', 'unique': True }) index2 = db['system.indexes'].find_one({ 'ns': 'test.mongolite', 'name': 'alsoindexed_2d_other.deep_-1', 'unique': True }) assert index1 is not None, 'No Index Found' assert index2 is not None, 'Index not found' def test_bad_index_descriptor(self): failed = False try: class Movie(Document): skeleton = {'standard': unicode} indexes = [{'unique': True}] except BadIndexError, e: self.assertEqual(str(e), "`fields` key must be specify in indexes") failed = True self.assertEqual(failed, True) failed = False try: class Movie(Document): skeleton = { 'standard': unicode, } indexes = [ { 'fields': 'std', }, ] except ValueError, e: self.assertEqual( str(e), "Error in indexes: can't find std in skeleton or optional") failed = True
class 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 InheritanceTestCase(unittest.TestCase): def setUp(self): self.connection = Connection() self.col = self.connection['test']['mongolite'] def tearDown(self): self.connection['test'].drop_collection('mongolite') def test_simple_inheritance(self): class A(SchemaDocument): skeleton = {"a": {"foo": int}} class B(A): skeleton = {"b": {"bar": unicode}} assert B() == {"a": {"foo": None}, "b": {"bar": None}}, B() def test_simple_inheritance_with_only_optional(self): class A(SchemaDocument): optional = { 'optfoo': int, } class B(A): optional = { 'optbar': float, } self.assertEqual(B(), {'optfoo': None, 'optbar': None}) def test_simple_inheritance_with_optional(self): class A(SchemaDocument): skeleton = { 'reqfoo': unicode, } optional = { 'optfoo': int, } class B(A): optional = { 'optbar': float, } self.assertEqual(B(), {'reqfoo': None, 'optfoo': None, 'optbar': None}) def test_gen_doc(self): class A(SchemaDocument): skeleton = { 'reqfoo': unicode, } optional = { 'optfoo': int, } class B(A): """this is a test doc""" optional = { 'optbar': float, } self.assertEqual( B.__doc__, """this is a test doc required fields: { reqfoo : <type 'unicode'> } optional fields: { optbar : <type 'float'> optfoo : <type 'int'> } """) def test_default_values_inheritance(self): class A(SchemaDocument): skeleton = {"a": {"foo": int}} default_values = {"a.foo": 3} class B(A): skeleton = {"b": {"bar": unicode}} assert B() == {"a": {"foo": 3}, "b": {"bar": None}} class C(A): skeleton = {"c": {"spam": unicode}} default_values = {"a.foo": 5} assert C() == {"a": {"foo": 5}, "c": {"spam": None}}, C() def test_default_values_inheritance_with_optional(self): class A(SchemaDocument): skeleton = {"a": {"foo": int}} optional = {"bar": int} default_values = {"a.foo": 3, "bar": 42} class B(A): skeleton = {"b": {"bar": unicode}} assert B() == {"a": {"foo": 3}, "b": {"bar": None}, "bar": 42} class C(A): skeleton = {"c": {"spam": unicode}} optional = { "bla": unicode, } default_values = {"a.foo": 5, "bla": u"foo"} assert C() == { "a": { "foo": 5 }, "c": { "spam": None }, "bar": 42, "bla": u"foo" }, C() def test_default_values_inheritance_with_function(self): from datetime import datetime class A(SchemaDocument): skeleton = {"a": {"foo": datetime}} default_values = {"a.foo": datetime.utcnow} class B(A): skeleton = {"b": {"bar": unicode}} assert isinstance(B()['a']['foo'], datetime) class C(A): skeleton = {"c": {"spam": unicode}} default_values = {"a.foo": datetime(2008, 8, 8)} assert C() == { "a": { "foo": datetime(2008, 8, 8) }, "c": { "spam": None } }, C() def test_complete_inheritance(self): class A(SchemaDocument): skeleton = {"a": {"foo": int}} default_values = {"a.foo": 3} class B(A): skeleton = {"b": {"bar": unicode}} default_values = {"a.foo": 5} b = B() assert b == {"a": {"foo": 5}, "b": {"bar": None}} class C(B): skeleton = {"c": {"spam": unicode}} c = C() assert c == { "a": { "foo": 5 }, "b": { "bar": None }, "c": { "spam": None } }, C() def test_polymorphism(self): class A(SchemaDocument): skeleton = {"a": {"foo": int}} default_values = {"a.foo": 3} class B(SchemaDocument): skeleton = {"b": {"bar": unicode}} required_fields = ['b.bar'] b = B() assert b == {"b": {"bar": None}} class C(A, B): skeleton = {"c": {"spam": unicode}} default_values = {"a.foo": 5} c = C() assert c == { "a": { "foo": 5 }, "b": { "bar": None }, "c": { "spam": None } }, C() def test_simple_manual_inheritance(self): class A(SchemaDocument): auto_inheritance = False skeleton = {"a": {"foo": int}} class B(A): skeleton = {"b": {"bar": unicode}} skeleton.update(A.skeleton) assert B() == {"a": {"foo": None}, "b": {"bar": None}} def test_default_values_manual_inheritance(self): class A(SchemaDocument): auto_inheritance = False skeleton = {"a": {"foo": int}} default_values = {"a.foo": 3} class B(A): skeleton = {"b": {"bar": unicode}} skeleton.update(A.skeleton) default_values = A.default_values assert B() == {"a": {"foo": 3}, "b": {"bar": None}} class C(A): skeleton = {"c": {"spam": unicode}} skeleton.update(A.skeleton) default_values = A.default_values default_values.update({"a.foo": 5}) assert C() == {"a": {"foo": 5}, "c": {"spam": None}}, C() def test_inheritance_with_document(self): class Doc(Document): skeleton = { "doc": { 'bla': int }, } class DocA(Doc): skeleton = { "doc_a": { 'foo': int }, } class DocB(DocA): skeleton = { "doc_b": { "bar": int }, } self.connection.register([Doc, DocA, DocB]) assert self.col.DocA() == { 'doc': { 'bla': None }, 'doc_a': { 'foo': None } } assert self.col.DocB() == { 'doc': { 'bla': None }, 'doc_b': { 'bar': None }, 'doc_a': { 'foo': None } } # creating DocA for i in range(10): mydoc = self.col.DocA() mydoc['doc']["bla"] = i + 1 mydoc['doc_a']["foo"] = i mydoc.save() assert self.col.find_one({'_id': mydoc['_id']}) == { u'doc': { u'bla': 10 }, u'_id': mydoc['_id'], u'doc_a': { u'foo': 9 } } # creating DocB for i in range(5): mydoc = self.col.DocB() mydoc['doc']["bla"] = i + 1 mydoc['doc_a']["foo"] = i mydoc['doc_b']["bar"] = i + 2 mydoc.save() assert self.col.find_one({'_id': mydoc['_id']}) == { u'doc': { u'bla': 5 }, u'_id': mydoc['_id'], u'doc_b': { u'bar': 6 }, u'doc_a': { u'foo': 4 } }
class 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')