26 changed files with 2348 additions and 128 deletions
|
@ -0,0 +1,106 @@ |
|||
#!/usr/bin/python |
|||
# -*- coding: utf-8 -*- |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
# Author : Ulrich Carmesin |
|||
# Source : gitea.ucarmesin.de |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
import os |
|||
import basic.program |
|||
import basic.constants as B |
|||
import tools.path_const as P |
|||
import tools.data_const as D |
|||
import tools.config_tool |
|||
import tools.path_tool |
|||
import tools.file_tool |
|||
# import tools.tdata_tool |
|||
|
|||
EXP_KEY_MISSING = "key is missing {}" |
|||
EXP_KEY_DOESNT_EXIST = "key doesnt exist in domain {}" |
|||
|
|||
class Catalog: |
|||
__instance = None |
|||
""" |
|||
in this class there should be managed each defined key-value-pairs |
|||
the pairs ara loaded from the path testdata/catalog: |
|||
* initially the csv-file catalog.csv |
|||
* on demand other csv-files in the path |
|||
""" |
|||
|
|||
def __init__(self): |
|||
self.catalog = {} |
|||
Catalog.__instance = self |
|||
pass |
|||
|
|||
|
|||
@staticmethod |
|||
def getInstance(): |
|||
if Catalog.__instance == None: |
|||
return Catalog() |
|||
return Catalog.__instance |
|||
|
|||
|
|||
def getValue(self, domain, key, job): |
|||
""" |
|||
this function gets the value of the domain an key |
|||
:param domain: |
|||
:param key: |
|||
:return: |
|||
""" |
|||
if not (isinstance(domain, str) or len(domain) < 1): |
|||
raise Exception(EXP_KEY_MISSING, (domain, key)) |
|||
if not (isinstance(key, str) or len(key) < 1): |
|||
job.m.setError(EXP_KEY_MISSING+" ("+domain+", "+key+")") |
|||
return "" |
|||
|
|||
if domain not in self.catalog: |
|||
self.readDomain(domain, job) |
|||
if key not in self.catalog[domain]: |
|||
job.m.setError(EXP_KEY_DOESNT_EXIST+" ("+domain+", "+key+")") |
|||
return "" |
|||
return self.catalog[domain][key] |
|||
|
|||
|
|||
def getKeys(self, domain, job): |
|||
""" |
|||
this function gets the value of the domain an key |
|||
:param domain: |
|||
:param key: |
|||
:return: |
|||
""" |
|||
if not (isinstance(domain, str) or len(domain) < 1): |
|||
raise Exception(EXP_KEY_MISSING, (domain)) |
|||
|
|||
if domain not in self.catalog: |
|||
self.readDomain(domain, job) |
|||
if domain not in self.catalog: |
|||
return [] |
|||
out = [] |
|||
for x in self.catalog[domain].keys(): |
|||
out.append(x) |
|||
return out |
|||
|
|||
|
|||
def readDomain(self, domain, job): |
|||
""" |
|||
this function reads the domain-entries |
|||
:param domain: |
|||
:return: |
|||
""" |
|||
if not (isinstance(domain, str) or len(domain) < 1): |
|||
raise Exception(EXP_KEY_MISSING, (domain)) |
|||
if domain in self.catalog: |
|||
return |
|||
pathname = tools.config_tool.getConfigPath(job, P.KEY_CATALOG, domain) |
|||
if pathname is None: |
|||
raise Exception(EXP_KEY_MISSING, (domain)) |
|||
data = tools.file_tool.readFileDict(job, pathname, job.m) |
|||
self.catalog[domain] = data[B.DATA_NODE_TABLES][domain][B.DATA_NODE_KEYS] |
|||
return data |
|||
|
|||
|
|||
def exportXSD(self, domain): |
|||
""" |
|||
this function exports the domain into xsd-declaration of simple types |
|||
:return: |
|||
""" |
|||
pass |
|||
@ -0,0 +1,46 @@ |
|||
import unittest |
|||
import os |
|||
import inspect |
|||
import shutil |
|||
|
|||
import tools.path_tool |
|||
import basic.program |
|||
from basic.componentHandling import ComponentManager |
|||
import test.constants |
|||
import basic.constants as B |
|||
import test.constants as T |
|||
import basic.componentHandling |
|||
import tools.file_tool |
|||
|
|||
HOME_PATH = test.constants.HOME_PATH |
|||
PYTHON_CMD = "python" |
|||
TEST_FUNCTIONS = ["test_00init"] |
|||
|
|||
PROGRAM_NAME = "clean_workspace" |
|||
|
|||
class MyTestCase(unittest.TestCase): |
|||
mymsg = "--------------------------------------------------------------" |
|||
|
|||
|
|||
def test_00init(self): |
|||
global mymsg |
|||
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 = basic.program.Job(PROGRAM_NAME) |
|||
print(str(job.__dict__)) |
|||
self.checkSimpleJob(job) |
|||
|
|||
def checkSimpleJob(self, job): |
|||
self.assertIn("conf", job.__dict__) |
|||
self.assertIn("jobid", job.__dict__) |
|||
self.assertIn("program", job.__dict__) |
|||
self.assertIn("start", job.__dict__) |
|||
self.assertIn("configpath", job.conf) |
|||
self.assertIn("paths", job.conf) |
|||
|
|||
|
|||
if __name__ == '__main__': |
|||
unittest.main() |
|||
@ -0,0 +1,349 @@ |
|||
#!/usr/bin/python |
|||
# -*- coding: utf-8 -*- |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
# Author : Ulrich Carmesin |
|||
# Source : gitea.ucarmesin.de |
|||
# https://ucarmesin.de/index.php/it/testautomatisierung-fuer-daten-test/225-konfiguration-der-testanwendung |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
import sys |
|||
import basic.constants as B |
|||
|
|||
try: |
|||
import basic.program |
|||
except ImportError: |
|||
print("ImportError: " + str(ImportError.with_traceback())) |
|||
pass |
|||
import basic.componentHandling |
|||
import tools.path_tool |
|||
import tools.file_tool |
|||
import os.path |
|||
import basic.constants as B |
|||
import tools.data_const as D |
|||
import tools.path_const as P |
|||
|
|||
COMP_FILES = [D.DDL_FILENAME] |
|||
CONFIG_FORMAT = [D.DFILE_TYPE_YML, D.DFILE_TYPE_JSON, D.DFILE_TYPE_CSV] |
|||
|
|||
def getExistingPath(job, pathnames): |
|||
if isinstance(pathnames, str): |
|||
pathnames = [pathnames] |
|||
for p in pathnames: |
|||
if p[-1:] == ".": |
|||
p = p[0:-1] |
|||
for format in CONFIG_FORMAT: |
|||
pathname = p+"."+format |
|||
if os.path.exists(pathname): |
|||
return pathname |
|||
return None |
|||
|
|||
def getConfigPath(job, modul, name, subname=""): |
|||
""" |
|||
gets the most specified configuration of different sources |
|||
Parameter: |
|||
* typ -- (basic, comp, tool) |
|||
* name -- the specific class |
|||
sources: |
|||
* programm << |
|||
* install << |
|||
* environ << basis-conf |
|||
* release << basis-conf |
|||
* testset << parameter/environ |
|||
* testcase << parameter |
|||
the parameter-files could be one of these file-types: |
|||
* yaml, json, csv |
|||
""" |
|||
if job is None: |
|||
verify = False # job = basic.program.Job.getInstance() |
|||
else: |
|||
verify = job.getDebugLevel("config_tool")-4 |
|||
if verify: job.debug(verify, "getConfig " + modul + ", " + name) |
|||
if modul == P.KEY_TOOL: |
|||
path = getExistingPath(job, os.path.join(job.conf["paths"][P.ATTR_PATH_COMPONENTS], |
|||
P.VAL_CONFIG, P.KEY_TOOL+"_"+name)) |
|||
if path is not None: |
|||
return path |
|||
path = getExistingPath(job, os.path.join(job.conf["paths"][P.ATTR_PATH_HOME], |
|||
P.VAL_CONFIG, P.KEY_TOOL+"_"+name)) |
|||
if path is not None: |
|||
return path |
|||
path = getExistingPath(job, os.path.join(job.conf["paths"][P.ATTR_PATH_PROGRAM], |
|||
P.VAL_UTIL, P.VAL_CONFIG, name)) |
|||
if path is not None: |
|||
return path |
|||
path = getExistingPath(job, os.path.join(job.conf["paths"][P.ATTR_PATH_ENV], |
|||
job.par.environment, P.VAL_CONFIG, P.KEY_TOOL+"_"+ name)) |
|||
if path is not None: |
|||
return path |
|||
raise Exception(P.EXP_CONFIG_MISSING, modul+", "+name) |
|||
elif modul == P.KEY_COMP: |
|||
for format in CONFIG_FORMAT: |
|||
pathname = os.path.join(job.conf["paths"][P.ATTR_PATH_HOME], |
|||
P.VAL_CONFIG, P.KEY_COMP+"_" + name + "."+format) |
|||
if verify: job.debug(verify, "4 " + pathname) |
|||
if os.path.exists(pathname): |
|||
return pathname |
|||
for format in CONFIG_FORMAT: |
|||
pathname = os.path.join(job.conf["paths"][P.ATTR_PATH_COMPONENTS], |
|||
basic.componentHandling.getComponentFolder(name), "CONFIG." + format) |
|||
if verify: job.debug(verify, "5 " + pathname) |
|||
if os.path.exists(pathname): |
|||
return pathname |
|||
if verify: job.debug(verify, "6 " + pathname) |
|||
raise Exception(P.EXP_CONFIG_MISSING, modul+", "+name) |
|||
elif modul in COMP_FILES: |
|||
# for example DATASTRUCURE or the table |
|||
pathnames = [] |
|||
pathnames.append(os.path.join(job.conf["paths"][P.ATTR_PATH_COMPONENTS], |
|||
basic.componentHandling.getComponentFolder(name), modul)) |
|||
pathnames.append(os.path.join(job.conf["paths"][P.ATTR_PATH_COMPONENTS], |
|||
basic.componentHandling.getComponentFolder(subname), modul)) |
|||
pathnames.append(os.path.join(job.conf["paths"][P.ATTR_PATH_PROGRAM], P.VAL_BASIC, modul)) |
|||
pathnames.append(os.path.join(job.conf["paths"][P.ATTR_PATH_PROGRAM], P.VAL_BASIC, subname)) |
|||
configpath = getExistingPath(job, pathnames) |
|||
if configpath is not None: |
|||
return configpath |
|||
for format in CONFIG_FORMAT: |
|||
pathname = os.path.join(job.conf["paths"][P.ATTR_PATH_COMPONENTS], |
|||
basic.componentHandling.getComponentFolder(name), modul+"."+format) |
|||
if os.path.exists(pathname): |
|||
return pathname |
|||
for format in CONFIG_FORMAT: |
|||
if len(subname) > 1: |
|||
pathname = os.path.join(job.conf["paths"][P.ATTR_PATH_COMPONENTS], |
|||
basic.componentHandling.getComponentFolder(name), subname+"."+format) |
|||
if os.path.exists(pathname): |
|||
return pathname |
|||
raise Exception(P.EXP_CONFIG_MISSING, modul+", "+name) |
|||
elif modul == P.KEY_BASIC: |
|||
for format in CONFIG_FORMAT: |
|||
pathname = os.path.join(job.conf["paths"][P.ATTR_PATH_COMPONENTS], |
|||
P.VAL_CONFIG , name + "."+format) |
|||
if verify: job.debug(verify, "4 " + pathname) |
|||
if os.path.exists(pathname): |
|||
return pathname |
|||
elif modul == P.KEY_TESTCASE: |
|||
for format in CONFIG_FORMAT: |
|||
pathname = os.path.join(job.conf["paths"][P.ATTR_PATH_TDATA], |
|||
name, D.DFILE_TESTCASE_NAME + "."+format) |
|||
if verify: job.debug(verify, "4 " + pathname) |
|||
if os.path.exists(pathname): |
|||
return pathname |
|||
elif modul == P.KEY_TESTSUITE: |
|||
for format in CONFIG_FORMAT: |
|||
pathname = os.path.join(job.conf["paths"][P.ATTR_PATH_TDATA], |
|||
name, D.DFILE_TESTSUITE_NAME + "." + format) |
|||
if verify: job.debug(verify, "4 " + pathname) |
|||
if os.path.exists(pathname): |
|||
return pathname |
|||
elif modul == P.KEY_CATALOG: |
|||
path = getExistingPath(job, os.path.join(job.conf["paths"][P.ATTR_PATH_TDATA], |
|||
P.KEY_CATALOG, name)) |
|||
if path is not None: |
|||
return path |
|||
path = getExistingPath(job, os.path.join(job.conf["paths"][P.ATTR_PATH_COMPONENTS], |
|||
P.KEY_CATALOG, name)) |
|||
if path is not None: |
|||
return path |
|||
path = getExistingPath(job, os.path.join(job.conf["paths"][P.ATTR_PATH_PROGRAM], |
|||
P.KEY_CATALOG, name)) |
|||
if path is not None: |
|||
return path |
|||
raise Exception(P.EXP_CONFIG_MISSING, name) |
|||
else: |
|||
pathname = tools.path_tool.composePath(job, P.P_TCPARFILE) |
|||
if verify: job.debug(verify, "7 " + pathname) |
|||
if os.path.exists(pathname): |
|||
return pathname |
|||
pathname = tools.path_tool.composePath(job, P.P_TSPARFILE) |
|||
if verify: job.debug(verify, "8 " + pathname) |
|||
if os.path.exists(pathname): |
|||
return pathname |
|||
for format in CONFIG_FORMAT: |
|||
if len(subname) > 1: |
|||
pathname = os.path.join(job.conf["paths"][P.ATTR_PATH_RELEASE], |
|||
P.VAL_CONFIG, "basis."+format) |
|||
if verify: job.debug(verify, "9 " + pathname) |
|||
if os.path.exists(pathname): |
|||
return pathname |
|||
for format in CONFIG_FORMAT: |
|||
if len(subname) > 1: |
|||
pathname = os.path.join(job.conf["paths"][P.ATTR_PATH_ENV], |
|||
P.VAL_CONFIG, "basis."+format) |
|||
if verify: job.debug(verify, "9 " + pathname) |
|||
if os.path.exists(pathname): |
|||
return pathname |
|||
for format in CONFIG_FORMAT: |
|||
if len(subname) > 1: |
|||
pathname = os.path.join(job.conf["paths"][P.ATTR_PATH_HOME], |
|||
P.VAL_CONFIG, "basis."+format) |
|||
if verify: job.debug(verify, "9 " + pathname) |
|||
if os.path.exists(pathname): |
|||
return pathname |
|||
raise Exception(P.EXP_CONFIG_MISSING, modul+", "+name) |
|||
|
|||
|
|||
def getConfValue(attribute, comp): |
|||
if attribute == B.ATTR_CONN_DBTYPE: |
|||
if not hasAttr(comp.conf[B.SUBJECT_CONN], "dbtype"): |
|||
if hasAttr(comp.conf[B.SUBJECT_CONN], "types") and hasAttr(comp.conf[B.SUBJECT_CONN]["types"], "dbtype"): |
|||
dbtype = comp.conf[B.SUBJECT_CONN]["types"]["dbtype"] |
|||
else: |
|||
raise LookupError("dbtype is not set in comp " + comp.name) |
|||
else: |
|||
dbtype = comp.conf["conn"]["dbtype"] |
|||
return "" |
|||
return "" |
|||
|
|||
|
|||
def getAttr(o, name): |
|||
if (isinstance(o, dict)): |
|||
if (name in o.keys()): |
|||
return o[name] |
|||
elif (isinstance(o, list)): |
|||
pass |
|||
elif hasattr(o, name): |
|||
return getattr(o, name) |
|||
return False |
|||
|
|||
|
|||
def hasAttr(o, name): |
|||
if (isinstance(o, dict)): |
|||
if (name in o.keys()): |
|||
return True |
|||
elif (isinstance(o, list)): |
|||
pass |
|||
|
|||
|
|||
elif hasattr(o, name): |
|||
return True |
|||
return False |
|||
|
|||
|
|||
def getConfig(job, modul, name, subname=""): |
|||
if job is None: |
|||
verify = 24 |
|||
else: |
|||
verify = job.getDebugLevel("config_tool")-4 |
|||
msg = None |
|||
if hasattr(job, "m"): msg = job.m |
|||
pathname = getConfigPath(job, modul, name, subname) |
|||
confs = {} |
|||
job.debug(verify, "getConfig " + pathname) |
|||
if len(pathname) < 1: |
|||
return confs |
|||
doc = tools.file_tool.readFileDict(job, pathname, msg) |
|||
if modul == D.DDL_FILENAME: |
|||
# in csv the root is the subname |
|||
# from the Dict-structure of DDL_FILENAME pick the substructure of the subname |
|||
keys = list(doc.keys()) |
|||
if subname not in keys and len(keys) == 1: |
|||
doc0 = doc[keys[0]] |
|||
doc = doc0 |
|||
keys = list(doc.keys()) |
|||
if subname in keys: |
|||
doc0 = doc[subname] |
|||
doc = doc0 |
|||
for i, v in doc.items(): |
|||
confs[i] = v |
|||
return confs |
|||
|
|||
|
|||
def getAttribute(comp, path, attr, job): |
|||
attrList = getAttributeList(comp, path, job) |
|||
if attr in attrList: |
|||
return attrList[attr] |
|||
else: |
|||
return "" |
|||
|
|||
|
|||
def getAttributeList(comp, path, job): |
|||
""" |
|||
gets a concrete attribute-list for an arteifact-element from the config-attributes from the connection-attributes |
|||
https://ucarmesin.de/index.php/it/testautomatisierung-fuer-daten-test/225-konfiguration-der-testanwendung#konfigurationshierarchie |
|||
:param comp: |
|||
:param path: artifact-type.artifact-name for example: DB.person |
|||
:return: list of all attributes for the artifact-element |
|||
""" |
|||
attrList = {} |
|||
a = path.split(".") |
|||
artType = a[0] |
|||
artName = a[1] |
|||
if B.SUBJECT_CONN not in comp.conf: |
|||
raise Exception ("Environment is not configured") |
|||
if artType in comp.conf[B.SUBJECT_CONN]: |
|||
if artName in comp.conf[B.SUBJECT_CONN][artType]: |
|||
for attr, val in comp.conf[B.SUBJECT_CONN][artType][artName].items(): |
|||
if attr not in B.LIST_ATTR[artType]: |
|||
continue |
|||
attrList[attr] = val |
|||
for attr, val in comp.conf[B.SUBJECT_CONN][artType].items(): |
|||
if attr not in B.LIST_ATTR[artType]: |
|||
continue |
|||
if attr in attrList: |
|||
continue |
|||
attrList[attr] = val |
|||
if artType in comp.conf[B.SUBJECT_ARTS]: |
|||
if artName in comp.conf[B.SUBJECT_ARTS][artType]: |
|||
for attr, val in comp.conf[B.SUBJECT_ARTS][artType][artName].items(): |
|||
if attr not in B.LIST_ATTR[artType]: |
|||
continue |
|||
if attr in attrList: |
|||
continue |
|||
attrList[attr] = val |
|||
for attr, val in comp.conf[B.SUBJECT_ARTS][artType].items(): |
|||
if attr not in B.LIST_ATTR[artType]: |
|||
continue |
|||
if attr in attrList: |
|||
continue |
|||
attrList[attr] = val |
|||
return attrList |
|||
|
|||
def mergeConn(msg, conf, conn): |
|||
""" |
|||
merges the config-attributes from the connection-attributes |
|||
because the connection-attributes has to overwrite the config-attributes if the subject is configured |
|||
https://ucarmesin.de/index.php/it/testautomatisierung-fuer-daten-test/225-konfiguration-der-testanwendung#konfigurationshierarchie |
|||
:param conf: |
|||
:param conn: |
|||
:return: |
|||
""" |
|||
if B.SUBJECT_INST not in conf: |
|||
conf[B.SUBJECT_INST] = {} |
|||
for a in conn[B.SUBJECT_INST]: |
|||
conf[B.SUBJECT_INST][a] = conn[B.SUBJECT_INST][a] |
|||
for topic in [B.TOPIC_NODE_DB, B.TOPIC_NODE_CLI, B.TOPIC_NODE_API, B.TOPIC_NODE_FILE]: |
|||
if topic not in conf[B.SUBJECT_ARTS]: |
|||
continue |
|||
if topic == B.TOPIC_NODE_DB: |
|||
list = B.LIST_DB_ATTR |
|||
if topic == B.TOPIC_NODE_CLI: |
|||
list = B.LIST_CLI_ATTR |
|||
if topic == B.TOPIC_NODE_API: |
|||
list = B.LIST_API_ATTR |
|||
if topic == B.TOPIC_NODE_FILE: |
|||
list = B.LIST_FILE_ATTR |
|||
print(" --- merge-conn " + topic + " " + str(list)) |
|||
for a in conf[B.SUBJECT_ARTS][topic]: |
|||
if topic not in conn: |
|||
continue |
|||
if a in list: |
|||
if a in conn[topic]: |
|||
conf[B.SUBJECT_ARTS][topic][a] = conn[topic][a] |
|||
else: |
|||
for b in conf[B.SUBJECT_ARTS][topic][a]: |
|||
print(" --- merge-conn b " + topic + " " + a+" "+b) |
|||
if b not in list: |
|||
msg.logError("not-topic-attribute in topic-connection: "+topic+", "+b) |
|||
continue |
|||
if a not in conn[topic]: |
|||
continue |
|||
if b in conn[topic][a]: |
|||
conf[B.SUBJECT_ARTS][topic][a][b] = conn[topic][a][b] |
|||
for a in list: |
|||
if topic not in conn: |
|||
break |
|||
if topic not in conn: |
|||
continue |
|||
if a in conn[topic]: |
|||
conf[B.SUBJECT_ARTS][topic][a] = conn[topic][a] |
|||
return conf |
|||
@ -0,0 +1,81 @@ |
|||
# functions about connections to other instances |
|||
# ------------------------------------------------------------------- |
|||
""" |
|||
|
|||
""" |
|||
import basic.program |
|||
import tools.config_tool |
|||
import basic.constants as B |
|||
import tools.data_const as D |
|||
|
|||
|
|||
def getConnection(job, comp, nr): |
|||
#job = basic.program.Job.getInstance() |
|||
verify = job.getDebugLevel("conn_tool") |
|||
conn = {} |
|||
if job.conf.confs.get(B.SUBJECT_TOOL).get("connsrc") == D.DFILE_TYPE_YML: |
|||
conn = tools.config_tool.getConfig(job, "tool", B.SUBJECT_CONN) |
|||
xtypes = None |
|||
if ("types" in conn["env"][comp]): |
|||
xtypes = conn["env"][comp]["types"] |
|||
instnr = "inst" + str(nr) |
|||
if conn["env"][comp][instnr]: |
|||
if (xtypes is not None): |
|||
conn["env"][comp][instnr]["types"] = xtypes |
|||
return conn["env"][comp][instnr] |
|||
else: |
|||
job.m.setFatal("Conn-Tool: Comp not configured " + comp + " " + str(nr)) |
|||
return None |
|||
|
|||
|
|||
def getConnections(job, comp): |
|||
""" |
|||
it reads the connection-attributes for each instances of this component |
|||
general attributes are added to the connection-attributes |
|||
:param comp: |
|||
:return: |
|||
""" |
|||
#job = basic.program.Job.getInstance() |
|||
verify = job.getDebugLevel("conn_tool") |
|||
msg = None |
|||
if hasattr(comp, "m") and comp.m is not None: |
|||
msg = comp.m |
|||
elif hasattr(job, "m") and job.m is not None: |
|||
msg = job.m |
|||
else: |
|||
raise Exception("message-object is missing") |
|||
msg.debug(verify, "getConnections " + comp) |
|||
conn = {} |
|||
conns = [] |
|||
# if a datest-database exists read the connections |
|||
conndb = {} |
|||
if job.conf.confs.get("db"): |
|||
# select |
|||
pass |
|||
|
|||
conn = tools.config_tool.getConfig(job, "tool", B.SUBJECT_CONN) |
|||
if not comp in conn[B.SUBJECT_ENV]: |
|||
job.m.setFatal("Conn-Tool: Comp not configured " + comp) |
|||
|
|||
attr = {} |
|||
if B.CONF_NODE_GENERAL in conn[B.SUBJECT_ENV]: |
|||
for a in conn[B.SUBJECT_ENV][B.CONF_NODE_GENERAL]: |
|||
attr[a] = conn[B.SUBJECT_ENV][B.CONF_NODE_GENERAL] |
|||
for a in conn[B.SUBJECT_ENV][comp]: |
|||
if "inst" in a and a != B.SUBJECT_INST: |
|||
continue |
|||
attr[a] = conn["env"][comp][a] |
|||
#if ("types" in conn["env"][comp]): |
|||
# xtypes = conn["env"][comp]["types"] |
|||
for i in range(conn[B.SUBJECT_ENV][comp][B.SUBJECT_INST][B.ATTR_INST_CNT]): |
|||
#print("range " + str(i + 1)) |
|||
instnr = "inst" + str(i + 1) |
|||
#if (xtypes is not None): |
|||
# conn["env"][comp][instnr]["types"] = xtypes |
|||
for a in attr: |
|||
if a in conn["env"][comp][instnr]: |
|||
continue # dont overwrite an instance-specific value |
|||
conn["env"][comp][instnr][a] = attr[a] |
|||
conns.append(conn["env"][comp][instnr]) |
|||
|
|||
return conns |
|||
@ -0,0 +1,116 @@ |
|||
#!/usr/bin/python |
|||
""" |
|||
constants for used for api-functions |
|||
""" |
|||
import basic.constants as B |
|||
|
|||
DDL_FILENAME = "DATASTRUCTURE" |
|||
|
|||
DATA_NODE_TYPE = "type" |
|||
TYPE_STRING = "string" |
|||
TYPE_STR = "str" |
|||
TYPE_TEXT = "text" |
|||
TYPE_INT = "int" |
|||
TYPE_FLOAT = "float" |
|||
TYPE_DOUBLE = "double" |
|||
TYPE_DATE = "date" |
|||
TYPE_TIME = "time" |
|||
TYPE_PK = "pk" |
|||
|
|||
# fields in DDL |
|||
DDL_FNULLABLE = "nullable" |
|||
DDL_FNAME = "field" |
|||
DDL_ACCEPTANCE = "acceptance" |
|||
DDL_KEY = "key" |
|||
DDL_TYPE = "type" |
|||
DDL_INDEX = "index" |
|||
|
|||
DFILE_TYPE_YML = "yml" |
|||
DFILE_TYPE_JSON = "json" |
|||
DFILE_TYPE_CSV = "csv" |
|||
DFILE_TYPE_XML = "xml" |
|||
DFILE_TESTCASE_NAME = "testspec" |
|||
DFILE_TESTSUITE_NAME = "testsuite" |
|||
DFILE_TABLE_PREFIX = "table_" |
|||
LIST_DFNAME_ATTR = [DFILE_TESTCASE_NAME, DFILE_TESTSUITE_NAME, DFILE_TABLE_PREFIX] |
|||
LIST_DFNAME_CONST = ["DFILE_TESTCASE_NAME", "DFILE_TESTSUITE_NAME", "DFILE_TABLE_PREFIX"] |
|||
|
|||
DATA_SRC_DIR = "dir" |
|||
DATA_SRC_CSV = "csv" |
|||
|
|||
DATA_ATTR_COUNT = "_count" |
|||
""" statistical information of data-count """ |
|||
DATA_ATTR_DATE = "_date" |
|||
""" reference-date for computing the actual date in relation to specification or expectation """ |
|||
DATA_ATTR_COMP = "_comp" |
|||
""" reference to using componente with their object """ |
|||
DATA_ATTR_CHAR = "_char" |
|||
""" character of the data in order to delete it ión initialization """ |
|||
DATA_ATTR_KEY = "_key" |
|||
""" key for a data-specification of a catalog-list - default: the first field is the key """ |
|||
DATA_ATTR_ALIAS = "_alias" |
|||
DATA_ATTR_IDS = "_ids" |
|||
DATA_ATTR_REF = "_ref" |
|||
LIST_DATA_ATTR = [DATA_ATTR_COUNT, DATA_ATTR_DATE, DATA_ATTR_CHAR, DATA_ATTR_COMP, |
|||
DATA_ATTR_REF, DATA_ATTR_IDS, DATA_ATTR_ALIAS, DATA_ATTR_KEY] |
|||
LIST_ATTR_CONST = ["DATA_ATTR_COUNT", "DATA_ATTR_DATE", "DATA_ATTR_CHAR", "DATA_ATTR_COMP", "DATA_ATTR_ALIAS", "DATA_ATTR_KEY"] |
|||
|
|||
HEAD_ATTR_DESCR = "decription" |
|||
HEAD_ATTR_TARGET = "target" |
|||
HEAD_ATTR_USECASE = "usecase" |
|||
HEAD_ATTR_UCID = "usecase-id" |
|||
HEAD_ATTR_STORY = "story" |
|||
HEAD_ATTR_STORYID = "storyid-id" |
|||
HEAD_ATTR_APPS = B.SUBJECT_APPS |
|||
HEAD_ATTR_DEPR = "deprecated" |
|||
LIST_HEAD_ATTR = [HEAD_ATTR_DESCR, HEAD_ATTR_TARGET, HEAD_ATTR_USECASE, HEAD_ATTR_UCID, |
|||
HEAD_ATTR_STORY, HEAD_ATTR_STORYID, HEAD_ATTR_APPS, HEAD_ATTR_DEPR] |
|||
LIST_HEAD_CONST = ["HEAD_ATTR_DESCR", "HEAD_ATTR_TARGET", "HEAD_ATTR_USECASE", "HEAD_ATTR_UCID", |
|||
"HEAD_ATTR_STORY", "HEAD_ATTR_STORYID", "HEAD_ATTR_APPS", "HEAD_ATTR_DEPR"] |
|||
|
|||
|
|||
CSV_HEADER_START = ["node", "table", "tabelle"] |
|||
CSV_DELIMITER = ";" |
|||
INTERNAL_DELIMITER = "||" |
|||
|
|||
""" |
|||
internal structure of testdata |
|||
""" |
|||
CSV_SPECTYPE_DATA = "data" |
|||
CSV_SPECTYPE_TREE = "tree" |
|||
CSV_SPECTYPE_KEYS = "keys" |
|||
CSV_SPECTYPE_CONF = "conf" |
|||
CSV_NODETYPE_KEYS = "_keys" |
|||
|
|||
CSV_BLOCK_HEAD = "_head" |
|||
CSV_BLOCK_OPTION = B.DATA_NODE_OPTION |
|||
CSV_BLOCK_STEP = B.DATA_NODE_STEPS |
|||
CSV_BLOCK_TABLES = B.DATA_NODE_TABLES |
|||
CSV_BLOCK_IMPORT = "_import" |
|||
LIST_CSV_BLOCKS = [CSV_BLOCK_HEAD, CSV_BLOCK_OPTION, CSV_BLOCK_STEP, CSV_BLOCK_TABLES, CSV_BLOCK_IMPORT] |
|||
LIST_BLOCK_CONST = ["CSV_BLOCK_HEAD", "CSV_BLOCK_OPTION", "CSV_BLOCK_STEP", "CSV_BLOCK_TABLES", "CSV_BLOCK_IMPORT"] |
|||
|
|||
STEP_COMP_I = 1 |
|||
STEP_EXECNR_I = 2 |
|||
STEP_REFNR_I = 3 |
|||
STEP_VARIANT_I = 4 |
|||
STEP_ARGS_I = 5 |
|||
STEP_LIST_I = 5 |
|||
STEP_ATTR_COMP = "component" |
|||
STEP_ATTR_EXECNR = "exec-step" |
|||
STEP_ATTR_REFNR = "reference-nr" |
|||
STEP_ATTR_ARGS = "arguments" |
|||
LIST_STEP_ATTR = [STEP_ATTR_COMP, STEP_ATTR_EXECNR, STEP_ATTR_REFNR, STEP_ATTR_ARGS] |
|||
LIST_STEP_CONST = ["STEP_ATTR_COMP", "STEP_ATTR_EXECNR", "STEP_ATTR_REFNR", "STEP_ATTR_ARGS"] |
|||
|
|||
EXCP_MALFORMAT = "malformated line: " |
|||
|
|||
ATTR_SRC_TYPE = "tdtyp" |
|||
ATTR_SRC_DATA = "tdsrc" |
|||
ATTR_SRC_NAME = "tdname" |
|||
|
|||
DEFAULT_DB_PARTITION = "n" |
|||
""" attribute if table is partitioned - partitions are parametrized """ |
|||
DEFAULT_DB_CONN_JAR = "n" |
|||
""" attribute for connection-jar-file instead of connection by ip, port """ |
|||
|
|||
@ -0,0 +1,175 @@ |
|||
# functions related to Date-fields |
|||
# ----------------------------------------------------- |
|||
""" |
|||
additionally functions for calculating date with formulas like [DATE+2M] and for comparison of date related on two reference-dates |
|||
""" |
|||
import datetime |
|||
import re |
|||
import tools.data_const as D |
|||
|
|||
|
|||
F_DIR = "%Y-%m-%d_%H-%M-%S" |
|||
F_DB_DATE = "%Y-%m-%d" |
|||
F_DB_TIME = "%Y-%m-%d %H:%M:%S" |
|||
F_DE = "%d.%m.%Y" |
|||
F_N8 = "%Y%m%d" |
|||
F_LOG = "%Y%m%d_%H%M%S" |
|||
F_DE_TSTAMP = "%d.%m.%Y %H:%M:%S" |
|||
MONTH_EN = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"] |
|||
MONTH_DE = ["jan", "feb", "mar", "apr", "mai", "jun", "jul", "aug", "sep", "okt", "nov", "dez"] |
|||
F_TIME_DEFAULT = F_DIR |
|||
|
|||
def getActdate(format): |
|||
return getFormatdate(datetime.datetime.now(), format) |
|||
|
|||
|
|||
def getFormatdate(date, format): |
|||
""" it return the date as string in the 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 formatParsedDate(instring, format): |
|||
dtupel = parseDate(instring) |
|||
#print ("---------------"+str(dtupel)) |
|||
return getFormatDatetupel(dtupel, 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() |
|||
formula = instring[7:-2].upper() |
|||
else: |
|||
dstring = instring[2:instring.find(" ")] |
|||
res = parseDate(dstring) |
|||
refdate = datetime.datetime(res[0], res[1], res[2], res[3], res[4], res[5]) |
|||
formula = instring[2+len(dstring):-2] |
|||
formula = re.sub(r' ', '', formula) |
|||
year = refdate.year |
|||
mon = refdate.month |
|||
day = refdate.day |
|||
hour = refdate.hour |
|||
min = refdate.minute |
|||
sec = refdate.second |
|||
if re.match(r"[-+]\d+[JYMDT]", formula): |
|||
ress = re.compile(r"([-+])(\d+)([JYMDT])") |
|||
for res in ress.finditer(formula): |
|||
summand = int(res.group(2)) |
|||
if res.group(1) == "-": |
|||
summand = summand * (-1) |
|||
if res.group(3) in "JY": |
|||
year = year + summand |
|||
if res.group(3) in "M": |
|||
mon = mon + summand |
|||
while mon <= 0: |
|||
mon = mon + 12 |
|||
year = year - 1 |
|||
while mon > 12: |
|||
mon = mon - 12 |
|||
year = year + 1 |
|||
if res.group(3) in "DT": |
|||
refdate = datetime.datetime(year, mon, day, hour, min, sec) |
|||
refdate = refdate + datetime.timedelta(days=summand) |
|||
year = refdate.year |
|||
mon = refdate.month |
|||
day = refdate.day |
|||
hour = refdate.hour |
|||
min = refdate.minute |
|||
sec = refdate.second |
|||
return (year, mon, day, hour, min, sec) |
|||
else: |
|||
print("re matcht nicht") |
|||
return (year, mon, day, hour, min, sec) |
|||
|
|||
def getMonthInt(instring): |
|||
i = 0 |
|||
j = 0 |
|||
for l in [MONTH_EN, MONTH_DE]: |
|||
i = 0 |
|||
for m in l: |
|||
i += 1 |
|||
if instring.lower() == m: |
|||
j = i |
|||
break |
|||
if j > 0: |
|||
break |
|||
return j |
|||
|
|||
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 |
|||
hour = 0 |
|||
min = 0 |
|||
sec = 0 |
|||
#print(instring) |
|||
if instring[0:2] == "{(" and instring[-2:] == ")}": |
|||
return parseFormula(instring) |
|||
if re.match(r"\d{8}_\d{6}", instring): |
|||
year = int(instring[0:4]) |
|||
mon = int(instring[4:6]) |
|||
day = int(instring[6:8]) |
|||
hour = int(instring[9:11]) |
|||
min = int(instring[11:13]) |
|||
sec = int(instring[13:]) |
|||
return (year, mon, day, hour, min, sec) |
|||
if len(instring) > 8: |
|||
for d in ["_", " "]: |
|||
if d in instring and instring.find(d) > 8: |
|||
dstring = instring[0:instring.find(d)] |
|||
tstring = instring[instring.find(d)+1:] |
|||
dres = parseDate(dstring) |
|||
tres = parseDate(tstring) |
|||
return (dres[0], dres[1], dres[2], tres[3], tres[4], tres[5]) |
|||
if re.match(r"\d{4}[-./]\d{2}[-./]\d{2}", instring): |
|||
res = re.match(r"(\d{4})[-./](\d{2})[-./](\d{2})", instring) |
|||
year = int(res.group(1)) |
|||
mon = int(res.group(2)) |
|||
day = int(res.group(3)) |
|||
return (year, mon, day, hour, min, sec) |
|||
if re.match(r"\d{1,2}[-./]\d{1,2}[-./]\d{4}", instring): |
|||
res = re.match(r"(\d{1,2})[-./](\d{1,2})[-./](\d{4})", instring) |
|||
year = int(res.group(3)) |
|||
mon = int(res.group(2)) |
|||
day = int(res.group(1)) |
|||
return (year, mon, day, hour, min, sec) |
|||
if re.match(r"\w{3} \w{3}\s+\d{1,2} \d{1,2}[:]\d{1,2}[:]\d{2} \d{4}", instring.strip()): |
|||
res = re.search(r"\w{3} (\w{3})\s+(\d{1,2}) (\d{1,2})[:](\d{1,2})[:](\d{2}) (\d{4})", instring.strip()) |
|||
month = res.group(1) |
|||
mon = getMonthInt(month) |
|||
day = int(res.group(2)) |
|||
hour = int(res.group(3)) |
|||
min = int(res.group(4)) |
|||
sec = int(res.group(5)) |
|||
year = int(res.group(6)) |
|||
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)) |
|||
min = int(res.group(2)) |
|||
sec = int(res.group(3)) |
|||
return (year, mon, day, hour, min, sec) |
|||
return (year, mon, day, hour, min, sec) |
|||
@ -0,0 +1,113 @@ |
|||
#!/usr/bin/python |
|||
# -*- coding: utf-8 -*- |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
# Author : Ulrich Carmesin |
|||
# Source : gitea.ucarmesin.de |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
import os |
|||
import basic.program |
|||
import tools.config_tool |
|||
import basic.constants as B |
|||
import basic.toolHandling |
|||
import tools.file_tool |
|||
import tools.path_tool |
|||
|
|||
|
|||
class FileFcts(): |
|||
""" |
|||
this is an abstract class |
|||
""" |
|||
def __init__(self): |
|||
pass |
|||
|
|||
def setComp(self, job, comp=None): |
|||
self.job = job |
|||
self.comp = comp |
|||
|
|||
def getMsg(self): |
|||
if self.comp is not None: |
|||
return self.comp.m |
|||
if self.job is not None: |
|||
return self.job.m |
|||
return None |
|||
|
|||
def loadFile(self, path): |
|||
""" |
|||
this function parses the text and translates it to dict |
|||
:param text: |
|||
:return: |
|||
""" |
|||
raise Exception(B.EXCEPT_NOT_IMPLEMENT) |
|||
|
|||
|
|||
def file2dict(self): |
|||
pass |
|||
|
|||
def reset_TData(self, job): |
|||
pass |
|||
|
|||
# Funktionen |
|||
#=== init_testcase === |
|||
def removeFiles(self): |
|||
tools.file_tool.removeFiles(self.comp.m, "envpath", "pattern", self.comp.conf["conn"]) |
|||
|
|||
def copyFiles(self): |
|||
fileList = [] |
|||
srcpath = "" |
|||
envpath = "" |
|||
pattern = "" |
|||
tools.file_tool.copyFiles(self.job, fileList, srcpath, envpath, pattern) |
|||
|
|||
def readEnvFiles(self, job): |
|||
envpath = "" |
|||
pattern = "" |
|||
fileList = tools.file_tool.getFiles(self.comp.m, job, envpath, pattern, self.comp.conf["conn"]) |
|||
|
|||
|
|||
# === execute_testcase === |
|||
def create_request(self, job, tdata, step): |
|||
mapping = "" |
|||
schema = "" |
|||
archivpath = "" |
|||
filename = step.args["filename"] |
|||
txt = "" |
|||
for o in self.comp.conf[B.SUBJECT_ARTS][B.TOPIC_NODE_FILE]: |
|||
if o["name"] != filename: |
|||
continue |
|||
mapping = o["mapping"] |
|||
schema = o["schema"] |
|||
archivpath = os.path.join(tools.path_tool.composePattern(job, "{tcresult}/request", self.comp), filename) # ergebnisse/comp/request ) |
|||
#txt = self.createDict() |
|||
tools.file_tool.writeFileText(self.comp.m, job, archivpath, txt) |
|||
|
|||
def send_request(self, job, step): |
|||
archivpath = "" |
|||
filename = step.args["filename"] |
|||
technique = step.args["technique"] |
|||
archivpath = os.path.join(tools.path_tool.composePattern(job, "{tcresult}/request", self.comp), filename) |
|||
if technique == "cli": |
|||
for o in self.comp.conf[B.SUBJECT_ARTS][B.TOPIC_NODE_FILE]: |
|||
if o["name"] != filename: |
|||
continue |
|||
envpath = o["envpath"] |
|||
envpath = tools.path_tool.composePattern(job, envpath, self.comp) |
|||
fct = basic.toolHandling.getCliTool(job, self.comp) |
|||
fct.copy(self.job, archivpath, envpath) |
|||
elif technique == "api": |
|||
txt = tools.file_tool.readFileText(job, archivpath, self.comp.m) |
|||
fct = basic.toolHandling.getApiTool(job, self.comp) |
|||
response = fct.send(self.job, self.comp, txt) |
|||
archivpath = os.path.join(tools.path_tool.composePattern(job, "{tcresult}/response", self.comp), filename) |
|||
|
|||
""" |
|||
get_response: |
|||
- channel (sync/async) |
|||
... implement |
|||
- archivpath ( ergebnisse/comp/response ) |
|||
- envpath ( ./log) / envconn ( = in Request empfangen ) |
|||
|
|||
=== collect_testcase === |
|||
- envpath |
|||
- pattern |
|||
> readfiles |
|||
""" |
|||
@ -0,0 +1,295 @@ |
|||
# Funktionen zum Dateizugriff mit Suchen, Lesen, Schreiben |
|||
# ------------------------------------------------------------ |
|||
""" |
|||
|
|||
""" |
|||
import codecs |
|||
import json |
|||
import os |
|||
import os.path |
|||
import re |
|||
import time |
|||
|
|||
import xmltodict |
|||
import yaml |
|||
import platform |
|||
import basic.toolHandling |
|||
|
|||
import basic.program |
|||
import tools.data_const as D |
|||
#import tools.tdata_tool |
|||
import tools.date_tool |
|||
|
|||
|
|||
def getDump(obj): |
|||
result = "" |
|||
print(str(type(obj))) |
|||
result = vars(obj) |
|||
return str(result) |
|||
|
|||
|
|||
# if type(obj) == "__dict__" |
|||
|
|||
|
|||
def getFiles(msg, job, path, pattern, conn): |
|||
""" |
|||
search filenames in the directory - if conn is set search remote |
|||
:param msg: -- msg-Objekt |
|||
:param path: -- path - String |
|||
:param pattern: -- filename or pattern |
|||
:param conn: |
|||
:return: Array with filenames |
|||
""" |
|||
if conn is not None: |
|||
return getRemoteFiles(msg, path, pattern, conn) |
|||
# job = basic.program.Job.getInstance() |
|||
verify = int(job.getDebugLevel("file_tool")) |
|||
out = [] |
|||
msg.debug(verify, "getFiles " + path + " , " + pattern) |
|||
if not os.path.exists(path): |
|||
return out |
|||
for f in os.listdir(path): |
|||
msg.debug(verify, "getFiles " + f) |
|||
if re.search(pattern, f): |
|||
msg.debug(verify, "match " + f) |
|||
out.append(f) |
|||
return out |
|||
|
|||
|
|||
def removeFiles(msg, path, pattern, conn): |
|||
""" |
|||
search filenames in the directory and removes it |
|||
- if conn is set search remote |
|||
:param msg: -- msg-Objekt |
|||
:param path: -- path - String |
|||
:param pattern: -- filename as Pattern |
|||
:param conn: |
|||
:return: Array filenames |
|||
""" |
|||
pass |
|||
|
|||
|
|||
def copyFiles(job, fileList, source, target, comp): |
|||
""" |
|||
copies files from source to target |
|||
:param job: |
|||
:param fileList: |
|||
:param source: |
|||
:param target: |
|||
:param comp: |
|||
:return: |
|||
""" |
|||
pass |
|||
|
|||
|
|||
def getRemoteFiles(msg, path, pattern, conn): |
|||
""" |
|||
search filenames in the directory - if conn is set search remote |
|||
:param msg: -- msg-Objekt |
|||
:param path: -- path - String |
|||
:param pattern: -- filename as Pattern |
|||
:param conn: |
|||
:return: Array filenames |
|||
""" |
|||
pass |
|||
|
|||
|
|||
def getFilesRec(msg, job, path, pattern): |
|||
""" |
|||
Sucht Dateien im Verzeichnis rekursiv |
|||
:param msg: -- msg-Objekt |
|||
:param path: -- Pfad - String |
|||
:param pattern: -- Dateiname als Pattern |
|||
:return: Array mit gefundenen Dateien, absoluter Pfad |
|||
""" |
|||
# job = basic.program.Job.getInstance() |
|||
verify = int(job.getDebugLevel("file_tool")) |
|||
out = [] |
|||
msg.debug(verify, "getFilesRec " + path + " , " + pattern) |
|||
for (r, dirs, files) in os.walk(path): |
|||
for f in files: |
|||
msg.debug(verify, "getFilesRec " + f) |
|||
if re.search(pattern, f): |
|||
msg.debug(verify, "match " + f) |
|||
out.append(os.path.join(r, f)) |
|||
return out |
|||
|
|||
|
|||
def getTree(msg, job, pfad): |
|||
# job = basic.program.Job.getInstance() |
|||
verify = int(job.getDebugLevel("file_tool")) |
|||
msg.debug(verify, "getTree " + pfad) |
|||
tree = {} |
|||
files = [] |
|||
for f in os.listdir(pfad): |
|||
if os.path.isDir(os.path.join(pfad, f)): |
|||
tree[f] = getTree(msg, job, os.path.join(pfad, f)) |
|||
elif os.path.isFile(os.path.join(pfad, f)): |
|||
files.append(f) |
|||
tree["_files_"] = files |
|||
return tree |
|||
|
|||
|
|||
def mkPaths(job, path, msg): |
|||
# job = basic.program.Job.getInstance() |
|||
verify = int(job.getDebugLevel("file_tool")) |
|||
# modus = job.conf.paths["mode"] |
|||
dirname = os.path.dirname(path) |
|||
if os.path.exists(dirname): |
|||
return |
|||
os.makedirs(dirname, exist_ok=True) |
|||
|
|||
|
|||
def getFileEncoding(msg, job, path): |
|||
print("--- getFileEncoding " + path) |
|||
encodings = ['utf-8', 'iso-8859-1'] # add more |
|||
for e in encodings: |
|||
print(e) |
|||
try: |
|||
fh = codecs.open(path, 'r', encoding=e) |
|||
fh.readlines() |
|||
fh.seek(0) |
|||
except UnicodeDecodeError: |
|||
print('got unicode error with %s , trying different encoding' % e) |
|||
except: |
|||
print("except") |
|||
else: |
|||
print('opening the file with encoding: %s ' % e) |
|||
return e |
|||
return detectFileEncode(job, path, msg) |
|||
|
|||
|
|||
def detectFileEncode(job, path, msg): # return "" |
|||
# job = basic.program.Job.getInstance() |
|||
verify = int(job.getDebugLevel("file_tool")) |
|||
print(path) |
|||
cntIso = 0 |
|||
cntUtf = 0 |
|||
j = 0 |
|||
CHAR_ISO = [196, 228, 214, 246, 220, 252, 191] |
|||
with open(path, 'rb') as file: |
|||
byte = file.read(1) |
|||
while (byte): |
|||
i = int.from_bytes(byte, "little") |
|||
# byte = file.read(1) |
|||
if (i in CHAR_ISO): |
|||
cntIso += 1 |
|||
if (i == 160): |
|||
pass |
|||
elif (i > 127): |
|||
cntUtf += 1 |
|||
j += 1 |
|||
l = i |
|||
byte = file.read(1) |
|||
file.close() |
|||
if (cntIso > cntUtf): |
|||
return 'iso-8859-1' |
|||
return 'utf-8' |
|||
|
|||
|
|||
def readFileLines(job, path, msg): |
|||
lines = readFileText(job, path, msg) |
|||
if isinstance(lines, (str)): |
|||
return lines.splitlines() |
|||
return [] |
|||
|
|||
|
|||
def readFileText(job, path, msg): |
|||
# job = basic.program.Job.getInstance() |
|||
verify = int(job.getDebugLevel("file_tool")) |
|||
if not os.path.exists(path): |
|||
return "" |
|||
enc = detectFileEncode(job, path, msg) |
|||
with open(path, 'r', encoding=enc) as file: |
|||
text = file.read() |
|||
file.close() |
|||
return text |
|||
|
|||
|
|||
def getModTime(job, filepath): |
|||
out = "" |
|||
mtime = os.path.getmtime(filepath) |
|||
out = tools.date_tool.formatParsedDate(time.ctime(mtime), tools.date_tool.F_TIME_DEFAULT) |
|||
return out |
|||
|
|||
|
|||
def readFileDict(job, path, msg): |
|||
""" |
|||
reads and gets general a dict from any kind of filetyp |
|||
:param path: with extension of filetype |
|||
:param msg: optionally |
|||
:return: |
|||
""" |
|||
# 20220329 generalize |
|||
# job = basic.program.Job.getInstance() |
|||
verify = int(job.getDebugLevel("file_tool")) |
|||
doc = {} |
|||
if not os.path.exists(path): |
|||
return doc |
|||
enc = detectFileEncode(job, path, msg) |
|||
if D.DFILE_TYPE_YML in path[-4:]: |
|||
with open(path, 'r', encoding=enc) as file: |
|||
doc = yaml.full_load(file) |
|||
file.close() |
|||
elif D.DFILE_TYPE_JSON in path[-5:]: |
|||
with open(path, 'r', encoding=enc) as file: |
|||
doc = json.load(file) |
|||
file.close() |
|||
elif D.DFILE_TYPE_XML in path[-4:]: |
|||
with open(path, 'r', encoding=enc) as file: |
|||
res = xmltodict.parse(file.read()) |
|||
# doc = dict(res) |
|||
doc = castOrderedDict(res) |
|||
file.close() |
|||
elif D.DFILE_TYPE_CSV in path[-5:]: |
|||
ffcts = basic.toolHandling.getFileTool(job, None, D.DFILE_TYPE_CSV) |
|||
#doc = tools.tdata_tool.getCsvSpec(msg, job, path, D.CSV_SPECTYPE_CONF) |
|||
doc = ffcts.loadFile(path) |
|||
# tools.tdata_tool.getCsvSpec(msg, job, path, D.CSV_SPECTYPE_CONF) |
|||
return doc |
|||
|
|||
|
|||
def castOrderedDict(res, job=None, key=""): |
|||
if isinstance(res, dict): |
|||
doc = dict(res) |
|||
for x in doc: |
|||
doc[x] = castOrderedDict(doc[x], job, x) |
|||
elif isinstance(res, list): |
|||
sublist = [] |
|||
for i in range(0, len(res)): |
|||
sublist.append(castOrderedDict(res[i], job, "")) |
|||
doc = sublist |
|||
else: |
|||
doc = res |
|||
return doc |
|||
|
|||
|
|||
def writeFileText(msg, job, path, text, enc="utf-8"): |
|||
# job = basic.program.Job.getInstance() |
|||
verify = int(job.getDebugLevel("file_tool")) |
|||
mkPaths(job, path, msg) |
|||
with open(path, 'w', encoding=enc) as file: |
|||
file.write(text) |
|||
file.close() |
|||
|
|||
|
|||
def writeFileDict(msg, job, path, dict, enc="utf-8"): |
|||
# job = basic.program.Job.getInstance() |
|||
mkPaths(job, path, msg) |
|||
if D.DFILE_TYPE_YML in path[-5:]: |
|||
with open(path, 'w', encoding=enc) as file: |
|||
yaml.dump(dict, file) |
|||
file.close() |
|||
elif D.DFILE_TYPE_JSON in path[-5:]: |
|||
with open(path, 'w', encoding=enc) as file: |
|||
doc = json.dumps(dict, indent=4) |
|||
file.write(doc) |
|||
file.close() |
|||
elif D.DFILE_TYPE_XML in path[-4:]: |
|||
with open(path, 'w', encoding=enc) as file: |
|||
text = xmltodict.unparse(dict, pretty=True) |
|||
if "<?xml version=" not in text: |
|||
text = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + text |
|||
file.write(text) |
|||
file.close() |
|||
|
|||
@ -0,0 +1,246 @@ |
|||
#!/usr/bin/python |
|||
# -*- coding: utf-8 -*- |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
# Author : Ulrich Carmesin |
|||
# Source : gitea.ucarmesin.de |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
import re |
|||
import basic.program |
|||
import tools.file_abstract |
|||
import basic.constants as B |
|||
import tools.data_const as D |
|||
import tools.file_tool |
|||
|
|||
|
|||
class FileFcts(tools.file_abstract.FileFcts): |
|||
|
|||
def __init__(self): |
|||
pass |
|||
|
|||
def loadFile(self, path): |
|||
""" |
|||
this function parses the text and translates it to dict |
|||
:param text: |
|||
:return: |
|||
""" |
|||
lines = tools.file_tool.readFileLines(self.job, path, self.getMsg()) |
|||
return self.parseCsv(self.getMsg(), self.job, lines) |
|||
|
|||
def parseCsv(self, msg, job, lines, ttype=""): |
|||
""" |
|||
|
|||
:param msg: |
|||
:param lines: |
|||
:param type: |
|||
:param job: |
|||
:return: |
|||
""" |
|||
tdata = {} |
|||
status = "start" |
|||
verbose = False |
|||
tableAttr = {} # table |
|||
tableDict = {} # table |
|||
for l in lines: |
|||
if verbose: print("lines "+l) |
|||
fields = splitFields(l, D.CSV_DELIMITER, job) |
|||
# check empty line, comment |
|||
if (len(fields) < 1) or (len(l.strip().replace(D.CSV_DELIMITER,"")) < 1): |
|||
status = "start" |
|||
continue |
|||
if (fields[0][0:1] == "#"): |
|||
continue |
|||
a = fields[0].lower().split(":") |
|||
# keywords option, step, table |
|||
if verbose: print(str(a)+" -- "+str(fields)) |
|||
tableAttr = setTableAttribute(tableAttr, a[0], fields[1], job) |
|||
if a[0].lower() in D.LIST_DATA_ATTR: |
|||
status = "TABLE_ALIAS" |
|||
if a[0].lower() == D.DATA_ATTR_KEY: |
|||
ttype = D.CSV_SPECTYPE_KEYS |
|||
continue |
|||
if (a[0].lower() in [D.CSV_BLOCK_HEAD]): |
|||
if verbose: print("head "+l) |
|||
setTdataLine(tdata, fields, D.CSV_BLOCK_HEAD, job) |
|||
status = "start" |
|||
continue |
|||
elif (a[0].lower() == D.CSV_BLOCK_OPTION): |
|||
if verbose: print("option " + l) |
|||
setTdataLine(tdata, fields, D.CSV_BLOCK_OPTION, job) |
|||
status = "start" |
|||
continue |
|||
elif (a[0].lower() == D.CSV_BLOCK_STEP): |
|||
if verbose: print("step "+l) |
|||
step = basic.step.parseStep(job, fields) |
|||
if D.CSV_BLOCK_STEP not in tdata: |
|||
tdata[D.CSV_BLOCK_STEP] = [] |
|||
tdata[D.CSV_BLOCK_STEP].append(step) |
|||
status = "start" |
|||
continue |
|||
elif (a[0].lower() == D.CSV_BLOCK_IMPORT): |
|||
if verbose: print("includes " + l) |
|||
if D.CSV_BLOCK_IMPORT not in tdata: |
|||
tdata[D.CSV_BLOCK_IMPORT] = [] |
|||
tdata[D.CSV_BLOCK_IMPORT].append(fields[1]) |
|||
status = "start" |
|||
continue |
|||
elif (a[0].lower() == D.CSV_BLOCK_TABLES) or (a[0].lower() in D.CSV_HEADER_START): |
|||
if verbose: print("tables "+l) |
|||
h = a |
|||
h[0] = B.DATA_NODE_TABLES |
|||
if ttype == D.CSV_SPECTYPE_CONF: |
|||
del h[0] |
|||
tableDict = getTdataContent(msg, tdata, h) |
|||
setTableHeader(tableDict, tableAttr, fields, ttype, job) |
|||
status = D.CSV_SPECTYPE_DATA |
|||
elif (status == D.CSV_SPECTYPE_DATA): |
|||
tableDict = getTdataContent(msg, tdata, h) |
|||
if verbose: print("setTableData "+str(h)+" "+str(tableDict)) |
|||
setTableData(tableDict, fields, ttype, job) |
|||
elif (status == "TABLE_ALIAS") and D.DATA_ATTR_ALIAS in tdata: |
|||
alias = tdata[D.DATA_ATTR_ALIAS] |
|||
b = alias.split(":") |
|||
h = [B.DATA_NODE_TABLES] + b |
|||
tableDict = getTdataContent(msg, tdata, h) |
|||
tableDict[D.DATA_ATTR_ALIAS] = alias |
|||
fields = [alias] + fields |
|||
setTableHeader(tableDict, tableAttr, fields, ttype, job) |
|||
status = D.CSV_SPECTYPE_DATA |
|||
if ttype == D.CSV_SPECTYPE_CONF: |
|||
header = [] |
|||
for k in tdata: |
|||
if k in D.LIST_DATA_ATTR: |
|||
continue |
|||
if B.DATA_NODE_DATA in tdata[k]: |
|||
tdata[k].pop(B.DATA_NODE_DATA) |
|||
for f in tdata[k]: |
|||
if f in [B.DATA_NODE_HEADER, "_hit"] + D.LIST_DATA_ATTR: |
|||
continue |
|||
header.append(f) |
|||
tdata[k][B.DATA_NODE_HEADER] = header |
|||
header = [] |
|||
if B.DATA_NODE_TABLES in tdata and B.DATA_NODE_TABLES in tdata[B.DATA_NODE_TABLES]: |
|||
for k in tdata[B.DATA_NODE_TABLES][B.DATA_NODE_TABLES]: |
|||
if k in tdata[B.DATA_NODE_TABLES]: |
|||
if verbose: print("Error") |
|||
else: |
|||
tdata[B.DATA_NODE_TABLES][k] = tdata[B.DATA_NODE_TABLES][B.DATA_NODE_TABLES][k] |
|||
tdata[B.DATA_NODE_TABLES].pop(B.DATA_NODE_TABLES) |
|||
return tdata |
|||
|
|||
def splitFields(line, delimiter, job): |
|||
out = [] |
|||
fields = line.split(delimiter) |
|||
for i in range(0, len(fields)): |
|||
if fields[i][0:1] == "#": |
|||
break |
|||
if re.match(r"^\"(.*)\"$", fields[i]): |
|||
fields[i] = fields[i][1:-1] |
|||
out.append(fields[i]) |
|||
return out |
|||
|
|||
def setTableAttribute(tableAttr, key, val, job): |
|||
for attr in D.LIST_DATA_ATTR: |
|||
if (key.lower() == attr): |
|||
tableAttr[attr] = val.strip() |
|||
tableAttr["_hit"] = True |
|||
return tableAttr |
|||
tableAttr["_hit"] = False |
|||
return tableAttr |
|||
|
|||
def setTdataLine(tdata, fields, block, job): |
|||
""" |
|||
sets field(s) into tdata as a key-value-pair |
|||
additional fields will be concatenate to a intern separated list |
|||
:param tdata: |
|||
:param fields: |
|||
:param block: |
|||
:param job: |
|||
:return: |
|||
""" |
|||
a = fields[0].lower().split(":") |
|||
a[0] = block # normalized key |
|||
val = "" |
|||
for i in range(1, len(fields)-1): |
|||
val += D.INTERNAL_DELIMITER+fields[i] |
|||
if len(val) > len(D.INTERNAL_DELIMITER): |
|||
val = val[len(D.INTERNAL_DELIMITER):] |
|||
setTdataContent(job.m, tdata, val, a) |
|||
return tdata |
|||
|
|||
def setTdataContent(msg, data, tabledata, path): |
|||
setTdataStructure(msg, data, path) |
|||
if len(path) == 2: |
|||
data[path[0]][path[1]] = tabledata |
|||
elif len(path) == 3: |
|||
data[path[0]][path[1]][path[2]] = tabledata |
|||
elif len(path) == 4: |
|||
data[path[0]][path[1]][path[2]][path[3]] = tabledata |
|||
|
|||
def setTdataStructure(msg, data, path): |
|||
if len(path) >= 1 and path[0] not in data: |
|||
data[path[0]] = {} |
|||
if len(path) >= 2 and path[1] not in data[path[0]]: |
|||
data[path[0]][path[1]] = {} |
|||
if len(path) >= 3 and path[2] not in data[path[0]][path[1]]: |
|||
data[path[0]][path[1]][path[2]] = {} |
|||
if len(path) >= 4 and path[3] not in data[path[0]][path[1]][path[2]]: |
|||
data[path[0]][path[1]][path[2]][path[3]] = {} |
|||
return data |
|||
|
|||
def getTdataContent(msg, data, path): |
|||
setTdataStructure(msg, data, path) |
|||
if len(path) == 2: |
|||
return data[path[0]][path[1]] |
|||
elif len(path) == 3: |
|||
return data[path[0]][path[1]][path[2]] |
|||
elif len(path) == 4: |
|||
return data[path[0]][path[1]][path[2]][path[3]] |
|||
elif len(path) == 1: |
|||
return data[path[0]] |
|||
else: |
|||
return None |
|||
|
|||
def setTableHeader(tableDict, tableAttr, fields, ttype, job): |
|||
header = [] |
|||
for i in range(1, len(fields)): |
|||
header.append(fields[i].strip()) |
|||
tableDict[B.DATA_NODE_HEADER] = header |
|||
for attr in tableAttr: |
|||
tableDict[attr] = tableAttr[attr] |
|||
# preparate the sub-structure for row-data |
|||
if ttype == D.CSV_SPECTYPE_TREE: |
|||
tableDict[B.DATA_NODE_DATA] = {} |
|||
elif ttype == D.CSV_SPECTYPE_KEYS: |
|||
tableDict[D.CSV_NODETYPE_KEYS] = {} |
|||
tableDict[D.DATA_ATTR_KEY] = 1 |
|||
if D.DATA_ATTR_KEY in tableAttr: |
|||
tableDict[D.DATA_ATTR_KEY] = header.index(tableAttr[D.DATA_ATTR_KEY]) + 1 |
|||
else: |
|||
tableDict[B.DATA_NODE_DATA] = [] |
|||
return tableDict |
|||
|
|||
def setTableData(tableDict, fields, ttype, job): |
|||
row = {} |
|||
if ttype == D.CSV_SPECTYPE_DATA and ":" not in fields[0] and D.DATA_ATTR_ALIAS in tableDict: |
|||
fields = [tableDict[D.DATA_ATTR_ALIAS]] + fields |
|||
i = 1 |
|||
for f in tableDict[B.DATA_NODE_HEADER]: |
|||
row[f] = fields[i].strip() |
|||
i += 1 |
|||
if ttype == D.CSV_SPECTYPE_DATA: |
|||
if B.ATTR_DATA_COMP in tableDict: |
|||
tcomps = tableDict[B.ATTR_DATA_COMP] |
|||
else: |
|||
tcomps = {} |
|||
row[B.ATTR_DATA_COMP] = {} |
|||
for c in fields[0].split(","): |
|||
a = c.split(":") |
|||
tcomps[a[0]] = a[1] |
|||
row[B.ATTR_DATA_COMP][a[0]] = a[1].strip() |
|||
tableDict[B.DATA_NODE_DATA].append(row) |
|||
tableDict[B.ATTR_DATA_COMP] = tcomps |
|||
elif ttype == D.CSV_SPECTYPE_KEYS: |
|||
tableDict[D.CSV_NODETYPE_KEYS][fields[tableDict[D.DATA_ATTR_KEY]].strip()] = row |
|||
elif ttype == D.CSV_SPECTYPE_CONF: |
|||
tableDict[fields[1]] = row |
|||
return tableDict |
|||
@ -0,0 +1,102 @@ |
|||
# GrundFunktionen zur Ablaufsteuerung |
|||
# |
|||
# -------------------------------------------------------- |
|||
""" |
|||
1. Programm -- implementiert in Main-Klasse |
|||
2. Anwndung -- steuert zu pruefende System [ in basis_Config ] |
|||
3. application -- steuert zu pruefende Maschine [ in dir/applicationen ] |
|||
4. release -- steuert zu prufendes Release [ aus dir/release kann spez. release_Config geladen werden, dir/lauf/release ] |
|||
5. ~Verz -- Dokumentationsverzeichnis zu Testlauf/Testfall/Soll-Branch |
|||
6. zyklus -- optional unterscheidet echte und entwicklungsLaeufe |
|||
7. Programmspezifische Parameter |
|||
8. loglevel -- steuert Protokollierung; default debug (fatal/error/warn/msg/info/debug1/debug2/trace1/trace2) |
|||
10. Laufart -- steuert die Verarbeitung; default echt |
|||
- echt-auto Lauf aus Automatisierung (1-7) |
|||
- test Lauf ohne Ausfuehrungen am Testsystem, wohl aber in Testverzeichnissen |
|||
- echt-spez Wiederholung einer spezifischen Funktion (1-13) |
|||
- unit Ausfuehrung der Unittests |
|||
11. Modul -- schraenkt Verarbeitung auf parametriserte componenten ein |
|||
12. Funktion -- schraenkt Verarbeitung auf parametriserte Funktionen ein |
|||
13. Tool -- schraenkt Protokollierung/Verarbeitung auf parametriserte Tools ein |
|||
""" |
|||
import basic.program |
|||
import basic.constants as B |
|||
try: |
|||
import collect_testcase |
|||
import compare_testcase |
|||
import execute_testcase |
|||
import finish_testsuite |
|||
import init_testcase |
|||
import init_testsuite |
|||
import test_executer |
|||
except Exception as e: |
|||
pass |
|||
import tools.path_tool |
|||
import tools.file_tool |
|||
import components.tools.job_tool |
|||
|
|||
|
|||
def hasModul(komp): |
|||
#job = Job.getInstance() |
|||
return False |
|||
def hasFunction(fct): |
|||
#job = Job.getInstance() |
|||
return False |
|||
def hasTool(tool): |
|||
#job = Job.getInstance() |
|||
return False |
|||
|
|||
def createJob(parentJob, jobargs): |
|||
job = basic.program.Job("temp") # meaning temp |
|||
job.par.setParameterArgs(job, jobargs) |
|||
job.startJob() |
|||
return |
|||
|
|||
def startJobProcesses(job): |
|||
""" function to open processes like db-connection """ |
|||
components.tools.job_tool.startJobProcesses(job) |
|||
pass |
|||
|
|||
def stopJobProcesses(job): |
|||
""" function to close processes like db-connection """ |
|||
components.tools.job_tool.stopJobProcesses(job) |
|||
pass |
|||
|
|||
def startProcess(job, process): |
|||
print(str(process)) |
|||
path = tools.path_tool.getActualJsonPath(job) |
|||
print("------- "+path) |
|||
tools.file_tool.writeFileDict(job.m, job, path, process) |
|||
jobargs = {} |
|||
jobargs[B.PAR_APP] = process["app"] |
|||
jobargs[B.PAR_ENV] = process["env"] |
|||
if B.PAR_STEP in process: |
|||
jobargs[B.PAR_STEP] = process[B.PAR_STEP] |
|||
if B.PAR_TCDIR in process: |
|||
jobargs[B.PAR_TCDIR] = process[B.PAR_TCDIR] |
|||
jobargs[B.PAR_TESTCASE] = process["entity"] |
|||
elif B.PAR_TSDIR in process: |
|||
jobargs[B.PAR_TSDIR] = process[B.PAR_TSDIR] |
|||
jobargs[B.PAR_TESTSUITE] = process["entity"] |
|||
print("process-programm "+process["program"]) |
|||
myjob = basic.program.Job(process["program"], jobargs) |
|||
myjob.startJob() |
|||
if process["program"] == "init_testcase": |
|||
init_testcase.startPyJob(myjob) |
|||
elif process["program"] == "execute_testcase": |
|||
execute_testcase.startPyJob(myjob) |
|||
elif process["program"] == "collect_testcase": |
|||
collect_testcase.startPyJob(myjob) |
|||
elif process["program"] == "compare_testcase": |
|||
compare_testcase.startPyJob(myjob) |
|||
elif process["program"] == "init_testsuite": |
|||
init_testsuite.startPyJob(myjob) |
|||
elif process["program"] == "execute_testsuite": |
|||
print("execute_testsuite.startPyJob(myjob) not implemented") |
|||
elif process["program"] == "collect_testsuite": |
|||
print("collect_testsuite.startPyJob(myjob) not implemented") |
|||
elif process["program"] == "finish_testsuite": |
|||
finish_testsuite.startPyJob(myjob) |
|||
elif process["program"] == "test_executer": |
|||
test_executer.startPyJob(myjob) |
|||
|
|||
@ -0,0 +1,115 @@ |
|||
import basic.constants as B |
|||
# ------------------------------------------------------------- |
|||
# values and keywords |
|||
KEY_PRECOND = "precond" |
|||
KEY_POSTCOND = "postcond" |
|||
KEY_RESULT = "result" |
|||
KEY_ORIGIN = "origin" |
|||
KEY_PARTS = "parts" |
|||
KEY_SUMFILE = "sumfile" |
|||
KEY_BACKUP = "backup" |
|||
KEY_REFFILE = "reffile" |
|||
KEY_TESTCASE = "tc" |
|||
KEY_TESTSUITE = "ts" |
|||
KEY_CATALOG = "catalog" |
|||
KEY_DEBUGNAME = "debugname" |
|||
KEY_LOGNAME = "logname" |
|||
KEY_BASIC = "basic" |
|||
""" keyword for basic config in components """ |
|||
KEY_COMP = "comp" |
|||
""" keyword for individual component """ |
|||
KEY_TOOL = "tool" |
|||
""" keyword for technical tools """ |
|||
VAL_UTIL = "utils" |
|||
""" subdir for any technical tools """ |
|||
VAL_CONFIG = "config" |
|||
""" subdir for any place of config-files """ |
|||
VAL_COMPS = "components" |
|||
""" subdir for the plugin components """ |
|||
VAL_BASIC = "basic" |
|||
""" subdir for the basic job-framework """ |
|||
VAL_BASE_DATA = "data" |
|||
""" subdir for the basis data-folder """ |
|||
VAL_TDATA = "testdata" |
|||
""" subdir for the basis data-folder """ |
|||
# ------------------------------------------------------------- |
|||
# parameter with arguments |
|||
PAR_APP = "job.par." + B.PAR_APP |
|||
PAR_ENV = "job.par." + B.PAR_ENV |
|||
PAR_REL = "job.par." + B.PAR_REL |
|||
PAR_TSDIR = "job.par." + B.PAR_TSDIR |
|||
PAR_TCDIR = "job.par." + B.PAR_TCDIR |
|||
PAR_XPDIR = "job.par." + B.PAR_XPDIR |
|||
PAR_TDTYP = "job.par." + B.PAR_TDTYP |
|||
PAR_TDSRC = "job.par." + B.PAR_TDSRC |
|||
PAR_TDNAME = "job.par." + B.PAR_TDNAME |
|||
PAR_LOG = "job.par." + B.PAR_LOG |
|||
PAR_MODUS = "job.par." + B.PAR_MODUS |
|||
PAR_COMP = "job.par." + B.PAR_COMP |
|||
PAR_FCT = "job.par." + B.PAR_FCT |
|||
PAR_TOOL = "job.par." + B.PAR_TOOL |
|||
PAR_STEP = "job.par." + B.PAR_STEP |
|||
PAR_DESCRIPT = "job.par." + B.PAR_DESCRIPT |
|||
PAR_TESTCASE = "job.par." + B.PAR_TESTCASE |
|||
PAR_TESTCASES = "job.par." + B.PAR_TESTCASES |
|||
PAR_TESTSUITE = "job.par." + B.PAR_TESTSUITE |
|||
PAR_TCTIME = "job.par." + B.PAR_TCTIME |
|||
PAR_TSTIME = "job.par." + B.PAR_TSTIME |
|||
PAR_TESTINSTANCES = "job.par." + B.PAR_TESTINSTANCES |
|||
|
|||
# ------------------------------------------------------------- |
|||
# attributes |
|||
ATTR_PATH_MODE = "mode" |
|||
""" This constant defines the home-folder in filesystem of test """ |
|||
ATTR_PATH_HOME = "home" |
|||
""" This constant defines the home-folder in testing-filesystem """ |
|||
ATTR_PATH_DEBUG = "debugs" |
|||
""" This constant defines the debug-folder in testing-filesystem """ |
|||
ATTR_PATH_ARCHIV = "archiv" |
|||
""" This constant defines the folder in testing-filesystem for results and log of execution """ |
|||
ATTR_PATH_PROGRAM = "program" |
|||
""" This constant defines the program-folder in the workspace """ |
|||
ATTR_PATH_COMPONENTS = "components" |
|||
""" This constant defines the program-folder in the workspace """ |
|||
ATTR_PATH_ENV = "environment" |
|||
""" This constant defines the folder in testing-filesystem, used for configs related to environments """ |
|||
ATTR_PATH_RELEASE = "release" |
|||
""" This constant defines the folder in testing-filesystem, used for configs related to release """ |
|||
ATTR_PATH_TDATA = "testdata" |
|||
""" This constant defines the folder in testing-filesystem with the testcase-specifications """ |
|||
ATTR_PATH_TEMP = "temp" |
|||
""" This constant defines the debug-folder in testing-filesystem """ |
|||
ATTR_PATH_PATTN = "pattern" |
|||
""" This constant defines the debug-folder in testing-filesystem """ |
|||
|
|||
|
|||
|
|||
# ------------------------------------------------------------- |
|||
# structure - nodes |
|||
P_DEBUGS = "debugs" |
|||
P_ENVBASE = "envbase" |
|||
P_ENVLOG = "envlog" |
|||
P_ENVPARFILE = "envparfile" |
|||
P_TCBASE = "tcbase" |
|||
P_TCLOG = "tclog" |
|||
P_TCRESULT = "tcresult" |
|||
P_TCPARFILE = "tcparfile" |
|||
P_TCDIFF = "tcdiff" |
|||
P_TCPREDIFF = "tcprediff" |
|||
P_TCRUNDIFF = "tcrundiff" |
|||
P_TCPRECOND = "tcprecond" |
|||
P_TCPOSTCOND = "tcpostcond" |
|||
P_TSBASE = "tsbase" |
|||
P_TSLOG = "tslog" |
|||
P_TSPARFILE = "tsparfile" |
|||
P_TSSUM = "tssum" |
|||
P_XPBASE = "xpbase" |
|||
P_XPRESULT = "xpresult" |
|||
P_XPBACKUP = "xpbackup" |
|||
|
|||
# ------------------------------------------------------------- |
|||
# exception texts |
|||
EXP_COMP_MISSING = "Component is missing for {}" |
|||
""" excetion for the case that a specific component doesnt exist, 1 parameter (context) """ |
|||
EXP_CONFIG_MISSING = "Configuration is missing for {}" |
|||
""" excetion for the case that a specific configuration is missing, 1 parameter (context) """ |
|||
@ -0,0 +1,320 @@ |
|||
#!/usr/bin/python |
|||
# -*- coding: utf-8 -*- |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
# Author : Ulrich Carmesin |
|||
# Source : gitea.ucarmesin.de |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
""" In diesem Modul werden alle Funktionen zusammengefasst zur Generierung und Ermittlung von pathsn """ |
|||
import os.path |
|||
import sys |
|||
import basic.program |
|||
import tools.config_tool |
|||
import re |
|||
import basic.constants as B |
|||
import tools.path_const as P |
|||
import tools.date_tool |
|||
import getpass |
|||
TOOL_NAME = "path_tool" |
|||
|
|||
def getHome(): |
|||
home = os.getcwd() |
|||
if home[-4:] == "test" and home[-6:] != "datest": |
|||
home = home[0:-5] |
|||
if home[-10:] == "components": |
|||
home = home[0:-11] |
|||
if home[-6:] == "datest": |
|||
prgdir = home[-6:] |
|||
home = home[0:-7] |
|||
elif home[-7:] == "program": |
|||
prgdir = home[-7:] |
|||
home = home[0:-8] |
|||
return home |
|||
|
|||
|
|||
def getBasisConfigPath(): |
|||
home = os.getcwd() |
|||
a = home.split(os.path.sep) |
|||
for i in range(1, len(a)): |
|||
path = os.path.sep.join(a[0:-i]) |
|||
path = os.path.join(path, P.VAL_CONFIG, B.BASIS_FILE) |
|||
for format in tools.config_tool.CONFIG_FORMAT: |
|||
filepath = path+"."+format |
|||
if os.path.isfile(filepath): |
|||
return filepath |
|||
if os.path.exists(filepath): |
|||
return filepath |
|||
raise Exception("no basis-configuration found") |
|||
|
|||
|
|||
def getActualJsonPath(job): |
|||
username = getpass.getuser() |
|||
path = os.path.join(job.conf.confs[B.SUBJECT_PATH][B.ATTR_PATH_DEBUG], username+"Job.json") |
|||
print("------ path "+path) |
|||
#if os.path.exists(path): |
|||
# return path |
|||
return path |
|||
|
|||
def getKeyValue(job, key, comp=None): |
|||
""" |
|||
this function gets the value for the key which relates to an attribute in the job or in the component |
|||
:param key: |
|||
:param comp: |
|||
:return: |
|||
""" |
|||
#job = basic.program.Job.getInstance() |
|||
try: |
|||
verify = job.getDebugLevel(TOOL_NAME)-4 |
|||
except: |
|||
verify = False |
|||
pt = PathConf.getInstance(job) |
|||
if verify: job.debug(verify, "getKeyValue " + key) |
|||
if 'job.par' in key: |
|||
val = job.getParameter(key[8:]) |
|||
return val |
|||
elif 'job.conf' in key: |
|||
val = job.conf.confs[B.SUBJECT_PATH][key[9:]] |
|||
if verify: job.debug(verify, val) |
|||
return val |
|||
elif 'job.' in key: |
|||
a = key[4:].split(":") |
|||
val = getattr(job, a[0]) |
|||
# only date with hours |
|||
if a[0] in ["start"]: |
|||
print("++++++++++++++"+str(val)) |
|||
val = tools.date_tool.formatParsedDate(str(val), tools.date_tool.F_LOG) |
|||
print("++++++++++++++"+val) |
|||
if len(a) > 1 and a[1] == "H": |
|||
val = val[0:-4]+"00" |
|||
if verify: job.debug(verify, val) |
|||
return val |
|||
# return job.conf.paths[key[9:]] |
|||
elif 'comp.' in key: |
|||
if comp is None: |
|||
raise Exception(P.EXP_COMP_MISSING.format(key)) |
|||
if tools.config_tool.hasAttr(comp.conf, key[5:]): |
|||
return tools.config_tool.getAttr(comp.conf, key[5:]) |
|||
if tools.config_tool.hasAttr(comp, key[5:]): |
|||
return tools.config_tool.getAttr(comp, key[5:]) |
|||
return "" |
|||
elif 'env.' in key: |
|||
if key[4:] in comp.conf["conn"]: |
|||
return comp.conf["conn"][key[4:]] |
|||
pass |
|||
elif key in pt.pattern: |
|||
return pt.pattern[key] |
|||
elif "time" in key and hasattr(job, "start"): |
|||
return getattr(job, "start") |
|||
else: |
|||
return "xx-"+key+"-xx" |
|||
|
|||
|
|||
def composePath(job, pathname, comp): |
|||
""" |
|||
this function composes a concrete path by the structured pathname |
|||
- the key of pathname is declared in path_const and the structure is configurated in config/path.yml. |
|||
:param pathname - plain keyword |
|||
:param comp: |
|||
:return: |
|||
""" |
|||
#job = basic.program.Job.getInstance() |
|||
verify = job.getDebugLevel(TOOL_NAME) |
|||
pt = PathConf.getInstance(job) |
|||
job.debug(verify, "composePath " + pathname + " zu " + str(pt) + "mit ") |
|||
job.debug(verify, str(pt.pattern)) |
|||
if pt.pattern[pathname]: |
|||
return composePattern(job, pt.pattern[pathname], comp) |
|||
else: |
|||
job.debug(verify, "in Pattern nicht vorhanden: " + pathname) |
|||
|
|||
|
|||
def composePattern(job, pattern, comp): |
|||
""" |
|||
the function composes the pattern to the standardarized path with the attributes |
|||
which are stored in the job and the component |
|||
- the key of pathname is declared in path_const and the structure is configurated in config/path.yml. |
|||
:param pattern: - keyword surroundet with {} |
|||
:param comp: |
|||
:return: path |
|||
""" |
|||
#job = basic.program.Job.getInstance() |
|||
try: |
|||
verify = job.getDebugLevel(TOOL_NAME) |
|||
except: |
|||
verify = False |
|||
verbose = not False |
|||
#job.debug(verify, "composePattern " + pattern) |
|||
max=5 |
|||
l = re.findall('\{.*?\}', pattern) |
|||
#job.debug(verify, l) |
|||
print(l) |
|||
for pat in l: |
|||
if verbose: print(str(max) + ": " + pattern + ": " + pat) |
|||
pit = getKeyValue(job, pat[1:-1], comp) |
|||
if verbose: print(str(pit) + ": " + pattern + ": " + pat) |
|||
#job.debug(verify, str(max) + ": " + pattern + ": " + pat + ": " + pit) |
|||
pattern = pattern.replace(pat, pit) |
|||
#job.debug(verify, str(max) + ": " + pattern + ": " + pat + ": " + pit) |
|||
while ("{" in pattern): |
|||
max = max-1 |
|||
#job.debug(verify, str(max) + ": " + pattern + ": " + pat + ": " + pit) |
|||
pattern = composePattern(job, pattern, comp) |
|||
#job.debug(verify, str(max) + ": " + pattern + ": " + pat + ": " + pit) |
|||
if (max < 3) : |
|||
break |
|||
return pattern |
|||
|
|||
|
|||
def rejoinPath(a, b="", c="", d="", e="", f=""): |
|||
""" |
|||
this function concatenates the arguments to a path in the correct format for the operating-system |
|||
:param a: |
|||
:param b: optional |
|||
:param c: optional |
|||
:param d: optional |
|||
:param e: optional |
|||
:param f: optional |
|||
:return: path |
|||
""" |
|||
work = a+"/"+b+"/"+c+"/"+d+"/"+e+"/"+f |
|||
if a.find("://") > 1: |
|||
protocol = True |
|||
else: |
|||
protocol = False |
|||
work = re.sub(r'\\', '/', work) |
|||
work = re.sub(r'\/', '/', work) |
|||
work = re.sub(r'//', '/', work) |
|||
while work[-1:] == "/": |
|||
work = work[0:-1] |
|||
l = work.split("/") |
|||
out = "" |
|||
for x in l: |
|||
if len(x) < 1: |
|||
continue |
|||
if protocol: |
|||
if len(out) < 1: |
|||
out = x |
|||
else: |
|||
out = out+"/"+x |
|||
else: |
|||
out = os.path.join(out, x) |
|||
if out[1:2] == ":" and out[2:3] != "\\": |
|||
out = out[0:2]+"\\"+out[2:] |
|||
elif protocol: |
|||
if "://" not in out or out.index("://") > 8 or out.index("://") < 1: |
|||
i = out.index(":/") |
|||
out = out[0:i+1] + "/" + out[i+1:] |
|||
pass |
|||
if not protocol and out.count("\\") < 1 and out[0:1] != "/" and out[0:2] != "..": |
|||
out = "/"+out |
|||
return out |
|||
|
|||
|
|||
def extractPattern(job, pathtyp, comp=None): |
|||
""" |
|||
this function extracts recoursively all parts of the pathstrucure as key and gets the values from the |
|||
job-parameter and job-configuration |
|||
:param pathtyp: the name of the path-structure |
|||
:param comp: |
|||
:return: dictionary of all part (key) with their valuess |
|||
""" |
|||
#job = basic.program.Job.getInstance() |
|||
verify = job.getDebugLevel(TOOL_NAME) |
|||
out = [] |
|||
pt = PathConf.getInstance(job) |
|||
pattern = pt.pattern[pathtyp] |
|||
work = pattern |
|||
while "{" in work: |
|||
i = work.index("{") |
|||
j = work.index("}") |
|||
pre = work[0:i] |
|||
pat = work[i+1:j] |
|||
job.debug(verify, work + " von " + str(i) + "-" + str(j) + " pre " + pre + "pat " + pat) |
|||
pit = getKeyValue(job, pat, comp) |
|||
tup = (pre, pat, pit) |
|||
out.append(tup) |
|||
work = work[j+1:] |
|||
return out |
|||
|
|||
def extractPath(job, pathtyp, path): |
|||
""" |
|||
this function extracts parts of a concrete structered path and stores the parts |
|||
as attributes into the actual job. So these attributes can read from the concrete |
|||
path instead of the related parameter-arguments. |
|||
It stores the values into the job-parameter |
|||
:param pathtyp: the structure of the concrete path |
|||
:param path: the concrete path - it should be the directory in the parameter of the job |
|||
:return: |
|||
""" |
|||
#job = basic.program.Job.getInstance() |
|||
patterlist = extractPattern(job, pathtyp) |
|||
verbose = False |
|||
work = path |
|||
i = 0 |
|||
if verbose: print("-- extractPatternList -- " + pathtyp + ":" + str(patterlist)) |
|||
for p in patterlist: |
|||
if len(p) < 1 : continue |
|||
delim = p[0] |
|||
key = p[1] |
|||
val = p[2] |
|||
nextdelim = "" |
|||
if i >= len(patterlist) - 1: |
|||
nextdelim = "" |
|||
else: |
|||
nextdelim = patterlist[i+1][0] |
|||
if verbose: print("xPath delim " + delim + " " + str(len(delim)) + ", " + nextdelim + " work " + work) |
|||
work = work[len(delim):] |
|||
if verbose: print("xPath key " + key + " i " + str(i) + " work " + work) |
|||
if val is not None: |
|||
if verbose: print("val not none " + val) |
|||
if val in work: |
|||
if verbose: print("val ok") |
|||
work = work.replace(val, "") |
|||
elif "time" in key and "job.par" in key: |
|||
prop = "" |
|||
if i < len(patterlist) - 1: |
|||
prop = work[0:work.index(nextdelim)] |
|||
else: |
|||
prop = work |
|||
key = key[8:] |
|||
if verbose: print("setprop " + key + " = " + prop) |
|||
if hasattr(job.par, key): delattr(job.par, key) |
|||
setattr(job.par, key, val) |
|||
else: |
|||
if verbose: print("val not not ok " + val + " zu " + key) |
|||
elif "job.par" in key: |
|||
prop = "" |
|||
if i < len(patterlist) - 1: |
|||
if verbose: print("job.par nextdelim " + nextdelim) |
|||
prop = work[0:work.index(nextdelim)] |
|||
else: |
|||
prop = work |
|||
key = key[8:] |
|||
if verbose: print("setprop " + key + " = " + prop) |
|||
if hasattr(job.par, key): delattr(job.par, key) |
|||
setattr(job.par, key, prop) |
|||
work = work.replace(prop, "") |
|||
else: |
|||
if verbose: print("val is none " + key) |
|||
i = i +1 |
|||
|
|||
|
|||
class PathConf: |
|||
""" |
|||
this class contains the structure-informations of the testrelevant directories |
|||
""" |
|||
__instance = None |
|||
def __init__(self, job=None): |
|||
#print('init pathConf') |
|||
confs = tools.config_tool.getConfig(job, "tool", "path") |
|||
self.pattern = confs["pattern"] |
|||
#print(self.pattern) |
|||
PathConf.__instance = self |
|||
|
|||
@staticmethod |
|||
def getInstance(job = None): |
|||
#print("PathConf getInstance " + str(PathConf.__instance)) |
|||
if (PathConf.__instance is None): |
|||
PathConf(job) |
|||
#print("PathConf getInstance " + str(PathConf.__instance)) |
|||
return PathConf.__instance |
|||
|
|||
@ -0,0 +1,76 @@ |
|||
#!/usr/bin/python |
|||
# -*- coding: utf-8 -*- |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
# Author : Ulrich Carmesin |
|||
# Source : gitea.ucarmesin.de |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
""" In diesem Modul werden alle Funktionen zusammengefasst zur Generierung und Ermittlung von pathsn """ |
|||
import os.path |
|||
import sys |
|||
import basic.program |
|||
import tools.config_tool |
|||
import re |
|||
import basic.constants as B |
|||
import tools.path_const as P |
|||
import tools.date_tool |
|||
import getpass |
|||
TOOL_NAME = "value_tool" |
|||
|
|||
DOM_JOB = "job" |
|||
DOM_PAR = "par" |
|||
DOM_COMP = "comp" |
|||
DOM_CONF = "conf" |
|||
DOM_ENV = "env" |
|||
|
|||
def getKeyValue(job, key, comp=None): |
|||
""" |
|||
this function gets the value for the key which relates to an attribute in the job or in the component |
|||
:param key: |
|||
:param comp: |
|||
:return: |
|||
""" |
|||
#job = basic.program.Job.getInstance() |
|||
try: |
|||
verify = job.getDebugLevel(TOOL_NAME)-4 |
|||
except: |
|||
verify = False |
|||
#pt = PathConf.getInstance(job) |
|||
if verify: job.debug(verify, "getKeyValue " + key) |
|||
if DOM_JOB == key[0:3]: |
|||
if DOM_PAR in key[4:7]: |
|||
val = job.getParameter(key[8:]) |
|||
return val |
|||
elif DOM_CONF in key[4:8]: |
|||
val = job.conf.confs[B.SUBJECT_PATH][key[9:]] |
|||
if verify: job.debug(verify, val) |
|||
return val |
|||
elif 'job.' in key: |
|||
a = key[4:].split(":") |
|||
val = getattr(job, a[0]) |
|||
# only date with hours |
|||
if a[0] in ["start"]: |
|||
print("++++++++++++++"+str(val)) |
|||
val = tools.date_tool.formatParsedDate(str(val), tools.date_tool.F_LOG) |
|||
print("++++++++++++++"+val) |
|||
if len(a) > 1 and a[1] == "H": |
|||
val = val[0:-4]+"00" |
|||
if verify: job.debug(verify, val) |
|||
return val |
|||
# return job.conf.paths[key[9:]] |
|||
elif DOM_COMP in key: |
|||
if comp is None: |
|||
raise Exception(P.EXP_COMP_MISSING.format(key)) |
|||
if tools.config_tool.hasAttr(comp.conf, key[5:]): |
|||
return tools.config_tool.getAttr(comp.conf, key[5:]) |
|||
if tools.config_tool.hasAttr(comp, key[5:]): |
|||
return tools.config_tool.getAttr(comp, key[5:]) |
|||
return "" |
|||
elif DOM_ENV in key: |
|||
if key[4:] in comp.conf["conn"]: |
|||
return comp.conf["conn"][key[4:]] |
|||
pass |
|||
elif "time" in key and hasattr(job, "start"): |
|||
return getattr(job, "start") |
|||
else: |
|||
return "xx-"+key+"-xx" |
|||
|
|||
Loading…
Reference in new issue