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 set_baselinepath(self): self.baselinepath = self.BASELINE_PATH if self.config.has_key("baseline"): paths = self.config["baseline"].split(".") for path in paths: self.baselinepath.append(path) ChorusGlobals.set_baselinepath(self.baselinepath)
def set_configfile(self): configfile = ConfigFile(self.options.configfile,self.options.configpath) configfile.get_env(self.options.env) self.parameters = configfile.parameters self.config = configfile.config ChorusGlobals.set_parameters(self.parameters) ChorusGlobals.set_configinfo(self.config)
def set_output_folder(self): '''Set output folder Input: options.outputpath Output: self.outputdir, ChorusGlobals.outputdir''' self.outputdir = os.path.abspath(Utils.create_folder(self.options.outputpath, "Output", True)) ChorusGlobals.set_outputdir(self.outputdir) print "Set output directory to %s" % self.outputdir
def set_output_folder(self): '''Set output folder Input: options.outputpath Output: self.outputdir, ChorusGlobals.outputdir''' self.outputdir = Utils.create_folder(self.options.outputpath, "Output", True) ChorusGlobals.set_outputdir(self.outputdir) print "Set output directory to %s" % self.outputdir
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 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 __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_knownissues(self): if os.environ.has_key(CommonConstants.KNOWN_ISSUE_KEY): known_issue_list = Utils.get_dict_from_json(os.environ[CommonConstants.KNOWN_ISSUE_KEY]) ChorusGlobals.set_knownissuelist(known_issue_list) self.logger.info("Known issue list found in environment variables") else: ChorusGlobals.set_knownissuelist(None) self.logger.debug("No known issue list found in environment variables")
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 set_xml_file(self): if self.options.xml: if os.path.isfile(self.options.xml): if str(self.options.xml).endswith(".xml"): ChorusGlobals.set_xml_file(self.options.xml) print "Load test execution infomation from file %s"%(str(self.options.xml)) return else: print "The test execution configuration file should be an XML file" else: print "Can't find xml file %s" % (str(self.options.xml)) ChorusGlobals.set_xml_file(None)
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 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 ''' 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 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 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 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 __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, 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.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 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 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 __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, 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)
def set_baselineinfo(self): self.updateinfo = { "output_path": self.output_path.replace("\\","\\\\"), "baseline_path": os.path.abspath(Utils.get_filestr(self.baseline_path)).replace("\\","\\\\") } self.logger.info("Getting svn info for update baseline...") svnflag, svninfo = Utils.get_svninfo() self.updateinfo["svn_message"] = None if svnflag else svninfo self.updateinfo["svn_baseline_link"] = svninfo + "/" + "/".join(self.baseline_path) if svnflag else "" if os.environ.has_key("BUILD_URL"): self.updateinfo["ci_link"] = os.environ["BUILD_URL"] + "HTML_Report" config = ChorusGlobals.get_configinfo() self.updateinfo["chorus_server"] = config.get("Chorus_Server") or os.environ.get("Chorus_Server") or "http://chorusserver.labs.microstrategy.com:8765" self.updateinfo["chorus_home"] = config.get("Chorus_Home") or os.environ.get("Chorus_Home") or "http://localhost:8765" if self.updateinfo["chorus_server"] and self.updateinfo["chorus_server"].endswith("/"): self.updateinfo["chorus_server"] = self.updateinfo["chorus_server"][:-1] if self.updateinfo["chorus_home"].endswith("/"): self.updateinfo["chorus_home"] = self.updateinfo["chorus_home"][:-1]
def setUp(self): ''' setUp is executed every time before run a test case you can do some initial work here ''' self.startTime = time.time() #has dependency test case if len(self.depends) > 0: suites = ChorusGlobals.get_testresult().suites.values() mapping = {} for s in suites: cases = s.cases for key, value in cases.iteritems(): mapping[key] = value.statusflag for d in self.depends: if mapping.has_key(d) and not mapping[d]: self.addCleanup(self.tearDown) raise Exception("Has failed dependency test case %s" %(str(d))) unittest.TestCase.setUp(self)
def setUp(self): ''' setUp is executed every time before run a test case you can do some initial work here ''' self.startTime = time.time() #has dependency test case if len(self.depends) > 0: suites = ChorusGlobals.get_testresult().suites.values() mapping = {} for s in suites: cases = s.cases for key, value in cases.iteritems(): mapping[key] = value.statusflag for d in self.depends: if mapping.has_key(d) and not mapping[d]: self.addCleanup(self.tearDown) raise Exception("Has failed dependency test case %s" % (str(d))) unittest.TestCase.setUp(self)
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 set_logserver(self, name = LogType.ChorusCore, level=Level.debug, formatter=Formatter.Console): self.logserver=LogServer(name, level, formatter, colorconsole = False if not hasattr(self,"options") else self.options.color) ChorusGlobals.set_logserver(self.logserver) ChorusGlobals.set_logger(self.logserver.get_logger())
def set_logserver(self, name = LogType.ChorusCore, level=Level.debug, formatter=Formatter.Console): self.logserver=LogServer(name, level, formatter, colorconsole = self.options.color) ChorusGlobals.set_logserver(self.logserver) ChorusGlobals.set_logger(self.logserver.get_logger())