def handle_final_url(bmc_ip, method, url_list, req_body=None, http_handler=None): '''execute the requested url to get the response ''' response_list = [] if method == 'GET': for url_case in url_list: rsp = execute_get_url(bmc_ip + url_case, http_handler) response_list.append(rsp) elif method == 'POST': if len(url_list) > 1: LOGGER.error(ERROR_CODE['E100002']) return None url_value = url_list[0] rsp = execute_post_url(req_body, http_handler, bmc_ip + url_value) response_list.append(rsp) elif method == 'PATCH': for url_case in url_list: LOGGER.info(url_case) temp = execute_patch_url(req_body, http_handler, bmc_ip + url_case) if temp is not None: response_list.append(temp) elif method == 'DELETE': pass LOGGER.info("response_list %s", response_list) return response_list
def compare_data(value, flag): ''' compare value content ''' if isinstance(value, tuple): if value[1] is None: if value[0] == 'N/A' or value[0] == None: return "Success", flag if value[1] is not None or value[1]: if value[0] == 'N/A': return "Success", flag elif isinstance(value[0], (bool, int, str)): if value[0] == value[1]: return "Success", flag else: flag += 1 return "Failure, expect value: " + str(value[0]) + \ ", return value: " + str(value[1]), flag elif value[1] in value[0] or value[0] == ['N/A']: return "Success", flag else: flag += 1 return "Failure, expect value: " + str(value[0]) + \ ", return value: " + str(value[1]), flag else: flag += 1 return "Failure, expect value: " + str(value[0]) + \ ", return value: " + str(value[1]), flag elif isinstance(value, list): for elem in enumerate(value, start=0): index = elem[0] value[index], flag = compare_data(value[index], flag) elif isinstance(value, dict): for key, val in value.items(): value[key], flag = compare_data(val, flag) else: LOGGER.error("%s", ERROR_CODE['E400007']) flag += 1 return value, flag
def execute_get_url(url, http_handler): """ execute the url """ LOGGER.debug("execute url %s", url) rsp = http_handler.get(url) if rsp is None: LOGGER.error("return None for url %s", url) return None ret_dict = {} ret_dict.update({"return_code": rsp.code}) return_value = json.loads(rsp.read()) ret_dict.update({"return_value": return_value}) LOGGER.info("ret_dict is %s", ret_dict) LOGGER.debug("ret_dict type is %s", type(ret_dict)) return ret_dict
def execute_patch_url(body, http_handler, url): ''' execute patch url ''' etag = get_etag(http_handler, url) LOGGER.info("etag %s", etag) rsp = http_handler.patch(url, body, etag) LOGGER.debug("patch response %s", rsp) LOGGER.debug("type response is %s", type(rsp)) ret_dict = {} if rsp is None: LOGGER.error("%s %s", ERROR_CODE['E100001'], url) ret_dict.update({"return_code": "N/A"}) ret_dict.update({"return_value": "Failure"}) return ret_dict ret_dict.update({"return_code": rsp.code}) return_value = json.loads(rsp.read()) ret_dict.update({"return_value": return_value}) return ret_dict
def execute_post_url(body, handler, url): ''' execute post url ''' LOGGER.debug("execute url %s", url) rsp = handler.post(url, body) LOGGER.debug("post response %s", rsp) if not isinstance(rsp, dict): LOGGER.error("%s,%s, expected type %s", ERROR_CODE["E400004"], type(rsp), dict) return None return rsp
def test_case_yaml_run(run, case): ''' run test case from cases.yaml ''' depends_id, http_handler, bmc_ip = run if (case['enabled'] is False): cases_result.append(case) LOGGER.debug("skipping case: %s", case["case_name"]) pytest.skip() LOGGER.debug("running case: %s", case["case_name"]) method, url, req_body, expected_code, expected_value, tc_name, key_flag_dict \ = case['method'], case['url'], case['request_body'], \ case['expected_code'], case['expected_result'], case['case_name'], case['key_flag_dict'] flag = 0 final_rst = {} rsp_list = execute_final_url(depends_id, http_handler, method, url, req_body, key_flag_dict, bmc_ip) if rsp_list is not None and len(rsp_list) > 0: return_value_list, return_code_list, final_rst, flag = \ parse_test_result( expected_value, expected_code, rsp_list, final_rst) final_rst.update({'info': return_value_list}) LOGGER.debug("final_rst:%s", final_rst) LOGGER.debug("return_code_list:%s", return_code_list) case['return_code_seq'] = str(return_code_list) else: LOGGER.error("%s", ERROR_CODE['E600001']) flag += 1 case['final_rst'] = "Success" if flag == 0 else "Failure" case['details_result'] = \ str(final_rst) if len(final_rst) > 0 else "N/A" cases_result.append(case) LOGGER.info("writing test final_rst for case %s", tc_name) assert flag == 0, final_rst
def create_obj_id_list(key_flags, response_list): ''' create object id list ''' if response_list is None or response_list.__len__() == 0: LOGGER.debug("response list is None") return None if key_flags is not None: key_list = key_flags.split(':') end_id_list = [] for response in response_list: if response is None: LOGGER.warning("response is None") continue return_value = response['return_value'] if len(key_list) == 1 and key_list[0] in return_value: for i in return_value[key_list[0]]: end_id_list.append(i['@odata.id']) elif len(key_list) > 1: for elem in enumerate(key_list, start=0): index = elem[0] if index == len(key_list) - 1: for case in return_value[key_list[index]]: end_id_list.append(case['@odata.id']) else: if isinstance(return_value, list): return_value = return_value[0] elif isinstance(return_value, dict): return_value = return_value[key_list[index]] else: LOGGER.warning("%s, %s", WARN_CODE['W100002'], type(return_value)) else: LOGGER.error("%s %s", ERROR_CODE['E400003'], key_flags) return end_id_list
def parse_config(config_json): """ parse setting from config.yaml :return: """ try: if not os.path.exists(config_json): LOGGER.error(" %s, %s", ERROR_CODE['E400001'], config_json) with open(config_json, 'r') as conf_file: config = json.load(conf_file) except FileNotFoundError as fnfe: LOGGER.error(fnfe) LOGGER.error(u"%s", ERROR_CODE['E400002']) return None else: config_list = [] for each_server in config["servers"]: config_list.append(each_server["ilo_info"]) return config_list
def parse_data(exp_value, act_value): ''' parse the expected value and actual value: @return: case 1: exp_value and actual value is str or int, then return tuple (exp_value,act_value) case 2: list,dict type, then return updated exp_value ERROR_CODE for unexpected case. ''' if isinstance(exp_value, (str, int, type(None))) and isinstance( act_value, (str, int, type(None))): return (exp_value, act_value) if isinstance(exp_value, list): if not isinstance(act_value, list): return (exp_value, act_value) else: for exp in enumerate(exp_value, start=0): index = exp[0] exp_value[index] = parse_data(exp_value[index], act_value[index]) elif isinstance(exp_value, dict): if isinstance(act_value, dict): for key, val in exp_value.items(): if key in act_value: exp_value[key] = parse_data(val, act_value[key]) else: exp_value[key] = ( val, "Can't find key {} in return value".format(key)) LOGGER.error("%s,%s", ERROR_CODE['E500001'], key) else: LOGGER.error("%s,expected: %s , actual: %s", ERROR_CODE['E400005'], exp_value, act_value) else: LOGGER.error("%s, expected type:%s, actual type %s", ERROR_CODE['E400006'], type(exp_value), type(act_value)) return exp_value
def run(config_list): ''' @param conf_file: config.yaml @param case_file: case yaml file access function ''' # parse config.yaml LOGGER.info("start engine ...") http_handler = UrllibHttpHandler() # get bmc info bmc_ip, bmc_user, bmc_pwd = \ "https://" + config_list["ip"], config_list["user"], config_list["password"] ACCOUNT_INFO.update({"UserName": bmc_user}) ACCOUNT_INFO.update({"Password": bmc_pwd}) url = "https://{0}/redfish/v1/SessionService/Sessions/".format(bmc_ip) x_auth_token = get_token(http_handler, url) LOGGER.info("x_auth_token: %s", x_auth_token) if x_auth_token is None: LOGGER.error("%s token is None", ERROR_CODE['E300001']) return None HEADERS.update({"X-Auth-Token": x_auth_token}) id_info_list = None depends_id = {} LOGGER.info("############### start perform test case #################") yield depends_id, http_handler, bmc_ip write_result_2_yaml(cases_result, config_list["ip"]) LOGGER.info("############### end perform test case ###################") LOGGER.info("done,checking the log %s", LOG_FILE) # parse cases_result for testapi and push it testapi_result = generate_testapi_result(cases_result) PushResults(testapi_result, LOGGER) cases_result.clear() return True
def create_real_url(url_value, id_dict, key_flag_dict, http_handler, bmc_ip): ''' create the real url either a static url, or a replaced url by depended_id ''' url_list = [] replaced = 0 regexp = r'[^{]*{(?P<var>[a-zA-Z_]*)}' # pattern = re.compile(regexp, re.S) pattern = re.compile(regexp, DT) LOGGER.info("url_value %s", url_value) matches = list(pattern.finditer(url_value)) for match in matches: value = match.groupdict() # stripping out value['var'] from end of the URL parent_url = match.group().rstrip('{' + value['var'] + '}') if value['var'] in id_dict: replaced = 1 url_list = id_dict[value['var']].copy() elif value['var'] in key_flag_dict: replaced = 2 if (len(url_list) == 0): url_list.append(parent_url) else: for index in range(len(url_list)): #Make sure link will not have merged with '//' two forward slashes if parent_url[0] == '/' and url_list[index][-1] == '/': parent_url = parent_url[1:] url_list[index] = url_list[index] + parent_url response_list = handle_depend_url("GET", url_list, http_handler, bmc_ip) url_list = create_obj_id_list(key_flag_dict[value['var']], response_list) if url_list is None or url_list.__len__() == 0: LOGGER.error("%s,%s", ERROR_CODE['E300003'], value['var']) continue id_dict.update({value['var']: url_list.copy()}) LOGGER.debug("id_dict content is %s", id_dict) else: replaced = 3 LOGGER.error("%s for parameter %s", ERROR_CODE['E300002'], value['var']) LOGGER.debug('url_list content is %s', url_list) # combine single case with list case together. if replaced == 0: LOGGER.info("adding static url %s into list", url_value) url_list.append(url_value) for index in range(len(url_list)): #Make sure link will not have merged with '//' two forward slashes if (url_value.split('}')[-1][0] == '/' and url_list[index][-1] == '/'): url_list[index] = url_list[index] + url_value.split('}')[-1][1:] else: url_list[index] = url_list[index] + url_value.split('}')[-1] LOGGER.debug("created real url list is %s", url_list) return url_list
import os import re import pytest from re import DOTALL as DT import json import copy from ast import literal_eval import yaml from openpyxl.reader.excel import load_workbook from http_handler import UrllibHttpHandler, HEADERS # pylint: disable=E0611 from log_utils import BASE_DIR, LOG_FILE, LOGGER from errors import ERROR_CODE, WARN_CODE from test_api import PushResults LOGGER.info(BASE_DIR) ACCOUNT_INFO = {} WAIT_INTERVAL = 5 cases_result = [] def parse_config(config_json): """ parse setting from config.yaml :return: """ try: if not os.path.exists(config_json): LOGGER.error(" %s, %s", ERROR_CODE['E400001'], config_json) with open(config_json, 'r') as conf_file: