Python Connection.slave_okay方法代码示例

本文整理汇总了Python中pymongo.connection.Connection.slave_okay方法的典型用法代码示例。如果您正苦于以下问题：Python Connection.slave_okay方法的具体用法？Python Connection.slave_okay怎么用？Python Connection.slave_okay使用的例子？那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类pymongo.connection.Connection的用法示例。

在下文中一共展示了Connection.slave_okay方法的6个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的Python代码示例。

示例1: test_baseobject

# 需要导入模块: from pymongo.connection import Connection [as 别名]
# 或者: from pymongo.connection.Connection import slave_okay [as 别名]
    def test_baseobject(self):

        # In Python 2.6+ we could use the catch_warnings context
        # manager to test this warning nicely. As we can't do that
        # we must test raising errors before the ignore filter is applied.
        warnings.simplefilter("error", UserWarning)
        self.assertRaises(UserWarning, lambda:
                Connection(host, port, wtimeout=1000, safe=False))
        try:
            Connection(host, port, wtimeout=1000, safe=True)
        except UserWarning:
            self.assertFalse(True)

        try:
            Connection(host, port, wtimeout=1000)
        except UserWarning:
            self.assertFalse(True)

        warnings.resetwarnings()

        warnings.simplefilter("ignore")

        c = Connection(pair)
        self.assertFalse(c.slave_okay)
        self.assertFalse(c.safe)
        self.assertEqual({}, c.get_lasterror_options())
        db = c.test
        db.drop_collection("test")
        self.assertFalse(db.slave_okay)
        self.assertFalse(db.safe)
        self.assertEqual({}, db.get_lasterror_options())
        coll = db.test
        self.assertFalse(coll.slave_okay)
        self.assertFalse(coll.safe)
        self.assertEqual({}, coll.get_lasterror_options())
        cursor = coll.find()
        self.assertFalse(cursor._Cursor__slave_okay)
        cursor = coll.find(slave_okay=True)
        self.assertTrue(cursor._Cursor__slave_okay)

        # Setting any safe operations overrides explicit safe
        self.assertTrue(Connection(host, port, wtimeout=1000, safe=False).safe)

        c = Connection(pair, slaveok=True, w='majority',
                                     wtimeout=300, fsync=True, j=True)
        self.assertTrue(c.slave_okay)
        self.assertTrue(c.safe)
        d = {'w': 'majority', 'wtimeout': 300, 'fsync': True, 'j': True}
        self.assertEqual(d, c.get_lasterror_options())
        db = c.test
        self.assertTrue(db.slave_okay)
        self.assertTrue(db.safe)
        self.assertEqual(d, db.get_lasterror_options())
        coll = db.test
        self.assertTrue(coll.slave_okay)
        self.assertTrue(coll.safe)
        self.assertEqual(d, coll.get_lasterror_options())
        cursor = coll.find()
        self.assertTrue(cursor._Cursor__slave_okay)
        cursor = coll.find(slave_okay=False)
        self.assertFalse(cursor._Cursor__slave_okay)

        c = Connection('mongodb://%s/?'
                       'w=2;wtimeoutMS=300;fsync=true;'
                       'journal=true' % (pair,))
        self.assertTrue(c.safe)
        d = {'w': 2, 'wtimeout': 300, 'fsync': True, 'j': True}
        self.assertEqual(d, c.get_lasterror_options())

        c = Connection('mongodb://%s/?'
                       'slaveok=true;w=1;wtimeout=300;'
                       'fsync=true;j=true' % (pair,))
        self.assertTrue(c.slave_okay)
        self.assertTrue(c.safe)
        d = {'w': 1, 'wtimeout': 300, 'fsync': True, 'j': True}
        self.assertEqual(d, c.get_lasterror_options())
        self.assertEqual(d, c.write_concern)
        db = c.test
        self.assertTrue(db.slave_okay)
        self.assertTrue(db.safe)
        self.assertEqual(d, db.get_lasterror_options())
        self.assertEqual(d, db.write_concern)
        coll = db.test
        self.assertTrue(coll.slave_okay)
        self.assertTrue(coll.safe)
        self.assertEqual(d, coll.get_lasterror_options())
        self.assertEqual(d, coll.write_concern)
        cursor = coll.find()
        self.assertTrue(cursor._Cursor__slave_okay)
        cursor = coll.find(slave_okay=False)
        self.assertFalse(cursor._Cursor__slave_okay)

        c.unset_lasterror_options()
        self.assertTrue(c.slave_okay)
        self.assertTrue(c.safe)
        c.safe = False
        self.assertFalse(c.safe)
        c.slave_okay = False
        self.assertFalse(c.slave_okay)
        self.assertEqual({}, c.get_lasterror_options())
#.........这里部分代码省略.........

开发者ID:barrycug，项目名称:mongo-python-driver，代码行数:103，代码来源:test_common.py

示例2: test_baseobject

# 需要导入模块: from pymongo.connection import Connection [as 别名]
# 或者: from pymongo.connection.Connection import slave_okay [as 别名]
    def test_baseobject(self):

        warnings.simplefilter("ignore")

        c = Connection(pair)
        self.assertFalse(c.slave_okay)
        self.assertFalse(c.safe)
        self.assertEqual({}, c.get_lasterror_options())
        db = c.test
        self.assertFalse(db.slave_okay)
        self.assertFalse(db.safe)
        self.assertEqual({}, db.get_lasterror_options())
        coll = db.test
        self.assertFalse(coll.slave_okay)
        self.assertFalse(coll.safe)
        self.assertEqual({}, coll.get_lasterror_options())
        cursor = coll.find()
        self.assertFalse(cursor._Cursor__slave_okay)
        cursor = coll.find(slave_okay=True)
        self.assertTrue(cursor._Cursor__slave_okay)

        c = Connection(pair, slaveok=True, w='majority',
                                     wtimeout=300, fsync=True, j=True)
        self.assertTrue(c.slave_okay)
        self.assertTrue(c.safe)
        d = {'w': 'majority', 'wtimeout': 300, 'fsync': True, 'j': True}
        self.assertEqual(d, c.get_lasterror_options())
        db = c.test
        self.assertTrue(db.slave_okay)
        self.assertTrue(db.safe)
        self.assertEqual(d, db.get_lasterror_options())
        coll = db.test
        self.assertTrue(coll.slave_okay)
        self.assertTrue(coll.safe)
        self.assertEqual(d, coll.get_lasterror_options())
        cursor = coll.find()
        self.assertTrue(cursor._Cursor__slave_okay)
        cursor = coll.find(slave_okay=False)
        self.assertFalse(cursor._Cursor__slave_okay)

        c = Connection('mongodb://%s/?'
                       'w=2;wtimeoutMS=300;fsync=true;'
                       'journal=true' % (pair,))
        self.assertTrue(c.safe)
        d = {'w': 2, 'wtimeout': 300, 'fsync': True, 'j': True}
        self.assertEqual(d, c.get_lasterror_options())

        c = Connection('mongodb://%s/?'
                       'slaveok=true;w=1;wtimeout=300;'
                       'fsync=true;j=true' % (pair,))
        self.assertTrue(c.slave_okay)
        self.assertTrue(c.safe)
        d = {'w': 1, 'wtimeout': 300, 'fsync': True, 'j': True}
        self.assertEqual(d, c.get_lasterror_options())
        db = c.test
        self.assertTrue(db.slave_okay)
        self.assertTrue(db.safe)
        self.assertEqual(d, db.get_lasterror_options())
        coll = db.test
        self.assertTrue(coll.slave_okay)
        self.assertTrue(coll.safe)
        self.assertEqual(d, coll.get_lasterror_options())
        cursor = coll.find()
        self.assertTrue(cursor._Cursor__slave_okay)
        cursor = coll.find(slave_okay=False)
        self.assertFalse(cursor._Cursor__slave_okay)

        c.unset_lasterror_options()
        self.assertTrue(c.slave_okay)
        self.assertTrue(c.safe)
        c.safe = False
        self.assertFalse(c.safe)
        c.slave_okay = False
        self.assertFalse(c.slave_okay)
        self.assertEqual({}, c.get_lasterror_options())
        db = c.test
        self.assertFalse(db.slave_okay)
        self.assertFalse(db.safe)
        self.assertEqual({}, db.get_lasterror_options())
        coll = db.test
        self.assertFalse(coll.slave_okay)
        self.assertFalse(coll.safe)
        self.assertEqual({}, coll.get_lasterror_options())
        cursor = coll.find()
        self.assertFalse(cursor._Cursor__slave_okay)
        cursor = coll.find(slave_okay=True)
        self.assertTrue(cursor._Cursor__slave_okay)

        coll.set_lasterror_options(j=True)
        self.assertEqual({'j': True}, coll.get_lasterror_options())
        self.assertEqual({}, db.get_lasterror_options())
        self.assertFalse(db.safe)
        self.assertEqual({}, c.get_lasterror_options())
        self.assertFalse(c.safe)

        db.set_lasterror_options(w='majority')
        self.assertEqual({'j': True}, coll.get_lasterror_options())
        self.assertEqual({'w': 'majority'}, db.get_lasterror_options())
        self.assertEqual({}, c.get_lasterror_options())
        self.assertFalse(c.safe)
