def debug_api(api, project, name=None, config=None, save=True):
"""debug api
api :dict or list
project: int
"""
if len(api) == 0:
return TEST_NOT_EXISTS
# testcases
if isinstance(api, dict):
"""
httprunner scripts or teststeps
"""
api = [api]
testcase_list = [
parse_tests(api, load_debugtalk(project), name=name, config=config)
]
kwargs = {"failfast": False}
runner = HttpRunner(**kwargs)
runner.run(testcase_list)
summary = parse_summary(runner.summary)
if save:
save_summary("", summary, project, type=1)
return summary
def runTestCase(self):
runner = HttpRunner(failfast=False)
summary = {}
for path in self.needRunCase:
runner.run(path, mapping=self.__mapping)
if (len(summary) == 0):
summary = runner.summary
else:
summary['time']['duration'] += runner.summary['time'][
'duration']
summary['stat']['teststeps']['total'] += runner.summary[
'stat']['teststeps']['total']
summary['stat']['teststeps']['successes'] += runner.summary[
'stat']['teststeps']['successes']
summary['stat']['teststeps']['failures'] += runner.summary[
'stat']['teststeps']['failures']
summary['stat']['teststeps']['errors'] += runner.summary[
'stat']['teststeps']['errors']
summary['stat']['teststeps']['skipped'] += runner.summary[
'stat']['teststeps']['skipped']
for each in runner.summary['details']:
summary['details'].append(each)
pass
self.summary = parse_summary(summary)
def test_run(request):
"""
运行用例
:param request:
:return:
"""
kwargs = {
"failfast": False,
}
runner = HttpRunner(**kwargs)
testcase_dir_path = os.path.join(os.getcwd(), "suite")
testcase_dir_path = os.path.join(testcase_dir_path, get_time_stamp())
if request.is_ajax():
kwargs = json.loads(request.body.decode('utf-8'))
id = kwargs.pop('id')
base_url = kwargs.pop('env_name')
type = kwargs.pop('type')
run_test_by_type(id, base_url, testcase_dir_path, type)
report_name = kwargs.get('report_name', None)
main_hrun.delay(testcase_dir_path, report_name)
return HttpResponse('用例执行中，请稍后查看报告即可,默认时间戳命名报告')
else:
id = request.POST.get('id')
base_url = request.POST.get('env_name')
type = request.POST.get('type', 'test')
run_test_by_type(id, base_url, testcase_dir_path, type)
runner.run(testcase_dir_path)
#shutil.rmtree(testcase_dir_path)
summary = timestamp_to_datetime(runner._summary, type=False)
print(summary)
return render(request, 'report_template.html', summary)
def test_log_file(self):
log_file_path = os.path.join(os.getcwd(), 'reports',
"test_log_file.log")
runner = HttpRunner(failfast=True, log_file=log_file_path)
runner.run(self.testcase_cli_path)
self.assertTrue(os.path.isfile(log_file_path))
os.remove(log_file_path)
def project_hrun(name, base_url, project):
"""
异步运行整个项目
:param env_name: str: 环境地址
:param project: str
:return:
"""
kwargs = {
"failfast": False,
}
runner = HttpRunner(**kwargs)
id = Project.objects.get(project_name=project).id
testcase_dir_path = os.path.join(os.getcwd(), "suite")
testcase_dir_path = os.path.join(testcase_dir_path, get_time_stamp())
run_by_project(id, base_url, testcase_dir_path)
runner.run(testcase_dir_path)
shutil.rmtree(testcase_dir_path)
summary = timestamp_to_datetime(runner.summary)
report_path = add_test_reports(summary, report_name=name)
os.remove(report_path)
def debug_cases(cases, config=None, debugtalk=None, project_mapping=None):
"""
:param cases: [ {case_name:'', case_steps:[]}, {}]
:param config:
:param debugtalk:
:param project_mapping:
:return:s
"""
if len(cases) == 0 or not isinstance(cases, list):
return "error! this case no steps"
cases_list = []
for case in cases:
testset = parse_case(case['case_steps'], case['case_name'], config,
debugtalk)
cases_list.append(testset)
testcases = {
"project_mapping": {
"PWD": "",
"functions": {},
"variables": {},
"env": {}
},
'testcases': cases_list
}
kwargs = {"failfast": False}
runner = HttpRunner(**kwargs)
runner.run(testcases)
summary = runner.summary
return summary
def project_hrun(name, base_url, project, receiver):
"""
异步运行整个项目
:param env_name: str: 环境地址
:param project: str
:return:
"""
logger.setup_logger('INFO')
kwargs = {
"failfast": False,
}
runner = HttpRunner(**kwargs)
id = ProjectInfo.objects.get(project_name=project).id
testcase_dir_path = os.path.join(os.getcwd(), "suite")
testcase_dir_path = os.path.join(testcase_dir_path, get_time_stamp())
run_by_project(id, base_url, testcase_dir_path)
# runner.run(testcase_dir_path)
runner.summary = runner.run(testcase_dir_path)
shutil.rmtree(testcase_dir_path)
runner.summary = timestamp_to_datetime(runner.summary)
report_path = add_test_reports(runner, report_name=name)[0]
if receiver != '':
send_email_reports(receiver, report_path, name=name)
os.remove(report_path)
def module_hrun(name, base_url, module, receiver):
"""
异步运行模块
:param env_name: str: 环境地址
:param project: str：项目所属模块
:param module: str：模块名称
:return:
"""
logger.setup_logger('INFO')
kwargs = {
"failfast": False,
}
runner = HttpRunner(**kwargs)
module = list(module)
testcase_dir_path = os.path.join(os.getcwd(), "suite")
testcase_dir_path = os.path.join(testcase_dir_path, get_time_stamp())
try:
for value in module:
run_by_module(value[0], base_url, testcase_dir_path)
except ObjectDoesNotExist:
return '找不到模块信息'
# runner.run(testcase_dir_path)
runner.summary = runner.run(testcase_dir_path)
shutil.rmtree(testcase_dir_path)
runner.summary = timestamp_to_datetime(runner.summary)
report_path = add_test_reports(runner, report_name=name)[0]
if receiver != '':
send_email_reports(receiver, report_path, name=name)
os.remove(report_path)
def debug_suite(suite, project, obj, config=None, save=True):
"""debug suite
suite :list
pk: int
project: int
"""
if len(suite) == 0:
return TEST_NOT_EXISTS
debugtalk = load_debugtalk(project)
test_sets = []
for index in range(len(suite)):
# copy.deepcopy 修复引用bug
testcases = copy.deepcopy(
parse_tests(suite[index],
debugtalk,
name=obj[index]['name'],
config=config))
test_sets.append(testcases)
kwargs = {"failfast": False}
runner = HttpRunner(**kwargs)
runner.run(test_sets)
summary = parse_summary(runner.summary)
if save:
save_summary("", summary, project, type=1)
return summary
def run(self, testdata):
data = json.loads(testdata)
runner = HttpRunner(failfast=False)
runner.run_tests(data)
self.summary = runner._summary
report_dir = os.path.join(urls.get_media_root(), "reports")
self.reportpath = gen_html_report(self.summary, report_dir=report_dir)
def setUp(self):
self.testcase_cli_path = "tests/data/demo_testcase_cli.yml"
self.testcase_file_path_list = [
os.path.join(
os.getcwd(), 'tests/data/demo_testcase_hardcode.yml'),
os.path.join(
os.getcwd(), 'tests/data/demo_testcase_hardcode.json')
]
testcases = [{
'config': {
'name': 'testcase description',
'request': {
'base_url': '',
'headers': {'User-Agent': 'python-requests/2.18.4'}
},
'variables': []
},
"teststeps": [
{
'name': '/api/get-token',
'request': {
'url': 'http://127.0.0.1:5000/api/get-token',
'method': 'POST',
'headers': {'Content-Type': 'application/json', 'app_version': '2.8.6',
'device_sn': 'FwgRiO7CNA50DSU', 'os_platform': 'ios', 'user_agent': 'iOS/10.3'},
'json': {'sign': '9c0c7e51c91ae963c833a4ccbab8d683c4a90c98'}
},
'extract': [
{'token': 'content.token'}
],
'validate': [
{'eq': ['status_code', 200]},
{'eq': ['headers.Content-Type', 'application/json']},
{'eq': ['content.success', True]}
]
},
{
'name': '/api/users/1000',
'request': {
'url': 'http://127.0.0.1:5000/api/users/1000',
'method': 'POST',
'headers': {'Content-Type': 'application/json',
'device_sn': 'FwgRiO7CNA50DSU','token': '$token'},
'json': {'name': 'user1', 'password': '******'}
},
'validate': [
{'eq': ['status_code', 201]},
{'eq': ['headers.Content-Type', 'application/json']},
{'eq': ['content.success', True]},
{'eq': ['content.msg', 'user created successfully.']}
]
}
]
}]
self.tests_mapping = {
"testcases": testcases
}
self.runner = HttpRunner(failfast=True)
self.reset_all()
def run_case(self):
scheduler.app.logger.info('测试数据：{}'.format(self.TEST_DATA))
# res = main_ate(self.TEST_DATA)
runner = HttpRunner()
runner.run(self.TEST_DATA)
jump_res = json.dumps(runner._summary, ensure_ascii=False, default=encode_object, cls=JSONEncoder)
# scheduler.app.logger.info('返回数据：{}'.format(jump_res))
return jump_res
def test_html_report_repsonse_image(self):
runner = HttpRunner(failfast=True)
summary = runner.run("tests/httpbin/load_image.yml")
report_save_dir = os.path.join(os.getcwd(), 'reports', "demo")
report_path = report.gen_html_report(summary, report_dir=report_save_dir)
self.assertTrue(os.path.isfile(report_path))
shutil.rmtree(report_save_dir)
def test_testcase_simple_run_suite(self):
testcase_path = "tests/testcases/setup.yml"
tests_mapping = loader.load_cases(testcase_path)
testcases = parser.parse_tests(tests_mapping)
runner = HttpRunner()
test_suite = runner._add_tests(testcases)
tests_results = runner._run_suite(test_suite)
self.assertEqual(len(tests_results[0][1].records), 2)
async def post(self, request):
host = await models.HostIP.filter(name=request.json.get("host")
).first()
config = await models.Config.filter(name=request.json.get("config")
).first()
name = request.json.get("name")
back_async = request.json.get("async")
relation = request.json.get("relation")
pro = await models.Project.filter(pk=request.json.get("project")
).first()
config_body = {} if request.json.get("config") == "请选择" else eval(
config.body)
test_case = []
if host != "请选择":
host = await models.HostIP.get(name=host, project=pro)
for relation_id in relation:
api = await models.API.filter(
project=request.json.get("project"),
relation=relation_id).order_by("id").values("body")
for content in api:
api = eval(content['body'])
data = {
"project_mapping": {
"PWD": "",
"functions": {},
"env": {}
},
"testcases": []
}
test_struct = {"config": config_body, "teststeps": [api]}
data["testcases"].append(test_struct)
runner = HttpRunner(failfast=False)
runner.run(data)
if back_async:
summary = loader.TEST_NOT_EXISTS
summary["msg"] = "接口运行中，请稍后查看报告"
else:
summary = runner.summary
result = {
"name": summary["time"]["start_datetime"],
"type": 1,
"summary": [summary],
"project": pro
}
await models.Report.create(**result)
return resp_json(msg="报告添加成功!")
def test_html_report(self):
report_save_dir = os.path.join(os.getcwd(), 'reports', "demo")
runner = HttpRunner(failfast=True, report_dir=report_save_dir)
runner.run(self.testcase_cli_path)
summary = runner.summary
self.assertEqual(summary["stat"]["testcases"]["total"], 1)
self.assertEqual(summary["stat"]["teststeps"]["total"], 10)
self.assertEqual(summary["stat"]["teststeps"]["skipped"], 4)
self.assertGreater(len(os.listdir(report_save_dir)), 0)
shutil.rmtree(report_save_dir)
def test_testsuite_add_tests(self):
testcase_path = "tests/testsuites/create_users.yml"
tests_mapping = loader.load_cases(testcase_path)
testcases = parser.parse_tests(tests_mapping)
runner = HttpRunner()
test_suite = runner._add_tests(testcases)
self.assertEqual(len(test_suite._tests), 2)
tests = test_suite._tests[0].teststeps
self.assertIn("setup and reset all (override)", tests[0]["config"]["name"].raw_string)
def generate_cookies():
if (not os.path.exists(COOKIES_PATH)) or (
3600 < int(time.time()) - int(os.path.getmtime(COOKIES_PATH))) or (
os.path.getsize(COOKIES_PATH) == 0):
# cookies 文件不存在 或 最后修改时间超过 3600 秒 (1小时) 或 cookie文件内容为空 则重新登录刷新 cookies
runner = HttpRunner()
runner.run(r'api/login.yml')
with open(COOKIES_PATH, 'r') as f:
cookies: str = f.read()
print("读取文件内cookie" + cookies)
return cookies
def hookFunction(testcase_path, variables):
testcase_path = os.path.join(os.getcwd(), testcase_path)
runner = HttpRunner(failfast=True)
tests_mapping = loader.load_tests(testcase_path)
# to add variables into tests_mapping.teststeps
tests_mapping['apis'][0]['variables'] = variables
parsed_tests_mapping = parser.parse_tests(tests_mapping)
runner.run(parsed_tests_mapping)
def test_html_report_with_fixed_report_file(self):
report_save_dir = os.path.join(os.getcwd(), 'reports', "demo")
report_file = 'test.html'
runner = HttpRunner(failfast=True, report_dir=report_save_dir, report_file=report_file)
runner.run(self.testcase_cli_path)
summary = runner.summary
self.assertEqual(summary["stat"]["testcases"]["total"], 1)
self.assertEqual(summary["stat"]["teststeps"]["total"], 10)
self.assertEqual(summary["stat"]["teststeps"]["skipped"], 4)
self.assertEqual(len(os.listdir(report_save_dir)), 1)
self.assertTrue(os.path.isfile(os.path.join(report_save_dir, report_file)))
shutil.rmtree(report_save_dir)
def test_testcase_add_tests(self):
testcase_path = "tests/testcases/setup.yml"
tests_mapping = loader.load_cases(testcase_path)
testcases = parser.parse_tests(tests_mapping)
runner = HttpRunner()
test_suite = runner._add_tests(testcases)
self.assertEqual(len(test_suite._tests), 1)
teststeps = test_suite._tests[0].teststeps
self.assertEqual(teststeps[0]["name"], "get token (setup)")
self.assertEqual(teststeps[0]["variables"]["device_sn"], "TESTCASE_SETUP_XXX")
self.assertIn("api", teststeps[0])
def run():
runner = HttpRunner(failfast=False, log_level='INFO')
run_report_path = r"reports/" + time.strftime('%Y%m%d%H%M%S') + ".html"
# 2、运行用例
# run方法支持如下参数:
# yml用例文件的路径
# 字典(用例的信息)
# runner.run('testsuites/')
# gen_html_report(runner._summary, report_template="templates/extent-theme-template.html")
summary = runner.run(r'testsuites', dot_env_path='conf/env/.online_zy.env')
gen_html_report(summary, report_file=run_report_path)
print("报告地址:", os.path.abspath('.') + '/' + run_report_path)
async def get(self, request):
host = await models.HostIP.filter(name=self.request.args.get("host")
).first()
name = self.request.args.get("name")
pro = self.request.args.get("project")
test_list = await models.CaseStep.filter(
case_id__in=self.request.args.get("id")
).order_by("step").values("body")
test_case = []
config = {}
if host != "请选择":
host = await models.HostIP.filter(name=host, project=pro)
for content in test_list:
body = eval(content["body"])
if "base_url" in body["request"]:
config = await models.Config.filter(
name=body["name"], project=request.json.get("project"))
continue
test_case.append(parse_host(host, body))
data = {
"project_mapping": {
"PWD": "",
"functions": {},
"env": {}
},
"testcases": []
}
test_struct = {"config": config, "teststeps": test_case}
data["testcases"].append(test_struct)
runner = HttpRunner(failfast=False)
runner.run(data)
summary = runner.summary
result = {
"name": summary["time"]["start_datetime"],
"type": 1,
"summary": [summary],
"project": pro
}
await models.Report.create(**result)
return resp_json(msg="报告添加成功!")
def test_testcase_complex_run_suite(self):
testcase_path = "tests/testcases/create_user.yml"
tests_mapping = loader.load_tests(testcase_path)
testcases = parser.parse_tests(tests_mapping)
runner = HttpRunner()
test_suite = runner._add_tests(testcases)
tests_results = runner._run_suite(test_suite)
self.assertEqual(len(tests_results[0][1].records), 2)
results = tests_results[0][1]
self.assertEqual(
results.records[0]["name"],
"setup and reset all (override) for TESTCASE_CREATE_XXX.")
self.assertEqual(results.records[1]["name"],
"create user and check result.")
def test_testcase_complex_run_suite(self):
testcase_path = "tests/testcases/create_and_check.yml"
tests_mapping = loader.load_tests(testcase_path)
parsed_tests_mapping = parser.parse_tests(tests_mapping)
runner = HttpRunner()
test_suite = runner._add_tests(parsed_tests_mapping)
tests_results = runner._run_suite(test_suite)
self.assertEqual(len(tests_results[0][1].records), 4)
results = tests_results[0][1]
self.assertEqual(
results.records[0]["name"],
"setup and reset all (override) for TESTCASE_CREATE_XXX.")
self.assertEqual(results.records[1]["name"],
"make sure user 9001 does not exist")
def run_batch_test(request):
"""
批量运行用例
:param request:
:return:
"""
kwargs = {
"failfast": False,
}
runner = HttpRunner(**kwargs)
testcase_dir_path = os.path.join(os.getcwd(), "suite")
testcase_dir_path = os.path.join(testcase_dir_path, get_time_stamp())
if request.is_ajax():
kwargs = json.loads(request.body.decode('utf-8'))
test_list = kwargs.pop('id')
base_url = kwargs.pop('env_name')
type = kwargs.pop('type')
report_name = kwargs.get('report_name', None)
run_by_batch(test_list, base_url, testcase_dir_path, type=type)
main_hrun.delay(testcase_dir_path, report_name)
return HttpResponse('用例执行中，请稍后查看报告即可,默认时间戳命名报告')
else:
type = request.POST.get('type', None)
base_url = request.POST.get('env_name')
test_list = request.body.decode('utf-8').split('&')
if type:
run_by_batch(test_list,
base_url,
testcase_dir_path,
type=type,
mode=True)
else:
run_by_batch(test_list, base_url, testcase_dir_path)
# runner.run(testcase_dir_path)
summary = runner.run(testcase_dir_path)
shutil.rmtree(testcase_dir_path)
# runner.summary = timestamp_to_datetime(runner.summary,type=False)
# summary = timestamp_to_datetime(summary,type=False)
# return render_to_response('report_template.html', runner.summary)
return render_to_response('extent-theme-template.html', summary)
def main_hrun(testset_path, report_name):
"""
用例运行
:param testset_path: dict or list
:param report_name: str
:return:
"""
logger.setLevel('INFO')
kwargs = {
"failfast": False,
}
runner = HttpRunner(**kwargs)
runner.run(testset_path)
#shutil.rmtree(testset_path)
summary = timestamp_to_datetime(runner.summary)
report_path = add_test_reports(summary, report_name=report_name)
os.remove(report_path)
class RunCaseAndUpload(object):
def __init__(self, **kwargs):
self.runner = HttpRunner()
self.summary = self._runTestCase()
self.section = kwargs.get('section')
self.build_id = kwargs.get('buildId')
# noinspection SpellCheckingInspection
def _runTestCase(self, dot_env_path=None, maping=None):
"""
Run the test case in the specified directory based on the parameters.
:param dot_env_path: Empty runs the default environment, otherwise the corresponding environment
:param maping: ignore
:return: test case result.
"""
path = getConfigValue(self.section, 'autoTest.casePath')
if not path:
print("test path nonentity or not find files 'properties.ini'")
raise FileNotFoundError
elif os.getenv("TEST_ENV") == 'txy':
self.runner.run(path, dot_env_path=dot_env_path, mapping=maping)
return self.runner.summary
elif os.getenv("TEST_ENV") == 'docker':
self.runner.run(path, dot_env_path='doc.env', mapping=maping)
return self.runner.summary
def uploadDataToStargazing(self):
"""
Processing is completed the processing of the results will be uploaded to stargazing platform.
:return:
"""
headers = {'Content-Type': 'application/json'}
url = getConfigValue('stargazing', 'total')
data = dataManipulation(self.summary,
self.section,
buildId=self.build_id)
# noinspection PyBroadException
try:
response = requests.post(url, json=data, headers=headers)
print("upload success: {}".format(
response.json() if response.status_code == 200 else
"upload failed:", response.content))
except Exception as e:
print(f'Upload Exception:{e}')
async def get(self, request):
api = await models.API.filter(id=self.request.args.get("id")).first()
config = await models.Config.filter(
name=self.request.args.get("config")).first()
pro = await models.Project.filter(pk=api.project_id).first()
debug_talk = await models.DebugTalk.filter(project_id=api.project_id
).first()
variables = await models.Variables.filter(project_id=api.project_id
).values("key", "value")
config_body = {} if self.request.args.get("config") == "请选择" else eval(
config.body)
data = {
"project_mapping": {
"PWD": "",
"functions": {},
"env": {}
},
"testcases": []
}
test_struct = {"config": config_body, "teststeps": [eval(api.body)]}
data["testcases"].append(test_struct)
runner = HttpRunner(failfast=False)
runner.run(data)
summary = runner.summary
result = {
"name": summary["time"]["start_datetime"],
"type": 1,
"summary": [summary],
"project": pro
}
await models.Report.create(**result)
return resp_json(msg="报告添加成功!")
def run_test(request):
"""
运行用例
:param request:
:return:
"""
kwargs = {
"failfast": False,
}
runner = HttpRunner(**kwargs)
testcase_dir_path = os.path.join(os.getcwd(), "suite")
testcase_dir_path = os.path.join(testcase_dir_path, get_time_stamp())
if request.is_ajax():
kwargs = json.loads(request.body.decode('utf-8'))
id = kwargs.pop('id')
base_url = kwargs.pop('env_name')
type = kwargs.pop('type')
run_test_by_type(id, base_url, testcase_dir_path, type)
report_name = kwargs.get('report_name', None)
main_hrun.delay(testcase_dir_path, report_name)
return HttpResponse('用例执行中，请稍后查看报告即可,默认时间戳命名报告')
else:
id = request.POST.get('id')
base_url = request.POST.get('env_name')
type = request.POST.get('type', 'test')
testcase_dir_path1 = os.path.join(testcase_dir_path, 'guest项目')
run_test_by_type(id, base_url, testcase_dir_path, type)
runner.run(testcase_dir_path1)
# shutil.rmtree(testcase_dir_path) # 递归删除所有文件
runner._summary = timestamp_to_datetime(runner._summary,
base_url,
type=False)
with open('summary.json', 'w', encoding='utf-8') as f:
json.dump(runner._summary,
f,
ensure_ascii=False,
sort_keys=True,
indent=4)
return render_to_response('report_template.html', runner._summary)
