def ready(self): """ The ready function is trigger only on events like server start up and server reload """ # print "***************You are in Core Katana App Config Class***************" nav_obj = Navigator() base_directory = nav_obj.get_katana_dir() warrior_dir = nav_obj.get_warrior_dir() config_file_name = "wf_config.json" config_json_file = join_path(base_directory, "config.json") settings_file_path = get_abs_path(join_path("wui", "settings.py"), base_directory) core_index_obj = CoreIndex(base_directory, settings_file_path=settings_file_path) available_apps = core_index_obj.get_available_apps() settings_apps = core_index_obj.get_apps_from_settings_file() AppInformation.information = Apps() AppInformation.information.set_apps({'base_directory': base_directory, 'config_file_name': config_file_name, 'available_apps': available_apps, 'settings_apps': settings_apps}) ordered_json = validate_config_json(read_json_data(config_json_file), warrior_dir) with open(config_json_file, "w") as f: f.write(json.dumps(ordered_json, indent=4))
def read_config_file(request): nav_obj = Navigator() config_file_path = join_path(nav_obj.get_katana_dir(), "config.json") data = read_json_data(config_file_path) if data is None: data = False return JsonResponse(data)
def index(request): navigator = Navigator() path_to_config = navigator.get_katana_dir() + os.sep + "config.json" config = json.loads(open(path_to_config).read()) fpath = config['projdir'] template = loader.get_template("./listAllProjects.html") files = glob.glob(fpath + "*/*.xml") tt = navigator.get_dir_tree_json(fpath) tt['state'] = { 'opened': True } print(tt) fulljsonstring = str(json.loads(json.dumps(tt))) fulljsonstring = fulljsonstring.replace('u"', "'").replace("u'", '"').replace( "'", '"') fulljsonstring = fulljsonstring.replace('None', '""') context = { 'title': 'List of Projects', 'docSpec': 'projectSpec', 'treejs': fulljsonstring, 'listOfFiles': files } context.update(csrf(request)) return HttpResponse(template.render(context, request))
def __init__(self, template, file_path): self.navigator = Navigator() self.template = template self.file_path = file_path self.template_data = read_xml_get_json(template, ordered_dict=True) self.data = read_xml_get_json(file_path, ordered_dict=True) self.output = {"status": True, "message": ""} self.root = "TestSuite"
def get_file_explorer_data(request): nav_obj = Navigator() if "data[start_dir]" in request.POST and request.POST["data[start_dir]"] != "false": start_dir = request.POST["data[start_dir]"] elif "data[path]" in request.POST and request.POST["data[path]"] != "false": start_dir = get_parent_directory(request.POST["data[path]"]) else: start_dir = join_path(nav_obj.get_warrior_dir(), "Warriorspace") output = nav_obj.get_dir_tree_json(start_dir_path=start_dir) return JsonResponse(output)
def __init__(self, template, file_path): """ Constructor of the VerifyCaseFile class """ self.navigator = Navigator() self.template = template self.file_path = file_path self.template_data = read_xml_get_json(template, ordered_dict=True) self.data = read_xml_get_json(file_path, ordered_dict=True) self.output = {"status": True, "message": ""} self.root = "TestWrapper" self.major = ("Details", "Requirements", "Steps")
def __init__(self, data_file, ref_data_file): self.data_file = data_file self.data = read_xml_get_json(data_file) self.ref_data_file = ref_data_file self.nav_obj = Navigator() self.dependency_template = join_path(self.nav_obj.get_katana_dir(), "native", "settings", "static", "settings", "base_templates", "empty.xml") self.ref_data = self._get_ref_data() self.dependency_dict = self.__get_dependency_dict()
def __init__(self, filepath): self.navigator = Navigator() self.app_name = get_sub_folders( join_path(filepath, "warriorframework_py3", "katana", "wapps"))[0] self.path_to_app = join_path(filepath, "warriorframework_py3", "katana", "wapps", self.app_name) self.wf_config_file = join_path(self.path_to_app, "wf_config.json") self.urls_inclusions = [] self.mandatory_fields = [ "app", "version", "warrior-compatibility", "warrior-incompatibility" ]
def save_warhorn_config_file(request): nav_obj = Navigator() directory = request.POST.get('directory') if directory == "default": directory = os.path.join(nav_obj.get_katana_dir(), "wapps", "assembler", ".data") filepath = os.path.join(directory, request.POST.get('filename') + ".xml") json_data = json.loads(request.POST.get('json_data')) json_data["data"]["warriorframework"] = "Test" data = xmltodict.unparse(json_data) response = _save_file(filepath, data) return JsonResponse(response)
def __init__(self): """ Constructor for execution app """ self.nav = Navigator() self.katana_dir = os.path.dirname(native.__path__[0]) self.wf_dir = os.path.dirname(self.katana_dir) self.warrior = os.path.join(self.wf_dir, 'warrior', 'Warrior') self.default_ws = os.path.join(self.wf_dir, 'warrior', 'Warriorspace') self.templates_dir = os.path.join(templates_dir, 'execution') self.jira_settings_file = os.path.join(self.wf_dir, 'warrior', 'Tools', 'jira', 'jira_config.xml') self.execution_settings_json = os.path.join(templates_dir, 'execution', 'execution_settings.json') self.config_json = os.path.join(self.katana_dir, 'config.json')
class CoreView(View): def __init__(self): self.navigator = Navigator() def get_user_data(self): json_file = self.navigator.get_katana_dir() + '/user_profile.json' with open(json_file, 'r') as f: json_data = json.load(f) return json_data def get(self, request): """ This get function get information about the installed apps Args: request: HttpRequest that contains metadata about the request Returns: HttpResponse: containing an HTML template and data HTML template: core/index.html Data: [{"url":"/url/of/app", "name": "app_name", "icon": "icon_name", "color": "red"}] """ template = 'core/index.html' return render(request, template, {"apps": AppInformation.information.apps, "userData": self.get_user_data()})
def get_jstree_dir(request): """ Prepare the json for jstree to use """ config = read_json_data(JSON_CONFIG) data = Navigator().get_dir_tree_json(config["idfdir"]) data["text"] = config["idfdir"] # print json.dumps(data, indent=4) return JsonResponse(data)
def getProjectDataBack(request): print("Got something back in request") navigator = Navigator() path_to_config = navigator.get_katana_dir() + os.sep + "config.json" config = json.loads(open(path_to_config).read()) fpath = config['projdir'] fname = request.POST.get('filetosave') ijs = request.POST.get('json') # This is a json string print(ijs) #print "--------------TREE----------------" if fname.find(".xml") < 2: fname = fname + ".xml" #fd = open(fpath + os.sep + fname+ ".json",'w'); #fd.write(ijs); #fd.close(); xml = xmltodict.unparse(json.loads(ijs), pretty=True) print("save to ", fpath + os.sep + fname) fd = open(fpath + os.sep + fname, 'w') fd.write(xml) fd.close() return redirect(request.META['HTTP_REFERER'])
def __init__(self): self.PYTHON_EXE = sys.executable self.WARRIOR_DIR = Navigator().get_warrior_dir() self.PLUGINSPACE_DIR = os.path.join(self.WARRIOR_DIR, "plugins", "mef18_plugin", "pluginspace") self.PLUGINSPACE_WDF_DIR = os.path.join(self.PLUGINSPACE_DIR, "data") self.PLUGINSPACE_TC_DIR = os.path.join(self.PLUGINSPACE_DIR, "testcases") self.PLUGINSPACE_TD_VC_DIR = os.path.join(self.PLUGINSPACE_DIR, "config_files") self.WARRIOR_EXE = os.path.join(self.WARRIOR_DIR, 'Warrior') self.TEMPLATE_WDF = "xml_templates/WDF_mef18_template.xml" self.TEMPLATE_WDF_CPE = "xml_templates/WDF_mef18_cpe_template.xml" self.TEMPLATE_VC = "xml_templates/VC_mef18_template.xml" self.FILENAME_WDF = "WDF_mef18.xml" self.FILENAME_WDF_CPE = "WDF_mef18_cpe.xml" self.FILENAME_TC_WAKEUP = "TC_mef18_tru_wakeup.xml" self.FILENAME_TC_WAKEUP_CPE = "TC_mef18_cpe_wakeup.xml" self.FILENAME_TC_NAPTIME = "TC_mef18_tru_naptime.xml" self._instance_lock = threading.RLock() self.status = self.STATUS_IDLE
class CliDataFileClass(View): nav_obj = Navigator() app_directory = join_path(nav_obj.get_katana_dir(), "wapps", "cli_data") app_static_dir = join_path(app_directory, "static") def get(self, request): filepath = request.GET.get('path') # filepath = join_path(CliDataFileClass.app_static_dir, "base_templates", "test.xml") base_filepath = join_path(CliDataFileClass.app_static_dir, "base_templates", "empty.xml") if filepath == "false": filepath = base_filepath name = "Untitled" else: name, _ = os.path.splitext(get_dir_from_path(filepath)) vcdc_obj = VerifyCliDataClass(filepath, base_filepath) json_data = vcdc_obj.verify_contents() return JsonResponse({ "contents": json_data, "name": name, "filepath": get_parent_dir_path(filepath) }) def post(self, request): json_data = json.loads(request.POST.get('json_data')) data = xmltodict.unparse(json_data) directory = request.POST.get('directory') filepath = os.path.join(directory, request.POST.get('filename') + ".xml") message = "" saved = True try: with open(filepath, 'w') as f: f.write(data) except Exception as e: saved = False message = e return JsonResponse({"saved": saved, "message": message})
def save_and_run_warhorn_config_file(request): nav_obj = Navigator() directory = request.POST.get('directory') if directory == "default": directory = os.path.join(nav_obj.get_katana_dir(), "wapps", "assembler", ".data") filepath = os.path.join(directory, request.POST.get('filename') + ".xml") json_data = json.loads(request.POST.get('json_data')) json_data["data"]["warriorframework"] = "Test" data = xmltodict.unparse(json_data) response = _save_file(filepath, data) nav_obj = Navigator() warhorn_dir = nav_obj.get_warhorn_dir() current_dir = os.getcwd() output = "" if response["saved"]: os.chdir(warhorn_dir) output = subprocess.Popen(["python3", "warhorn.py", filepath], stdout=subprocess.PIPE).communicate()[0] os.chdir(current_dir) os.remove(filepath) return JsonResponse({"output": output.decode('utf-8')})
# -*- coding: utf-8 -*- import json import os import subprocess import xmltodict from django.http import JsonResponse from django.shortcuts import render from django.views import View from wapps.assembler.assembler_utils.repository_details import KwRepositoryDetails from wapps.assembler.assembler_utils.verify_file_contents import VerifyFileContents from utils.directory_traversal_utils import delete_dir from utils.git_utils import get_repository_name, check_url_is_a_valid_repo from utils.navigator_util import Navigator nav_obj = Navigator() REF_FILE = os.path.join(nav_obj.get_katana_dir(), "wapps", "assembler", "static", "assembler", "base_templates", "empty.xml") class AssemblerView(View): def get(self, request): return render(request, 'assembler/assembler.html') class ConfigurationFileOps(View): def post(self, request): template = request.POST.get('filepath') filename = "Untitled" final_data = {} if template == "false":
class AppValidator: def __init__(self, filepath): self.navigator = Navigator() self.app_name = get_sub_folders( join_path(filepath, "warriorframework_py3", "katana", "wapps"))[0] self.path_to_app = join_path(filepath, "warriorframework_py3", "katana", "wapps", self.app_name) self.wf_config_file = join_path(self.path_to_app, "wf_config.json") self.urls_inclusions = [] self.mandatory_fields = [ "app", "version", "warrior-compatibility", "warrior-incompatibility" ] def is_valid(self): output = {"status": True, "message": ""} if os.path.exists(self.wf_config_file): data = read_json_data(self.wf_config_file) if data is not None: for field in self.mandatory_fields: if output["status"] and field not in data: output["status"] = False output[ "message"] = "wf_config.json is not in the correct format." print("-- An Error Occurred -- {0}".format( output["message"])) if output["status"]: output = self.__verify_app_details(data["app"]) # validate version compatibility if output["status"]: output = self.__is_compatible(data) # validate databases if any if output["status"] and "database" in data: if isinstance(data["database"], list): for db_details in data["database"]: if output["status"]: output = self.__verify_db_details(db_details) else: output = self.__verify_db_details(data["database"]) else: output["status"] = False output[ "message"] = "wf_config.json is not in the correct format." print("-- An Error Occurred -- {0}".format(output["message"])) if output["status"]: output = self.__validate_static_directory() else: output["status"] = False output["message"] = "wf_config.json does not exist." print("-- An Error Occurred -- {0}".format(output["message"])) return output def __verify_app_details(self, app_details): output = {"status": True, "message": ""} if "name" not in app_details or "url" not in app_details or "include" not in app_details: print( "-- An Error Occurred -- wf_config.json file is not in the correct format." ) output["status"] = False else: self.urls_inclusions.append("url(r'^" + app_details["url"] + "', include('" + app_details["include"] + "')),") path_dir = app_details["include"].split(".") path_urls = "" for d in range(2, len(path_dir)): path_urls += os.sep + path_dir[d] path_urls = path_urls.strip(os.sep) path_urls += ".py" path_to_urls_abs = join_path(self.path_to_app, path_urls) if not os.path.isfile(path_to_urls_abs): output["status"] = False output["message"] = "Package {0} does not exist.".format( app_details["include"]) print("-- An Error Occurred -- {0}".format(output["message"])) return output def __is_compatible(self, data): output = {"status": True, "message": ""} warrior_version = self.navigator.get_wf_version() all_warrior_versions = self.navigator.get_all_wf_versions() allowed, bounds, err_alwd = get_version_list( data[self.mandatory_fields[2]], all_warrior_versions) disallowed, excluded_bounds, err_disalwd = get_version_list( data[self.mandatory_fields[3]], all_warrior_versions) in_allowed = check_against_version_list(warrior_version, allowed, bounds) in_disallowed = check_against_version_list(warrior_version, disallowed, excluded_bounds) if not in_allowed: output["status"] = False if not err_alwd: output["message"] = "-- An Error Occurred -- {0} (Version: {1}) incompatible with " \ "the current WarriorFramework (Version: {2})."\ .format(self.app_name, data["version"], warrior_version) else: output[ "message"] = "-- An Error Occurred -- Compatible versions could not be verified." elif in_disallowed: output["status"] = False output["message"] = "-- An Error Occurred -- {0} (Version: {1}) incompatible with " \ "the current WarriorFramework (Version: {2})." \ .format(self.app_name, data["version"], warrior_version) elif not in_disallowed and err_disalwd: output["status"] = False output[ "message"] = "-- An Error Occurred -- Incompatible versions could not be verified." return output def __verify_db_details(self, db_details): output = {"status": True, "message": ""} for key in db_details: if not key.startswith(self.app_name): output["status"] = False output[ "message"] = "wf_config.json file is not formatted correctly" print("-- An Error Occurred -- {0}".format(output["message"])) return output def __validate_static_directory(self): output = {"status": True, "message": ""} if os.path.isdir(join_path(self.path_to_app, "static")): subs = get_sub_dirs_and_files(join_path(self.path_to_app, "static")) if len(subs["files"]) > 0: output["status"] = False output["message"] = "static directory does not follow the required " \ "directory structure." print("-- An Error Occurred -- {0}".format(output["message"])) else: if not os.path.isdir( join_path(self.path_to_app, "static", self.app_name)): output["status"] = False output["message"] = "static directory does not follow the required " \ "directory structure." print("-- An Error Occurred -- {0}".format( output["message"])) else: subs_files = get_paths_of_subfiles( join_path(self.path_to_app, "static", self.app_name), re.compile("\.js$")) path_to_js = join_path(self.path_to_app, "static", self.app_name, "js") for sub_file in subs_files: if not sub_file.startswith(path_to_js): output["status"] = False output[ "message"] = "A .js file cannot be outside the 'js' folder." print("-- An Error Occurred -- {0}".format( output["message"])) return output
class VerifyFileContents: def __init__(self, data_file, ref_data_file): self.data_file = data_file self.data = read_xml_get_json(data_file) self.ref_data_file = ref_data_file self.nav_obj = Navigator() self.dependency_template = join_path(self.nav_obj.get_katana_dir(), "native", "settings", "static", "settings", "base_templates", "empty.xml") self.ref_data = self._get_ref_data() self.dependency_dict = self.__get_dependency_dict() def _get_ref_data(self): data = read_xml_get_json(self.ref_data_file) dependency_data = read_xml_get_json(self.dependency_template) data["data"]["warhorn"] = copy.deepcopy( dependency_data["data"]["warhorn"]) return data def __get_dependency_dict(self): output = {} for el in self.ref_data["data"]["warhorn"]["dependency"]: output[el["@name"]] = { "version": el["@version"], "description": el["@description"] } return output def verify_file(self): output = {"status": True, "message": ""} if self.data is None: output["status"] = False output[ "message"] = "An error occurred while trying to read {0}".format( self.data_file) elif "data" not in self.data: output["status"] = False output[ "message"] = "{0} does not seem to be in correct format".format( self.data_file) if output["status"]: self.verify_dependency_json() self.verify_tools_data() self.verify_drivers_json() self.verify_warriorspace_data() return output def verify_dependency_json(self, ): flag = True if "warhorn" not in self.data["data"]: self.data["data"]["warhorn"] = copy.deepcopy( self.ref_data["data"]["warhorn"]) flag = False if "dependency" not in self.data["data"]["warhorn"]: self.data["data"]["warhorn"]["dependency"] = copy.deepcopy( self.ref_data["data"]["warhorn"]["dependency"]) flag = False if not isinstance(self.data["data"]["warhorn"]["dependency"], list): self.data["data"]["warhorn"]["dependency"] = [ self.data["data"]["warhorn"]["dependency"] ] if flag: data = copy.deepcopy(self.data["data"]["warhorn"]["dependency"]) extra_dependencies = set() for i in range(0, len(data)): for key, value in list(data[i].items()): if key == "@name": if value in self.dependency_dict: data[i]["version"] = self.dependency_dict[value][ "version"] data[i]["description"] = self.dependency_dict[ value]["description"] try: module_name = __import__(value) some_var = module_name.__version__ except ImportError: data[i]["installed"] = False data[i]["matched"] = False except Exception as e: print("-- An Exception Occurred -- while getting details about " \ "{0}: {1}".format(value, e)) data[i]["installed"] = False data[i]["matched"] = False else: data[i]["installed"] = some_var if self.dependency_dict[value] == some_var: data[i]["matched"] = True elif self.dependency_dict[value] > some_var: data[i]["matched"] = "lower" else: data[i]["matched"] = "higher" break else: extra_dependencies.add(i) dependency_list = [] for i in range(0, len(data)): if i not in extra_dependencies: dependency_list.append(copy.deepcopy(data[i])) self.data["data"]["warhorn"]["dependency"] = copy.deepcopy( dependency_list) def verify_tools_data(self): if "tools" not in self.data["data"]: self.data["data"]["tools"] = copy.deepcopy( self.ref_data["data"]["tools"]) else: for key, value in list(self.ref_data["data"]["tools"].items()): if key not in self.data["data"]["tools"]: self.data["data"]["tools"][key] = self.ref_data["data"][ "tools"][key] url = self.data["data"]["tools"]["@url"] if url != "": self.data["data"]["tools"]["name"] = get_repository_name( url=url) self.data["data"]["tools"][ "available"] = check_url_is_a_valid_repo(url=url) else: self.data["data"]["tools"]["available"] = False def verify_drivers_json(self): flag = True if "drivers" not in self.data["data"]: self.data["data"]["drivers"] = copy.deepcopy( self.ref_data["data"]["drivers"]) flag = False if "repository" not in self.data["data"]["drivers"]: self.data["data"]["drivers"]["repository"] = copy.deepcopy( self.ref_data["data"]["drivers"]["repository"]) flag = False if not isinstance(self.data["data"]["drivers"]["repository"], list): self.data["data"]["drivers"]["repository"] = [ self.data["data"]["drivers"]["repository"] ] if flag: for i in range(0, len(self.data["data"]["drivers"]["repository"])): for key, value in list(self.ref_data["data"]["drivers"] ["repository"].items()): if key not in self.data["data"]["drivers"]["repository"][ i]: if key != "driver": self.data["data"]["drivers"]["repository"][i][ key] = self.ref_data["data"]["drivers"][ "repository"]["key"] else: self.data["data"]["drivers"]["repository"][i][ key] = copy.deepcopy( self.ref_data["data"]["drivers"] ["repository"][key]) if not isinstance( self.data["data"]["drivers"]["repository"] [i][key], list): self.data["data"]["drivers"]["repository"][i][ key] = [ self.data["data"]["drivers"] ["repository"][i][key] ] url = self.data["data"]["drivers"]["repository"][i]["@url"] if url != "": self.data["data"]["drivers"]["repository"][i][ "name"] = get_repository_name(url=url) available = check_url_is_a_valid_repo(url=url) self.data["data"]["drivers"]["repository"][i][ "available"] = available if available: drivers_data = [] drivers_index = set() temp_directory = os.path.join( self.nav_obj.get_katana_dir(), "wapps", "assembler", ".data") kw_repo_obj = KwRepositoryDetails(url, temp_directory) drivers = set(kw_repo_obj.get_pd_names()) if not isinstance( self.data["data"]["drivers"]["repository"][i] ["driver"], list): self.data["data"]["drivers"]["repository"][i][ "driver"] = [ self.data["data"]["drivers"]["repository"] [i]["driver"] ] for j in range( 0, len(self.data["data"]["drivers"]["repository"] [i]["driver"])): if "@name" not in self.data["data"]["drivers"][ "repository"][i]["driver"][j]: self.data["data"]["drivers"]["repository"][i][ "driver"][j]["@name"] = self.ref_data[ "data"]["drivers"]["repository"][ "driver"]["@name"] else: if self.data["data"]["drivers"]["repository"][ i]["driver"][j]["@name"] in drivers: drivers.remove(self.data["data"]["drivers"] ["repository"][i]["driver"] [j]["@name"]) else: drivers_index.add(j) if "@clone" not in self.data["data"]["drivers"][ "repository"][i]["driver"][j]: self.data["data"]["drivers"]["repository"][i][ "driver"][j]["@clone"] = self.ref_data[ "data"]["drivers"]["repository"][ "driver"]["@clone"] for j in range( 0, len(self.data["data"]["drivers"]["repository"] [i]["driver"])): if j not in drivers_index: drivers_data.append( copy.deepcopy( self.data["data"]["drivers"] ["repository"][i]["driver"][j])) self.data["data"]["drivers"]["repository"][i][ "driver"] = copy.deepcopy(drivers_data) for driver_name in drivers: self.data["data"]["drivers"]["repository"][i][ "driver"].append({ "@name": driver_name, "@clone": "no" }) if os.path.isdir(kw_repo_obj.repo_directory): delete_dir(kw_repo_obj.repo_directory) else: self.data["data"]["drivers"]["repository"][i][ "available"] = False def verify_warriorspace_data(self): flag = True if "warriorspace" not in self.data["data"]: flag = False self.data["data"]["warriorspace"] = copy.deepcopy( self.ref_data["data"]["warriorspace"]) if "repository" not in self.data["data"]["warriorspace"]: flag = False self.data["data"]["warriorspace"]["repository"] = copy.copy( self.ref_data["data"]["warriorspace"]["repository"]) if not isinstance(self.data["data"]["warriorspace"]["repository"], list): self.data["data"]["warriorspace"]["repository"] = [ self.data["data"]["warriorspace"]["repository"] ] if flag: for i in range( 0, len(self.data["data"]["warriorspace"]["repository"])): for key, value in list(self.ref_data["data"]["warriorspace"] ["repository"].items()): if key not in self.data["data"]["warriorspace"][ "repository"][i]: self.data["data"]["warriorspace"]["repository"][i][ key] = self.ref_data["data"]["warriorspace"][ "repository"][key] url = self.data["data"]["warriorspace"]["repository"][i][ "@url"] if url != "": self.data["data"]["warriorspace"]["repository"][i][ "name"] = get_repository_name(url=url) self.data["data"]["warriorspace"]["repository"][i][ "available"] = check_url_is_a_valid_repo(url=url) else: self.data["data"]["warriorspace"]["repository"][i][ "available"] = False
import json import os import xmltodict from django.http import JsonResponse from django.shortcuts import render from django.template.loader import render_to_string from django.views import View from utils.directory_traversal_utils import join_path, get_dir_from_path, get_parent_dir_path from utils.json_utils import read_json_data from utils.navigator_util import Navigator from wapps.testwrapper.testwrapper_utils.defaults import impacts, on_errors, runmodes, iteration_types, contexts from wapps.testwrapper.testwrapper_utils.get_drivers import GetDriversActions from wapps.testwrapper.testwrapper_utils.verify_testwrapper_file import VerifyTestWrapperFile navigator = Navigator() CONFIG_FILE = join_path(navigator.get_katana_dir(), "config.json") APP_DIR = join_path(navigator.get_katana_dir(), "wapps", "testwrapper") STATIC_DIR = join_path(APP_DIR, "static", "testwrapper") TEMPLATE = join_path(STATIC_DIR, "base_templates", "Untitled.xml") DROPDOWN_DEFAULTS = read_json_data(join_path(STATIC_DIR, "base_templates", "dropdowns_data.json")) clas TestWrapperView(View): def get(self, request): """ Get Request Method """ return render(request, 'testwrapper/cases.html')
class Execution(object): """ Execution app class """ def __init__(self): """ Constructor for execution app """ self.nav = Navigator() self.katana_dir = os.path.dirname(native.__path__[0]) self.wf_dir = os.path.dirname(self.katana_dir) self.warrior = os.path.join(self.wf_dir, 'warrior', 'Warrior') self.default_ws = os.path.join(self.wf_dir, 'warrior', 'Warriorspace') self.templates_dir = os.path.join(templates_dir, 'execution') self.jira_settings_file = os.path.join(self.wf_dir, 'warrior', 'Tools', 'jira', 'jira_config.xml') self.execution_settings_json = os.path.join(templates_dir, 'execution', 'execution_settings.json') self.config_json = os.path.join(self.katana_dir, 'config.json') def index(self, request): """ Index page for exeution app """ execution_settings_dict = update_jira_proj_list( self.jira_settings_file, self.execution_settings_json) #json.loads(open(self.execution_settings_json).read()) start_dir = self.default_ws if execution_settings_dict['defaults']['start_dir'] == 'default' \ else execution_settings_dict['defaults']['start_dir'] execution_settings_dict['defaults']['start_dir'] = start_dir index_template = os.path.join(self.templates_dir, 'execution.html') return render(request, index_template, execution_settings_dict) def get_results_index(self, request): """ Render the results index html to the client """ fname = 'live_html_results' path = data_live_dir fpath = file_utils.get_new_filepath(fname, path, '.html') html_file = open(fpath, 'w') html_file.write('<div data-currentTable="1"> </div> ') html_file.close() result_setting = {'fpath': fpath} results_template = os.path.join(self.templates_dir, 'execution_results.html') return render(request, results_template, result_setting) def get_html_results(self, request): """ Update the html results by reading the live html results file sent in the request """ data_dict = json.loads(request.GET.get('data')) fpath = data_dict['liveHtmlFpath'] with open(fpath) as htmlfile: data = htmlfile.readlines() return HttpResponse(data) def delete_live_html_file(self, request): """ delete the live html file created """ status = 'success' try: data_dict = json.loads(request.GET.get('data')) fpath = data_dict['liveHtmlFpath'] os.remove(fpath) except Exception as err: status = 'failure' return HttpResponse(status) def get_logfile_contents(self, request): """ Update the html results by reading the live html results file sent in the request """ data_dict = json.loads(request.GET.get('data')) logpath = data_dict['logpath'] logtype = data_dict['logtype'] op_data = {} logfile_name = logpath.split(os.sep)[-1] if str(logtype.lower()) == 'defects': contents = json.loads(open(logpath).read()) if str(logtype.lower()) == 'console_logs': contents = open(logpath).read() contents = contents.replace('\n', '<br>') op_data['logfile_name'] = logfile_name op_data['contents'] = contents return JsonResponse(op_data) def cleanup_data_live_dir(self, request): """ Update the html results by reading the live html results file sent in the request """ status = 'success' try: for item in os.listdir(data_live_dir): path = os.path.join(data_live_dir, item) if os.path.isfile( path) and not path.endswith('donotdeletethisfile.txt'): os.remove(path) elif os.path.isdir(path): shutil.rmtree(path, 'ignore_errors') except Exception as err: print("error ceaning up dir {0}".format(data_live_dir)) print(err) status = 'failure' return HttpResponse(status) def get_ws(self, request): """ return the dir tree json for warriorspace """ data_dict = json.loads(request.GET.get('data')) ws_dir = data_dict['start_dir'] layout = self.nav.get_dir_tree_json(ws_dir) return JsonResponse(layout) def execute_warrior(self, request): """ Execute warrior command and send console logs to the client in a streaming fashion. """ data_dict = json.loads(request.GET.get('data')) execution_file_list = data_dict['execution_file_list'] cmd_string = data_dict['cmd_string'] live_html_res_file = data_dict['liveHtmlFpath'] config_json_dict = json.loads(open(self.config_json).read()) python_path = config_json_dict['pythonpath'] return StreamingHttpResponse( stream_warrior_output(self.warrior, cmd_string, execution_file_list, live_html_res_file, python_path))
def editProject(request): """ Set up JSON object for editing a project file. """ navigator = Navigator() path_to_config = navigator.get_katana_dir() + os.sep + "config.json" config = json.loads(open(path_to_config).read()) fpath = config['projdir'] template = loader.get_template("./editProject.html") filename = request.GET.get('fname', 'NEW') # Create Mandatory empty object. xml_r = {} xml_r["Project"] = {} xml_r["Project"]["Details"] = {} xml_r["Project"]["Details"]["Name"] = "" # "" xml_r["Project"]["Details"]["Title"] = "" #OrderedDict([('$', '')]) xml_r["Project"]["Details"]["Category"] = "" #OrderedDict([('$', '')]) xml_r["Project"]["Details"]["State"] = "" #OrderedDict([('$', 'New')]) xml_r["Project"]["Details"]["Date"] = "" #OrderedDict([('$', '')]) xml_r["Project"]["Details"]["Time"] = "" #OrderedDict([('$', '')]) xml_r["Project"]["Details"]["Datatype"] = "" #OrderedDict([('$', '')]) xml_r["Project"]["Details"]["Engineer"] = "" #OrderedDict([('$', '')]) xml_r["Project"]["Details"]["ResultsDir"] = "" #OrderedDict([('$', '')]) xml_r["Project"]["Details"]["default_onError"] = { '@action': '', '@value': '' } #OrderedDict([('$', '')]) xml_r["Project"]["Testsuites"] = [] xml_r['Project']['filename'] = "" #OrderedDict([('$', filename)]); if filename != 'NEW': xlines = open(filename.strip()).read() #xml_d = bf.data(fromstring(xlines)); # xml_d = xmltodict.parse(xlines, dict_constructor=dict) # Map the input to the response collector for xstr in ["Name", "Title", "Category", "Date", "Time", "Engineer", \ "Datatype", "ResultsDir"]: try: xml_r["Project"]["Details"][xstr] = xml_d["Project"][ "Details"][xstr] except: pass try: xml_r['Project']['Testsuites'] = copy.copy( xml_d['Project']['Testsuites']) except: xml_r["Project"]["Testsuites"] = [] else: filename = path_to_config + os.sep + "new.xml" fulljsonstring = str(json.loads(json.dumps(xml_r['Project']))) print(fulljsonstring) fulljsonstring = fulljsonstring.replace('u"', "'").replace("u'", '"').replace( "'", '"') fulljsonstring = fulljsonstring.replace('None', '""') context = { 'savefilename': os.path.split(filename)[1], 'savefilepath': fpath, 'fullpathname': filename, 'myfile': filename, 'docSpec': 'projectSpec', 'projectName': xml_r["Project"]["Details"]["Name"], 'projectTitle': xml_r["Project"]["Details"]["Title"], 'projectState': xml_r["Project"]["Details"]["State"], 'projectEngineer': xml_r["Project"]["Details"]["Engineer"], 'projectCategory': xml_r["Project"]["Details"]["Category"], 'projectDate': xml_r["Project"]["Details"]["Date"], 'projectTime': xml_r["Project"]["Details"]["Time"], 'resultsDir': xml_r["Project"]["Details"]["ResultsDir"], 'projectdefault_onError': xml_r["Project"]["Details"]["default_onError"].get('@action'), 'projectdefault_onError_goto': xml_r["Project"]["Details"]["default_onError"]['@value'], #'fulljson': xml_r['Project'] 'fulljson': fulljsonstring, } # # I have to add json objects for every test suite. # return HttpResponse(template.render(context, request))
import os, sys, glob, copy from collections import OrderedDict from django.http import HttpResponse, JsonResponse from django.template import loader, RequestContext from xml.sax.saxutils import escape, unescape from django.core.serializers import serialize from django.db.models.query import QuerySet from django.template import Library import json #from katana.utils.navigator_util import get_dir_tree_json import xmltodict from utils.navigator_util import Navigator navigator = Navigator() path_to_src_python_file = navigator.get_katana_dir() + os.sep + "config.json" def old_index(request): return render(request, 'settings/index.html', {"data": controls.get_location()}) def getEmpty(): edata = { "Project": { "Testsuites": { "Testsuite": [{ "onError": { "@action": "goto",
def __init__(self): self.navigator = Navigator() self.static_dir = join_path(self.navigator.get_katana_dir(), "native", "settings", "static", "settings")
class Settings: def __init__(self): self.navigator = Navigator() self.static_dir = join_path(self.navigator.get_katana_dir(), "native", "settings", "static", "settings") def get_location(self): pass def smart_analysis_handler(self, request): mainFile = self.navigator.get_warrior_dir( ) + os.sep + 'Tools' + os.sep + 'connection' + os.sep + 'connect_settings.xml' if request.method == 'POST': val = xmltodict.unparse( { 'credentials': { 'system': json.loads(request.POST.get('data')) } }, pretty=True) with open(mainFile, 'w') as f: f.write(val) else: with open(mainFile, 'r') as f: mainDict = xmltodict.parse(f)['credentials'] if mainDict is not None and not isinstance(mainDict['system'], list): mainDict['system'] = [mainDict['system']] return mainDict def general_setting_handler(self, request): json_file = self.navigator.get_katana_dir() + os.sep + 'config.json' w_settings = self.navigator.get_warrior_dir( ) + 'Tools' + os.sep + 'w_settings.xml' elem_file = xml_controler.parse(w_settings) elem_file = elem_file.getroot() elem = self.search_by_name('def_dir', elem_file) def_dir_string = xml_controler.tostring(elem) def_dir_xml_obj = elem if request.method == 'POST': w_settings_data = { 'Setting': { 'Logsdir': '', 'Resultsdir': '', '@name': '' } } returned_json = json.loads(request.POST.get('data')) for k, v in list(w_settings_data['Setting'].items()): w_settings_data['Setting'][k] = returned_json[0][k] del returned_json[0][k] elem_file.remove(def_dir_xml_obj) val = xmltodict.unparse(w_settings_data, pretty=True) elem_file.insert(0, xml_controler.fromstring(val)) with open(w_settings, 'wb') as f: f.write(xml_controler.tostring(elem_file)) with open(json_file, 'w') as f: f.write( json.dumps(returned_json[0], indent=4, separators=(',', ': '))) else: with open(json_file, 'r') as f: json_data = json.load(f) data = { 'fromXml': xmltodict.parse(def_dir_string).get('Setting'), 'fromJson': validate_config_json(json_data, self.navigator.get_warrior_dir()) } return data def profile_setting_handler(self, request): json_file = self.navigator.get_katana_dir( ) + os.sep + 'user_profile.json' config_json_file = self.navigator.get_katana_dir( ) + os.sep + 'config.json' if request.method == 'POST': data = json.loads(request.POST.get('data')) with open(json_file, 'w') as f: f.write( json.dumps(data[0], sort_keys=True, indent=4, separators=(',', ': '))) with open(config_json_file, 'r+') as a: new_json = json.load(a) new_json['engineer'] = data[0]['firstName'] a.seek(0) a.truncate() a.write( json.dumps(new_json, sort_keys=True, indent=4, separators=(',', ': '))) else: with open(json_file, 'r') as f: json_data = json.load(f) return json_data def search_by_name(self, name, file): for elem in file.findall('Setting'): if elem.get('name') == name: return elem def email_setting_handler(self, request): w_settings = self.navigator.get_warrior_dir( ) + 'Tools' + os.sep + 'w_settings.xml' elem_file = xml_controler.parse(w_settings) elem_file = elem_file.getroot() elem = self.search_by_name('mail_to', elem_file) email_string = xml_controler.tostring(elem) email_xml_obj = elem if request.method == 'POST': elem_file.remove(email_xml_obj) val = xmltodict.unparse( {'Setting': json.loads(request.POST.get('data'))}, pretty=True) elem_file.append(xml_controler.fromstring(val)) with open(w_settings, 'w') as f: f.write(xml_controler.tostring(elem_file)) else: xmldoc = xmltodict.parse(email_string) return xmldoc def jira_setting_handler(self, request): jira_config = self.navigator.get_warrior_dir( ) + 'Tools' + os.sep + 'jira' + os.sep + 'jira_config.xml' elem_file = xml_controler.parse(jira_config) elem_file = elem_file.getroot() xml_string = xml_controler.tostring(elem_file) if request.method == 'POST': val = xmltodict.unparse( {'jira': { 'system': json.loads(request.POST.get('data')) }}, pretty=True) with open(jira_config, 'w') as f: f.write(val) else: xmldoc = xmltodict.parse(xml_string) if xmldoc is not None and xmldoc['jira'] is not None: if not isinstance(xmldoc['jira']['system'], list): xmldoc['jira']['system'] = [xmldoc['jira']['system']] for system in xmldoc['jira']['system']: for k, v in list(system.items()): if k == 'issue_type': v = json.dumps(v) system[k] = v return xmldoc def secret_handler(self, request): keyDoc = self.navigator.get_warrior_dir( ) + os.sep + 'Tools' + os.sep + 'admin' + os.sep + 'secret.key' if request.method == 'POST': val = request.POST.get("data[0][value]") elem_file = open(keyDoc, 'w') elem_file.write(val) elem_file.close() else: elem_file = open(keyDoc, 'r') key_data = elem_file.read() elem_file.close() return key_data def prerequisites_handler(self, request): ref_file = join_path(self.static_dir, "base_templates", "empty.xml") prereqs = read_xml_get_json(ref_file)["data"]["warhorn"]["dependency"] prereq_data = [] for prereq in prereqs: temp = {} for key, value in list(prereq.items()): temp[key.strip('@')] = value temp["status"] = "install" try: module_name = __import__(temp["name"]) some_var = module_name.__version__ except ImportError: temp["available_version"] = "--" temp["installBtnText"] = "Install" except Exception as e: print( "-- An Exception Occurred -- while getting details about {0}: {1}" .format(temp["name"], e)) temp["available_version"] = "--" temp["installBtnText"] = "Install" else: temp["available_version"] = some_var if LooseVersion(str(temp["version"])) <= LooseVersion( str(temp["available_version"])): temp["installBtnText"] = "Installed" temp["status"] = "installed" else: temp["installBtnText"] = "Upgrade" temp["status"] = "upgrade" prereq_data.append(copy.deepcopy(temp)) return prereq_data def prereq_installation_handler(self, request): name = request.POST.get('name') admin = request.POST.get('admin') version = request.POST.get('version') status = False return_code = -9 command = ["pip", "install", "{0}=={1}".format(name, version)] if admin == "true": if not hasattr(sys, 'real_prefix'): command.insert(0, "sudo") else: command.append("--user") p = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE) kill = lambda process: process.kill() my_timer = Timer(10, kill, [p]) try: my_timer.start() out, err = p.communicate() return_code = p.returncode if return_code == 0: status = True finally: if return_code == -9: err = "Command could not be completed." out = "Command could not be completed in 30 seconds - may be the user is not authorized to install {0}".format( name) my_timer.cancel() return { "status": status, "return_code": return_code, "errors": err, "output": out }
def __init__(self): self.navigator = Navigator()
# -*- coding: utf-8 -*- import json, xmltodict, os, copy from utils.navigator_util import Navigator from utils.json_utils import read_json_data from collections import OrderedDict from django.template.defaulttags import register from django.shortcuts import render from django.http import JsonResponse JSON_CONFIG = Navigator().get_katana_dir() + os.sep + "config.json" # Create your views here. def process_xml(data): # The first and only key in xml file should be the only root tag root = list(data.keys())[0] if not isinstance(data[root]["system"], list): # The whole xml only has one system data[root]["system"] = [data[root]["system"]] for sys in data[root]["system"]: if "subsystem" in sys: if isinstance(sys["subsystem"], list): # Multiple subsystems for subsys in sys["subsystem"]: for k, v in list(subsys.items()): subsys[k] = "" if subsys[k] is None else subsys[k] if k.startswith( "@") and k != "@name" and k != "@default":
def get_data_directory(request): nav_obj = Navigator() directory = os.path.join(nav_obj.get_katana_dir(), "wapps", "assembler", ".data") return JsonResponse({"data_directory": directory})
import shutil import zipfile from django.http import JsonResponse from django.shortcuts import render from django.views import View import xml.etree.cElementTree as ET from native.wapp_management.wapp_management_utils.app_validator import AppValidator from native.wapp_management.wapp_management_utils.installer import Installer from native.wapp_management.wapp_management_utils.uninstaller import Uninstaller from utils.directory_traversal_utils import join_path, get_sub_files, get_parent_directory, \ create_dir, get_dir_from_path from utils.file_utils import copy_dir from utils.navigator_util import Navigator from utils.string_utils import get_repository_name from wui.core.core_utils.app_info_class import AppInformation nav_obj = Navigator() class WappManagementView(View): template = 'wapp_management/wapp_management.html' dot_data_directory = join_path(nav_obj.get_katana_dir(), "native", "wapp_management", ".data") def get(self, request): """ Get Request Method """ files = get_sub_files(WappManagementView.dot_data_directory) preferences = [] for subfile in files:
class VerifySuiteFile: def __init__(self, template, file_path): self.navigator = Navigator() self.template = template self.file_path = file_path self.template_data = read_xml_get_json(template, ordered_dict=True) self.data = read_xml_get_json(file_path, ordered_dict=True) self.output = {"status": True, "message": ""} self.root = "TestSuite" def verify_file(self): """ This function verifies the suite file """ self.__verify_root() if self.output["status"]: self.__verify_details() self.__verify_requirements() self.__verify_cases() return self.output, self.data def __verify_root(self): """ Verifies the root of the suite file """ for key in self.data: if key != self.root: self.output["status"] = False self.output["message"] = "{0} is not is the correct format." print("-- An Error Occurred -- {0}".format(self.output["message"])) break def __verify_details(self): """ Verifies details section of the suite """ top_key = "Details" if top_key not in self.data[self.root] or self.data[self.root][top_key] is None: self.data[self.root][top_key] = {} for key, value in self.template_data[self.root][top_key].items(): key, value = self.__verified_details_key_value(key, value) self.data[self.root][top_key][key] = self.__verify_values(key, value, self.data[self.root][top_key]) def __verify_requirements(self): """ Verifies the requirements section of the suite file """ top_key = "Requirements" if top_key not in self.data[self.root] or self.data[self.root][top_key] is None: self.data[self.root][top_key] = {"Requirement": []} elif "Requirement" not in self.data[self.root][top_key] or self.data[self.root][top_key]["Requirement"] is None: self.data[self.root][top_key]["Requirement"] = [] elif not isinstance(self.data[self.root][top_key]["Requirement"], list): self.data[self.root][top_key]["Requirement"] = [self.data[self.root][top_key]["Requirement"]] def __verify_cases(self): """ Verifies the cases section of the suite file """ top_key = "Testcases" if top_key not in self.data[self.root] or self.data[self.root][top_key] is None: self.data[self.root][top_key] = {"Testcase": []} elif "Testcase" not in self.data[self.root][top_key] or self.data[self.root][top_key]["Testcase"] is None: self.data[self.root][top_key]["Testcase"] = [] elif not isinstance(self.data[self.root][top_key]["Testcase"], list): self.data[self.root][top_key]["Testcase"] = [self.data[self.root][top_key]["Testcase"]] @staticmethod def __verified_steps_key_value(key, value, verify_data): """ Verifies specific keys in each step """ if value is None: value = "" if key == "Execute": if key not in verify_data or verify_data[key] is None: verify_data[key] = {} if "Rule" not in verify_data[key] or verify_data[key]["Rule"] is None: verify_data[key]["Rule"] = [{}] elif not isinstance(verify_data[key]["Rule"], list): verify_data[key]["Rule"] = [verify_data[key]["Rule"]] return key, value, verify_data def __verified_details_key_value(self, key, value): """ Verifies specific keys in details """ if value is None: value = "" if value == "": if key == "Engineer": value = self.navigator.get_engineer_name() if key == "Date": now = datetime.now() value = "{0}-{1}-{2}".format(now.year, now.month, now.day) if key == "Time": now = datetime.now() value = "{0}:{1}".format(now.hour, now.minute) return key, value def __verify_values(self, tmpl_key, tmpl_value, parent): """ Verifies key value in each step with the case template file """ output = "" if tmpl_key not in parent: output = tmpl_value elif parent[tmpl_key] is None: output = tmpl_value else: if isinstance(parent[tmpl_key], list): for i in range(0, len(parent[tmpl_key])): for k, v in tmpl_value.items(): parent[tmpl_key][i][k] = self.__verify_values(k, v, parent[tmpl_key][i]) output = parent[tmpl_key] elif isinstance(tmpl_value, OrderedDict): for k, v in list(tmpl_value.items()): parent[tmpl_key][k] = self.__verify_values(k, v, parent[tmpl_key]) output = parent[tmpl_key] else: output = parent[tmpl_key] if parent[tmpl_key].strip() != "" else tmpl_value return output