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)