def update(self, document=None, safe=True, callback=None):
        """Update a document

        :Parameters:
        - `safe` (optional): safe update operation
        - `callback` : method which will be called when update is finished
        """
        pre_update.send(instance=self)

        if not document:
            document = self.as_dict()

        database = Database()
        collection_name = database.get_collection_name(self.__collection__)
        spec = {'_id': self._id}

        message_update = message.update(collection_name, False,
                False, spec, document, safe, {})

        response, error = yield gen.Task(database.send_message, message_update)

        post_update.send(instance=self)

        if callback:
            callback((response, error))

    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)

    def tearDown(self):
        super(SignalTestCase, self).tearDown()

        class CollectionTest(Collection):
            __collection__ = "collection_test"

        CollectionTest.objects.truncate(callback=self.stop)
        self.wait()
        Database.disconnect()

    def _insert_document(self, document):
        message_insert = message.insert('mongotor_test.cursor_test', [document],
            True, True, {})

        node = Database().get_node(ReadPreference.PRIMARY)
        node.connection(self.stop)
        connection = self.wait()

        connection.send_message(message_insert, with_last_error=True, callback=self.stop)
        self.wait()

    def tearDown(self):
        super(CursorTestCase, self).tearDown()

        # delete all documents
        message_delete = message.delete('mongotor_test.cursor_test',
            {}, True, {})
        Database().send_message(message_delete, callback=self.stop)
        self.wait()

        Database.disconnect()

    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_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)

    def tearDown(self):
        super(CursorTestCase, self).tearDown()

        # delete all documents
        message_delete = message.delete('mongotor_test.cursor_test',
            {}, True, {})

        node = Database().get_node(ReadPreference.PRIMARY)
        node.connection(self.stop)
        connection = self.wait()

        connection.send_message(message_delete, with_last_error=True, callback=self.stop)
        self.wait()

        Database.disconnect()

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

    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"
        )

    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)

    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_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

    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_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))

    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 save(self, safe=True, callback=None):
        """Save a document

        :Parameters:
        - `safe` (optional): safe insert operation 
        - `callback` : method which will be called when save is finished
        """
        pre_save.send(instance=self)

        database = Database()
        collection_name = database.get_collection_name(self.__collection__)

        message_insert = message.insert(collection_name, [self.as_dict()],
            True, safe, {})

        response, error = yield gen.Task(database.send_message, message_insert)

        post_save.send(instance=self)

        if callback:
            callback((response, error))

    def remove(self, safe=True, callback=None):
        """Remove a document

        :Parameters:
        - `safe` (optional): safe remove operation
        - `callback` : method which will be called when remove is finished
        """
        pre_remove.send(instance=self)

        database = Database()
        collection_name = database.get_collection_name(self.__collection__)

        message_delete = message.delete(collection_name, {'_id': self._id},
            safe, {})

        response, error = yield gen.Task(database.send_message, message_delete)

        post_remove.send(instance=self)

        if callback:
            callback((response, error))