You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
280 lines
9.0 KiB
280 lines
9.0 KiB
#!/usr/bin/python
|
|
# program to execute programs for a testcases or for a testsuite
|
|
# PARAM from INPUT: --granularity --application --environment --testcase/testsuite
|
|
# main functions
|
|
# + input_param() : cache-actjob --> user-input --> local-param
|
|
# + start_job() : local-param --> cache-actjob --> start-param
|
|
# ---------------------------------------------------
|
|
|
|
"""
|
|
|
|
"""
|
|
import os.path
|
|
import json
|
|
import re
|
|
|
|
import basic.program
|
|
import basic.constants as B
|
|
import tools.job_tool
|
|
import tools.file_tool
|
|
import tools.data_const as D
|
|
import tools.date_tool
|
|
import tools.path_tool
|
|
import tools.path_const as P
|
|
|
|
tempJob = {}
|
|
|
|
PROGRAM_NAME = "service"
|
|
|
|
DLG_TESTCASE = "Testfall"
|
|
DLG_TESTSUITE = "Testsuite"
|
|
DLG_COMPLETE = "Komplettausfuehrung"
|
|
LIST_DLG_GRAN = [DLG_TESTCASE, DLG_TESTSUITE]
|
|
DLG_START_QUESTION = "was soll getestet werden"
|
|
# DLG_TESTPLAN = "Testplan"
|
|
DLG_ENVIRONMENT = "Umgebung"
|
|
DLG_APPLICATION = "Anwendung"
|
|
DLG_REDO = "wiederholen"
|
|
DLG_CONTINUE = "fortsetzen"
|
|
DLG_DUMMY_STEP = "Dummy-Schritt"
|
|
DLG_NEWJOB = "neuer Job"
|
|
|
|
JOB_NR = {
|
|
DLG_TESTSUITE : {
|
|
"start": "init_testsuite",
|
|
"init_testsuite": {
|
|
"jobnr": "0" },
|
|
"execute_testsuite": {
|
|
"jobnr": "1"},
|
|
"collect_testsuite": {
|
|
"jobnr": "2"},
|
|
"compare_testsuite": {
|
|
"jobnr": "3"},
|
|
"finish_testsuite": {
|
|
"jobnr": "4"}
|
|
},
|
|
DLG_TESTCASE: {
|
|
"start": "init_testcase",
|
|
"init_testcase": {
|
|
"jobnr": "5" },
|
|
"execute_testcase": {
|
|
"jobnr": "6" },
|
|
"collect_testcase": {
|
|
"jobnr": "7" },
|
|
"copy_appdummy": {
|
|
"jobnr": "8" },
|
|
"compare_testcase": {
|
|
"jobnr": "9" },
|
|
},
|
|
"check_environment": {
|
|
"jobnr": "10" },
|
|
"test_executer": {
|
|
"jobnr": "11"},
|
|
}
|
|
|
|
JOB_LIST = [
|
|
"init_testsuite", # 0
|
|
"execute_testsuite", # 1
|
|
"collect_testsuite", # 2
|
|
"compare_testsuite", # 3
|
|
"finish_testsuite", # 4
|
|
"init_testcase", # 5
|
|
"execute_testcase", # 6
|
|
"collect_testcase", # 7
|
|
"copy_appdummy", # 8
|
|
"compare_testcase", # 9
|
|
"check_environment", # 10
|
|
"test_executer" # 11
|
|
]
|
|
|
|
appList = []
|
|
envList = []
|
|
entities = {}
|
|
entities[DLG_TESTCASE] = {}
|
|
entities[DLG_TESTSUITE] = {}
|
|
|
|
def readContext(job):
|
|
for k in job.conf[B.SUBJECT_APPS]:
|
|
appList.append(k)
|
|
path = job.conf[B.SUBJECT_PATH][B.ATTR_PATH_ENV]
|
|
if os.path.exists(path):
|
|
for d in os.listdir(path):
|
|
print ("-- "+d)
|
|
if not os.path.isdir(os.path.join(path, d)):
|
|
continue
|
|
if d[0:1] == "_":
|
|
continue
|
|
envList.append(d)
|
|
path = job.conf[B.SUBJECT_PATH][B.ATTR_PATH_TDATA]
|
|
if os.path.exists(path):
|
|
for d in os.listdir(path):
|
|
print("tdata path "+d)
|
|
if not os.path.isdir(os.path.join(path, d)):
|
|
print("continue a")
|
|
continue
|
|
if d[0:1] == "_":
|
|
print("continue b")
|
|
continue
|
|
specpath = os.path.join(path, d, D.DFILE_TESTCASE_NAME + ".csv")
|
|
readSpec(job, d, DLG_TESTCASE, specpath)
|
|
specpath = os.path.join(path, d, D.DFILE_TESTSUITE_NAME + ".csv")
|
|
readSpec(job, d, DLG_TESTSUITE, specpath)
|
|
|
|
def readSpec(job, testentity, testgran, specpath):
|
|
print("spec "+specpath)
|
|
if not os.path.isfile(specpath):
|
|
print("continue c")
|
|
return
|
|
text = tools.file_tool.read_file_text(job, specpath, job.m)
|
|
print("-----------\n"+text+"\n------------------")
|
|
if re.match(r".*?depricated;[jJyY]", text):
|
|
return
|
|
if re.match(r".*\nhead:application;", text):
|
|
print("## app gematcht")
|
|
res = re.search(r".*head:application;(.+)\n", text)
|
|
apps = res.group(1).replace(";", ",").split(",")
|
|
print("# "+str(apps))
|
|
for a in apps:
|
|
if len(a) < 1:
|
|
break
|
|
if a not in entities[testgran]:
|
|
entities[testgran][a] = []
|
|
print(a+" in "+testentity+" "+testgran+" -- "+str(entities))
|
|
entities[testgran][a].append(testentity)
|
|
|
|
def printProc(job, process):
|
|
print("--------------------------------------------------")
|
|
for k in process:
|
|
print("| {0:15s} : {1}".format(k, process[k]))
|
|
print("--------------------------------------------------")
|
|
|
|
|
|
def restartActualProcess(job):
|
|
"""
|
|
check if an actual process is open
|
|
:return:
|
|
"""
|
|
path = tools.path_tool.getActualJsonPath(job)
|
|
if os.path.exists(path):
|
|
actProc = tools.file_tool.read_file_dict(job, path, job.m)
|
|
print("restartActJob "+str(actProc))
|
|
printProc(job, actProc)
|
|
step = int(actProc["step"])
|
|
if actProc["program"] == "test_executer":
|
|
if step > 5:
|
|
dialogProcess(job)
|
|
else:
|
|
actProc["step"] = str(step+1)
|
|
tools.job_tool.start_child_process(job, actProc)
|
|
restartActualProcess(job)
|
|
selection = [DLG_NEWJOB, DLG_REDO]
|
|
|
|
nr = int(JOB_NR[actProc["gran"]][actProc["program"]]["jobnr"])
|
|
if (actProc["gran"] == DLG_TESTSUITE and nr < 4) or (actProc["gran"] == DLG_TESTCASE and nr < 9):
|
|
selection.append(DLG_CONTINUE)
|
|
if nr == 7:
|
|
selection.append(DLG_DUMMY_STEP)
|
|
choice = getChoice(job, selection, DLG_ENVIRONMENT)
|
|
print(choice)
|
|
if choice == DLG_REDO:
|
|
tools.job_tool.start_child_process(job, actProc)
|
|
restartActualProcess(job)
|
|
elif choice == DLG_DUMMY_STEP:
|
|
actProc["program"] = JOB_LIST[nr+1]
|
|
tools.job_tool.start_child_process(job, actProc)
|
|
restartActualProcess(job)
|
|
elif choice == DLG_CONTINUE:
|
|
if nr == 7:
|
|
nr = 9
|
|
else:
|
|
nr += 1
|
|
print (" act nr "+str(nr))
|
|
actProc["step"] = str(step + 1)
|
|
actProc["program"] = JOB_LIST[nr]
|
|
tools.job_tool.start_child_process(job, actProc)
|
|
elif choice == DLG_NEWJOB:
|
|
dialogProcess(job)
|
|
else:
|
|
dialogProcess(job)
|
|
|
|
|
|
def dialogProcess(job):
|
|
"""
|
|
dialog for selection and starting a process
|
|
:param job:
|
|
:return:
|
|
"""
|
|
process = {}
|
|
index = 0
|
|
print("create new process")
|
|
selection = []
|
|
selection = LIST_DLG_GRAN
|
|
if DLG_TESTCASE + " - " + DLG_COMPLETE not in selection:
|
|
selection.append(DLG_TESTCASE + " - " + DLG_COMPLETE)
|
|
if DLG_TESTSUITE + " - " + DLG_COMPLETE not in selection:
|
|
selection.append(DLG_TESTSUITE + " - " + DLG_COMPLETE)
|
|
choice = getChoice(job, LIST_DLG_GRAN, DLG_START_QUESTION)
|
|
if DLG_COMPLETE in choice:
|
|
process["gran"] = choice[0:-3-len(DLG_COMPLETE)]
|
|
process["program"] = "test_executer"
|
|
process["step"] = 1
|
|
else:
|
|
process["gran"] = choice
|
|
process["program"] = JOB_NR[process["gran"]]["start"]
|
|
process["step"] = 1
|
|
if len(appList) == 1:
|
|
process["app"] = appList[0]
|
|
else:
|
|
process["app"] = getChoice(job, appList, DLG_ENVIRONMENT)
|
|
#
|
|
if len(envList) == 1:
|
|
process["env"] = envList[0]
|
|
else:
|
|
process["env"] = getChoice(job, envList, DLG_ENVIRONMENT)
|
|
#
|
|
if len(entities[process["gran"]][process["app"]]) == 1:
|
|
process["entity"] = entities[process["gran"]][process["app"]][0]
|
|
else:
|
|
process["entity"] = getChoice(job, entities[process["gran"]][process["app"]], process["gran"])
|
|
print(str(process))
|
|
setattr(job.par, B.PAR_ENV, process["env"])
|
|
setattr(job.par, B.PAR_APP, process["app"])
|
|
if process["gran"] == DLG_TESTCASE:
|
|
setattr(job.par, B.PAR_TESTCASE, process["entity"])
|
|
setattr(job.par, B.PAR_TCTIME, tools.date_tool.getActdate(tools.date_tool.F_DIR))
|
|
path = tools.path_tool.composePattern(job, "{"+P.P_TCBASE+"}", None)
|
|
process[B.PAR_TCDIR] = path
|
|
elif process["gran"] == DLG_TESTSUITE:
|
|
setattr(job.par, B.PAR_TESTSUITE, process["entity"])
|
|
setattr(job.par, B.PAR_TSTIME, tools.date_tool.getActdate(tools.date_tool.F_DIR))
|
|
path = tools.path_tool.composePattern(job, "{"+P.P_TSBASE+"}", None)
|
|
process[B.PAR_TSDIR] = path
|
|
tools.job_tool.start_child_process(job, process)
|
|
restartActualProcess(job)
|
|
|
|
def getChoice(job, choiselist, description):
|
|
index = 0
|
|
print("+------------- "+description+" ----------")
|
|
print('| | {:2d} : {:60s}'.format(0, "exit"))
|
|
for k in choiselist:
|
|
index += 1
|
|
print('| | {:2d} : {:60s}'.format(index, k))
|
|
print("+-----------------------------------------------")
|
|
choice = input("Auswahl 1-" + str(index) + ": ")
|
|
if not choice.isnumeric():
|
|
print("FEHLER Fehleingabe "+choice)
|
|
getChoice(job, choiselist, description)
|
|
elif int(choice) < 1:
|
|
exit(0)
|
|
elif int(choice) > index:
|
|
print("FEHLER Fehleingabe "+choice)
|
|
getChoice(job, choiselist, description)
|
|
else:
|
|
return choiselist[int(choice) - 1]
|
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
job = basic.program.Job(PROGRAM_NAME, "", {})
|
|
readContext(job)
|
|
restartActualProcess(job)
|
|
|