def getPlancase(self,
planid,
caseid=None,
owner=None,
status=None,
scenarioName=None,
caseName=None,
fields='*'):
sql = self.sqlConn.getSql("plancase", Sql.select, True, fields)
sql.appendWhereByJson({
'planid': planid,
"caseid": caseid,
"status": status
})
if not Sql.isEmpty(owner):
owner = '%%%s%%' % owner
sql.appendCondition("(owner like '%s')", (owner, ))
if not Sql.isEmpty(scenarioName):
caseTags = '%%%s%%' % scenarioName
sql.appendCondition("(tags like '%s' or scenario like '%s')",
(caseTags, caseTags))
if not Sql.isEmpty(caseName):
caseName = '%%%s%%' % caseName
sql.appendCondition("(name like '%s')", (caseName, ))
sql.orderBy('tags,scenario,caseid')
return sql.execute()
def saveCtestplanStatus(self,
planid,
status=None,
progress=None,
starttime=None,
endtime=None,
mailto=None,
mailfrom=None,
mailcc=None):
if Sql.isEmpty(planid):
return 0
if Sql.isEmpty(mailto): mailto = None
if Sql.isEmpty(mailfrom): mailfrom = None
if Sql.isEmpty(mailcc): mailcc = None
sql = self.sqlConn.getSql("testplan", Sql.update, True)
sql.appendValueByJson({
'status': status,
'progress': progress,
'starttime': starttime,
'endtime': endtime,
'mailto': mailto,
'mailfrom': mailfrom,
'mailcc': mailcc
})
sql.appendWhere("planid", planid)
return sql.execute()
def getTestEnv(self,
envname,
hostip,
vmaccount,
owner,
ownerStatus,
fnid,
nid1,
nid2,
testenvid=None):
sql = self.sqlConn.getSql("testenv", Sql.select, True)
sql.appendWhereByJson({
'hostip': hostip,
'owner': owner,
'ownerStatus': ownerStatus
})
sql.startCondition().appendWhere(
'fnid', fnid,
isAnd=False).appendWhere('nid1', nid1, isAnd=False).appendWhere(
'nid2', nid2, isAnd=False).endCondition()
if not Sql.isEmpty(vmaccount):
vmaccount = '%%%s%%' % vmaccount
sql.appendCondition("(vmaccount like '%s')", (vmaccount, ))
if not Sql.isEmpty(envname):
envname = '%%%s%%' % envname
sql.appendCondition("(envname like '%s' or tags like '%s')",
(envname, envname))
# 'vmammounts': vmammounts
# 'ownerStartTime': ownerStartTime, 'ownerEndTime': ownerEndTime,
sql.appendWhere("testenvid", testenvid)
return sql.execute()
def _makeTimeBetween(self, sql, cstarttime, cendtime, sqlStart, sqlEnd):
if not Sql.isEmpty(cstarttime):
if not Sql.isEmpty(cendtime):
sql.appendCondition("(({0}<='%s' and '%s'<={1}) or ({0}<='%s' and '%s'<={1}) or ('%s'<={0} and {0}<='%s'))".format(sqlStart, sqlEnd), \
(cstarttime, cstarttime, cendtime, cendtime, cstarttime, cendtime))
else:
sql.appendCondition("(%s>='%s')", (sqlEnd, cstarttime))
elif not Sql.isEmpty(cendtime):
sql.appendCondition("(%s<='%s')", (sqlStart, cendtime))
def savePlancase(self,
planid=None,
caseid=None,
scenario=None,
tags=None,
name=None,
owner=None,
status=None,
remark=None,
plancaseid=None):
# status: not-start, executing, passed, failed
modifytime = TimmerOperation.getFormatTime(time.time())
sql = self.sqlConn.getSql(
"plancase", Sql.insert if Sql.isEmpty(plancaseid) else Sql.update,
True)
sql.appendValueByJson({
'planid': planid,
"caseid": caseid,
"tags": tags,
"scenario": scenario,
"name": name,
'owner': owner,
'remark': remark,
"status": status,
"modifytime": modifytime
})
sql.appendWhere("plancaseid", plancaseid)
return sql.execute()
def savePlandaily(self,
planid,
day,
status,
progress,
caseprogress,
costtime,
costman,
summary,
issues,
dailyId=None):
sql = self.sqlConn.getSql(
"plandaily", Sql.insert if Sql.isEmpty(dailyId) else Sql.update,
True)
sql.appendValueByJson({
'planid': planid,
"day": day,
"status": status,
"progress": progress,
'caseprogress': caseprogress,
'costtime': costtime,
'costman': costman,
'summary': summary,
'issues': issues,
"dailyId": dailyId
})
sql.appendWhere("dailyId", dailyId)
return sql.execute()
def updateCtestplan(self, planid, plan):
if Sql.isEmpty(planid):return 0
tryget = ObjOperation.tryGetVal
return self.dbapi.saveCtestplan(owner=tryget(plan, 'owner', None), ptype=tryget(plan, 'ptype', None),
priority=tryget(plan, 'priority', None), status=tryget(plan, 'status', None), progress=tryget(plan, 'progress', None),
pendtime=tryget(plan, 'pendtime', None), endtime=tryget(plan, 'endtime', None),
summary=tryget(plan, 'summary', None), issues=tryget(plan, 'issues', None), planid=planid)
def saveCtestcase(self,
scenario=None,
tags=None,
name=None,
ttype=None,
priority=None,
steps=None,
remark=None,
owner=None,
fnid=None,
nid1=None,
nid2=None,
caseid=None):
modifytime = TimmerOperation.getFormatTime(time.time())
sql = self.sqlConn.getSql(
"testcase", Sql.insert if Sql.isEmpty(caseid) else Sql.update,
True)
sql.appendValueByJson({
'scenario': scenario,
'tags': tags,
'name': name,
"ttype": ttype,
"priority": priority,
'steps': steps,
"remark": remark,
"owner": owner,
'modifytime': modifytime,
"fnid": fnid,
"nid1": nid1,
"nid2": nid2,
"caseid": caseid
})
sql.appendWhere("caseid", caseid)
return sql.execute()
def saveTestConfig(self,
cname,
calias,
status,
subject,
ckey,
stype,
ccontent,
owner,
fnid,
nid1,
nid2,
configid=None):
modifytime = TimmerOperation.getFormatTime(time.time())
sql = self.sqlConn.getSql(
"cconfig", Sql.insert if Sql.isEmpty(configid) else Sql.update,
True)
sql.appendValueByJson({
'cname': cname,
'calias': calias,
'status': status,
'subject': subject,
'ckey': ckey,
'stype': stype,
'ccontent': ccontent,
"owner": owner,
'modifytime': modifytime,
'fnid': fnid,
'nid1': nid1,
'nid2': nid2
})
sql.appendWhere("configid", configid)
return sql.execute()
def getCtestplan(self,
fnid=None,
nid1=None,
nid2=None,
nameOrTags=None,
ptype=None,
priority=None,
inStatus=None,
outStatus=None,
cstarttime=None,
cendtime=None,
owner=None,
name=None,
tags=None,
planid=None):
sql = self.sqlConn.getSql("testplan", Sql.select, True)
sql.startCondition().appendWhere(
'fnid', fnid,
isAnd=False).appendWhere('nid1', nid1, isAnd=False).appendWhere(
'nid2', nid2, isAnd=False).endCondition()
if not Sql.isEmpty(nameOrTags):
nameOrTags = '%%%s%%' % nameOrTags
sql.appendCondition(
"(name like '%s' or tags like '%s' or owner like '%s')",
(nameOrTags, nameOrTags, nameOrTags))
if not Sql.isEmpty(name):
name = '%%%s%%' % name
sql.appendWhere('name', name, 'like')
if not Sql.isEmpty(tags):
tags = '%%%s%%' % tags
sql.appendWhere('tags', tags, 'like')
sql.appendWhereByJson({
"owner": owner,
'priority': priority,
'status': inStatus,
"planid": planid
})
sql.appendWhere('ptype', ptype, 'in')
sql.appendWhere('status', outStatus, '!=')
self._makeTimeBetween(sql, cstarttime, cendtime, "pstarttime",
"pendtime")
sql.orderBy("status,pendtime,priority,ptype,fnid desc,tags,name")
return sql.execute()
def setPlancase(self,
plancaseid,
status,
owner,
planid=None,
curstatus=None):
# status: not-start, executing, passed, failed
if Sql.isEmpty(planid) and Sql.isEmpty(plancaseid): return 0
sql = self.sqlConn.getSql("plancase", Sql.update, True)
sql.appendValueByJson({"status": status, 'owner': owner})
sql.appendWhere("plancaseid", plancaseid).appendWhere(
"planid", planid).appendWhere("status", curstatus)
result = sql.execute()
if result > 0 and not Sql.isEmpty(plancaseid):
self.savePlancase(plancaseid=plancaseid)
return result
def __executeSql__(self, operation="show", fields="*", table="db", dbName="",
where="1=1", whereArgs="", affectRows=100, dbConfig="local"):
if Sql.isEmpty(dbConfig):
return "no db config"
if Sql.isEmpty(dbName):dbName = None
if Sql.isEmpty(affectRows):
affectRows = 100
affectRows, operationType = int(affectRows), operation[0:10].lower().strip()
try:
argIndex = 0
for arg in StrOperation.splitStr(whereArgs, ",", "'"):
where = where.replace("{%s}" % argIndex, arg)
argIndex += 1
except Exception as ex:
return ("%s" % ex)
conn = self.__getConn(dbConfig)
if operationType == "select":
query = "select %s from %s.%s where %s limit %s" % (fields, dbName, table, where, affectRows)
return conn.executeSql(query, True, dbName=dbName)
elif operationType == "update":
if self.isCheckUpdate:
query = "select count(1) as affectRows from %s.%s where %s " % (dbName, table, where)
actAffectRows = conn.executeSql(query, True, dbName=dbName)[0]['affectRows']
else:
actAffectRows = affectRows
if actAffectRows == affectRows:
update = "update %s.%s set %s where %s limit %s" % (dbName, table, fields, where, affectRows)
return conn.executeSql(update, isSelect=False, isCommit=True, dbName=dbName)
else:
return "Actual %s != Expect %s" % (actAffectRows, affectRows)
elif self.isSupportDelete and operationType == "delete":
delete = "delete from %s.%s where %s limit %s" % (dbName, table, where, affectRows)
return conn.executeSql(delete, isSelect=False, isCommit=True, dbName=dbName)
elif operationType == "show":
if Sql.isEmpty(dbName):
return conn.executeSql("show databases", dbName=dbName)
else:
return conn.executeSql("show tables", dbName=dbName)
elif self.isSupportAnySql:
return conn.executeSql(operation, dbName=dbName)
else:
return "Bad operation %s" % operation
def saveCdeploy(self,
version=None,
procode=None,
proname=None,
protype=None,
branch=None,
brancharg=None,
pendtime=None,
creator=None,
owner=None,
notifyer=None,
remark=None,
attach=None,
fnid=None,
nid1=None,
nid2=None,
phase=None,
status=None,
deployarg=None,
deploytimes=None,
isSetModifytime=False,
deployid=None):
creattime = TimmerOperation.getFormatTime(
time.time()) if deployid is None else None
modifytime = TimmerOperation.getFormatTime(
time.time()) if isSetModifytime else None
creator = creator if deployid is None else None
sql = self.sqlConn.getSql(
"cdeploy", Sql.insert if Sql.isEmpty(deployid) else Sql.update,
True)
sql.appendValueByJson({
'version': version,
'procode': procode,
'proname': proname,
'protype': protype,
'branch': branch,
'brancharg': brancharg,
'pendtime': pendtime,
"creator": creator,
"owner": owner,
"notifyer": notifyer,
"remark": remark,
'attach': attach,
'creattime': creattime,
'modifytime': modifytime,
"phase": phase,
"status": status,
"deployarg": deployarg,
'deploytimes': deploytimes,
'fnid': fnid,
'nid1': nid1,
'nid2': nid2
})
sql.appendWhere("deployid", deployid)
return sql.execute()
def startDeploy(self, deployid, deployargs, __session__):
if Sql.isEmpty(deployid):raise Exception("Not found deployid")
deploy = self.dbapi.getCdeploy(deployid=deployid)[0]
owner = __session__['name']
if self._isRelativeDeploy(owner, deploy):
if deploy['status'] == '1': return deploy['status']
self.dbapi.saveCdeploy(status=1, deployarg=deployargs, deploytimes=deploy['deploytimes'] + 1, isSetModifytime=True, deployid=deployid)
return "1"
else:
raise Exception("Not the creator or owner")
def getCdeploy(self,
branchversion=None,
projectremark=None,
phase=None,
creator=None,
fnid=None,
nid1=None,
nid2=None,
cstarttime=None,
cendtime=None,
deployid=None):
sql = self.sqlConn.getSql("cdeploy", Sql.select, True)
sql.appendWhereByJson({'deployid': deployid})
if phase == '9':
sql.appendWhere("phase", 4, "!=")
else:
sql.appendWhere("phase", phase)
sql.startCondition().appendWhere(
'fnid', fnid,
isAnd=False).appendWhere('nid1', nid1, isAnd=False).appendWhere(
'nid2', nid2, isAnd=False).endCondition()
if creator is not None:
sql.appendCondition(
"(creator='%s' or owner='%s' or notifyer like '%%%s%%')",
(creator, creator, creator))
if not Sql.isEmpty(branchversion):
branchversion = '%%%s%%' % branchversion
sql.appendCondition("(branch like '%s' or version like '%s')",
(branchversion, branchversion))
if not Sql.isEmpty(projectremark):
projectremark = '%%%s%%' % projectremark
sql.appendCondition("(procode like '%s' or remark like '%s')",
(projectremark, projectremark))
self._makeTimeBetween(sql, cstarttime, cendtime, "creattime",
"pendtime")
sql.orderBy("version,procode")
return sql.execute()
def saveCtestplan(self,
name=None,
owner=None,
version=None,
tags=None,
summary=None,
issues=None,
ptype=None,
priority=None,
status=None,
progress=None,
pstarttime=None,
pendtime=None,
starttime=None,
endtime=None,
mailto=None,
fnid=None,
nid1=None,
nid2=None,
planid=None):
# status: created, executing, finished, paused
pstarttime = self._checkDate(pstarttime)
pendtime = self._checkDate(pendtime)
starttime = self._checkDate(starttime)
endtime = self._checkDate(endtime)
sql = self.sqlConn.getSql(
"testplan", Sql.insert if Sql.isEmpty(planid) else Sql.update,
True)
sql.appendValueByJson({
'name': name,
'owner': owner,
'version': version,
'tags': tags,
'summary': summary,
'issues': issues,
'ptype': ptype,
'priority': priority,
"status": status,
"progress": progress,
'pstarttime': pstarttime,
"pendtime": pendtime,
"starttime": starttime,
'endtime': endtime,
"mailto": mailto,
"fnid": fnid,
"nid1": nid1,
"nid2": nid2,
"planid": planid
})
sql.appendWhere("planid", planid)
return sql.execute()
def syncPlancase(self, planid):
for plancase in self.dbapi.getPlancase(planid, fields='plancaseid,caseid,remark'):
plancaseid, caseid, remark = plancase['plancaseid'], plancase['caseid'], plancase['remark']
case = self.dbapi.getCtestcase(caseid=caseid)
if len(case) == 0:
self.dbapi.deletePlancase(plancaseid)
else:
scenario, name = case[0]['scenario'], case[0]['name']
if Sql.isEmpty(remark):
remark = case[0]['remark']
else:
remark = None
self.dbapi.savePlancase(scenario=scenario, name=name, remark=remark, plancaseid=plancaseid)
def addDeploy(self, version, procode, branch, pendtime=None, owner=None, notifyer=None, remark=None, attach=None,
fnid=None, nid1=None, nid2=None, phaseInit=False, deployid=None, __session__=None):
proname, protype, brancharg, deployarg = None, None, None, None
phase, status = (1 if phaseInit else 0, 0) if deployid is None else (None, None)
creator = __session__['name']
if deployid is not None:
deploy = self.dbapi.getCdeploy(deployid=deployid)[0]
if not __session__['admin'] and not self._isRelativeDeploy(creator, deploy):
raise Exception("Not the creator or owner")
if not Sql.isEmpty(attach):
attach = toJsonStr(attach)
return self.dbapi.saveCdeploy(version, procode, proname, protype, branch, brancharg, pendtime,
creator, owner, notifyer, remark, attach, fnid, nid1, nid2, phase, status, deployarg, deployid=deployid)
def getTestConfig(self,
subject=None,
stype=None,
cname=None,
ckey=None,
fnid=None,
nid1=None,
nid2=None,
status=None,
fields='*',
configid=None):
sql = self.sqlConn.getSql("cconfig", Sql.select, True, fields)
sql.appendWhereByJson({
'configid': configid,
'stype': stype,
'status': status
})
sql.startCondition().appendWhere(
'fnid', fnid,
isAnd=False).appendWhere('nid1', nid1, isAnd=False).appendWhere(
'nid2', nid2, isAnd=False).endCondition()
if not Sql.isEmpty(subject):
subject = '%%%s%%' % subject
sql.appendCondition("(subject like '%s')", (subject, ))
if not Sql.isEmpty(cname):
cname = '%%%s%%' % cname
sql.appendCondition("(cname like '%s' or calias like '%s')",
(cname, cname))
if not Sql.isEmpty(ckey):
ckey = '%%%s%%' % ckey
sql.appendCondition("(ckey like '%s')", (ckey, ))
sql.orderBy("subject,ckey,cname")
return sql.execute()
def getCtestcase(self,
fnid=None,
nid1=None,
nid2=None,
searchKey=None,
ttype=None,
priority=None,
name=None,
owner=None,
planid=None,
caseid=None,
isInplan=True):
sql = self.sqlConn.getSql("testcase", Sql.select, True)
sql.startCondition().appendWhere(
'fnid', fnid,
isAnd=False).appendWhere('nid1', nid1, isAnd=False).appendWhere(
'nid2', nid2, isAnd=False).endCondition()
sql.appendWhereByJson({
'name': name,
"ttype": ttype,
"priority": priority,
"owner": owner,
"caseid": caseid
})
if not Sql.isEmpty(planid):
sql.appendCondition(
"caseid %s in (select caseid from plancase where planid=%s)",
("" if isInplan else "not", planid))
if not Sql.isEmpty(searchKey):
searchKey = '%%%s%%' % searchKey
sql.appendCondition(
"(name like '%s' or tags like '%s'or scenario like '%s')",
(searchKey, searchKey, searchKey))
sql.orderBy("scenario,oindex")
return sql.execute()
def getCtestplanById(self, planid):
if Sql.isEmpty(planid):
return
plans = self.dbapi.getCtestplan(planid=planid)
if len(plans) > 0:
plan = plans[0]
planStatus = cprop.getVal('plan', 'planStatus').split()
plan['planStatus'] = planStatus[plan['status']]
if plan['version'] is None:plan['version'] = ""
plan['pstarttime'] = str(plan['pstarttime']).split()[0]
plan['pendtime'] = str(plan['pendtime']).split()[0]
plan['starttime'] = str(plan['starttime']).split()[0]
plan['endtime'] = str(plan['endtime']).split()[0]
plan['reportTarget'] = cprop.getVal('plan', 'reportTarget').format(**plan)
plan['reportSummary'] = cprop.getVal('plan', 'reportSummary').format(**plan)
caseprogress = self.calcPlancaseprogress(planid)
plan['reportSummary'] = plan['reportSummary'].format(caseprogress=caseprogress)
return plans
def saveTestEnv(self,
envname,
tags,
hostip,
hostaccount,
hostinfo,
vmaccount,
vmammounts,
vminfo,
owner,
ownerStatus,
ownerInfo,
ownerStartTime,
ownerEndTime,
fnid,
nid1,
nid2,
testenvid=None):
sql = self.sqlConn.getSql(
"testenv", Sql.insert if Sql.isEmpty(testenvid) else Sql.update,
True)
sql.appendValueByJson({
'envname': envname,
'tags': tags,
'hostip': hostip,
'hostaccount': hostaccount,
'hostinfo': hostinfo,
'vmaccount': vmaccount,
'vmammounts': vmammounts,
'vminfo': vminfo,
'owner': owner,
'ownerStatus': ownerStatus,
'ownerInfo': ownerInfo,
'ownerStartTime': ownerStartTime,
'ownerEndTime': ownerEndTime,
'fnid': fnid,
'nid1': nid1,
'nid2': nid2
})
sql.appendWhere("testenvid", testenvid)
return sql.execute()
def deleteCdeploy(self, deployid, creator):
if Sql.isEmpty(deployid):
return 0
sql = self.sqlConn.getSql("cdeploy", Sql.delete, True)
sql.appendWhere("deployid", deployid).appendWhere("creator", creator)
return sql.execute()
def deleteCtestcase(self, caseid):
if Sql.isEmpty(caseid):
return 0
sql = self.sqlConn.getSql("testcase", Sql.delete, True)
sql.appendWhere("caseid", caseid)
return sql.execute()
def _checkDate(self, d):
return None if Sql.isEmpty(d) else d
def deleteTestConfig(self, configid):
if Sql.isEmpty(configid):
return 0
sql = self.sqlConn.getSql("cconfig", Sql.delete, True)
sql.appendWhere("configid", configid)
return sql.execute()
def deletePlancase(self, plancaseid):
if Sql.isEmpty(plancaseid):
return 0
sql = self.sqlConn.getSql("plancase", Sql.delete, True)
sql.appendWhere("plancaseid", plancaseid)
return sql.execute()
def deleteCtree(self, nid):
if Sql.isEmpty(nid):
return 0
sql = self.sqlConn.getSql("ctree", Sql.delete, True)
sql.appendWhere("nid", nid)
return sql.execute()
def deleteTestEnv(self, testenvid):
if Sql.isEmpty(testenvid):
return 0
sql = self.sqlConn.getSql("testenv", Sql.delete, True)
sql.appendWhere("testenvid", testenvid)
return sql.execute()
def deleteCtestplan(self, planid):
if Sql.isEmpty(planid):
return 0
sql = self.sqlConn.getSql("testplan", Sql.delete, True)
sql.appendWhere("planid", planid)
return sql.execute()
