def test_not_raise_when_database_was_initiated(self): """[DatabaseTestCase] - Not raises ValueError when connect to inititated database""" database1 = Database.init("localhost:27027", dbname='test') database2 = Database.init("localhost:27027", dbname='test') database1.should.be.equal(database2)
def test_raises_erro_when_use_collection_with_not_initialized_database( self): """[CollectionTestCase] - Raises DatabaseError when use collection with a not initialized database""" class CollectionTest(Collection): __collection__ = 'collection_test' Database.disconnect() CollectionTest().save.when.called_with(callback=None) \ .throw(DatabaseError, 'you must be initialize database before perform this action') Database.init(["localhost:27027", "localhost:27028"], dbname='test')
def test_raises_erro_when_use_collection_with_not_initialized_database(self): """[CollectionTestCase] - Raises DatabaseError when use collection with a not initialized database""" class CollectionTest(Collection): __collection__ = 'collection_test' Database.disconnect() CollectionTest().save.when.called_with(callback=None) \ .throw(DatabaseError, 'you must be initialize database before perform this action') Database.init(["localhost:27027", "localhost:27028"], dbname='test')
def test_count_documents_in_find(self): """[ClientTestCase] - counting documents in query""" db = Database.init(["localhost:27027", "localhost:27028"], dbname='test') documents = [{ '_id': ObjectId(), 'param': 'shouldbeparam1' }, { '_id': ObjectId(), 'param': 'shouldbeparam1' }, { '_id': ObjectId(), 'param': 'shouldbeparam2' }] db.collection_test.insert(documents, callback=self.stop) response, error = self.wait() db.collection_test.find({ "param": 'shouldbeparam1' }).count(callback=self.stop) total = self.wait() total.should.be.equal(2)
def test_find_document(self): """[ClientTestCase] - find a document""" db = Database.init(["localhost:27027", "localhost:27028"], dbname='test') documents = [{ '_id': ObjectId(), 'someflag': 1 }, { '_id': ObjectId(), 'someflag': 1 }, { '_id': ObjectId(), 'someflag': 2 }] db.collection_test.insert(documents, callback=self.stop) response, error = self.wait() db.collection_test.find({'someflag': 1}, callback=self.stop) response, error = self.wait() response[0]['_id'].should.be(documents[0]['_id']) response[1]['_id'].should.be(documents[1]['_id']) error.should.be.none
def test_insert_and_find_with_elemmatch(self): documents = [{ '_id': ObjectId(), 'name': 'should be name 1', 'comment': [{'author': 'joe'}, {'author': 'ana'}] }, { '_id': ObjectId(), 'name': 'should be name 2', 'comment': [{'author': 'ana'}] }] db = Database.init(["localhost:27027", "localhost:27028"], dbname='test') db.articles.insert(documents, callback=self.stop) self.wait() db.articles.find({'comment.author': 'joe'}, ('comment.$.author', ), limit=-1, callback=self.stop) result, _ = self.wait() keys = result.keys() keys.sort() keys.should.be.equal(['_id', 'comment']) str(result['_id']).should.be.equal(str(documents[0]['_id'])) result['comment'].should.have.length_of(1) result['comment'][0]['author'].should.be.equal('joe') _.should.be.none
def test_update_document(self): """[ClientTestCase] - update a document""" db = Database.init(["localhost:27027", "localhost:27028"], dbname='test') documents = [{ '_id': ObjectId(), 'name': 'shouldbename' }, { '_id': ObjectId(), 'name': 'shouldbename2' }] db.collection_test.insert(documents, callback=self.stop) response, error = self.wait() db.collection_test.update(documents[0], {'$set': { 'name': 'should be a new name' }}, callback=self.stop) response, error = self.wait() response['ok'].should.be.equal(1.0) error.should.be.none
def test_raises_error_when_could_not_find_node(self): """[DatabaseTestCase] - Raises DatabaseError when could not find valid nodes""" database = Database.init(["localhost:27030"], dbname="test") database.send_message.when.called_with("", callback=None).throw( DatabaseError, "could not find an available node" )
def test_find_one_document(self): """[ClientTestCase] - find one document""" db = Database.init(["localhost:27027", "localhost:27028"], dbname='test') documents = [{ '_id': ObjectId(), 'param': 'shouldbeparam' }, { '_id': ObjectId(), 'param': 'shouldbeparam1' }, { '_id': ObjectId(), 'param': 'shouldbeparam2' }] db.collection_test.insert(documents, callback=self.stop) response, error = self.wait() db.collection_test.find_one({'param': 'shouldbeparam1'}, callback=self.stop) response, error = self.wait() response['_id'].should.be(documents[1]['_id']) error.should.be.none
def test_distinct_all_documents(self): """[ClientTestCase] - distinct among all documents""" db = Database.init(["localhost:27027", "localhost:27028"], dbname='test') documents = [{ '_id': ObjectId(), 'param': 'shouldbeparam1', 'uuid': 100 }, { '_id': ObjectId(), 'param': 'shouldbeparam1', 'uuid': 100 }, { '_id': ObjectId(), 'param': 'shouldbeparam2', 'uuid': 200 }] db.collection_test.insert(documents, callback=self.stop) response, error = self.wait() db.collection_test.distinct('uuid', callback=self.stop) distincts = self.wait() distincts.should.have.length_of(2) distincts[0].should.be.equal(100) distincts[1].should.be.equal(200)
def test_send_test_message(self): """[DatabaseTestCase] - Send a test message to database""" Database.init(["localhost:27027", "localhost:27028"], dbname="test") object_id = ObjectId() message_test = message.query(0, "mongotor_test.$cmd", 0, 1, {"driverOIDTest": object_id}) Database().send_message(message_test, callback=self.stop) response, _ = self.wait() response = helpers._unpack_response(response) result = response["data"][0] result["oid"].should.be(object_id) result["ok"].should.be(1.0) result["str"].should.be(str(object_id))
def test_run_command(self): """[DatabaseTestCase] - Run a database command""" database = Database.init(["localhost:27027"], dbname='test') database.command('ismaster', callback=self.stop) response, error = self.wait() response['ok'].should.be.ok
def test_send_test_message(self): """[DatabaseTestCase] - Send a test message to database""" Database.init(["localhost:27027", "localhost:27028"], dbname='test') object_id = ObjectId() message_test = message.query(0, 'mongotor_test.$cmd', 0, 1, {'driverOIDTest': object_id}) Database().send_message(message_test, callback=self.stop) response, _ = self.wait() response = helpers._unpack_response(response) result = response['data'][0] result['oid'].should.be(object_id) result['ok'].should.be(1.0) result['str'].should.be(str(object_id))
def test_raises_error_when_could_not_find_node(self): """[DatabaseTestCase] - Raises DatabaseError when could not find valid nodes""" database = Database.init(["localhost:27030"], dbname='test') def send_message(): database.send_message('', callback=self.stop) self.wait() send_message.when.called.throw(DatabaseError, 'could not find an available node')
def test_aggregate_collection(self): """[ClientTestCase] - aggregate command""" db = Database.init(["localhost:27027", "localhost:27028"], dbname='test') documents = [{ "title": "this is my title", "author": "bob", "posted": datetime.now(), "pageViews": 5, "tags": ["good", "fun"], }, { "title": "this is my title", "author": "joe", "posted": datetime.now(), "pageViews": 5, "tags": ["good"], }] db.articles.insert(documents, callback=self.stop) response, error = self.wait() try: pipeline = { "$project": { "author": 1, "tags": 1, } }, { "$unwind": "$tags" }, { "$group": { "_id": { "tags": "$tags" }, "authors": { "$addToSet": "$author" } } } db.articles.aggregate(pipeline, callback=self.stop) response = self.wait() response['result'][0]['_id'].should.be.equal({u'tags': u'fun'}) response['result'][0]['authors'].should.be.equal([u'bob']) response['result'][1]['_id'].should.be.equal({u'tags': u'good'}) response['result'][1]['authors'].should.be.equal([u'joe', u'bob']) finally: db.articles.remove({}, callback=self.stop) self.wait()
def test_insert_a_single_document(self): """[ClientTestCase] - insert a single document with client""" db = Database.init(["localhost:27027", "localhost:27028"], dbname='test') document = {'_id': ObjectId(), 'name': 'shouldbename'} db.collection_test.insert(document, callback=self.stop) response, error = self.wait() response['ok'].should.be.equal(1.0) error.should.be.none
def test_aggregate_collection(self): """[ClientTestCase] - aggregate command""" db = Database.init(["localhost:27027", "localhost:27028"], dbname='test') documents = [{ "title": "this is my title", "author": "bob", "posted": datetime.now(), "pageViews": 5, "tags": ["good", "fun"], }, { "title": "this is my title", "author": "joe", "posted": datetime.now(), "pageViews": 5, "tags": ["good"], }] db.articles.insert(documents, callback=self.stop) response, error = self.wait() try: pipeline = { "$project": { "author": 1, "tags": 1, } }, { "$unwind": "$tags" }, { "$group": { "_id": {"tags": "$tags"}, "authors": {"$addToSet": "$author"} } } db.articles.aggregate(pipeline, callback=self.stop) response = self.wait() response['result'][0]['_id'].should.be.equal({u'tags': u'fun'}) response['result'][0]['authors'].should.be.equal([u'bob']) response['result'][1]['_id'].should.be.equal({u'tags': u'good'}) response['result'][1]['authors'].should.be.equal([u'joe', u'bob']) finally: db.articles.remove({}, callback=self.stop) self.wait()
def test_count_all_documents(self): """[ClientTestCase] - counting among all documents""" db = Database.init(["localhost:27027", "localhost:27028"], dbname='test') documents = [{'_id': ObjectId(), 'param': 'shouldbeparam1'}, {'_id': ObjectId(), 'param': 'shouldbeparam1'}, {'_id': ObjectId(), 'param': 'shouldbeparam2'}] db.collection_test.insert(documents, callback=self.stop) response, error = self.wait() db.collection_test.count(callback=self.stop) total = self.wait() total.should.be.equal(3)
def test_remove_document_by_spec(self): """[ClientTestCase] - remove a document by spec""" db = Database.init(["localhost:27027", "localhost:27028"], dbname='test') documents = [{'_id': ObjectId(), 'name': 'shouldbename'}, {'_id': ObjectId(), 'name': 'shouldbename2'}] db.collection_test.insert(documents, callback=self.stop) response, error = self.wait() db.collection_test.remove({'name': 'shouldbename'}, callback=self.stop) response, error = self.wait() response['ok'].should.be.equal(1.0) error.should.be.none
def test_find_on_secondary(self): """[SecondaryPreferredTestCase] - test find document from secondary""" db = Database.init(["localhost:27027", "localhost:27028"], dbname='test', read_preference=ReadPreference.SECONDARY_PREFERRED) db._connect(callback=self.stop) self.wait() doc = {'_id': ObjectId()} db.test.insert(doc, callback=self.stop) self.wait() time.sleep(2) db.test.find_one(doc, callback=self.stop) doc_found, error = self.wait() doc_found.should.be.eql(doc)
def test_raises_error_when_mode_is_secondary_and_secondary_is_down(self): """[ReplicaSetTestCase] - Raise error when mode is secondary and secondary is down""" os.system("make mongo-kill-node2") time.sleep(1) # stops are fast try: db = Database.init(["localhost:27027", "localhost:27028"], dbname="test") db._connect(callback=self.stop) self.wait() Database().send_message.when.called_with((None, ""), read_preference=ReadPreference.SECONDARY).throw( DatabaseError ) finally: os.system("make mongo-start-node2") time.sleep(5) # wait to become secondary again
def test_update_document(self): """[ClientTestCase] - update a document""" db = Database.init(["localhost:27027", "localhost:27028"], dbname='test') documents = [{'_id': ObjectId(), 'name': 'shouldbename'}, {'_id': ObjectId(), 'name': 'shouldbename2'}] db.collection_test.insert(documents, callback=self.stop) response, error = self.wait() db.collection_test.update(documents[0], {'$set': {'name': 'should be a new name'}}, callback=self.stop) response, error = self.wait() response['ok'].should.be.equal(1.0) error.should.be.none
def test_check_connections_when_use_cursors(self): """[ConnectionPoolTestCase] - check connections when use cursors""" db = Database.init('localhost:27027', dbname='test', maxconnections=10, maxusage=29) try: for i in range(2): db.cards.insert({'_id': ObjectId(), 'range': i}, callback=self.stop) self.wait() db._nodes[0].pool._connections.should.be.equal(0) db.cards.find({}, callback=self.stop) self.wait() db._nodes[0].pool._connections.should.be.equal(0) finally: Database.disconnect()
def test_raises_error_when_mode_is_secondary_and_secondary_is_down(self): """[ReplicaSetTestCase] - Raise error when mode is secondary and secondary is down""" os.system('make mongo-kill-node2') time.sleep(1) # stops are fast try: db = Database.init(["localhost:27027", "localhost:27028"], dbname='test') db._connect(callback=self.stop) self.wait() Database().send_message.when.called_with((None, ''), read_preference=ReadPreference.SECONDARY)\ .throw(DatabaseError) finally: os.system('make mongo-start-node2') time.sleep(5) # wait to become secondary again
def test_distinct_documents_in_find(self): """[ClientTestCase] - distinct documents in query""" db = Database.init(["localhost:27027", "localhost:27028"], dbname='test') documents = [{'_id': ObjectId(), 'param': 'shouldbeparam1', 'uuid': 100}, {'_id': ObjectId(), 'param': 'shouldbeparam1', 'uuid': 100}, {'_id': ObjectId(), 'param': 'shouldbeparam2', 'uuid': 200}] db.collection_test.insert(documents, callback=self.stop) response, error = self.wait() db.collection_test.find({"param": 'shouldbeparam1'}).distinct('uuid', callback=self.stop) distincts = self.wait() distincts.should.have.length_of(1) distincts[0].should.be.equal(100)
def test_find_document(self): """[ClientTestCase] - find a document""" db = Database.init(["localhost:27027", "localhost:27028"], dbname='test') documents = [{'_id': ObjectId(), 'someflag': 1}, {'_id': ObjectId(), 'someflag': 1}, {'_id': ObjectId(), 'someflag': 2}] db.collection_test.insert(documents, callback=self.stop) response, error = self.wait() db.collection_test.find({'someflag': 1}, callback=self.stop) response, error = self.wait() response[0]['_id'].should.be(documents[0]['_id']) response[1]['_id'].should.be(documents[1]['_id']) error.should.be.none
def test_find_one_document_by_id(self): """[ClientTestCase] - find one document by id""" db = Database.init(["localhost:27027", "localhost:27028"], dbname='test') documents = [{'_id': ObjectId(), 'param': 'shouldbeparam'}, {'_id': ObjectId(), 'param': 'shouldbeparam1'}, {'_id': ObjectId(), 'param': 'shouldbeparam2'}] db.collection_test.insert(documents, callback=self.stop) response, error = self.wait() db.collection_test.find_one(documents[2]['_id'], callback=self.stop) response, error = self.wait() response['_id'].should.be(documents[2]['_id']) error.should.be.none
def test_configure_nodes(self): """[ReplicaSetTestCase] - Configure nodes""" db = Database.init(["localhost:27027", "localhost:27028"], dbname='test') db._connect(callback=self.stop) self.wait() master_node = ReadPreference.select_primary_node(Database()._nodes) secondary_node = ReadPreference.select_node(Database()._nodes, mode=ReadPreference.SECONDARY) master_node.host.should.be('localhost') master_node.port.should.be(27027) secondary_node.host.should.be('localhost') secondary_node.port.should.be(27028) nodes = Database()._nodes nodes.should.have.length_of(2)
def test_group(self): """[ClientTestCase] - group command""" db = Database.init(["localhost:27027", "localhost:27028"], dbname='test') group = { 'key': None, 'condition': { 'author': 'joe' }, 'initial': { 'csum': 0 }, 'reduce': 'function(obj,prev){prev.csum+=obj.pageViews;}' } documents = [{ "title": "this is my title", "author": "bob", "posted": datetime.now(), "pageViews": 5, "tags": ["good", "fun"], }, { "title": "this is my title", "author": "joe", "posted": datetime.now(), "pageViews": 6, "tags": ["good"], }, { "title": "this is my title", "author": "joe", "posted": datetime.now(), "pageViews": 10, "tags": ["good"], }] db.articles.insert(documents, callback=self.stop) response, error = self.wait() try: db.articles.group(callback=self.stop, **group) result = self.wait() result['retval'][0]['csum'].should.be.equal(16) finally: db.articles.remove({}, callback=self.stop) self.wait()
def test_raises_error_when_mode_is_secondary_and_secondary_is_down(self): """[ReplicaSetTestCase] - Raise error when mode is secondary and secondary is down""" os.system('make mongo-kill > /dev/null 2>&1') os.system('make mongo-start-node1') os.system('make mongo-start-arbiter') time.sleep(10) try: db = Database.init(["localhost:27027", "localhost:27028"], dbname='test') db._connect(callback=self.stop) self.wait() Database().send_message.when.called_with((None, ''), read_preference=ReadPreference.SECONDARY)\ .throw(DatabaseError) finally: os.system('make mongo-start-node2') time.sleep(10)
def test_configure_nodes(self): """[ReplicaSetTestCase] - Configure nodes""" db = Database.init(["localhost:27027", "localhost:27028"], dbname='test') db._connect(callback=self.stop) self.wait() master_node = ReadPreference.select_primary_node(Database()._nodes) secondary_node = ReadPreference.select_node( Database()._nodes, mode=ReadPreference.SECONDARY) master_node.host.should.be('localhost') master_node.port.should.be(27027) secondary_node.host.should.be('localhost') secondary_node.port.should.be(27028) nodes = Database()._nodes nodes.should.have.length_of(2)
def test_remove_document_by_spec(self): """[ClientTestCase] - remove a document by spec""" db = Database.init(["localhost:27027", "localhost:27028"], dbname='test') documents = [{ '_id': ObjectId(), 'name': 'shouldbename' }, { '_id': ObjectId(), 'name': 'shouldbename2' }] db.collection_test.insert(documents, callback=self.stop) response, error = self.wait() db.collection_test.remove({'name': 'shouldbename'}, callback=self.stop) response, error = self.wait() response['ok'].should.be.equal(1.0) error.should.be.none
def test_group(self): """[ClientTestCase] - group command""" db = Database.init(["localhost:27027", "localhost:27028"], dbname='test') group = { 'key': None, 'condition': {'author': 'joe'}, 'initial': {'csum': 0}, 'reduce': 'function(obj,prev){prev.csum+=obj.pageViews;}' } documents = [{ "title": "this is my title", "author": "bob", "posted": datetime.now(), "pageViews": 5, "tags": ["good", "fun"], }, { "title": "this is my title", "author": "joe", "posted": datetime.now(), "pageViews": 6, "tags": ["good"], }, { "title": "this is my title", "author": "joe", "posted": datetime.now(), "pageViews": 10, "tags": ["good"], }] db.articles.insert(documents, callback=self.stop) response, error = self.wait() try: db.articles.group(callback=self.stop, **group) result = self.wait() result['retval'][0]['csum'].should.be.equal(16) finally: db.articles.remove({}, callback=self.stop) self.wait()
def test_insert_and_find_with_elemmatch(self): documents = [{ '_id': ObjectId(), 'name': 'should be name 1', 'comment': [{ 'author': 'joe' }, { 'author': 'ana' }] }, { '_id': ObjectId(), 'name': 'should be name 2', 'comment': [{ 'author': 'ana' }] }] db = Database.init(["localhost:27027", "localhost:27028"], dbname='test') db.articles.insert(documents, callback=self.stop) self.wait() db.articles.find({'comment.author': 'joe'}, ('comment.$.author', ), limit=-1, callback=self.stop) result, _ = self.wait() keys = result.keys() keys.sort() keys.should.be.equal(['_id', 'comment']) str(result['_id']).should.be.equal(str(documents[0]['_id'])) result['comment'].should.have.length_of(1) result['comment'][0]['author'].should.be.equal('joe') _.should.be.none
def test_check_connections_when_use_cursors(self): """[ConnectionPoolTestCase] - check connections when use cursors""" db = Database.init('localhost:27027', dbname='test', maxconnections=10, maxusage=29) try: for i in range(2): db.cards.insert({ '_id': ObjectId(), 'range': i }, callback=self.stop) self.wait() db._nodes[0].pool._connections.should.be.equal(0) db.cards.find({}, callback=self.stop) self.wait() db._nodes[0].pool._connections.should.be.equal(0) finally: Database.disconnect()
def test_disconnect_database(self): """[DatabaseTestCase] - Disconnect the database""" Database.init(["localhost:27027"], dbname='test') Database.disconnect() Database._instance.should.be.none
def setUp(self): super(CollectionTestCase, self).setUp() Database.init(["localhost:27027", "localhost:27028"], dbname='test')
def setUp(self): super(ManagerTestCase, self).setUp() Database.init(["localhost:27027", "localhost:27028"], dbname='mongotor_test')
def test_create_singleton_database_connection(self): """[DatabaseTestCase] - Create a singleton database connection""" database = Database.init("localhost:27027", dbname='test') database.should.be.equal(Database())
def test_raises_error_when_could_not_find_node(self): """[DatabaseTestCase] - Raises DatabaseError when could not find valid nodes""" database = Database.init(["localhost:27030"], dbname='test') database.send_message.when.called_with("", callback=None) \ .throw(DatabaseError, 'could not find an available node')
def setUp(self): super(SignalTestCase, self).setUp() SignalTestCase.signal_triggered = False Database.init(["localhost:27027", "localhost:27028"], dbname='mongotor_test')