#.........这里部分代码省略.........

开发者ID:Basis，项目名称:mongo-python-driver，代码行数:103，代码来源:test_common.py

示例3: test_baseobject

# 需要导入模块: from pymongo.connection import Connection [as 别名]
# 或者: from pymongo.connection.Connection import slave_okay [as 别名]
    def test_baseobject(self):

        ctx = catch_warnings()
        try:
            warnings.simplefilter("error", UserWarning)
            self.assertRaises(UserWarning, lambda:
                    MongoClient(host, port, wtimeout=1000, w=0))
            try:
                MongoClient(host, port, wtimeout=1000, w=1)
            except UserWarning:
                self.fail()

            try:
                MongoClient(host, port, wtimeout=1000)
            except UserWarning:
                self.fail()
        finally:
            ctx.exit()

        # Connection tests
        ctx = catch_warnings()
        try:
            warnings.simplefilter("ignore", DeprecationWarning)
            c = Connection(pair)
            self.assertFalse(c.slave_okay)
            self.assertFalse(c.safe)
            self.assertEqual({}, c.get_lasterror_options())
            db = c.pymongo_test
            db.drop_collection("test")
            self.assertFalse(db.slave_okay)
            self.assertFalse(db.safe)
            self.assertEqual({}, db.get_lasterror_options())
            coll = db.test
            self.assertFalse(coll.slave_okay)
            self.assertFalse(coll.safe)
            self.assertEqual({}, coll.get_lasterror_options())

            self.assertEqual((False, {}), coll._get_write_mode())
            coll.safe = False
            coll.write_concern.update(w=1)
            self.assertEqual((True, {}), coll._get_write_mode())
            coll.write_concern.update(w=3)
            self.assertEqual((True, {'w': 3}), coll._get_write_mode())

            coll.safe = True
            coll.write_concern.update(w=0)
            self.assertEqual((False, {}), coll._get_write_mode())

            coll = db.test
            cursor = coll.find()
            self.assertFalse(cursor._Cursor__slave_okay)
            cursor = coll.find(slave_okay=True)
            self.assertTrue(cursor._Cursor__slave_okay)

            # MongoClient test
            c = MongoClient(pair)
            self.assertFalse(c.slave_okay)
            self.assertTrue(c.safe)
            self.assertEqual({}, c.get_lasterror_options())
            db = c.pymongo_test
            db.drop_collection("test")
            self.assertFalse(db.slave_okay)
            self.assertTrue(db.safe)
            self.assertEqual({}, db.get_lasterror_options())
            coll = db.test
            self.assertFalse(coll.slave_okay)
            self.assertTrue(coll.safe)
            self.assertEqual({}, coll.get_lasterror_options())

            self.assertEqual((True, {}), coll._get_write_mode())
            coll.safe = False
            coll.write_concern.update(w=1)
            self.assertEqual((True, {}), coll._get_write_mode())
            coll.write_concern.update(w=3)
            self.assertEqual((True, {'w': 3}), coll._get_write_mode())

            coll.safe = True
            coll.write_concern.update(w=0)
            self.assertEqual((False, {}), coll._get_write_mode())

            coll = db.test
            cursor = coll.find()
            self.assertFalse(cursor._Cursor__slave_okay)
            cursor = coll.find(slave_okay=True)
            self.assertTrue(cursor._Cursor__slave_okay)

            # Setting any safe operations overrides explicit safe
            self.assertTrue(MongoClient(host, port, wtimeout=1000, safe=False).safe)

            c = MongoClient(pair, slaveok=True, w='majority',
                            wtimeout=300, fsync=True, j=True)
            self.assertTrue(c.slave_okay)
            self.assertTrue(c.safe)
            d = {'w': 'majority', 'wtimeout': 300, 'fsync': True, 'j': True}
            self.assertEqual(d, c.get_lasterror_options())
            db = c.pymongo_test
            self.assertTrue(db.slave_okay)
            self.assertTrue(db.safe)
            self.assertEqual(d, db.get_lasterror_options())
            coll = db.test
#.........这里部分代码省略.........

