def write_result_2_yaml(result, bmc_ip):
'''
write test result to new report.yaml
'''
if not os.path.exists('result'):
os.makedirs('result')
report_file = "./result/" + bmc_ip + "_" + str(
time.time()) + "_report.yaml"
LOGGER.info("writing to yaml file %s", report_file)
yaml.safe_dump(result, open(report_file, "w"), explicit_start=True)
def generate_testapi_result(cases_result):
'''
convert cases_result from list to dictionary for pushing to testapi
'''
testapi_result = {}
for case_result in cases_result:
testapi_result[case_result['case_sn']] = case_result
print(case_result)
LOGGER.info("generated result for testapi %s", testapi_result)
return testapi_result
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 get_token(http_handler, url):
"""
:return: x_auth_token
"""
retry_num = 3
x_auth_token = None
while retry_num:
retry_num -= 1
res = http_handler.post(url, ACCOUNT_INFO)
if res is None:
LOGGER.error("%s, %s", WARN_CODE['W100001'], url)
LOGGER.info("wait %s seconds to try again", WAIT_INTERVAL)
time.sleep(WAIT_INTERVAL)
continue
data = res.info()
if "X-Auth-Token" in data:
x_auth_token = data.get("X-Auth-Token")
return x_auth_token
else:
time.sleep(WAIT_INTERVAL)
return None
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 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_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: