def execute_sql_dict(sql, db_handler=None, keep_connection=True): '''execute sql and return a dict format data''' try: data = [] datadict = [] if db_handler: conn = db_handler else: if "default_handler" in globals().keys(): conn = default_handler else: keep_connection = False conn = __init_connection(db_info) cursor = conn.cursor() ChorusGlobals.get_logger().info("Execute SQL '%s'" % sql) cursor.execute(sql) for row in cursor: data.append(row) for row in data: rid = data.index(row) celldict = {} for i in range(len(row)): celldict[cursor.column_names[i]] = row[i] datadict.append(celldict) conn.commit() except Exception, e: traceback.print_exc() ChorusGlobals.get_logger().critical("Errors in sql execution: %s" % e) raise Exception("Errors in sql execution: %s" % e)
def close_connection(db_handler=None): if not db_handler: db_handler = default_handler cursor = db_handler.cursor() cursor.close() db_handler.close() ChorusGlobals.get_logger().info("close mysql connection")
def execute_sql_dict(sql, db_handler = None, keep_connection = True): '''execute sql and return a dict format data''' try: data = [] datadict=[] if db_handler: conn = db_handler else: if "default_handler" in globals().keys(): conn = default_handler else: keep_connection = False conn = __init_connection(db_info) cursor = conn.cursor() ChorusGlobals.get_logger().info("Execute SQL '%s'" % sql) cursor.execute(sql) for row in cursor: data.append(row) for row in data: rid=data.index(row) celldict={} for i in range(len(row)): celldict[cursor.column_names[i]]=row[i] datadict.append(celldict) conn.commit() except Exception, e: traceback.print_exc() ChorusGlobals.get_logger().critical("Errors in sql execution: %s" % e) raise Exception("Errors in sql execution: %s" % e)
def close_connection(db_handler = None): if not db_handler: db_handler = default_handler cursor = db_handler.cursor() cursor.close() db_handler.close() ChorusGlobals.get_logger().info("close mysql connection")
def generate_json(detail): try: finaldetail = Utils.parse_description(detail) if type(detail)==str else detail jsdata = json.dumps(finaldetail) except Exception,e: message = "The input detail cannot be transfer into json type, error is %s" % str(e) ChorusGlobals.get_logger().warning(message) jsdata = json.dumps({"message":message})
def generate_json(detail): try: finaldetail = Utils.parse_description(detail) if type( detail) == str else detail jsdata = json.dumps(finaldetail) except Exception, e: message = "The input detail cannot be transfer into json type, error is %s" % str( e) ChorusGlobals.get_logger().warning(message) jsdata = json.dumps({"message": message})
def add(cls, name, detail, time_taken, timeout=30): status = True if time_taken <= timeout else False if not status: cls.status = False cls.failed += 1 else: cls.passed += 1 js_detail = cls.generate_json(detail) cls.data.append(Performance_Object(name, status, js_detail, time_taken, timeout)) ChorusGlobals.get_logger().info("Add Performance Result %s, status %s, time_taken %s" % (name, status, str(time_taken))) cls.number += 1
def __init_connection(connection): host = connection["host"] port = connection["port"] user = connection["username"] passwd = connection["password"] database = connection["database"] db_handler = mysql.connector.connect(host = host, port = int(port), user = user, passwd = passwd, database = database) ChorusGlobals.get_logger().info("start mysql connection") return db_handler
def __init_connection(connection): host = connection["host"] port = connection["port"] user = connection["username"] passwd = connection["password"] database = connection["database"] db_handler = mysql.connector.connect(host=host, port=int(port), user=user, passwd=passwd, database=database) ChorusGlobals.get_logger().info("start mysql connection") return db_handler
def add(cls, name, detail, time_taken, timeout=30): status = True if time_taken <= timeout else False if not status: cls.status = False cls.failed += 1 else: cls.passed += 1 js_detail = cls.generate_json(detail) cls.data.append( Performance_Object(name, status, js_detail, time_taken, timeout)) ChorusGlobals.get_logger().info( "Add Performance Result %s, status %s, time_taken %s" % (name, status, str(time_taken))) cls.number += 1
def setUpClass(cls): ''' setUpClass is executed every time before run a test suite ''' suite_dependency = cls.get_suite_dependency() if len(suite_dependency) > 0: suites = ChorusGlobals.get_testresult().suites mapping = {} for key, value in suites.iteritems(): mapping[key] = value.statusflag for d in suite_dependency: if mapping.has_key(d) and not mapping[d]: raise Exception("Has failed dependency test suite %s" %(str(d))) cls.suite_starttime = time.time() cls.logserver = ChorusGlobals.get_logserver() cls.logserver.flush_console() super(MyTestCase,cls).setUpClass() cls.logger = ChorusGlobals.get_logger() cls.suite_name = Utils.get_current_classname(cls) ChorusGlobals.set_current_suitename(cls.suite_name) from VerificationManagement import VerificationManagement cls.vm = VerificationManagement() cls.result = cls.vm.check_suitebaseline(cls.suite_name) cls.result.description = Utils.parse_description(cls.__doc__) cls.timestamp = Utils.get_timestamp() cls.config = ChorusGlobals.get_configinfo() cls.parameters = ChorusGlobals.get_parameters()
def execute_sql(sql, db_info): '''execute sql and return a list format data''' try: data = [] conn_info = __get_db_info(db_info) print conn_info conn = __init_connection(conn_info) cursor = conn.cursor() cursor.execute(sql) for row in cursor: data.append(row) conn.commit() except Exception, e: ChorusGlobals.get_logger().critical("Errors in sql execution: %s" % e) raise Exception("Errors in sql execution: %s" % e)
def setUpClass(cls): ''' setUpClass is executed every time before run a test suite ''' suite_dependency = cls.get_suite_dependency() if len(suite_dependency) > 0: suites = ChorusGlobals.get_testresult().suites mapping = {} for key, value in suites.iteritems(): mapping[key] = value.statusflag for d in suite_dependency: if mapping.has_key(d) and not mapping[d]: raise Exception("Has failed dependency test suite %s" % (str(d))) cls.suite_starttime = time.time() cls.logserver = ChorusGlobals.get_logserver() cls.logserver.flush_console() super(MyTestCase, cls).setUpClass() cls.logger = ChorusGlobals.get_logger() cls.suite_name = Utils.get_current_classname(cls) ChorusGlobals.set_current_suitename(cls.suite_name) from VerificationManagement import VerificationManagement cls.vm = VerificationManagement() cls.result = cls.vm.check_suitebaseline(cls.suite_name) cls.result.description = Utils.parse_description(cls.__doc__) cls.timestamp = Utils.get_timestamp() cls.config = ChorusGlobals.get_configinfo() cls.parameters = ChorusGlobals.get_parameters()
def get_parameters(*args): import ChorusGlobals parameters = ChorusGlobals.get_parameters() result = None if parameters.has_key(args[0]): result = parameters[args[0]] if len(args)==1: return result for path in args[1:]: if result: if result.has_key(path): result = result[path] else: result = None if not result: ChorusGlobals.get_logger().warning("No value retrieved for path %s" % str(args)) return result
def __get_db_info(db_info): parameters = ChorusGlobals.get_parameters() try: db_config = parameters[db_info] connection = { "host": db_config['addr'], "port": db_config['port'], "username": db_config['username'], "password": db_config['password'], "database": db_config['database'] } return connection except Exception,e: ChorusGlobals.get_logger().critical("The %s in config file is not correctly configured, errors: %s" % (db_info,str(e))) raise Exception("The %s in config file is not correctly configured, errors: %s" % (db_info,str(e)))
def __init__(self): self.suite_dict = ChorusGlobals.get_suitedict() self.logger = ChorusGlobals.get_logger() self.configinfo = ChorusGlobals.get_configinfo() self.baseline_path = ChorusGlobals.get_baselinepath() self.outputdir = ChorusGlobals.get_outputdir() self.result = ChorusGlobals.get_testresult() self.known_issue_list = ChorusGlobals.get_knownissuelist()
def __init__(self): self.logger = ChorusGlobals.get_logger() self.suiteinfo = ChorusGlobals.get_suiteinfo() self.set_baselinepath() self.suite_dict = self.get_test_mapping() self.filter_test_mapping() self.set_scope() self.get_testsuites()
def get_parameters(*args): import ChorusGlobals parameters = ChorusGlobals.get_parameters() result = None if parameters.has_key(args[0]): result = parameters[args[0]] if len(args) == 1: return result for path in args[1:]: if result: if result.has_key(path): result = result[path] else: result = None if not result: ChorusGlobals.get_logger().warning("No value retrieved for path %s" % str(args)) return result
def __init__(self, imga, imgb, lb=1, tol=15): """Store the images in the instance.""" self.logger = ChorusGlobals.get_logger() sizea, sizeb = imga.size, imgb.size if sizea != sizeb: #sizea=sizeb in most cases newx = min(sizea[0], sizeb[0]) newy = min(sizea[1], sizeb[1]) ''' Rescale to a common size:''' imga = imga.resize((newx, newy), Image.ANTIALIAS) imgb = imgb.resize((newx, newy), Image.ANTIALIAS) self._imga, self._imgb, self._lb, self._tol = imga, imgb, lb, tol
def __init__(self): self.job = "Test Result" self.startuser = "******" self.joblink = "" self.starttime = 0 self.duration = 0 self.htmllink = "" self.consolelink = "" self.knownissueflag = False self.machine_name = "" self.suites={} self.logger = ChorusGlobals.get_logger()
def set_base_db_info(db_config, keep_connection = True): global db_info try: db_info = { "host": db_config['db_addr'], "port": db_config['db_port'], "username": db_config['db_username'], "password": db_config['db_password'], "database": db_config['db_database'] } if keep_connection: db_handler = __init_connection(db_info) global default_handler default_handler = db_handler return db_handler else: return None except Exception, e: traceback.print_exc() ChorusGlobals.get_logger().critical("Errors %s in db_info format: %s" % (str(e),str(db_info))) raise Exception("Errors %s in db_info format: %s" % (str(e),str(db_info)))
def execute_sql_dict(sql,db_info): '''execute sql and return a dict format data''' try: data = [] datadict=[] conn_info = __get_db_info(db_info) conn = __init_connection(conn_info) cursor = conn.cursor() cursor.execute(sql) for row in cursor: data.append(row) for row in data: rid=data.index(row) celldict={} for i in range(len(row)): celldict[cursor.column_names[i]]=row[i] datadict.append(celldict) conn.commit() except Exception, e: ChorusGlobals.get_logger().critical("Errors in sql execution: %s" % e) raise Exception("Errors in sql execution: %s" % e)
def __init__(self): self.logger = ChorusGlobals.get_logger() self.config = ChorusGlobals.get_configinfo() ChorusGlobals.init_testresult() self.result = ChorusGlobals.get_testresult() self.suite_dict = self.get_test_mapping() self.filter_test_mapping() self.set_scope() self.get_testsuites() self.set_baselinepath() self.get_knownissues() ChorusGlobals.set_suitedict(self.suite_dict)
def __init__(self): self.job = "Test Result" self.startuser = "******" self.joblink = "" self.starttime = 0 self.duration = 0 self.htmllink = "" self.consolelink = "" self.knownissueflag = False self.machine_name = "" self.suites={} self.logger = ChorusGlobals.get_logger() self.parameters = {}
def set_base_db_info(db_config, keep_connection=True): global db_info try: db_info = { "host": db_config['db_addr'], "port": db_config['db_port'], "username": db_config['db_username'], "password": db_config['db_password'], "database": db_config['db_database'] } if keep_connection: db_handler = __init_connection(db_info) global default_handler default_handler = db_handler return db_handler else: return None except Exception, e: traceback.print_exc() ChorusGlobals.get_logger().critical("Errors %s in db_info format: %s" % (str(e), str(db_info))) raise Exception("Errors %s in db_info format: %s" % (str(e), str(db_info)))
def execute_sql(sql, db_handler=None, keep_connection=True): '''execute sql and return a list format data''' try: data = [] if db_handler: conn = db_handler else: if "default_handler" in globals().keys(): conn = default_handler else: keep_connection = False conn = __init_connection(db_info) cursor = conn.cursor() ChorusGlobals.get_logger().info("Execute SQL '%s'" % sql) cursor.execute(sql) for row in cursor: data.append(row) conn.commit() except Exception, e: traceback.print_exc() ChorusGlobals.get_logger().critical("Errors in sql execution: %s" % e) raise Exception("Errors in sql execution: %s" % e)
def __init__(self, config_filename, config_filepath=None): self.CONFIG_KEY = CommonConstants.CONFIG_KEY self.logger = ChorusGlobals.get_logger() if config_filepath=="": config_filepath = "Config" else: config_filepath = "/".join("Config","config_file_path") self.cfg=Utils.read_config(config_filename, config_filepath) try: self.get_config() self.get_parameters() except Exception,e: self.logger.critical("Cannot get suite information from config file %s with error: %s" % (config_filename,str(e))) raise Exception("Cannot get suite information from config file %s with error: %s" % (config_filename,str(e)))
def execute_sql(sql, db_handler = None, keep_connection = True): '''execute sql and return a list format data''' try: data = [] if db_handler: conn = db_handler else: if "default_handler" in globals().keys(): conn = default_handler else: keep_connection = False conn = __init_connection(db_info) cursor = conn.cursor() ChorusGlobals.get_logger().info("Execute SQL '%s'" % sql) cursor.execute(sql) for row in cursor: data.append(row) conn.commit() except Exception, e: traceback.print_exc() ChorusGlobals.get_logger().critical("Errors in sql execution: %s" % e) raise Exception("Errors in sql execution: %s" % e)
def setUpClass(cls): ''' setUpClass is executed every time before run a test suite ''' cls.suite_starttime = time.time() cls.logserver = ChorusGlobals.get_logserver() cls.logserver.flush_console() super(MyTestCase,cls).setUpClass() cls.logger = ChorusGlobals.get_logger() cls.suite_name = Utils.get_current_classname(cls) from VerificationManagement import VerificationManagement cls.vm = VerificationManagement() cls.result = cls.vm.check_suitebaseline(cls.suite_name) cls.timestamp = Utils.get_timestamp() cls.config = ChorusGlobals.get_configinfo() cls.parameters = ChorusGlobals.get_parameters()
def __init__(self, config_filename, config_filepath=None): self.CONFIG_KEY = CommonConstants.CONFIG_KEY self.logger = ChorusGlobals.get_logger() if config_filepath=="": config_filepath = "Config" else: config_filepath = os.path.join("Config",config_filepath) config_paths = config_filepath.split(os.path.sep) self.config_filepath = Utils.get_filestr(config_paths, config_filename) self.cfg=Utils.read_config(self.config_filepath) try: self.get_config() self.get_parameters() except Exception,e: traceback.print_exc() self.logger.critical("Cannot get suite information from config file %s with error: %s:%s" % (config_filename,str(Exception),str(e))) raise Exception("Cannot get suite information from config file %s with error: %s:%s" % (config_filename,str(Exception),str(e)))
def __init__(self): self.logger = ChorusGlobals.get_logger() self.config = ChorusGlobals.get_configinfo() ChorusGlobals.init_testresult() self.result = ChorusGlobals.get_testresult() self.get_project_run() self.xml_file = ChorusGlobals.get_xml_file() self.suite_dict = self.get_test_mapping() if self.xml_file: self.load_testsuites_from_xml() self.get_testsuites_from_xml() else: print "Doesn't have xml file to specify test execution order" self.filter_test_mapping() self.set_scope() self.get_testsuites() self.set_baselinepath() self.get_knownissues() ChorusGlobals.set_suitedict(self.suite_dict)
for row in cursor: data.append(row) conn.commit() except Exception, e: traceback.print_exc() ChorusGlobals.get_logger().critical("Errors in sql execution: %s" % e) raise Exception("Errors in sql execution: %s" % e) finally: if not keep_connection: if 'cursor' in locals(): cursor.close() if 'conn' in locals(): conn.close() ChorusGlobals.get_logger().info("close mysql connection") return data def execute_sql_dict(sql, db_handler=None, keep_connection=True): '''execute sql and return a dict format data''' try: data = [] datadict = [] if db_handler: conn = db_handler else: if "default_handler" in globals().keys(): conn = default_handler else: keep_connection = False
def __init__(self): self.result = ChorusGlobals.get_testresult() self.logger = ChorusGlobals.get_logger() self.baseline_path = ChorusGlobals.get_baselinepath() self.output_path = ChorusGlobals.get_outputdir()
def __init__(self, imga, imgb, lb=1, tol=15): """Store the images in the instance.""" self.logger = ChorusGlobals.get_logger() self._imga, self._imgb, self._lb, self._tol = imga, imgb, lb, tol
for row in cursor: data.append(row) conn.commit() except Exception, e: traceback.print_exc() ChorusGlobals.get_logger().critical("Errors in sql execution: %s" % e) raise Exception("Errors in sql execution: %s" % e) finally: if not keep_connection: if 'cursor' in locals(): cursor.close() if 'conn' in locals(): conn.close() ChorusGlobals.get_logger().info("close mysql connection") return data def execute_sql_dict(sql, db_handler = None, keep_connection = True): '''execute sql and return a dict format data''' try: data = [] datadict=[] if db_handler: conn = db_handler else: if "default_handler" in globals().keys(): conn = default_handler else: keep_connection = False conn = __init_connection(db_info)