class TestConfig(unittest.TestCase): def setUp(self): filename = dirname(__file__) + '/logging-test.config' fileConfig(filename) """ Create an empty database that could be used for logging """ self.db_name = '_mongolog_test' self.collection_name = 'log_test' self.conn = Connection('localhost') self.conn.drop_database(self.db_name) def tearDown(self): """ Drop used database """ self.conn.drop_database(self.db_name) def testLoggingFileConfiguration(self): log = logging.getLogger('example') log.debug('test') r = self.conn[self.db_name][self.collection_name] message = r.find_one({'level': 'debug', 'msg': 'test'}) self.assertEquals(message['msg'], 'test')
def test_copy_db(self): c = Connection(self.host, self.port) self.assertTrue(c.in_request()) self.assertRaises(TypeError, c.copy_database, 4, "foo") self.assertRaises(TypeError, c.copy_database, "foo", 4) self.assertRaises(InvalidName, c.copy_database, "foo", "$foo") c.pymongo_test.test.drop() c.drop_database("pymongo_test1") c.drop_database("pymongo_test2") c.pymongo_test.test.insert({"foo": "bar"}) # Due to SERVER-2329, databases may not disappear from a master in a # master-slave pair if not server_is_master_with_slave(c): self.assertFalse("pymongo_test1" in c.database_names()) self.assertFalse("pymongo_test2" in c.database_names()) c.copy_database("pymongo_test", "pymongo_test1") # copy_database() didn't accidentally end the request self.assertTrue(c.in_request()) self.assertTrue("pymongo_test1" in c.database_names()) self.assertEqual("bar", c.pymongo_test1.test.find_one()["foo"]) c.end_request() self.assertFalse(c.in_request()) c.copy_database("pymongo_test", "pymongo_test2", "%s:%d" % (self.host, self.port)) # copy_database() didn't accidentally restart the request self.assertFalse(c.in_request()) self.assertTrue("pymongo_test2" in c.database_names()) self.assertEqual("bar", c.pymongo_test2.test.find_one()["foo"]) if version.at_least(c, (1, 3, 3, 1)): c.drop_database("pymongo_test1") c.pymongo_test.add_user("mike", "password") self.assertRaises( OperationFailure, c.copy_database, "pymongo_test", "pymongo_test1", username="******", password="******" ) if not server_is_master_with_slave(c): self.assertFalse("pymongo_test1" in c.database_names()) self.assertRaises( OperationFailure, c.copy_database, "pymongo_test", "pymongo_test1", username="******", password="******" ) if not server_is_master_with_slave(c): self.assertFalse("pymongo_test1" in c.database_names()) if not is_mongos(c): # See SERVER-6427 c.copy_database("pymongo_test", "pymongo_test1", username="******", password="******") self.assertTrue("pymongo_test1" in c.database_names()) self.assertEqual("bar", c.pymongo_test1.test.find_one()["foo"])
def setUp(self): """ set up DAS core module """ debug = 0 self.das = DASCore(debug=debug) config = deepcopy(das_readconfig()) dburi = config['mongodb']['dburi'] connection = Connection(dburi) connection.drop_database('das')
def test_copy_db(self): c = Connection(self.host, self.port) self.assertRaises(TypeError, c.copy_database, 4, "foo") self.assertRaises(TypeError, c.copy_database, "foo", 4) self.assertRaises(InvalidName, c.copy_database, "foo", "$foo") c.pymongo_test.test.drop() c.drop_database("pymongo_test1") c.drop_database("pymongo_test2") c.pymongo_test.test.insert({"foo": "bar"}) self.assertFalse("pymongo_test1" in c.database_names()) self.assertFalse("pymongo_test2" in c.database_names()) c.copy_database("pymongo_test", "pymongo_test1") self.assert_("pymongo_test1" in c.database_names()) self.assertEqual("bar", c.pymongo_test1.test.find_one()["foo"]) c.copy_database("pymongo_test", "pymongo_test2", "%s:%s" % (self.host, self.port)) self.assert_("pymongo_test2" in c.database_names()) self.assertEqual("bar", c.pymongo_test2.test.find_one()["foo"]) if version.at_least(c, (1, 3, 3, 1)): c.drop_database("pymongo_test1") c.pymongo_test.add_user("mike", "password") self.assertRaises(OperationFailure, c.copy_database, "pymongo_test", "pymongo_test1", username="******", password="******") self.assertFalse("pymongo_test1" in c.database_names()) self.assertRaises(OperationFailure, c.copy_database, "pymongo_test", "pymongo_test1", username="******", password="******") self.assertFalse("pymongo_test1" in c.database_names()) c.copy_database("pymongo_test", "pymongo_test1", username="******", password="******") self.assert_("pymongo_test1" in c.database_names()) self.assertEqual("bar", c.pymongo_test1.test.find_one()["foo"])
class TestDictConfig(unittest.TestCase): def setUp(self): """ Create an empty database that could be used for logging """ self.db_name = '_mongolog_test_dict' self.collection_name = 'log_test' self.configDict = { 'version': 1, 'handlers': { 'mongo': { 'class': 'mongolog.handlers.MongoHandler', 'db': self.db_name, 'collection': self.collection_name, 'level': 'INFO' } }, 'root': { 'handlers': ['mongo'], 'level': 'INFO' } } self.conn = Connection('localhost') self.conn.drop_database(self.db_name) def testLoggingDictConfiguration(self): dictConfig(self.configDict) log = logging.getLogger('dict_example') log.debug('testing dictionary config') r = self.conn[self.db_name][self.collection_name] message = r.find_one({'level': 'debug', 'msg': 'dict_example'}) self.assertEquals( message, None, "Logger put debug message in when info level handler requested") log.info('dict_example') message = r.find_one({'level': 'info', 'msg': 'dict_example'}) self.assertNotEquals(message, None, "Logger didn't insert message into database") self.assertEquals( message['msg'], 'dict_example', "Logger didn't insert correct message into database") def tearDown(self): """ Drop used database """ self.conn.drop_database(self.db_name)
def setUp(self): """ set up DAS core module """ debug = 0 config = deepcopy(das_readconfig()) logger = PrintManager('TestDASMongocache', verbose=debug) config['logger'] = logger config['verbose'] = debug dburi = config['mongodb']['dburi'] connection = Connection(dburi) connection.drop_database('das') dasmapping = DASMapping(config) config['dasmapping'] = dasmapping self.dasmongocache = DASMongocache(config)
def generate_doc_content(): generate_random_content() conn = Connection() conn.drop_database("peduli") print("Adding users.", sep="") for i in range(50): create_new_user() print(".", end="") print(".\nAdding contents.", end="") for i in range(500): create_new_content(i) print(".", end="") sys.stdout.flush() print(".")
def generate_doc_content(): generate_random_content() conn = Connection() conn.drop_database('peduli') print("Adding users.", sep="") for i in range(50): create_new_user() print(".", end="") print(".\nAdding contents.", end="") for i in range(500): create_new_content(i) print(".", end="") sys.stdout.flush() print(".")
def test_copy_db(self): c = Connection(self.host, self.port) self.assertRaises(TypeError, c.copy_database, 4, "foo") self.assertRaises(TypeError, c.copy_database, "foo", 4) self.assertRaises(InvalidName, c.copy_database, "foo", "$foo") c.pymongo_test.test.drop() c.drop_database("pymongo_test1") c.drop_database("pymongo_test2") c.pymongo_test.test.insert({"foo": "bar"}) self.assertFalse("pymongo_test1" in c.database_names()) self.assertFalse("pymongo_test2" in c.database_names()) c.copy_database("pymongo_test", "pymongo_test1") self.assert_("pymongo_test1" in c.database_names()) self.assertEqual("bar", c.pymongo_test1.test.find_one()["foo"]) c.copy_database("pymongo_test", "pymongo_test2", "%s:%s" % (self.host, self.port)) self.assert_("pymongo_test2" in c.database_names()) self.assertEqual("bar", c.pymongo_test2.test.find_one()["foo"]) if version.at_least(c, (1, 3, 3, 1)): c.drop_database("pymongo_test1") c.pymongo_test.add_user("mike", "password") self.assertRaises(OperationFailure, c.copy_database, "pymongo_test", "pymongo_test1", username="******", password="******") self.assertFalse("pymongo_test1" in c.database_names()) self.assertRaises(OperationFailure, c.copy_database, "pymongo_test", "pymongo_test1", username="******", password="******") self.assertFalse("pymongo_test1" in c.database_names()) c.copy_database("pymongo_test", "pymongo_test1", username="******", password="******") self.assert_("pymongo_test1" in c.database_names()) self.assertEqual("bar", c.pymongo_test1.test.find_one()["foo"])
class TestDictConfig(unittest.TestCase): def setUp(self): """ Create an empty database that could be used for logging """ self.db_name = '_mongolog_test_dict' self.collection_name = 'log_test' self.configDict = { 'version': 1, 'handlers': { 'mongo': { 'class': 'mongolog.handlers.MongoHandler', 'db': self.db_name, 'collection': self.collection_name, 'level': 'INFO' } }, 'root': { 'handlers': ['mongo'], 'level': 'INFO' } } self.conn = Connection('localhost') self.conn.drop_database(self.db_name) def testLoggingDictConfiguration(self): dictConfig(self.configDict) log = logging.getLogger('dict_example') log.debug('testing dictionary config') r = self.conn[self.db_name][self.collection_name] message = r.find_one({'levelname':'DEBUG', 'msg':'dict_example'}) self.assertEquals(message, None, "Logger put debug message in when info level handler requested") log.info('dict_example') message = r.find_one({'levelname':'INFO', 'msg':'dict_example'}) self.assertNotEquals(message, None, "Logger didn't insert message into database") self.assertEquals(message['msg'], 'dict_example', "Logger didn't insert correct message into database") def tearDown(self): """ Drop used database """ self.conn.drop_database(self.db_name)
def test_drop_database(self): connection = Connection(self.host, self.port) self.assertRaises(TypeError, connection.drop_database, 5) self.assertRaises(TypeError, connection.drop_database, None) connection.pymongo_test.test.save({"dummy": u"object"}) dbs = connection.database_names() self.assert_("pymongo_test" in dbs) connection.drop_database("pymongo_test") dbs = connection.database_names() self.assert_("pymongo_test" not in dbs) connection.pymongo_test.test.save({"dummy": u"object"}) dbs = connection.database_names() self.assert_("pymongo_test" in dbs) connection.drop_database(connection.pymongo_test) dbs = connection.database_names() self.assert_("pymongo_test" not in dbs)
class TestRootLoggerHandler(unittest.TestCase): """ Test Handler attached to RootLogger """ def setUp(self): """ Create an empty database that could be used for logging """ self.db_name = '_mongolog_test' self.conn = Connection('localhost') self.conn.drop_database(self.db_name) self.db = self.conn[self.db_name] self.collection = self.db['log'] def tearDown(self): """ Drop used database """ self.conn.drop_database('_mongolog_test') def testLogging(self): """ Simple logging example """ log = logging.getLogger('') log.setLevel(logging.DEBUG) log.addHandler(MongoHandler(self.collection)) log.debug('test') r = self.collection.find_one({'levelname':'DEBUG', 'msg':'test'}) self.assertEquals(r['msg'], 'test') def testLoggingException(self): """ Logging example with exception """ log = logging.getLogger('') log.setLevel(logging.DEBUG) log.addHandler(MongoHandler(self.collection)) try: 1/0 except ZeroDivisionError: log.error('test zero division', exc_info=True) r = self.collection.find_one({'levelname':'ERROR', 'msg':'test zero division'}) self.assertTrue(r['exc_info'].startswith('Traceback'))
def test_drop_database(self): connection = Connection(self.host, self.port) self.assertRaises(TypeError, connection.drop_database, 5) self.assertRaises(TypeError, connection.drop_database, None) connection.pymongo_test.test.save({"dummy": u"object"}) dbs = connection.database_names() self.assert_("pymongo_test" in dbs) connection.drop_database("pymongo_test") dbs = connection.database_names() self.assert_("pymongo_test" not in dbs) connection.pymongo_test.test.save({"dummy": u"object"}) dbs = connection.database_names() self.assert_("pymongo_test" in dbs) connection.drop_database(connection.pymongo_test) dbs = connection.database_names() self.assert_("pymongo_test" not in dbs)
class TestMongosHighAvailability(unittest.TestCase): def setUp(self): seed_list = ha_tools.create_sharded_cluster() self.dbname = 'pymongo_mongos_ha' self.conn = Connection(seed_list) self.conn.drop_database(self.dbname) def test_mongos_ha(self): coll = self.conn[self.dbname].test self.assertTrue(coll.insert({'foo': 'bar'}, safe=True)) first = '%s:%d' % (self.conn.host, self.conn.port) ha_tools.kill_mongos(first) # Fail first attempt self.assertRaises(AutoReconnect, coll.count) # Find new mongos self.assertEqual(1, coll.count()) second = '%s:%d' % (self.conn.host, self.conn.port) self.assertNotEqual(first, second) ha_tools.kill_mongos(second) # Fail first attempt self.assertRaises(AutoReconnect, coll.count) # Find new mongos self.assertEqual(1, coll.count()) third = '%s:%d' % (self.conn.host, self.conn.port) self.assertNotEqual(second, third) ha_tools.kill_mongos(third) # Fail first attempt self.assertRaises(AutoReconnect, coll.count) # We've killed all three, restart one. ha_tools.restart_mongos(first) # Find new mongos self.assertEqual(1, coll.count()) def tearDown(self): self.conn.drop_database(self.dbname) ha_tools.kill_all_members()
class TestMongosHighAvailability(unittest.TestCase): def setUp(self): seed_list = ha_tools.create_sharded_cluster() self.dbname = 'pymongo_mongos_ha' self.conn = Connection(seed_list) self.conn.drop_database(self.dbname) def test_mongos_ha(self): coll = self.conn[self.dbname].test self.assertTrue(coll.insert({'foo': 'bar'}, safe=True)) first = '%s:%d' % (self.conn.host, self.conn.port) ha_tools.kill_mongos(first) # Fail first attempt self.assertRaises(AutoReconnect, coll.count) # Find new mongos self.assertEqual(1, coll.count()) second = '%s:%d' % (self.conn.host, self.conn.port) self.assertNotEqual(first, second) ha_tools.kill_mongos(second) # Fail first attempt self.assertRaises(AutoReconnect, coll.count) # Find new mongos self.assertEqual(1, coll.count()) third = '%s:%d' % (self.conn.host, self.conn.port) self.assertNotEqual(second, third) ha_tools.kill_mongos(third) # Fail first attempt self.assertRaises(AutoReconnect, coll.count) # We've killed all three, restart one. ha_tools.restart_mongos(first) # Find new mongos self.assertEqual(1, coll.count()) def tearDown(self): self.conn.drop_database(self.dbname) ha_tools.kill_all_members()
class TestAutoReferencePatch(unittest.TestCase): def setUp(self): self.connection = Connection() self.connection.drop_database("test_autoreference_patch") self.db = self.connection["test_autoreference_patch"] self.db.add_son_manipulator(NamespaceInjector()) self.db.add_son_manipulator(AutoReference(self.db)) messages = [{'title': i} for i in range(1000)] self.db.messages.insert(messages) user = {'name': 'tom', 'messages': messages} self.db.users.save(user) def test_patch(self): start = time.time() original = self.db.users.find_one() print time.time() - start import autoreference_patch start = time.time() patched = self.db.users.find_one() print time.time() - start self.assertEqual(original, patched)
def test_drop_database(self): connection = Connection(self.host, self.port) self.assertRaises(TypeError, connection.drop_database, 5) self.assertRaises(TypeError, connection.drop_database, None) raise SkipTest("This test often fails due to SERVER-2329") connection.pymongo_test.test.save({"dummy": u"object"}) dbs = connection.database_names() self.assertTrue("pymongo_test" in dbs) connection.drop_database("pymongo_test") dbs = connection.database_names() self.assertTrue("pymongo_test" not in dbs) connection.pymongo_test.test.save({"dummy": u"object"}) dbs = connection.database_names() self.assertTrue("pymongo_test" in dbs) connection.drop_database(connection.pymongo_test) dbs = connection.database_names() self.assertTrue("pymongo_test" not in dbs)
def test_drop_database(self): connection = Connection(self.host, self.port) self.assertRaises(TypeError, connection.drop_database, 5) self.assertRaises(TypeError, connection.drop_database, None) raise SkipTest("This test often fails due to SERVER-2329") connection.pymongo_test.test.save({"dummy": u"object"}) dbs = connection.database_names() self.assertTrue("pymongo_test" in dbs) connection.drop_database("pymongo_test") dbs = connection.database_names() self.assertTrue("pymongo_test" not in dbs) connection.pymongo_test.test.save({"dummy": u"object"}) dbs = connection.database_names() self.assertTrue("pymongo_test" in dbs) connection.drop_database(connection.pymongo_test) dbs = connection.database_names() self.assertTrue("pymongo_test" not in dbs)
class TestConfig(unittest.TestCase): def setUp(self): filename = dirname(__file__) + '/logging-test.config' fileConfig(filename) """ Create an empty database that could be used for logging """ self.db_name = '_mongolog_test' self.collection_name = 'log_test' self.conn = Connection('localhost') self.conn.drop_database(self.db_name) def tearDown(self): """ Drop used database """ self.conn.drop_database(self.db_name) def testLoggingFileConfiguration(self): log = logging.getLogger('example') log.debug('test') r = self.conn[self.db_name][self.collection_name] message = r.find_one({'level': 'debug', 'msg': 'test'}) self.assertEquals(message['msg'], 'test')
def setUp(self): """ set up DAS core module """ debug = 0 self.db = 'test_mapping.db' config = deepcopy(das_readconfig()) dburi = config['mongodb']['dburi'] logger = PrintManager('TestDASMapping', verbose=debug) config['logger'] = logger config['verbose'] = debug dbname = 'test_mapping' collname = 'db' config['mappingdb'] = dict(dburi=dburi, dbname=dbname, collname=collname) # add some maps to mapping db conn = Connection(dburi) conn.drop_database(dbname) coll = conn[dbname][collname] self.pmap = {"presentation": {"block":[{"ui": "Block name", "das": "block.name"}, {"ui": "Block size", "das": "block.size"}]}} coll.insert(self.pmap) self.mgr = DASMapping(config)
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): 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.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) warnings.resetwarnings()
Then do: $ python auto_reference.py """ from pymongo.connection import Connection from pymongo.son_manipulator import AutoReference, NamespaceInjector # Make a connection to Mongo. try: connection = Connection("localhost", 27017) except ConnectionFailure: print "couldn't connect: be sure that Mongo is running on localhost:27017" sys.exit(1) # We need a database to use, but first make sure it's clean. connection.drop_database("pymongo_examples") db = connection["pymongo_examples"] # Now we need to add the NamespaceInjector and AutoReference manipulators. # These are what actually handle translating documents as the enter and exit # MongoDB. db.add_son_manipulator(NamespaceInjector()) # inject _ns db.add_son_manipulator(AutoReference(db)) # Save a message to the database. message = {"title": "foo"} db.messages.save(message) # Now save a user - the message will get automatically referenced (converted # to a DBRef) since we've already saved it to the database. user = {"name": "hello", "message": message}
class TestRootLoggerHandler(unittest.TestCase): """ Test Handler attached to RootLogger """ def setUp(self): """ Create an empty database that could be used for logging """ self.db_name = '_mongolog_test' self.conn = Connection('localhost') self.conn.drop_database(self.db_name) self.db = self.conn[self.db_name] self.collection = self.db['log'] def tearDown(self): """ Drop used database """ self.conn.drop_database(self.db_name) def testLogging(self): """ Simple logging example """ log = logging.getLogger('') log.setLevel(logging.DEBUG) log.addHandler(MongoHandler(self.collection)) log.debug('test') r = self.collection.find_one({'levelname':'DEBUG', 'msg':'test'}) self.assertEquals(r['msg'], 'test') def testLoggingException(self): """ Logging example with exception """ log = logging.getLogger('') log.setLevel(logging.DEBUG) log.addHandler(MongoHandler(self.collection)) try: 1/0 except ZeroDivisionError: log.error('test zero division', exc_info=True) r = self.collection.find_one({'levelname':'ERROR', 'msg':'test zero division'}) self.assertTrue(r['exc_info'].startswith('Traceback')) def testQueryableMessages(self): """ Logging example with dictionary """ log = logging.getLogger('query') log.setLevel(logging.DEBUG) log.addHandler(MongoHandler(self.collection)) log.info({'address': '340 N 12th St', 'state': 'PA', 'country': 'US'}) log.info({'address': '340 S 12th St', 'state': 'PA', 'country': 'US'}) log.info({'address': '1234 Market St', 'state': 'PA', 'country': 'US'}) cursor = self.collection.find({'level':'info', 'msg.address': '340 N 12th St'}) self.assertEquals(cursor.count(), 1, "Expected query to return 1 " "message; it returned %d" % cursor.count()) self.assertEquals(cursor[0]['msg']['address'], '340 N 12th St') cursor = self.collection.find({'level':'info', 'msg.state': 'PA'}) self.assertEquals(cursor.count(), 3, "Didn't find all three documents")
class TestHandler(unittest.TestCase): def setUp(self): """ Create an empty database that could be used for logging """ self.db_name = '_mongolog_test' self.conn = Connection('localhost') self.conn.drop_database(self.db_name) self.db = self.conn[self.db_name] self.collection = self.db['log'] def tearDown(self): """ Drop used database """ self.conn.drop_database(self.db_name) def testLogging(self): """ Simple logging example """ log = logging.getLogger('example') log.setLevel(logging.DEBUG) log.addHandler(MongoHandler(self.collection)) log.debug('test') r = self.collection.find_one({'level':'debug', 'msg':'test'}) self.assertEquals(r['msg'], 'test') def testLoggingException(self): """ Logging example with exception """ log = logging.getLogger('example') log.setLevel(logging.DEBUG) log.addHandler(MongoHandler(self.collection)) try: 1/0 except ZeroDivisionError: log.error('test', exc_info=True) r = self.collection.find_one({'level':'error'}) assert r['msg'].startswith('test\nTraceback') assert r['exc_info'].startswith('Traceback') def testLoggingWithExtra(self): """ Logging example with exception """ log = logging.getLogger('example') log.setLevel(logging.DEBUG) log.addHandler(MongoHandler(self.collection)) log.info('extra', extra={'more':123}) r = self.collection.find_one({'level':'info', 'msg':'extra'}) self.assertEquals(r['extra']['more'], 123) def testLoggingWithExtraV2(self): """ Logging example with exception """ log = logging.getLogger('example') log.setLevel(logging.DEBUG) log.addHandler(MongoHandler(self.collection)) log.info('extra', more=123) r = self.collection.find_one({'level':'info', 'msg':'extra'}) self.assertEquals(r['extra']['more'], 123) def testLoggingWithExtraV3(self): """ Logging example with exception """ log = logging.getLogger('example') log.setLevel(logging.DEBUG) log.addHandler(MongoHandler(self.collection)) log.info('extra', more={'moar':456}) r = self.collection.find_one({'level':'info', 'msg':'extra'}) self.assertEquals(r['extra']['more']['moar'], 456)
def test_copy_db(self): c = Connection(self.host, self.port) self.assertTrue(c.in_request()) self.assertRaises(TypeError, c.copy_database, 4, "foo") self.assertRaises(TypeError, c.copy_database, "foo", 4) self.assertRaises(InvalidName, c.copy_database, "foo", "$foo") c.pymongo_test.test.drop() c.drop_database("pymongo_test1") c.drop_database("pymongo_test2") c.pymongo_test.test.insert({"foo": "bar"}) # Due to SERVER-2329, databases may not disappear from a master in a # master-slave pair if not server_is_master_with_slave(c): self.assertFalse("pymongo_test1" in c.database_names()) self.assertFalse("pymongo_test2" in c.database_names()) c.copy_database("pymongo_test", "pymongo_test1") # copy_database() didn't accidentally end the request self.assertTrue(c.in_request()) self.assertTrue("pymongo_test1" in c.database_names()) self.assertEqual("bar", c.pymongo_test1.test.find_one()["foo"]) c.end_request() c.copy_database("pymongo_test", "pymongo_test2", "%s:%d" % (self.host, self.port)) # copy_database() didn't accidentally restart the request self.assertFalse(c.in_request()) self.assertTrue("pymongo_test2" in c.database_names()) self.assertEqual("bar", c.pymongo_test2.test.find_one()["foo"]) if version.at_least(c, (1, 3, 3, 1)): c.drop_database("pymongo_test1") c.pymongo_test.add_user("mike", "password") self.assertRaises(OperationFailure, c.copy_database, "pymongo_test", "pymongo_test1", username="******", password="******") if not server_is_master_with_slave(c): self.assertFalse("pymongo_test1" in c.database_names()) self.assertRaises(OperationFailure, c.copy_database, "pymongo_test", "pymongo_test1", username="******", password="******") if not server_is_master_with_slave(c): self.assertFalse("pymongo_test1" in c.database_names()) if not is_mongos(c): # See SERVER-6427 c.copy_database("pymongo_test", "pymongo_test1", username="******", password="******") self.assertTrue("pymongo_test1" in c.database_names()) self.assertEqual("bar", c.pymongo_test1.test.find_one()["foo"])
Then do: $ python auto_reference.py """ from pymongo.connection import Connection from pymongo.son_manipulator import AutoReference, NamespaceInjector # Make a connection to Mongo. try: connection = Connection("localhost", 27017) except ConnectionFailure: print "couldn't connect: be sure that Mongo is running on localhost:27017" sys.exit(1) # We need a database to use, but first make sure it's clean. connection.drop_database("pymongo_examples") db = connection["pymongo_examples"] # Now we need to add the NamespaceInjector and AutoReference manipulators. # These are what actually handle translating documents as the enter and exit # MongoDB. db.add_son_manipulator(NamespaceInjector()) # inject _ns db.add_son_manipulator(AutoReference(db)) # Save a message to the database. message = {"title": "foo"} db.messages.save(message) # Now save a user - the message will get automatically referenced (converted # to a DBRef) since we've already saved it to the database. user = {"name": "hello", "message": message}
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): 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)
class TestRootLoggerHandler(unittest.TestCase): """ Test Handler attached to RootLogger """ def setUp(self): """ Create an empty database that could be used for logging """ self.db_name = '_mongolog_test' self.conn = Connection('localhost') self.conn.drop_database(self.db_name) self.db = self.conn[self.db_name] self.collection = self.db['log'] def tearDown(self): """ Drop used database """ self.conn.drop_database(self.db_name) def testLogging(self): """ Simple logging example """ log = logging.getLogger('') log.setLevel(logging.DEBUG) log.addHandler(MongoHandler(self.collection)) log.debug('test') r = self.collection.find_one({'levelname': 'DEBUG', 'msg': 'test'}) self.assertEquals(r['msg'], 'test') def testLoggingException(self): """ Logging example with exception """ log = logging.getLogger('') log.setLevel(logging.DEBUG) log.addHandler(MongoHandler(self.collection)) try: 1 / 0 except ZeroDivisionError: log.error('test zero division', exc_info=True) r = self.collection.find_one({ 'levelname': 'ERROR', 'msg': 'test zero division' }) self.assertTrue(r['exc_info'].startswith('Traceback')) def testQueryableMessages(self): """ Logging example with dictionary """ log = logging.getLogger('query') log.setLevel(logging.DEBUG) log.addHandler(MongoHandler(self.collection)) log.info({'address': '340 N 12th St', 'state': 'PA', 'country': 'US'}) log.info({'address': '340 S 12th St', 'state': 'PA', 'country': 'US'}) log.info({'address': '1234 Market St', 'state': 'PA', 'country': 'US'}) cursor = self.collection.find({ 'level': 'info', 'msg.address': '340 N 12th St' }) self.assertEquals( cursor.count(), 1, "Expected query to return 1 " "message; it returned %d" % cursor.count()) self.assertEquals(cursor[0]['msg']['address'], '340 N 12th St') cursor = self.collection.find({'level': 'info', 'msg.state': 'PA'}) self.assertEquals(cursor.count(), 3, "Didn't find all three documents")
class TestRootLoggerHandler(unittest.TestCase): """ Test Handler attached to RootLogger """ def setUp(self): """ Create an empty database that could be used for logging """ self.db_name = "_mongolog_test" self.conn = Connection("localhost") self.conn.drop_database(self.db_name) self.db = self.conn[self.db_name] self.collection = self.db["log"] self.log = logging.getLogger("") self.log.setLevel(logging.DEBUG) self.handler = MongoHandler(self.collection) self.log.addHandler(self.handler) def tearDown(self): """ Drop used database """ self.conn.drop_database(self.db_name) self.log.removeHandler(self.handler) def testLogging(self): """ Simple logging example """ self.log.debug("test") r = self.collection.find_one({"levelname": "DEBUG", "msg": "test"}) self.assertEquals(r["msg"], "test") def testLoggingException(self): """ Logging example with exception """ try: 1 / 0 except ZeroDivisionError: self.log.error("test zero division", exc_info=True) r = self.collection.find_one({"levelname": "ERROR", "msg": "test zero division"}) self.assertTrue(r["exc_info"].startswith("Traceback")) def testQueryableMessages(self): """ Logging example with dictionary """ self.log.info({"address": "340 N 12th St", "state": "PA", "country": "US"}) self.log.info({"address": "340 S 12th St", "state": "PA", "country": "US"}) self.log.info({"address": "1234 Market St", "state": "PA", "country": "US"}) cursor = self.collection.find({"levelname": "INFO", "msg.address": "340 N 12th St"}) self.assertEquals(cursor.count(), 1, "Expected query to return 1 " "message; it returned %d" % cursor.count()) self.assertEquals(cursor[0]["msg"]["address"], "340 N 12th St") cursor = self.collection.find({"levelname": "INFO", "msg.state": "PA"}) self.assertEquals(cursor.count(), 3, "Didn't find all three documents") def testFormatter(self): formatString = "%(message)s from %(levelname)s" self.handler.setFormatter(MongoFormatter(formatString)) self.log.info("%s within a message", "message") document = self.collection.find_one() self.assertEquals(document["message"], "message within a message from" " INFO") def testNoneArgs(self): """ Logging example with "None" as logging args """ self.log.info("This is a string %s with no args", None)