diff --git a/basic/component.py b/basic/component.py index b228e21..679408c 100644 --- a/basic/component.py +++ b/basic/component.py @@ -8,15 +8,10 @@ # --------------------------------------------------------------------- from datetime import datetime -import components.sysmonitor -import components.testexec -import components.report -import components.maintain -import components.catalog +import basic.testexec import basic.message import basic.program import inspect -import threading class CompData: @@ -29,7 +24,7 @@ class CompData: #class Component(components.sysmonitor.SystemMonitor, components.testexec.Testexecuter, components.report.Report, # components.maintain.Maintainer, components.catalog, threading.Thread): -class Component(components.testexec.Testexecuter): +class Component(basic.testexec.Testexecuter): """ A component represents an application of the system-under-test or a data-artifact which is created from the system-under-test. As the representation it has to knowlegde of the url, which other components depends on this component. diff --git a/basic/program.py b/basic/program.py index 615896a..417d000 100644 --- a/basic/program.py +++ b/basic/program.py @@ -134,9 +134,16 @@ class Job: @staticmethod def popInstance(pjob=None): + """ pop and stop a subjob """ if pjob is not None and Job.__instance is not None and Job.__instance != pjob: raise Exception(B.EXP_CANT_POP) + # for guarantee that both the stack and the original variable is empty if one is empty if len(Job.instances) < 1: + Job.__instance = None + return None + if Job.__instance is None: + while len(Job.instances) > 0: + Job.instances.pop() return None if len(Job.instances) == 1: job = Job.__instance @@ -160,6 +167,7 @@ class Job: @staticmethod def pushInstance(pjob): + """ push a new created subjob """ if len(Job.instances) > 0: job = Job.instances.pop() if pjob is not None and job is not None and job != pjob: @@ -404,11 +412,11 @@ class Parameter: if dirpath is not None: utils.path_tool.extractPath(dirpath[0], dirpath[1]) + def setParameterLoaded(self): job = Job.getInstance() print("setParLoaded " ) readedPar = job.loadParameter() - if readedPar is not None: for k in readedPar["par"].keys(): if not hasattr(self, k): diff --git a/test/constants.py b/test/constants.py index 53cad32..8b6fe23 100644 --- a/test/constants.py +++ b/test/constants.py @@ -1,2 +1,3 @@ HOME_PATH = "/home/ulrich/6_Projekte/Programme/datest" +DATA_PATH = "/home/ulrich/6_Projekte/Programme/data" OS_SYSTEM = "linux" \ No newline at end of file diff --git a/test/test_file.py b/test/test_file.py index afbc7c7..5b6de5e 100644 --- a/test/test_file.py +++ b/test/test_file.py @@ -8,60 +8,65 @@ import test.constants import test.testtools HOME_PATH = test.constants.HOME_PATH +DATA_PATH = test.constants.DATA_PATH TEST_FUNCTIONS = ["test_getFiles", "test_pathTool", "test_encoding"] class MyTestCase(unittest.TestCase): - mymsg = "" + mymsg = "" - def test_getFiles(self): - global mymsg - actfunction = str(inspect.currentframe().f_code.co_name) - cnttest = 0 - if actfunction not in TEST_FUNCTIONS: - return - job = test.testtools.getJob() - r = t.getFiles(job.m, job.conf.getPath("program") + "/utils", "file_.*.py", None) - self.assertEqual((len(r) == 1), True) - cnttest += 3 - r = t.getFiles(job.m, job.conf.getPath("program") + "/utils", "file__.*.py", None) - self.assertEqual((len(r) == 0), True) - r = t.getFiles(job.m, job.conf.getPath("program") + "/utils", ".*_tool.py", None) - self.assertEqual((len(r) > 2), True) - cnttest += 3 - r = t.getFilesRec(job.m, job.conf.getPath("program"), ".*?file.*.py") - MyTestCase.mymsg += "\n----- " + actfunction + " : " + str(cnttest) + def test_getFiles(self): + global mymsg + actfunction = str(inspect.currentframe().f_code.co_name) + cnttest = 0 + if actfunction not in TEST_FUNCTIONS: + return + job = test.testtools.getJob() + r = t.getFiles(job.m, job.conf.getPath("program") + "/utils", "^file_.*.py", None) + self.assertEqual(len(r), 1) + cnttest += 3 + r = t.getFiles(job.m, job.conf.getPath("program") + "/utils", "^file__.*.py", None) + self.assertEqual((len(r) == 0), True) + r = t.getFiles(job.m, job.conf.getPath("program") + "/utils", ".*_tool.py", None) + self.assertEqual((len(r) > 2), True) + cnttest += 3 + r = t.getFilesRec(job.m, job.conf.getPath("program"), ".*?file.*.py") + MyTestCase.mymsg += "\n----- " + actfunction + " : " + str(cnttest) - def test_pathTool(self): - global mymsg - actfunction = str(inspect.currentframe().f_code.co_name) - cnttest = 0 - if actfunction not in TEST_FUNCTIONS: - return - job = test.testtools.getJob() - #self.assertEqual(utils.path_tool.generatePath("program", "komp", "testA", "CONFIG.yml"), - # os.path.join(HOME_PATH, "components","testA","COFIG.yml")) - MyTestCase.mymsg += "\n----- " + actfunction + " : " + str(cnttest) + def test_pathTool(self): + global mymsg + actfunction = str(inspect.currentframe().f_code.co_name) + cnttest = 0 + if actfunction not in TEST_FUNCTIONS: + return + job = test.testtools.getJob() + #self.assertEqual(utils.path_tool.generatePath("program", "komp", "testA", "CONFIG.yml"), + # os.path.join(HOME_PATH, "components","testA","COFIG.yml")) + MyTestCase.mymsg += "\n----- " + actfunction + " : " + str(cnttest) - def test_encoding(self): - global mymsg - actfunction = str(inspect.currentframe().f_code.co_name) - cnttest = 0 - if actfunction not in TEST_FUNCTIONS: - return - job = test.testtools.getJob() - print("------- test_encoding") - encodings = ['utf-8', 'windows-1250', 'iso-8859-1'] - res = utils.file_tool.getFileEncoding(job.m, os.path.join(HOME_PATH,"test","conf","tdata","encoded_iso8859.txt")) - self.assertEqual(res, "iso-8859-1") - res = utils.file_tool.getFileEncoding(job.m, os.path.join(HOME_PATH,"test","conf","tdata","encoded_win1250.txt")) - self.assertEqual(res, "iso-8859-1") - res = utils.file_tool.getFileEncoding(job.m, os.path.join(HOME_PATH,"test","conf","tdata","encoded_utf8.txt")) - self.assertEqual(res, "utf-8") - cnttest += 3 - MyTestCase.mymsg += "\n----- " + actfunction + " : " + str(cnttest) + def test_encoding(self): + global mymsg + actfunction = str(inspect.currentframe().f_code.co_name) + cnttest = 0 + if actfunction not in TEST_FUNCTIONS: + return + job = test.testtools.getJob() + print("------- test_encoding") + encodings = ['utf-8', 'windows-1250', 'iso-8859-1'] + res = utils.file_tool.getFileEncoding(job.m, os.path.join(DATA_PATH, "tdata", "encoded_iso8859.txt")) + self.assertEqual(res, "iso-8859-1") + res = utils.file_tool.getFileEncoding(job.m, os.path.join(DATA_PATH, "tdata", "encoded_win1250.txt")) + self.assertEqual(res, "iso-8859-1") + res = utils.file_tool.getFileEncoding(job.m, os.path.join(DATA_PATH, "tdata", "encoded_utf8.txt")) + self.assertEqual(res, "utf-8") + cnttest += 3 + MyTestCase.mymsg += "\n----- " + actfunction + " : " + str(cnttest) + + + def test_zzz(self): + print(MyTestCase.mymsg) if __name__ == '__main__': diff --git a/test/test_path.py b/test/test_path.py index ded4629..a0d0d04 100644 --- a/test/test_path.py +++ b/test/test_path.py @@ -9,6 +9,7 @@ import test.testtools import utils.path_const as P HOME_PATH = test.constants.HOME_PATH +DATA_PATH = test.constants.DATA_PATH OS_SYSTEM = test.constants.OS_SYSTEM # here you can select single testfunction for developping the tests @@ -138,7 +139,7 @@ class MyTestCase(unittest.TestCase): return job = test.testtools.getJob() pt = utils.path_tool.PathConf() - r = utils.path_tool.extractPath("tsbase" , os.path.join(HOME_PATH, "test","conf","lauf","testlauf","startjob_2021-08-21_10-02-01")) + r = utils.path_tool.extractPath("tsbase" , os.path.join(DATA_PATH, "lauf", "testlauf", "startjob_2021-08-21_10-02-01")) print("r " + str(r)) #print(vars(job.par)) #self.assertEqual(job.par.release, "V0.1") diff --git a/test/test_report.py b/test/test_report.py index 16d7b9b..0808e04 100644 --- a/test/test_report.py +++ b/test/test_report.py @@ -1,12 +1,9 @@ import unittest -import os - -import basic.program +import inspect +import test.testtools import basic.program -import components.component +import basic.component from basic.componentHandling import ComponentManager -import init_testcase -import test_executer import test.constants import utils.report_tool import utils.match_tool @@ -14,8 +11,13 @@ import utils.match_const as M import basic.constants as B HOME_PATH = test.constants.HOME_PATH +DATA_PATH = test.constants.DATA_PATH +TEST_FUNCTIONS = ["test_20cssClass", "test_21title", "test_22overview", "test_23filename", + "test_24headlines", "test_30reportS"] +TEST_FUNCTIONS = ["test_21title"] class MyTestCase(unittest.TestCase): + mymsg = "--------------------------------------------------------------" def getReport(self): job = basic.program.Job.getInstance() @@ -38,20 +40,28 @@ class MyTestCase(unittest.TestCase): i = 0 return report - def test_cssClass(self): - job = basic.program.Job("unit") - args = { "application": "TEST", "environment": "ENV01", "modus": "unit", "tstime": "2022-03-19_12-09-09", - "tsdir": '/home/ulrich/6_Projekte/Programme/datest/test/conf/lauf/testlauf/TST001_2022-03-19_12-09-09', - "step": 2 } - # "usecase": "TST001", "tstime": "2022-03-17_17-28"} - job.par.setParameterArgs(args) - job.setProgram("test_executer") + def test_20cssClass(self): + global mymsg + actfunction = str(inspect.currentframe().f_code.co_name) + cnttest = 0 + if actfunction not in TEST_FUNCTIONS: + return + job = test.testtools.getJob() + #job = basic.program.Job("unit") + #args = { "application": "TEST", "environment": "ENV01", "modus": "unit", "tstime": "2022-03-19_12-09-09", + # "tsdir": '/home/ulrich/6_Projekte/Programme/datest/test/conf/lauf/testlauf/TST001_2022-03-19_12-09-09', + # "step": 2 } + ## "usecase": "TST001", "tstime": "2022-03-17_17-28"} + #job.par.setParameterArgs(args) + #job.setProgram("test_executer") + job = test.testtools.getJob() report = self.getReport() i = 0 for m in M.MATCH_TYPES: cssClass = report.getCssClass("TC0001", "comp01", "arte01", m) print(m + " test0111 " + cssClass) self.assertEqual(cssClass, "result"+str(i)) + cnttest += 1 i += 1 if i > 4: i = 0 @@ -67,11 +77,18 @@ class MyTestCase(unittest.TestCase): self.assertEqual(cssClass, "result1") cssClass = report.getCssClass("TC0002") self.assertEqual(cssClass, "result4") + cnttest += 4 + MyTestCase.mymsg += "\n----- "+actfunction+" : "+str(cnttest) - def test_title(self): - job = basic.program.Job.getInstance() + def test_21title(self): + global mymsg + actfunction = str(inspect.currentframe().f_code.co_name) + cnttest = 0 + if actfunction not in TEST_FUNCTIONS: + return + job = test.testtools.getJob() print(" ---------- test_title") - setattr(job.par, "testsuite", "TST001") + setattr(job.par, B.PAR_TESTSUITE, "TST001") report = self.getReport() html = report.getTitle("TC0001", "comp01", "arte01", M.MATCH_POSTCOND) print(html) @@ -79,44 +96,64 @@ class MyTestCase(unittest.TestCase): self.assertEqual((utils.report_tool.REP_TITLE in html), True) self.assertEqual((utils.report_tool.REP_TC in html), True) self.assertEqual(("TC0001" in html), True) + cnttest += 3 html = report.getTitle() self.assertEqual((utils.report_tool.REP_TITLE in html), True) self.assertEqual((utils.report_tool.REP_TS in html), True) self.assertEqual(("TST001" in html), True) + cnttest += 3 + MyTestCase.mymsg += "\n----- "+actfunction+" : "+str(cnttest) - def test_overview(self): - job = basic.program.Job.getInstance() + def test_22overview(self): + global mymsg + actfunction = str(inspect.currentframe().f_code.co_name) + cnttest = 0 + if actfunction not in TEST_FUNCTIONS: + return + job = test.testtools.getJob() print(" ---------- test_overview") report = self.getReport() html = report.getOverview("TC0001") print(html) + MyTestCase.mymsg += "\n----- "+actfunction+" : "+str(cnttest) - def test_filename(self): - job = basic.program.Job.getInstance() + def test_23filename(self): + global mymsg + actfunction = str(inspect.currentframe().f_code.co_name) + cnttest = 0 + if actfunction not in TEST_FUNCTIONS: + return + #job = basic.program.Job.getInstance() + job = test.testtools.getJob() setattr(job.par, "testcase", "TC0001") setattr(job.par, "tctime", "2022-03-23_21-23-32") print(" ---------- test_filename") cm = basic.componentHandling.ComponentManager() for c in ["comp02"]: - comp = components.component.Component() + comp = basic.component.Component() comp.conf = {} comp.name = c - basic.componentHandling.comps[c] = comp + cm.comps[c] = comp report = self.getReport() html = report.getFilepath("TC0001", "comp02", "arte01", M.MATCH_POSTCOND) print(html) + MyTestCase.mymsg += "\n----- "+actfunction+" : "+str(cnttest) - - def test_headlines(self): - job = basic.program.Job.getInstance() + def test_24headlines(self): + global mymsg + actfunction = str(inspect.currentframe().f_code.co_name) + cnttest = 0 + if actfunction not in TEST_FUNCTIONS: + return + job = test.testtools.getJob() setattr(job.par, "testcase", "TC0001") setattr(job.par, "tctime", "2022-03-23_21-23-32") cm = basic.componentHandling.ComponentManager() for c in ["comp02"]: - comp = components.component.Component() + comp = basic.component.Component() comp.conf = {} comp.name = c - basic.componentHandling.comps[c] = comp + cm.comps[c] = comp print(" ---------- test_headlines") report = self.getReport() html = report.getTestcaseHead("TC0001") @@ -125,9 +162,15 @@ class MyTestCase(unittest.TestCase): print(html) html = report.getArtefactBlock("TC0001", "comp02", "arte01") print(html) + MyTestCase.mymsg += "\n----- "+actfunction+" : "+str(cnttest) - def xtest_reportS(self): - job = basic.program.Job.getInstance() + def test_30reportS(self): + global mymsg + actfunction = str(inspect.currentframe().f_code.co_name) + cnttest = 0 + if actfunction not in TEST_FUNCTIONS: + return + job = test.testtools.getJob() setattr(job.par, "testcase", "TC0001") setattr(job.par, "testcases", ["TC0001", "TC0002"]) setattr(job.par, "tctime", "2022-03-23_21-23-32") @@ -136,11 +179,11 @@ class MyTestCase(unittest.TestCase): cm = basic.componentHandling.ComponentManager() for compname in ["comp01", "comp02"]: conf = {} - comp = components.component.Component() + comp = basic.component.Component() comp.files = { "A": "/home/match/pre.csv", "B": "/home/match/post.csv"} comp.name = compname comp.conf = conf - basic.componentHandling.comps[compname] = comp + cm.comps[compname] = comp html_1 = report.reportTestcase("TC0001") print(html_1) print("<<---------------------------------- TC0001") @@ -154,8 +197,13 @@ class MyTestCase(unittest.TestCase): setattr(job.par, B.PAR_TESTCASES, ["TC0001", "TC0002"]) #html = report.reportTestsuite() #print(html) + MyTestCase.mymsg += "\n----- "+actfunction+" : "+str(cnttest) print("<<---------------------------------- TST001") + + def test_zzz(self): + print(MyTestCase.mymsg) + if __name__ == '__main__': unittest.main() diff --git a/test/test_toolhandling.py b/test/test_toolhandling.py index 7320604..ace4419 100644 --- a/test/test_toolhandling.py +++ b/test/test_toolhandling.py @@ -1,10 +1,9 @@ -import unittest, os +import unittest import basic.program -import utils.path_tool import basic.toolHandling import test.constants -import components.component +import basic.component import basic.constants as B HOME_PATH = test.constants.HOME_PATH @@ -20,14 +19,14 @@ class MyTestCase(unittest.TestCase): "modus": "unit"} job.par.setParameterArgs(args) #t = basic.toolHandling.ToolManager() - comp = components.component.Component() + comp = basic.component.Component() comp.name = "testb" comp.conf = {} comp.conf[B.SUBJECT_CONN] = {} comp.conf[B.SUBJECT_CONN][B.TOPIC_NODE_CLI] = {} #self.assertRaises(LookupError, basic.toolHandling.getDbTool, comp) - comp = components.component.Component() + comp = basic.component.Component() comp.name = "testb" comp.conf = {} comp.conf[B.SUBJECT_ARTS] = {} diff --git a/test/testtools.py b/test/testtools.py index 65b4897..b70689a 100644 --- a/test/testtools.py +++ b/test/testtools.py @@ -1,6 +1,7 @@ import basic.program import basic.constants as B -import components.component +import basic.component +import utils.data_const as D DEFAULT_GRAN = "tc" DEFAULT_APP = "TEST" @@ -15,6 +16,32 @@ tstamp = "" mode = "" path = "" +# xample-DDL +conf = { + B.SUBJECT_ARTS: { + B.TOPIC_NODE_DB: { + B.ATTR_TYPE: "csv", + "person": { + "tabname": "tbl_person" + } + }, + B.TOPIC_NODE_CLI: { + B.ATTR_TYPE: "cmd" + } + }, + B.DATA_NODE_DDL: { + "person": { + "id": { D.DDL_FNAME: "id", D.DDL_TYPE: "int", D.DDL_ACCEPTANCE: "ignore", D.DDL_KEY: "T:3" }, + "name": { D.DDL_FNAME: "name", D.DDL_TYPE: "string", D.DDL_ACCEPTANCE: "must", D.DDL_KEY: "F:1" }, + "birth": { D.DDL_FNAME: "id", D.DDL_TYPE: "date", D.DDL_ACCEPTANCE: "must", D.DDL_KEY: "" }, + "year": { D.DDL_FNAME: "year", D.DDL_TYPE: "int", D.DDL_ACCEPTANCE: "must", D.DDL_KEY: "F:2" }, + "position": { D.DDL_FNAME: "id", D.DDL_TYPE: "string", D.DDL_ACCEPTANCE: "must", D.DDL_KEY: "" }, + "hobby": { D.DDL_FNAME: "id", D.DDL_TYPE: "string", D.DDL_ACCEPTANCE: "must", D.DDL_KEY: "" }, + "_header": ["id", "name", "birth", "year", "position", "hobby"] + } + } +} + def getJob(pgran="", papp="", penv="", ptstamp="", pmode=""): job = basic.program.Job.popInstance() if not job is None: @@ -53,7 +80,8 @@ def getJob(pgran="", papp="", penv="", ptstamp="", pmode=""): def getComp(): - comp = components.component.Component() + comp = basic.component.Component() comp.conf = {} - comp.name = "testcomp" + comp.name = "person" + pass \ No newline at end of file diff --git a/utils/date_tool.py b/utils/date_tool.py index 76d493a..fd0918a 100644 --- a/utils/date_tool.py +++ b/utils/date_tool.py @@ -11,6 +11,7 @@ import utils.data_const as D F_DIR = "%Y-%m-%d_%H-%M-%S" F_DE = "%d.%m.%Y" +F_N8 = "%Y%m%d" def getActdate(format): return getFormatdate(datetime.datetime.now(), format) @@ -21,7 +22,22 @@ def getFormatdate(date, format): return date.strftime(format) +def getFormatDatetupel(dtupel, format): + """ it return the date as string in the format """ + if format == F_N8: + return f'{dtupel[0]:04}'+f'{dtupel[1]:02}'+f'{dtupel[2]:02}' + return getFormatdate(datetime.datetime(dtupel[0], dtupel[1], dtupel[2], + dtupel[3], dtupel[4], dtupel[5]) ,format) + + def parseFormula(instring): + """ + the function parses the string as a formula. In the formula the input-date - actdate or explicite date - + will be added resp. subtracted with years, months or dates which are specified in the formula. + The structure of the formula: DATE +/- mY +/-nM +/-qD + :param instring: + :return: + """ instring = instring.upper() if instring[2:6] == "DATE": refdate = datetime.datetime.today() @@ -70,6 +86,11 @@ def parseFormula(instring): def parseDate(instring): + """ + the function parses the string as a date or timestamp which is formed in one of the typical formates + :param the string to be parse: + :return timestamp as tupel (y, m, d, H, M ,S): + """ year = 0 mon = 0 day = 0 @@ -97,6 +118,11 @@ def parseDate(instring): mon = int(res.group(2)) day = int(res.group(1)) return (year, mon, day, hour, min, sec) + if re.match(r"\d{8}", instring): + year = instring[0:4] + mon = instring[4:6] + day = instring[6:8] + return (year, mon, day, hour, min, sec) if re.match(r"\d{2}[-:]\d{2}[-:/]\d{2}", instring): res = re.match(r"(\d{2})[-:/](\d{2})[-:/](\d{2})", instring) hour = int(res.group(1))