From cdf12cf68b7c56d0ed58cd4502169cb84a5679ea Mon Sep 17 00:00:00 2001 From: Ulrich Date: Wed, 11 Jan 2023 20:42:59 +0100 Subject: [PATCH] start dialog: testsuite --- basic/component.py | 2 +- basic/constants.py | 2 +- basic/program.py | 2 +- model/application.py | 74 +++++++++---------- model/catalog.py | 4 +- {basic => model}/entity.py | 32 +++++++- model/environment.py | 41 ++++++++++ {basic => model}/testcase.py | 55 +++++++++++++- {basic => model}/testplan.py | 4 +- {basic => model}/testsuite.py | 56 +++++++++++++- test/test_07catalog.py | 2 +- test/test_20application.py | 40 ++++++++++ test/test_21environment.py | 41 ++++++++++ test/test_26testsuite.py | 41 ++++++++++ test/{test_21tdata.py => test_31tdata.py} | 4 +- test/{test_22compare.py => test_42compare.py} | 0 test/{test_23report.py => test_43report.py} | 2 +- test/{test_24gen.py => test_44gen.py} | 0 {utils => tools}/git_tool.py | 0 unit_tester.py | 2 +- 20 files changed, 345 insertions(+), 59 deletions(-) rename {basic => model}/entity.py (80%) create mode 100644 model/environment.py rename {basic => model}/testcase.py (53%) rename {basic => model}/testplan.py (96%) rename {basic => model}/testsuite.py (51%) create mode 100644 test/test_20application.py create mode 100644 test/test_21environment.py create mode 100644 test/test_26testsuite.py rename test/{test_21tdata.py => test_31tdata.py} (98%) rename test/{test_22compare.py => test_42compare.py} (100%) rename test/{test_23report.py => test_43report.py} (99%) rename test/{test_24gen.py => test_44gen.py} (100%) rename {utils => tools}/git_tool.py (100%) diff --git a/basic/component.py b/basic/component.py index 17ae56e..866f382 100644 --- a/basic/component.py +++ b/basic/component.py @@ -43,7 +43,7 @@ def syncEnitity(job, elem): dbTime = basic.entity.VAL_ZERO_TIME # get git-commit if "git" in syncMethod: - comppath = tools.config_tool.getConfigPath(job, P.KEY_COMP, elem) + comppath = tools.config_tool.select_config_path(job, P.KEY_COMP, elem) repopath = comppath[len(job.conf[B.SUBJECT_PATH][B.ATTR_PATH_COMPS]) + 1:] gitresult = tools.git_tool.gitLog(job, B.ATTR_PATH_COMPS, repopath, 1) fileTime = gitresult[0]["date"] diff --git a/basic/constants.py b/basic/constants.py index 487d000..b1ee2a6 100644 --- a/basic/constants.py +++ b/basic/constants.py @@ -67,7 +67,7 @@ PAR_STRING = 'parstring' PAR_TESTPLAN = "testplan" PAR_TESTCASE = "testcase" PAR_TESTCASES = "testcases" -PAR_TESTSUITE = "usecase" +PAR_TESTSUITE = "testsuite" # todo Trennung testsuite - usecase denn n:1-Zuordnung PAR_TCTIME = "tctime" PAR_TSTIME = "tstime" diff --git a/basic/program.py b/basic/program.py index 6649063..9935d0b 100644 --- a/basic/program.py +++ b/basic/program.py @@ -142,7 +142,7 @@ class Job: catalog = model.catalog.Catalog.getInstance() self.programDef = catalog.getValue(self, CTLG_NAME, program, "") try: - path = tools.config_tool.getConfigPath(self, P.KEY_BASIC, B.BASIS_FILE) + path = tools.config_tool.select_config_path(self, P.KEY_BASIC, B.BASIS_FILE) self.conf = self.getConfiguration(path) except: print("FATAL: config-file could not be loaded") diff --git a/model/application.py b/model/application.py index c580aa3..e965a2e 100644 --- a/model/application.py +++ b/model/application.py @@ -5,14 +5,14 @@ import os import basic.toolHandling import basic.constants as B -import basic.entity -import utils.path_const as P -import utils.config_tool -import utils.file_tool -import utils.git_tool +import model.entity +import tools.path_const as P +import tools.config_tool +import tools.file_tool +import tools.git_tool TABLE_NAMES = ["application", "ap_project", "ap_component"] -DEFAULT_SYNC = basic.entity.SYNC_FULL_GIT2DB +DEFAULT_SYNC = model.entity.SYNC_FULL_GIT2DB def getProjects(job): """ @@ -21,7 +21,7 @@ def getProjects(job): :param job: :return: """ - appl = utils.config_tool.getConfig(job, P.KEY_BASIC, B.SUBJECT_APPS) + appl = tools.config_tool.getConfig(job, P.KEY_BASIC, B.SUBJECT_APPS) return searchProjects(job, appl) def searchProjects(job, appl): @@ -66,27 +66,27 @@ def getEnvironments(job, projectList): continue if hasattr(job.par, B.PAR_ENV) and envdir != getattr(job.par, B.PAR_ENV): continue - for format in utils.config_tool.CONFIG_FORMAT: + for format in tools.config_tool.CONFIG_FORMAT: pathname = os.path.join(job.conf.getPath(P.ATTR_PATH_ENV), envdir, P.VAL_CONFIG, P.KEY_TOOL + "_conn." + format) if os.path.exists(pathname): break if os.path.exists(pathname): - doc = utils.file_tool.readFileDict(job, pathname, job.m) + doc = tools.file_tool.readFileDict(job, pathname, job.m) print(str(doc)) for proj in doc[B.SUBJECT_ENV][B.CONF_NODE_GENERAL][B.SUBJECT_PROJECTS]: if proj in projectList: projects[proj][B.SUBJECT_ENV].append(envdir) return projects -def getApplications(job, projectList): +def select_applications(job, projectList): """ get all project which are configured for the workspace with all environments where the application of the project are installed :param job: :return: """ - appl = utils.config_tool.getConfig(job, P.KEY_BASIC, B.SUBJECT_APPS) + appl = tools.config_tool.getConfig(job, P.KEY_BASIC, B.SUBJECT_APPS) return searchApplications(job, projectList, appl) def searchApplications(job, projectList, appl): @@ -94,8 +94,8 @@ def searchApplications(job, projectList, appl): for proj in projectList: if hasattr(job.par, B.PAR_PROJ) and proj != getattr(job.par, B.PAR_PROJ): continue - for app in appl[B.SUBJECT_PROJECTS][proj][B.SUBJECT_APPS]: - if hasattr(job.par, B.PAR_APP) and app != getattr(job.par, B.PAR_APP): + for app in appl[B.SUBJECT_APPS]: + if B.ATTR_APPS_PROJECT in appl[B.SUBJECT_APPS][app] and proj != appl[B.SUBJECT_APPS][app][B.ATTR_APPS_PROJECT]: continue appList[app] = appl[B.SUBJECT_APPS][app] return appList @@ -115,13 +115,13 @@ def syncEnitities(job): syncMethod = job.conf["entity"][TABLE_NAMES[0]]["storage"] if syncMethod.count("-") < 2: return - fileTime = basic.entity.VAL_ZERO_TIME - dbTime = basic.entity.VAL_ZERO_TIME + fileTime = model.entity.VAL_ZERO_TIME + dbTime = model.entity.VAL_ZERO_TIME # get git-commit if "git" in syncMethod: - apppath = utils.config_tool.getConfigPath(job, P.KEY_BASIC, B.SUBJECT_APPS, "") + apppath = tools.config_tool.select_config_path(job, P.KEY_BASIC, B.SUBJECT_APPS, "") repopath = apppath[len(job.conf[B.SUBJECT_PATH][B.ATTR_PATH_COMPS]) + 1:] - gitresult = utils.git_tool.gitLog(job, B.ATTR_PATH_COMPS, repopath, 1) + gitresult = tools.git_tool.gitLog(job, B.ATTR_PATH_COMPS, repopath, 1) fileTime = gitresult[0]["date"] print(str(gitresult)) if "db" in syncMethod: @@ -140,12 +140,12 @@ def syncEnitities(job): print("db vorne") (appObjects, appDict) = selectEntities(job, dbi) print(str(appDict)) - applPath = utils.config_tool.getConfigPath(job, P.KEY_BASIC, B.SUBJECT_APPS) - utils.file_tool.writeFileDict(job.m, job, applPath, appDict) + applPath = tools.config_tool.select_config_path(job, P.KEY_BASIC, B.SUBJECT_APPS) + tools.file_tool.writeFileDict(job.m, job, applPath, appDict) # elif fileTime > dbTime: print("git vorne") - applData = utils.config_tool.getConfig(job, P.KEY_BASIC, B.SUBJECT_APPS) + applData = tools.config_tool.getConfig(job, P.KEY_BASIC, B.SUBJECT_APPS) insertEntities(job, applData, dbTime, dbi) def selectEntities(job, dbi): @@ -161,7 +161,7 @@ def selectEntities(job, dbi): ao.setAppRow(row, "") appDict[B.SUBJECT_APPS][ao.name] = {} for f in job.testserver.conf[B.DATA_NODE_DDL][TABLE_NAMES[0]][B.DATA_NODE_HEADER]: - if f in basic.entity.ENTITY_FIELDS: + if f in model.entity.ENTITY_FIELDS: continue appDict[B.SUBJECT_APPS][ao.name][f] = getattr(ao, f) apid = ao.apid @@ -178,7 +178,7 @@ def selectEntities(job, dbi): appDict[B.SUBJECT_PROJECTS][proj][B.SUBJECT_APPS].append(ao.name) aoproj = getattr(ao, "project")[proj] for f in job.testserver.conf[B.DATA_NODE_DDL][TABLE_NAMES[1]][B.DATA_NODE_HEADER]: - if f in basic.entity.ENTITY_FIELDS + ["approid", "apid"]: + if f in model.entity.ENTITY_FIELDS + ["approid", "apid"]: continue appDict[B.SUBJECT_PROJECTS][proj][f] = aoproj[f] rows = [row for row in compData[B.DATA_NODE_DATA] if row["apid"] == apid] @@ -192,7 +192,7 @@ def selectEntities(job, dbi): def insertEntities(job,applData, dbTime, dbi): # insertRows # get list of application - if dbTime != basic.entity.VAL_ZERO_TIME: + if dbTime != model.entity.VAL_ZERO_TIME: for t in TABLE_NAMES: dbi.deleteRows(t, job) for app in applData[B.SUBJECT_APPS]: @@ -200,7 +200,7 @@ def insertEntities(job,applData, dbTime, dbi): ao.readEntity(job, app) ao.insertEntity(dbi) -class Application(basic.entity.Entity): +class Application(model.entity.Entity): table = "application" name = "" description = "" @@ -226,20 +226,20 @@ class Application(basic.entity.Entity): self.readEntity(job, name) def readEntity(self, job, app): - apppath = utils.config_tool.getConfigPath(job, P.KEY_BASIC, B.SUBJECT_APPS, "") + apppath = tools.config_tool.select_config_path(job, P.KEY_BASIC, B.SUBJECT_APPS, "") repopath = apppath[len(job.conf[B.SUBJECT_PATH][B.ATTR_PATH_COMPS]) + 1:] - gitresult = utils.git_tool.gitLog(job, B.ATTR_PATH_COMPS, repopath, 1) - applData = utils.config_tool.getConfig(job, P.KEY_BASIC, B.SUBJECT_APPS) + gitresult = tools.git_tool.gitLog(job, B.ATTR_PATH_COMPS, repopath, 1) + applData = tools.config_tool.getConfig(job, P.KEY_BASIC, B.SUBJECT_APPS) # main object for f in job.testserver.conf[B.DATA_NODE_DDL][TABLE_NAMES[0]][B.DATA_NODE_HEADER]: - if f == basic.entity.ENTITY_NAME: + if f == model.entity.ENTITY_NAME: setattr(self, f, app) - elif f == basic.entity.ENTITY_ATTRIBUTES: + elif f == model.entity.ENTITY_ATTRIBUTES: setattr(self, f, {}) elif f in applData[B.SUBJECT_APPS][app]: setattr(self, f, applData[B.SUBJECT_APPS][app][f]) - elif f in basic.entity.ENTITY_FIELDS: - setattr(self, f, basic.entity.getEntityValue(job, f, gitresult[0])) + elif f in model.entity.ENTITY_FIELDS: + setattr(self, f, model.entity.getEntityValue(job, f, gitresult[0])) else: setattr(self, f, "xx") project = {} @@ -247,16 +247,16 @@ class Application(basic.entity.Entity): for proj in applData[B.SUBJECT_APPS][app][B.SUBJECT_PROJECTS]: project[proj] = {} for f in job.testserver.conf[B.DATA_NODE_DDL][TABLE_NAMES[1]][B.DATA_NODE_HEADER]: - if f == basic.entity.ENTITY_NAME: + if f == model.entity.ENTITY_NAME: project[proj][f] = proj elif f == "project": project[proj][f] = proj - elif f == basic.entity.ENTITY_ATTRIBUTES: + elif f == model.entity.ENTITY_ATTRIBUTES: project[proj][f] = {} elif f in applData[B.SUBJECT_PROJECTS][proj]: project[proj][f] = applData[B.SUBJECT_PROJECTS][proj][f] - elif f in basic.entity.ENTITY_FIELDS: - project[proj][f] = basic.entity.getEntityValue(job, f, gitresult[0]) + elif f in model.entity.ENTITY_FIELDS: + project[proj][f] = model.entity.getEntityValue(job, f, gitresult[0]) else: project[proj][f] = "xx" setattr(self, "project", project) @@ -297,7 +297,7 @@ class Application(basic.entity.Entity): def selectEntity(self, job, app): dbi = basic.toolHandling.getDbTool(job, job.testserver, job.conf[B.TOPIC_NODE_DB][B.ATTR_TYPE]) - data = dbi.selectRows(TABLE_NAMES[0], job, "WHERE name = \'"+app+"\' AND actual = "+basic.entity.ENTITY_ACTUAL) + data = dbi.selectRows(TABLE_NAMES[0], job, "WHERE name = \'" + app +"\' AND actual = " + model.entity.ENTITY_ACTUAL) # main object self.setAppRow(data[B.DATA_NODE_DATA][0], app) apid = getattr(self, "apid") @@ -308,7 +308,7 @@ class Application(basic.entity.Entity): def setAppRow(self, row, app): for f in self.job.testserver.conf[B.DATA_NODE_DDL][TABLE_NAMES[0]][B.DATA_NODE_HEADER]: - if f not in row and f == basic.entity.ENTITY_NAME: + if f not in row and f == model.entity.ENTITY_NAME: setattr(self, f, app) else: setattr(self, f, str(row[f])) diff --git a/model/catalog.py b/model/catalog.py index b9472dd..4b95d02 100644 --- a/model/catalog.py +++ b/model/catalog.py @@ -61,7 +61,7 @@ class Catalog: if subkey not in self.catalog[domain][key]: job.m.setError(EXP_KEY_DOESNT_EXIST + " (" + domain + ", " + key + ", " + subkey + ")") return "" - return self.catalog[domain][key][subkey] + return self.catalog[domain][key][subkey].strip() return self.catalog[domain][key] @@ -95,7 +95,7 @@ class Catalog: raise Exception(EXP_KEY_MISSING, (domain)) if domain in self.catalog: return - pathname = tools.config_tool.getConfigPath(job, P.KEY_CATALOG, domain) + pathname = tools.config_tool.select_config_path(job, P.KEY_CATALOG, domain) if pathname is None: raise Exception(EXP_KEY_MISSING, (domain)) if hasattr(job, "m"): diff --git a/basic/entity.py b/model/entity.py similarity index 80% rename from basic/entity.py rename to model/entity.py index fbe96f9..68645a0 100644 --- a/basic/entity.py +++ b/model/entity.py @@ -1,9 +1,11 @@ import getpass +import os +import re import basic.toolHandling -import utils.data_const as D +import tools.data_const as D import basic.constants as B -import utils.date_tool - +import tools.date_tool +import tools.file_tool ENTITY_NAME = "name" ENTITY_ATTRIBUTES = "attributes" @@ -32,7 +34,7 @@ def getEntityValue(job, field, gitcommit): if field == ENTITY_INS_AUTHOR: return getpass.getuser() if field == ENTITY_INS_TIME: - return utils.date_tool.getActdate(utils.date_tool.F_DIR) + return tools.date_tool.getActdate(tools.date_tool.F_DIR) if field == ENTITY_UPD_COMMIT: return gitcommit["commit"] if field == ENTITY_UPD_AUTHOR: @@ -110,3 +112,25 @@ class Entity: dbi = basic.toolHandling.getDbTool(self.job, None, dbtype) sql = dbi.getSchemaIndex(table, "actual") + "\n" return sql + + +def read_spec(job, testentity, testgran, specpath): + if not os.path.isfile(specpath): + return + text = tools.file_tool.read_file_text(job, specpath, job.m) + if re.match(r".*?depricated;[jJyY]", text): + return None + spec = {} + regex = re.compile(r".*\nhead:(.*?);(.+)") + for res in regex.finditer(text): + #res = re.search(r".*head:(.*?);(.+)\n", text) + key = res.group(1) + if key == B.SUBJECT_DESCRIPTION: + spec[B.SUBJECT_DESCRIPTION] = res.group(2).replace(";", "") + elif key in [B.SUBJECT_APPS, B.PAR_APP]: + apps = res.group(2).replace(";", ",").split(",") + spec[B.SUBJECT_APPS] = apps + else: + val = res.group(2).replace(";", "") + spec[key] = val + return spec diff --git a/model/environment.py b/model/environment.py new file mode 100644 index 0000000..68d516a --- /dev/null +++ b/model/environment.py @@ -0,0 +1,41 @@ +# --------------------------------------------------------------------------------------------------------- +# Author : Ulrich Carmesin +# Source : gitea.ucarmesin.de +# --------------------------------------------------------------------------------------------------------- +import os +import basic.constants as B +import model.entity +import tools.path_const as P +import tools.config_tool +import tools.file_tool +import tools.git_tool + +TABLE_NAMES = ["environment", "en_project", "en_component"] +DEFAULT_SYNC = model.entity.SYNC_FULL_GIT2DB + +def select_environments(job, projectList): + """ + searches and gets environments in which the applications of the project are declared that these are installed + filtered by parameter --environment + :param job: + :return: + """ + environments = {} + path = job.conf[B.SUBJECT_PATH][B.ATTR_PATH_ENV] + if not os.path.exists(path): + raise Exception("Umgebungsverzeichnis existiert nicht "+path) + for envdir in os.listdir(path): + if not os.path.isdir(os.path.join(path, envdir)): + continue + if envdir[0:1] == "_": + continue + try: + pathname = tools.config_tool.select_config_path(job, P.KEY_TOOL, "conn", envdir) + doc = tools.file_tool.read_file_dict(job, pathname, job.m) + for proj in doc[B.SUBJECT_ENV][B.CONF_NODE_GENERAL][B.SUBJECT_PROJECTS]: + if proj in projectList: + environments[envdir] = doc[B.SUBJECT_ENV][B.CONF_NODE_GENERAL] + except: + continue + return environments + diff --git a/basic/testcase.py b/model/testcase.py similarity index 53% rename from basic/testcase.py rename to model/testcase.py index 2eb78ef..0bbb4ab 100644 --- a/basic/testcase.py +++ b/model/testcase.py @@ -4,11 +4,19 @@ # Author : Ulrich Carmesin # Source : gitea.ucarmesin.de # --------------------------------------------------------------------------------------------------------- +import os import basic.toolHandling import utils.data_const as D import basic.constants as B -import basic.entity -class Testcase(basic.entity.Entity): +import model.entity +import tools.config_tool +import tools.job_tool +import tools.path_tool +import tools.path_const as P +import model.entity + + +class Testcase(model.entity.Entity): name = "" description = "" application = "" @@ -45,4 +53,45 @@ class Testcase(basic.entity.Entity): sql += dbi.getSchemaSubtable("tc", [{"attr":attr, "atype": D.TYPE_STR}, {"attr":"attributes", "atype": D.TYPE_TEXT}])+"\n" sql += dbi.getSchemaIndex(dbi.getSubTableName("tc", attr), dbi.getSubTableId(dbi.getSubTableName("tc", attr), attr))+"\n" - return sql \ No newline at end of file + return sql + +def select_testcase(job, project, testsuite): + jobProj = None + if hasattr(job.par, B.PAR_PROJ): + jobProj = getattr(job.par, B.PAR_PROJ) + setattr(job.par, B.PAR_PROJ, project) + path = tools.path_tool.compose_path(job, P.P_TDROOT, None) + specpath = os.path.join(path, testsuite, D.DFILE_TESTSUITE_NAME + ".csv") + spec = model.entity.read_spec(job, testsuite, tools.job_tool.GRAN_TS, specpath) + if jobProj is None: + delattr(job.par, B.PAR_PROJ) + else: + setattr(job.par, B.PAR_PROJ, jobProj) + return spec + +def select_testcases(job, projList, appList): + out = {} + jobProj = None + if hasattr(job.par, B.PAR_PROJ): + jobProj = getattr(job.par, B.PAR_PROJ) + for proj in projList: + setattr(job.par, B.PAR_PROJ, proj) + path = tools.path_tool.compose_path(job, P.P_TDROOT, None) + if os.path.exists(path): + for d in os.listdir(path): + if not os.path.isdir(os.path.join(path, d)): + continue + if d[0:1] == "_": + continue + print(d) + specpath = os.path.join(path, d, D.DFILE_TESTCASE_NAME + ".csv") + spec = model.entity.read_spec(job, d, tools.job_tool.GRAN_TS, specpath) + if spec is None: + continue + out[d] = spec + out[d][B.SUBJECT_PROJECTS] = [proj] + if jobProj is None: + delattr(job.par, B.PAR_PROJ) + else: + setattr(job.par, B.PAR_PROJ, jobProj) + return out diff --git a/basic/testplan.py b/model/testplan.py similarity index 96% rename from basic/testplan.py rename to model/testplan.py index b209e78..0773b93 100644 --- a/basic/testplan.py +++ b/model/testplan.py @@ -7,9 +7,9 @@ import basic.toolHandling import utils.data_const as D import basic.constants as B -import basic.entity +import model.entity -class Testplan(basic.entity.Entity): +class Testplan(model.entity.Entity): name = "" description = "" release = "" diff --git a/basic/testsuite.py b/model/testsuite.py similarity index 51% rename from basic/testsuite.py rename to model/testsuite.py index 577ca2d..9c0bd21 100644 --- a/basic/testsuite.py +++ b/model/testsuite.py @@ -4,12 +4,19 @@ # Author : Ulrich Carmesin # Source : gitea.ucarmesin.de # --------------------------------------------------------------------------------------------------------- +import os import basic.toolHandling import utils.data_const as D import basic.constants as B -import basic.entity +import model.entity +import tools.config_tool +import tools.job_tool +import tools.path_tool +import tools.path_const as P +import model.entity -class Testsuite(basic.entity.Entity): + +class Testsuite(model.entity.Entity): name = "" description = "" application = "" @@ -46,4 +53,47 @@ class Testsuite(basic.entity.Entity): sql += dbi.getSchemaSubtable("ts", [{"attr":attr, "atype": D.TYPE_STR}, {"attr":"attributes", "atype": D.TYPE_TEXT}])+"\n" sql += dbi.getSchemaIndex(dbi.getSubTableName("ts", attr), dbi.getSubTableId(dbi.getSubTableName("ts", attr), attr))+"\n" - return sql \ No newline at end of file + return sql + +def select_testsuite(job, project, testsuite): + jobProj = None + print("testsuite select: "+str(project)+" "+str(testsuite)) + if hasattr(job.par, B.PAR_PROJ): + jobProj = getattr(job.par, B.PAR_PROJ) + setattr(job.par, B.PAR_PROJ, project) + path = tools.path_tool.compose_path(job, P.P_TDROOT, None) + specpath = os.path.join(path, testsuite, D.DFILE_TESTSUITE_NAME + ".csv") + spec = model.entity.read_spec(job, testsuite, tools.job_tool.GRAN_TS, specpath) + if jobProj is None: + delattr(job.par, B.PAR_PROJ) + else: + setattr(job.par, B.PAR_PROJ, jobProj) + return spec + +def select_testsuites(job, projList, appList): + out = {} + jobProj = None + print("testsuite select: "+str(projList)+" "+str(appList)) + if hasattr(job.par, B.PAR_PROJ): + jobProj = getattr(job.par, B.PAR_PROJ) + for proj in projList: + setattr(job.par, B.PAR_PROJ, proj) + path = tools.path_tool.compose_path(job, P.P_TDROOT, None) + if os.path.exists(path): + for d in os.listdir(path): + if not os.path.isdir(os.path.join(path, d)): + continue + if d[0:1] == "_": + continue + print(d) + specpath = os.path.join(path, d, D.DFILE_TESTSUITE_NAME + ".csv") + spec = model.entity.read_spec(job, d, tools.job_tool.GRAN_TS, specpath) + if spec is None: + continue + out[d] = spec + out[d][B.SUBJECT_PROJECTS] = [proj] + if jobProj is None: + delattr(job.par, B.PAR_PROJ) + else: + setattr(job.par, B.PAR_PROJ, jobProj) + return out diff --git a/test/test_07catalog.py b/test/test_07catalog.py index e8c10b0..100b7de 100644 --- a/test/test_07catalog.py +++ b/test/test_07catalog.py @@ -74,7 +74,7 @@ class MyTestCase(unittest.TestCase): cnttest += 1 res = catalog.getValue(job, "countries", "TD", "") print(str(res)) - self.assertEqual(res["Land"], "Tschad") + self.assertEqual(res["Land"].strip(), "Tschad") cnttest += 1 res = catalog.getValue(job, "countries", "TD", "Land") print(str(res)) diff --git a/test/test_20application.py b/test/test_20application.py new file mode 100644 index 0000000..a610027 --- /dev/null +++ b/test/test_20application.py @@ -0,0 +1,40 @@ +import unittest +import os +import inspect +import shutil + +import tools.path_tool +import basic.program +import test.testtools +import basic.constants as B +import test.constants as T +import tools.file_tool +import model.application + +HOME_PATH = test.constants.HOME_PATH +PYTHON_CMD = "python" +TEST_FUNCTIONS = ["test_10getApplications"] + +PROGRAM_NAME = "clean_workspace" + +class MyTestCase(unittest.TestCase): + mymsg = "--------------------------------------------------------------" + + def test_10getApplications(self): + global mymsg + global jobObject + actfunction = str(inspect.currentframe().f_code.co_name) + cnttest = 0 + if actfunction not in TEST_FUNCTIONS: + return + # simple job instantiate - without parameter and only simple messaging + job = test.testtools.getJob() + print(str(job.__dict__)) + jobObject = job + projList = ["TESTPROJ"] + apps = model.application.select_applications(job, projList) + print(str(apps)) + + +if __name__ == '__main__': + unittest.main() diff --git a/test/test_21environment.py b/test/test_21environment.py new file mode 100644 index 0000000..0cd8772 --- /dev/null +++ b/test/test_21environment.py @@ -0,0 +1,41 @@ +import unittest +import os +import inspect +import shutil + +import tools.path_tool +import basic.program +import test.testtools +import basic.constants as B +import test.constants as T +import tools.file_tool +import model.environment + +HOME_PATH = test.constants.HOME_PATH +PYTHON_CMD = "python" +TEST_FUNCTIONS = ["test_10getEnvironments"] + +PROGRAM_NAME = "clean_workspace" + +class MyTestCase(unittest.TestCase): + mymsg = "--------------------------------------------------------------" + + def test_10getEnvironments(self): + global mymsg + global jobObject + actfunction = str(inspect.currentframe().f_code.co_name) + cnttest = 0 + if actfunction not in TEST_FUNCTIONS: + return + # simple job instantiate - without parameter and only simple messaging + job = test.testtools.getJob() + print(str(job.__dict__)) + jobObject = job + projList = ["TESTPROJ"] + envs = model.environment.select_environments(job, projList) + print(str(envs)) + print(str(envs.keys())) + + +if __name__ == '__main__': + unittest.main() diff --git a/test/test_26testsuite.py b/test/test_26testsuite.py new file mode 100644 index 0000000..57984ae --- /dev/null +++ b/test/test_26testsuite.py @@ -0,0 +1,41 @@ +import unittest +import os +import inspect +import shutil + +import tools.path_tool +import basic.program +import test.testtools +import basic.constants as B +import test.constants as T +import tools.file_tool +import model.testsuite + +HOME_PATH = test.constants.HOME_PATH +PYTHON_CMD = "python" +TEST_FUNCTIONS = ["test_10getEnvironments"] + +PROGRAM_NAME = "clean_workspace" + +class MyTestCase(unittest.TestCase): + mymsg = "--------------------------------------------------------------" + + def test_10getEnvironments(self): + global mymsg + global jobObject + actfunction = str(inspect.currentframe().f_code.co_name) + cnttest = 0 + if actfunction not in TEST_FUNCTIONS: + return + # simple job instantiate - without parameter and only simple messaging + job = test.testtools.getJob() + print(str(job.__dict__)) + jobObject = job + projList = ["TESTPROJ"] + appList = [] + envs = model.testsuite.select_testsuites(job, projList, appList) + print(str(envs)) + + +if __name__ == '__main__': + unittest.main() diff --git a/test/test_21tdata.py b/test/test_31tdata.py similarity index 98% rename from test/test_21tdata.py rename to test/test_31tdata.py index c76bebd..5559745 100644 --- a/test/test_21tdata.py +++ b/test/test_31tdata.py @@ -38,7 +38,7 @@ class MyTestCase(unittest.TestCase): setattr(job.par, "tdtyp", "dir") setattr(job.par, "tdsrc", "TC0001") setattr(job.par, "tdname", "testspec") - filename = str(job.conf.confs["paths"]["testdata"]) + "/" + getattr(job.par, "tdsrc") + "/" + getattr(job.par, "tdname") + ".csv" + filename = str(job.conf["paths"]["testdata"]) + "/" + getattr(job.par, "tdsrc") + "/" + getattr(job.par, "tdname") + ".csv" #tdata = t.readCsv(job.m, filename, None) #self.assertEqual(len(tdata["testa1"]), 3) setattr(job.par, "tdtyp", "dir") @@ -54,7 +54,7 @@ class MyTestCase(unittest.TestCase): if actfunction not in TEST_FUNCTIONS: return job = test.testtools.getJob() - # filename = os.path.join(job.conf.confs["paths"]["testdata"], getattr(job.par, "tdsrc"), getattr(job.par, "tdname") + ".csv") + # filename = os.path.join(job.conf["paths"]["testdata"], getattr(job.par, "tdsrc"), getattr(job.par, "tdname") + ".csv") """ a) data : like a table with data-array of key-value-pairs a_0 is keyword [option, step, CSV_HEADER_START ] diff --git a/test/test_22compare.py b/test/test_42compare.py similarity index 100% rename from test/test_22compare.py rename to test/test_42compare.py diff --git a/test/test_23report.py b/test/test_43report.py similarity index 99% rename from test/test_23report.py rename to test/test_43report.py index 6887753..382ec3f 100644 --- a/test/test_23report.py +++ b/test/test_43report.py @@ -22,7 +22,7 @@ class MyTestCase(unittest.TestCase): def getReport(self, job): # job = test.testtools.getJob() report = utils.report_tool.Report(job) - archiv = job.conf.confs[B.SUBJECT_PATH][B.ATTR_PATH_ARCHIV]+"/" + archiv = job.conf[B.SUBJECT_PATH][B.ATTR_PATH_ARCHIV]+"/" i = 0 for m in M.MATCH_TYPES: report.setPaths("TC0001", "comp01", "arte01", m, archiv+"path0111"+str(i), archiv+"path0111"+str(i)+"02") diff --git a/test/test_24gen.py b/test/test_44gen.py similarity index 100% rename from test/test_24gen.py rename to test/test_44gen.py diff --git a/utils/git_tool.py b/tools/git_tool.py similarity index 100% rename from utils/git_tool.py rename to tools/git_tool.py diff --git a/unit_tester.py b/unit_tester.py index 5cd51d9..d72f580 100644 --- a/unit_tester.py +++ b/unit_tester.py @@ -42,7 +42,7 @@ def create_test_suite(job): testnum = t[len(testdir)+11:len(testdir)+13] if not testnum.isnumeric(): continue - if testnum not in ["01", "03", "08", "10", "11"]: + if testnum not in ["01", "03", "07", "08", "10", "11", "20", "21"]: continue if testdir == T.COMP_PATH: v = "components.test." + t[len(testdir) + 6:-3]