Python Database.connect方法代码示例

# 需要导入模块: from mongotor.database import Database [as 别名]
# 或者: from mongotor.database.Database import connect [as 别名]
    def test_not_raise_when_database_was_initiated(self):
        """[DatabaseTestCase] - Not raises ValueError when connect to inititated database"""

        database1 = Database.connect("localhost:27027", dbname="test")
        database2 = Database.connect("localhost:27027", dbname="test")

        database1.should.be.equal(database2)

# 需要导入模块: from mongotor.database import Database [as 别名]
# 或者: from mongotor.database.Database import connect [as 别名]
    def test_raises_erro_when_use_collection_with_not_connected_database(self):
        """[CollectionTestCase] - Raises DatabaseError when use collection with a not connected database"""

        class CollectionTest(Collection):
            __collection__ = 'collection_test'

        Database.disconnect()
        CollectionTest().save.when.called_with(callback=None) \
            .throw(DatabaseError, 'you must be connect')

        Database.connect(["localhost:27027", "localhost:27028"], dbname='test')

# 需要导入模块: from mongotor.database import Database [as 别名]
# 或者: from mongotor.database.Database import connect [as 别名]
    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(2)

        Database.connect(["localhost:27027", "localhost:27028"], dbname='test')
        Database().send_message.when.called_with('',
            read_preference=ReadPreference.SECONDARY)\
            .throw(DatabaseError)

        os.system('make mongo-start-node2')
        time.sleep(10)

# 需要导入模块: from mongotor.database import Database [as 别名]
# 或者: from mongotor.database.Database import connect [as 别名]
    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.connect(["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

# 需要导入模块: from mongotor.database import Database [as 别名]
# 或者: from mongotor.database.Database import connect [as 别名]
    def test_raises_error_when_could_not_find_node(self):
        """[DatabaseTestCase] - Raises DatabaseError when could not find valid nodes"""

        database = Database.connect(["localhost:27030"], dbname="test")
        database.send_message.when.called_with("", callback=None).throw(
            DatabaseError, "could not find an available node"
        )

# 需要导入模块: from mongotor.database import Database [as 别名]
# 或者: from mongotor.database.Database import connect [as 别名]
    def test_configure_nodes(self):
        """[ReplicaSetTestCase] - Configure nodes"""

        Database.connect(["localhost:27027", "localhost:27028"], dbname='test')

        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)

# 需要导入模块: from mongotor.database import Database [as 别名]
# 或者: from mongotor.database.Database import connect [as 别名]
    def test_send_test_message(self):
        """[DatabaseTestCase] - Send a test message to database"""

        Database.connect(["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, error = self.wait()

        result = response["data"][0]

        result["oid"].should.be(object_id)
        result["ok"].should.be(1.0)
        result["str"].should.be(str(object_id))

# 需要导入模块: from mongotor.database import Database [as 别名]
# 或者: from mongotor.database.Database import connect [as 别名]
    def test_run_command(self):
        """[DatabaseTestCase] - Run a database command"""

        database = Database.connect(["localhost:27027"], dbname="test")
        database.command("ismaster", callback=self.stop)

        response, error = self.wait()
        response["ok"].should.be.ok

# 需要导入模块: from mongotor.database import Database [as 别名]
# 或者: from mongotor.database.Database import connect [as 别名]
    def test_send_test_message(self):
        """[DatabaseTestCase] - Send a test message to database"""

        Database.connect(["localhost:27017"], dbname='test')

        object_id = ObjectId()
        message_test = message.query(0, 'mongotor_test.$cmd', 0, 1,
            {'driverOIDTest': object_id})

        Database().send_message(message_test, self.stop)
        response, error = self.wait()

        result = response['data'][0]

        result['oid'].should.be(object_id)
        result['ok'].should.be(1.0)
        result['str'].should.be(str(object_id))

# 需要导入模块: from mongotor.database import Database [as 别名]
# 或者: from mongotor.database.Database import connect [as 别名]
    def test_insert_a_single_document(self):
        """[ClientTestCase] - insert a single document with client"""

        db = Database.connect(["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

# 需要导入模块: from mongotor.database import Database [as 别名]
# 或者: from mongotor.database.Database import connect [as 别名]
    def test_find_on_secondary(self):
        """[SecondaryPreferredTestCase] - test find document from secondary"""
        db = Database.connect(["localhost:27027", "localhost:27028"], dbname='test',
            read_preference=ReadPreference.SECONDARY_PREFERRED)

        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)

# 需要导入模块: from mongotor.database import Database [as 别名]
# 或者: from mongotor.database.Database import connect [as 别名]
    def test_aggregate_collection(self):
        """[ClientTestCase] - aggregate command"""
        db = Database.connect(["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()

# 需要导入模块: from mongotor.database import Database [as 别名]
# 或者: from mongotor.database.Database import connect [as 别名]
    def test_count_all_documents(self):
        """[ClientTestCase] - counting among all documents"""
        db = Database.connect(["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)

# 需要导入模块: from mongotor.database import Database [as 别名]
# 或者: from mongotor.database.Database import connect [as 别名]
    def test_remove_document_by_spec(self):
        """[ClientTestCase] - remove a document by spec"""
        db = Database.connect(["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

# 需要导入模块: from mongotor.database import Database [as 别名]
# 或者: from mongotor.database.Database import connect [as 别名]
    def test_distinct_documents_in_find(self):
        """[ClientTestCase] - distinct documents in query"""
        db = Database.connect(["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)