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)
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)
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.assertEqual(None, coll.find_one(slave_okay=True))
coll.unset_lasterror_options()
coll.set_lasterror_options(w=4, wtimeout=10)
# Fails if we don't have 4 active nodes or we don't have replication...
self.assertRaises(OperationFailure, coll.insert, {'foo': 'bar'})
# Succeeds since we override the lasterror settings per query.
self.assertTrue(coll.insert({'foo': 'bar'}, fsync=True))
drop_collections(db)
warnings.resetwarnings()
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())
self.assertEqual({}, c.write_concern)
db = c.test
self.assertFalse(db.slave_okay)
self.assertFalse(db.safe)
self.assertEqual({}, db.get_lasterror_options())
self.assertEqual({}, db.write_concern)
coll = db.test
self.assertFalse(coll.slave_okay)
self.assertFalse(coll.safe)
self.assertEqual({}, coll.get_lasterror_options())
self.assertEqual({}, coll.write_concern)
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({'j': True}, coll.write_concern)
self.assertEqual({}, db.get_lasterror_options())
self.assertEqual({}, db.write_concern)
self.assertFalse(db.safe)
self.assertEqual({}, c.get_lasterror_options())
self.assertEqual({}, c.write_concern)
self.assertFalse(c.safe)
db.set_lasterror_options(w='majority')
self.assertEqual({'j': True}, coll.get_lasterror_options())
self.assertEqual({'j': True}, coll.write_concern)
self.assertEqual({'w': 'majority'}, db.get_lasterror_options())
self.assertEqual({'w': 'majority'}, db.write_concern)
self.assertEqual({}, c.get_lasterror_options())
self.assertEqual({}, c.write_concern)
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)
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.assertEqual(None, coll.find_one(slave_okay=True))
coll.unset_lasterror_options()
coll.set_lasterror_options(w=4, wtimeout=10)
# Fails if we don't have 4 active nodes or we don't have replication...
self.assertRaises(OperationFailure, coll.insert, {'foo': 'bar'})
# Succeeds since we override the lasterror settings per query.
self.assertTrue(coll.insert({'foo': 'bar'}, fsync=True))
drop_collections(db)
warnings.resetwarnings()
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)
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 = MongoClient("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 = MongoClient("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.pymongo_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())
self.assertEqual({}, c.write_concern)
db = c.pymongo_test
self.assertFalse(db.slave_okay)
self.assertFalse(db.safe)
self.assertEqual({}, db.get_lasterror_options())
self.assertEqual({}, db.write_concern)
coll = db.test
self.assertFalse(coll.slave_okay)
self.assertFalse(coll.safe)
self.assertEqual({}, coll.get_lasterror_options())
self.assertEqual({}, coll.write_concern)
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({"j": True}, coll.write_concern)
self.assertEqual({}, db.get_lasterror_options())
self.assertEqual({}, db.write_concern)
self.assertFalse(db.safe)
self.assertEqual({}, c.get_lasterror_options())
self.assertEqual({}, c.write_concern)
self.assertFalse(c.safe)
db.set_lasterror_options(w="majority")
self.assertEqual({"j": True}, coll.get_lasterror_options())
self.assertEqual({"j": True}, coll.write_concern)
self.assertEqual({"w": "majority"}, db.get_lasterror_options())
self.assertEqual({"w": "majority"}, db.write_concern)
self.assertEqual({}, c.get_lasterror_options())
self.assertEqual({}, c.write_concern)
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)
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.assertEqual(None, coll.find_one(slave_okay=True))
coll.unset_lasterror_options()
coll.set_lasterror_options(w=4, wtimeout=10)
# Fails if we don't have 4 active nodes or we don't have replication...
self.assertRaises(OperationFailure, coll.insert, {"foo": "bar"})
# Succeeds since we override the lasterror settings per query.
self.assertTrue(coll.insert({"foo": "bar"}, fsync=True))
drop_collections(db)
warnings.resetwarnings()
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
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 = MongoClient('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 = MongoClient('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.pymongo_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())
self.assertEqual({}, c.write_concern)
db = c.pymongo_test
self.assertFalse(db.slave_okay)
self.assertFalse(db.safe)
self.assertEqual({}, db.get_lasterror_options())
self.assertEqual({}, db.write_concern)
coll = db.test
self.assertFalse(coll.slave_okay)
self.assertFalse(coll.safe)
self.assertEqual({}, coll.get_lasterror_options())
self.assertEqual({}, coll.write_concern)
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(fsync=True)
self.assertEqual({'fsync': True}, coll.get_lasterror_options())
self.assertEqual({'fsync': True}, coll.write_concern)
self.assertEqual({}, db.get_lasterror_options())
self.assertEqual({}, db.write_concern)
self.assertFalse(db.safe)
self.assertEqual({}, c.get_lasterror_options())
self.assertEqual({}, c.write_concern)
self.assertFalse(c.safe)
db.set_lasterror_options(w='majority')
self.assertEqual({'fsync': True}, coll.get_lasterror_options())
self.assertEqual({'fsync': True}, coll.write_concern)
self.assertEqual({'w': 'majority'}, db.get_lasterror_options())
self.assertEqual({'w': 'majority'}, db.write_concern)
self.assertEqual({}, c.get_lasterror_options())
self.assertEqual({}, c.write_concern)
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)
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.assertEqual(None, coll.find_one(slave_okay=True))
coll.unset_lasterror_options()
coll.set_lasterror_options(w=4, wtimeout=10)
# Fails if we don't have 4 active nodes or we don't have replication...
self.assertRaises(OperationFailure, coll.insert, {'foo': 'bar'})
# Succeeds since we override the lasterror settings per query.
self.assertTrue(coll.insert({'foo': 'bar'}, fsync=True))
drop_collections(db)
finally:
ctx.exit()
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")
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())
self.assertEqual({}, c.write_concern)
db = c.test
self.assertFalse(db.slave_okay)
self.assertFalse(db.safe)
self.assertEqual({}, db.get_lasterror_options())
self.assertEqual({}, db.write_concern)
coll = db.test
self.assertFalse(coll.slave_okay)
self.assertFalse(coll.safe)
self.assertEqual({}, coll.get_lasterror_options())
self.assertEqual({}, coll.write_concern)
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({'j': True}, coll.write_concern)
self.assertEqual({}, db.get_lasterror_options())
self.assertEqual({}, db.write_concern)
self.assertFalse(db.safe)
self.assertEqual({}, c.get_lasterror_options())
self.assertEqual({}, c.write_concern)
self.assertFalse(c.safe)
db.set_lasterror_options(w='majority')
self.assertEqual({'j': True}, coll.get_lasterror_options())
self.assertEqual({'j': True}, coll.write_concern)
self.assertEqual({'w': 'majority'}, db.get_lasterror_options())
self.assertEqual({'w': 'majority'}, db.write_concern)
self.assertEqual({}, c.get_lasterror_options())
self.assertEqual({}, c.write_concern)
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)
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.assertEqual(None, coll.find_one(slave_okay=True))
coll.unset_lasterror_options()
coll.set_lasterror_options(w=4, wtimeout=10)
# Fails if we don't have 4 active nodes or we don't have replication...
self.assertRaises(OperationFailure, coll.insert, {'foo': 'bar'})
# Succeeds since we override the lasterror settings per query.
self.assertTrue(coll.insert({'foo': 'bar'}, fsync=True))
drop_collections(db)
warnings.resetwarnings()
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)
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=4, wtimeout=10)
# Fails if we don't have 4 active nodes or we don't have replication...
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)
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)
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)
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)
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.assertEqual(None, coll.find_one(slave_okay=True))
coll.unset_lasterror_options()
coll.set_lasterror_options(w=4, wtimeout=10)
# Fails if we don't have 4 active nodes or we don't have replication...
self.assertRaises(OperationFailure, coll.insert, {'foo': 'bar'})
# Succeeds since we override the lasterror settings per query.
self.assertTrue(coll.insert({'foo': 'bar'}, fsync=True))
drop_collections(db)
warnings.resetwarnings()
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)
