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 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 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):
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, 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())
