def _init_all(self):
'''
init all api case needed
:return:
'''
self.ids = Ids()
self.run = CASE_RUN
self.dependent = []
self.dependent_var = []
self.bench_name = ""
self.request = Request()
self.expect = Expect()
self.response = Response()
self.sqlinfo = SqlInfo()
self.log_key = ""
self.error = None
def load_dict_to_case(case_dict: dict):
'''
load_dict_to_case : load case from dict
:param case_dict:
:return:
'''
cases = []
id = 0
name = ""
for suites_key in case_dict.keys():
suites = case_dict.get(suites_key)
for suite in suites.get("classes"):
for suite_key in suite.keys():
suite_temp = suite.get(suite_key)
id += 1
subid = 1
for case in suite_temp.get("cases"):
for key in case.keys():
case_temp = {
"id":
id,
"subid":
subid,
"name":
key,
"run":
case.get(key).run if hasattr(
case.get(key), 'run') else False,
"reason":
case.get(key).reason if hasattr(
case.get(key), 'reason') else None
}
case_temp["func"] = key
case_temp["suite"] = suite_key
case_temp["request"] = suite_temp.get(
"request", Request())
func = case.get(key)
if hasattr(func, "params"):
for param in func.params:
case_temp_1 = case_temp.copy()
case_temp_1["subid"] = subid
case_temp_1["param"] = param
cases.append(case_temp_1)
subid += 1
elif hasattr(func, "stress"):
threads = func.stress.get("threads")
count = func.stress.get("count")
for case_index in range(threads):
case_stress = case_temp.copy()
case_stress["subid"] = subid
case_stress["run_times"] = count
cases.append(case_stress)
subid += 1
else:
subid += 1
cases.append(case_temp)
def constructor(self, *args, **kwargs):
'''
:param args:
:param kwargs:
:return:
'''
args_init = {}
if len(args) > 0 and isinstance(args[0], dict):
args_init = args[0]
else:
args_init = kwargs
# logger.info(args_init)
self.ids.constructor(args_init)
self.run = CASE_RUN if args_init.get("run") is True else CASE_SKIP
self.func = args_init.get("func")
self.suite = args_init.get("suite")
self.param = args_init.get("param")
self.request = args_init.get("request", Request())
self.run_times = args_init.get("runt_times", 1)
def get_case_from_class(class_list: dict) -> dict:
'''
get_case_from_class : get case from class of class_list
:param class_list: list
:return: dict
'''
case_dict = {}
for cl in class_list.keys():
case_dict[cl] = {}
case_dict[cl]["classes"] = []
suites = class_list.get(cl)
if suites is None:
raise FailLoadCaseFromPyException
for suite in suites:
suite_dict = {}
for class_temp_key in suite.keys():
suite_dict[class_temp_key] = {
"cases": [],
"request": Request()
}
class_temp = suite.get(class_temp_key)
for func_key in dir(class_temp):
func = getattr(class_temp, func_key)
func_temp = {}
if isinstance(func, test):
func_temp[func_key] = func
suite_dict[class_temp_key]["cases"].append(
func_temp)
elif isinstance(func, skip):
func_temp[func_key] = func
suite_dict[class_temp_key]["cases"].append(
func_temp)
elif inspect.isfunction(func):
if hasattr(func, "mark") and func.mark == "test":
func_temp[func_key] = func
suite_dict[class_temp_key]["cases"].append(
func_temp)
elif isinstance(func, Request):
suite_dict[class_temp_key]["request"] = func
case_dict[cl]["classes"].append(suite_dict)
return case_dict
class TestHello(BaseCase):
request = Request()
@test("test hello11")
def test_1(self):
assert 1 + 1 == 2
assert 1 == 5
@skip
@test("test hello12")
def test_2(self):
assert 1 + 1 == 2
@test
@parameterize([{"test": 123}, {"test": 245}])
def test_3(self, params):
print(params)
assert 1 + 1 == 2
@parameterize([{"test": 123}, {"test": 245}])
def test_4(self, params):
assert params.get("test") == 123
class TestHello(BaseCase):
request = Request()
@parameterize([{i:i} for i in range(10000)])
def test_1(self, params):
print(f"[{params}]start at", datetime.now().strftime("%H:%M:%S"))
time_begin = datetime.now()
print(params)
data_request = {
"request_header": {},
"request_data": {},
"method": "get",
"host_port": "www.baidu.com",
# "url": "/v1/front/keng/?building_id=2&location_id=1"
"url": ""
}
time_temp = datetime.now()
print(f"1:{datetime.now()-time_begin}")
self.request.constructor(data_request)
self.response = Utils.http_request(self.request)
print(f"2:{datetime.now()-time_temp}")
assert self.response.code == 200
print(f"[{params}]end at", datetime.now().strftime("%H:%M:%S"))
print(f"{datetime.now()-time_begin}")
def test1(self):
self.request = Request()
assert 1 + 1 == 2
class HttpApiCase(BaseCase):
'''
http api case
'''
def __init__(self):
super().__init__()
self.mark = CASE_MARK_API
self.type = CASE_TYPE_HTTPAPI
self.message_type = MESSAGE_TYPE_CASE
self.log_key = ""
self._init_all()
def _init_all(self):
'''
init all api case needed
:return:
'''
self.ids = Ids()
self.run = CASE_RUN
self.dependent = []
self.dependent_var = []
self.bench_name = ""
self.request = Request()
self.expect = Expect()
self.response = Response()
self.sqlinfo = SqlInfo()
self.log_key = ""
self.error = None
def constructor(self, *args, **kwargs):
'''
:param args:
:param kwargs:
:return:
'''
args_init = {}
if len(args) > 0 and isinstance(args[0], dict):
args_init = args[0]
else:
args_init = kwargs
self.ids.constructor(args_init)
self.run = CASE_RUN if args_init.get("run") is True else CASE_SKIP
self.run_time = args_init.get('run_times', 1)
self.dependent = [
x for x in str(args_init.get("dependent")).split(";")
if args_init.get("dependent") is not None
]
self.dependent_var = [
x for x in str(args_init.get("dependent_var")).split(";")
if args_init.get("dependent_var") is not None
]
self.request.constructor(args_init)
self.response.constructor(args_init)
self.expect.constructor(args_init)
self.sqlinfo.constructor(args_init)
def bind_bench(self, bench_name):
'''
bind bench with bench_name
:param bench_name:
:return:
'''
self.bench_name = bench_name
self.generate_log_key()
def generate_log_key(self):
'''
generate log key to self
:return:
'''
self.log_key = self.key = f"{self.bench_name}$%{self.ids.id}.{self.ids.subid}.{self.ids.name}$%"
def deserialize(self):
'''
return dict type of api case
:return:
'''
return {
"ids": self.ids.deserialize(),
"run": self.run,
"dependent": self.dependent,
"dependent_var": self.dependent_var,
"bench_name": self.bench_name,
"request": self.request.deserialize(),
"response": self.response.deserialize(),
"expect": self.expect.deserialize(),
"sqlinfo": self.sqlinfo.deserialize(),
"type": self.type,
"runt_times": self.run_times
}