开发者ID:AlexSnet，项目名称:oneline，代码行数:103，代码来源:test_common.py

示例4: test_baseobject

# 需要导入模块: from pymongo.connection import Connection [as 别名]
# 或者: from pymongo.connection.Connection import slave_okay [as 别名]
    def test_baseobject(self):

        # In Python 2.6+ we could use the catch_warnings context
        # manager to test this warning nicely. As we can't do that
        # we must test raising errors before the ignore filter is applied.
        warnings.simplefilter("error", UserWarning)
        self.assertRaises(UserWarning, lambda: MongoClient(host, port, wtimeout=1000, w=0))
        try:
            MongoClient(host, port, wtimeout=1000, w=1)
        except UserWarning:
            self.fail()

        try:
            MongoClient(host, port, wtimeout=1000)
        except UserWarning:
            self.fail()

        warnings.resetwarnings()

        warnings.simplefilter("ignore")

        # Connection tests
        c = Connection(pair)
        self.assertFalse(c.slave_okay)
        self.assertFalse(c.safe)
        self.assertEqual({}, c.get_lasterror_options())
        db = c.pymongo_test
        db.drop_collection("test")
        self.assertFalse(db.slave_okay)
        self.assertFalse(db.safe)
        self.assertEqual({}, db.get_lasterror_options())
        coll = db.test
        self.assertFalse(coll.slave_okay)
        self.assertFalse(coll.safe)
        self.assertEqual({}, coll.get_lasterror_options())

        self.assertEqual((False, {}), coll._get_write_mode())
        coll.safe = False
        coll.write_concern.update(w=1)
        self.assertEqual((True, {}), coll._get_write_mode())
        coll.write_concern.update(w=3)
        self.assertEqual((True, {"w": 3}), coll._get_write_mode())

        coll.safe = True
        coll.write_concern.update(w=0)
        self.assertEqual((False, {}), coll._get_write_mode())

        coll = db.test
        cursor = coll.find()
        self.assertFalse(cursor._Cursor__slave_okay)
        cursor = coll.find(slave_okay=True)
        self.assertTrue(cursor._Cursor__slave_okay)

        # MongoClient test
        c = MongoClient(pair)
        self.assertFalse(c.slave_okay)
        self.assertTrue(c.safe)
        self.assertEqual({}, c.get_lasterror_options())
        db = c.pymongo_test
        db.drop_collection("test")
        self.assertFalse(db.slave_okay)
        self.assertTrue(db.safe)
        self.assertEqual({}, db.get_lasterror_options())
        coll = db.test
        self.assertFalse(coll.slave_okay)
        self.assertTrue(coll.safe)
        self.assertEqual({}, coll.get_lasterror_options())

        self.assertEqual((True, {}), coll._get_write_mode())
        coll.safe = False
        coll.write_concern.update(w=1)
        self.assertEqual((True, {}), coll._get_write_mode())
        coll.write_concern.update(w=3)
        self.assertEqual((True, {"w": 3}), coll._get_write_mode())

        coll.safe = True
        coll.write_concern.update(w=0)
        self.assertEqual((False, {}), coll._get_write_mode())

        coll = db.test
        cursor = coll.find()
        self.assertFalse(cursor._Cursor__slave_okay)
        cursor = coll.find(slave_okay=True)
        self.assertTrue(cursor._Cursor__slave_okay)

        # Setting any safe operations overrides explicit safe
        self.assertTrue(MongoClient(host, port, wtimeout=1000, safe=False).safe)

        c = MongoClient(pair, slaveok=True, w="majority", wtimeout=300, fsync=True, j=True)
        self.assertTrue(c.slave_okay)
        self.assertTrue(c.safe)
        d = {"w": "majority", "wtimeout": 300, "fsync": True, "j": True}
        self.assertEqual(d, c.get_lasterror_options())
        db = c.pymongo_test
        self.assertTrue(db.slave_okay)
        self.assertTrue(db.safe)
        self.assertEqual(d, db.get_lasterror_options())
        coll = db.test
        self.assertTrue(coll.slave_okay)
        self.assertTrue(coll.safe)
#.........这里部分代码省略.........

开发者ID:rozza，项目名称:mongo-python-driver，代码行数:103，代码来源:test_common.py

示例5: test_baseobject

# 需要导入模块: from pymongo.connection import Connection [as 别名]
# 或者: from pymongo.connection.Connection import slave_okay [as 别名]
    def test_baseobject(self):

        c = Connection()
        self.assertFalse(c.slave_okay)
        self.assertFalse(c.safe)
        self.assertEqual({}, c.get_lasterror_options())
        db = c.test
        self.assertFalse(db.slave_okay)
        self.assertFalse(db.safe)
        self.assertEqual({}, db.get_lasterror_options())
        coll = db.test
        self.assertFalse(coll.slave_okay)
        self.assertFalse(coll.safe)
        self.assertEqual({}, coll.get_lasterror_options())
        cursor = coll.find()
        self.assertFalse(cursor._Cursor__slave_okay)
        cursor = coll.find(slave_okay=True)
        self.assertTrue(cursor._Cursor__slave_okay)

        c = Connection(slaveok=True, w=1, wtimeout=300, fsync=True, j=True)
        self.assertTrue(c.slave_okay)
        self.assertTrue(c.safe)
        d = {'w': 1, 'wtimeout': 300, 'fsync': True, 'j': True}
        self.assertEqual(d, c.get_lasterror_options())
        db = c.test
        self.assertTrue(db.slave_okay)
        self.assertTrue(db.safe)
        self.assertEqual(d, db.get_lasterror_options())
        coll = db.test
        self.assertTrue(coll.slave_okay)
        self.assertTrue(coll.safe)
        self.assertEqual(d, coll.get_lasterror_options())
        cursor = coll.find()
        self.assertTrue(cursor._Cursor__slave_okay)
        cursor = coll.find(slave_okay=False)
        self.assertFalse(cursor._Cursor__slave_okay)

        c = Connection('mongodb://localhost:27017/?'
                       'slaveok=true;w=1;wtimeout=300;fsync=true;j=true')
        self.assertTrue(c.slave_okay)
        self.assertTrue(c.safe)
        d = {'w': 1, 'wtimeout': 300, 'fsync': True, 'j': True}
        self.assertEqual(d, c.get_lasterror_options())
        db = c.test
        self.assertTrue(db.slave_okay)
        self.assertTrue(db.safe)
        self.assertEqual(d, db.get_lasterror_options())
        coll = db.test
        self.assertTrue(coll.slave_okay)
        self.assertTrue(coll.safe)
        self.assertEqual(d, coll.get_lasterror_options())
        cursor = coll.find()
        self.assertTrue(cursor._Cursor__slave_okay)
        cursor = coll.find(slave_okay=False)
        self.assertFalse(cursor._Cursor__slave_okay)

        c.unset_lasterror_options()
        self.assertTrue(c.slave_okay)
        self.assertTrue(c.safe)
        c.safe = False
        self.assertFalse(c.safe)
        c.slave_okay = False
        self.assertFalse(c.slave_okay)
        self.assertEqual({}, c.get_lasterror_options())
        db = c.test
        self.assertFalse(db.slave_okay)
        self.assertFalse(db.safe)
        self.assertEqual({}, db.get_lasterror_options())
        coll = db.test
        self.assertFalse(coll.slave_okay)
        self.assertFalse(coll.safe)
        self.assertEqual({}, coll.get_lasterror_options())
        cursor = coll.find()
        self.assertFalse(cursor._Cursor__slave_okay)
        cursor = coll.find(slave_okay=True)
        self.assertTrue(cursor._Cursor__slave_okay)

        coll.set_lasterror_options(j=True)
        self.assertEqual({'j': True}, coll.get_lasterror_options())
        self.assertEqual({}, db.get_lasterror_options())
        self.assertFalse(db.safe)
        self.assertEqual({}, c.get_lasterror_options())
        self.assertFalse(c.safe)

        db.set_lasterror_options(w=1)
        self.assertEqual({'j': True}, coll.get_lasterror_options())
        self.assertEqual({'w': 1}, db.get_lasterror_options())
        self.assertEqual({}, c.get_lasterror_options())
        self.assertFalse(c.safe)
        db.slave_okay = True
        self.assertTrue(db.slave_okay)
        self.assertFalse(c.slave_okay)
        self.assertFalse(coll.slave_okay)
        cursor = coll.find()
        self.assertFalse(cursor._Cursor__slave_okay)
        cursor = db.coll2.find()
        self.assertTrue(cursor._Cursor__slave_okay)
        cursor = db.coll2.find(slave_okay=False)
        self.assertFalse(cursor._Cursor__slave_okay)

#.........这里部分代码省略.........

开发者ID:abhayv，项目名称:mongo-python-driver，代码行数:103，代码来源:test_common.py

示例6: test_baseobject

# 需要导入模块: from pymongo.connection import Connection [as 别名]
# 或者: from pymongo.connection.Connection import slave_okay [as 别名]
    def test_baseobject(self):

        c = Connection()
        self.assertFalse(c.slave_okay)
        self.assertFalse(c.safe)
        self.assertEqual({}, c.get_lasterror_options())
        db = c.test
        self.assertFalse(db.slave_okay)
        self.assertFalse(db.safe)
        self.assertEqual({}, db.get_lasterror_options())
        coll = db.test
        self.assertFalse(coll.slave_okay)
        self.assertFalse(coll.safe)
        self.assertEqual({}, coll.get_lasterror_options())

        c = Connection(slaveok=True, w=1, wtimeout=300, fsync=True, j=True)
        self.assertTrue(c.slave_okay)
        self.assertTrue(c.safe)
        d = {"w": 1, "wtimeout": 300, "fsync": True, "j": True}
        self.assertEqual(d, c.get_lasterror_options())
        db = c.test
        self.assertTrue(db.slave_okay)
        self.assertTrue(db.safe)
        self.assertEqual(d, db.get_lasterror_options())
        coll = db.test
        self.assertTrue(coll.slave_okay)
        self.assertTrue(coll.safe)
        self.assertEqual(d, coll.get_lasterror_options())

        c = Connection("mongodb://localhost:27017/?" "slaveok=true;w=1;wtimeout=300;fsync=true;j=true")
        self.assertTrue(c.slave_okay)
        self.assertTrue(c.safe)
        d = {"w": 1, "wtimeout": 300, "fsync": True, "j": True}
        self.assertEqual(d, c.get_lasterror_options())
        db = c.test
        self.assertTrue(db.slave_okay)
        self.assertTrue(db.safe)
        self.assertEqual(d, db.get_lasterror_options())
        coll = db.test
        self.assertTrue(coll.slave_okay)
        self.assertTrue(coll.safe)
        self.assertEqual(d, coll.get_lasterror_options())

        c.unset_lasterror_options()
        self.assertTrue(c.slave_okay)
        self.assertTrue(c.safe)
        c.safe = False
        self.assertFalse(c.safe)
        c.slave_okay = False
        self.assertFalse(c.slave_okay)
        self.assertEqual({}, c.get_lasterror_options())
        db = c.test
        self.assertFalse(db.slave_okay)
        self.assertFalse(db.safe)
        self.assertEqual({}, db.get_lasterror_options())
        coll = db.test
        self.assertFalse(coll.slave_okay)
        self.assertFalse(coll.safe)
        self.assertEqual({}, coll.get_lasterror_options())

        coll.set_lasterror_options(j=True)
        self.assertEqual({"j": True}, coll.get_lasterror_options())
        self.assertEqual({}, db.get_lasterror_options())
        self.assertFalse(db.safe)
        self.assertEqual({}, c.get_lasterror_options())
        self.assertFalse(c.safe)

        db.set_lasterror_options(w=1)
        self.assertEqual({"j": True}, coll.get_lasterror_options())
        self.assertEqual({"w": 1}, db.get_lasterror_options())
        self.assertEqual({}, c.get_lasterror_options())
        self.assertFalse(c.safe)
        db.slave_okay = True
        self.assertTrue(db.slave_okay)
        self.assertFalse(c.slave_okay)
        self.assertFalse(coll.slave_okay)

        self.assertRaises(ConfigurationError, coll.set_lasterror_options, foo=20)
        self.assertRaises(TypeError, coll._BaseObject__set_slave_okay, 20)
        self.assertRaises(TypeError, coll._BaseObject__set_safe, 20)

        coll.remove()
        self.assertEquals(None, coll.find_one(slave_okay=True))
        coll.unset_lasterror_options()
        coll.set_lasterror_options(w=2, wtimeout=10)
        # Fails if we aren't in a replica set
        self.assertRaises(OperationFailure, coll.insert, {"foo": "bar"})
        # Succeeds since we override the lasterror settings per query.
        self.assert_(coll.insert({"foo": "bar"}, fsync=True))
        c.drop_database(db)

开发者ID:apendleton，项目名称:mongo-python-driver，代码行数:92，代码来源:test_common.py

注：本文中的pymongo.connection.Connection.slave_okay方法示例由纯净天空整理自Github/MSDocs等开源代码及文档管理平台，相关代码片段筛选自各路编程大神贡献的开源项目，源码版权归原作者所有，传播和使用请参考对应项目的License；未经允许，请勿转载。