def get(self, request, *args, **kwargs):
"""
请求用例列表数据
:param request:
:param args:
:param kwargs:
:return:
"""
service_id = request.GET.get('service_id')
size = str(request.GET.get('size'))
page = str(request.GET.get('page'))
if not size.isdigit() or not size: #先判断是否是数字,是否为空
size = 10
if not page.isdigit() or not page: #先判断是否是数字,是否为空
page = 1
size = int(size)
page = int(page)
if not service_id:
return response_success(data=[])
cases = TestCase.objects.filter(service_id=service_id)
ret = []
p = Paginator(cases, size) # size条数据为一页，实例化分页对象
page_cases = p.page(page) # 取第几页
total = p.count # 总共元素
for item in page_cases.object_list:
tmp = test_case_model_to_dict(item)
ret.append(tmp)
return response_success(data={"total": total, "list": ret})
def delete(self, request, task_id, *args, **kwargs):
"""
删除数据
:param request:
:param task_id:
:param args:
:param kwargs:
:return:
"""
task_test_case_id = request.GET.get('task_test_case_id')
if not task_test_case_id:
return response_success()
TaskTestCase.objects.filter(id=task_test_case_id).delete()
return response_success()
def put(self, request, project_id, *args, **kwargs):
"""
这个是修改数据
:param request:
:param project_id:
:param args:
:param kwargs:
:return:
"""
project = Project.objects.filter(id=project_id).first()
if not project:
return response_failed(code=ErrorCode.project, message='数据不存在')
body = request.body
data = json.loads(body, encoding='utf-8')
if not self.update_schema.is_valid(data):
return response_failed()
data = self.update_schema.validate(data)
if not data: # 如果没有传数据，就不需要处理
pass
else:
Project.objects.filter(id=project_id).update(**data)
# 为什么会有三种情况, 因为data的确存在三种情况
# {"name": 'x'} {"description": 'x'} {"description": 'x', "name": 'x'}
# Project.objects.filter(id=project_id).update(name='x', description='x')
# Project.objects.filter(id=project_id).update(name='x')
# Project.objects.filter(id=project_id).update(description='x')
project = Project.objects.filter(id=project_id).first()
project_dict = model_to_dict(project)
return response_success(data=project_dict)
def put(self, request, service_id, *args, **kwargs):
"""
这个是修改数据
:param request:
:param service_id:
:param args:
:param kwargs:
:return:
"""
service = Service.objects.filter(id=service_id).first()
if not service:
return response_failed(code=ErrorCode.service, message='数据不存在')
body = request.body
data = json.loads(body, encoding='utf-8')
if not self.update_schema.is_valid(data):
return response_failed()
data = self.update_schema.validate(data)
if not data: # 如果没有传数据，就不需要处理
pass
else:
Service.objects.filter(id=service_id).update(**data)
service = Service.objects.filter(id=service_id).first()
service_dict = model_to_dict(service)
return response_success(data=service_dict)
def put(self, request, case_id, *args, **kwargs):
"""
这个是修改数据
:param request:
:param case_id:
:param args:
:param kwargs:
:return:
"""
case = TestCase.objects.filter(id=case_id).first()
if not case:
return response_failed(code=ErrorCode.test_case, message='数据不存在')
body = request.body
data = json.loads(body, encoding='utf-8')
if not self.update_schema.is_valid(data):
return response_failed()
data = self.update_schema.validate(data)
if not data: # 如果没有传数据，就不需要处理
pass
else:
if data.get('request_body'):
data['request_body'] = json.dumps(data['request_body'])
if data.get('response_assert'):
data['response_assert'] = json.dumps(data['response_assert'])
TestCase.objects.filter(id=case_id).update(**data)
case = TestCase.objects.filter(id=case_id).first()
ret = test_case_model_to_dict(case)
return response_success(data=ret)
def delete(self, request, task_id, *args, **kwargs):
"""
停止任务循环执行
:param request:
:param task_id:
:param args:
:param kwargs:
:return:
"""
task = Task.objects.filter(id=task_id).first()
if not task:
return response_failed(code=ErrorCode.task, message='数据不存在')
data = {
"interval_switch": False,
"days": 0,
"hours": 0,
"minutes": 0,
"start_time": None
}
Task.objects.filter(id=task_id).update(**data)
job = scheduler.get_job("task" + str(task_id))
if job:
scheduler.remove_job("task" + str(task_id))
return response_success()
def get(self, request, *args, **kwargs):
"""
请求列表数据
:param request:
:param args:
:param kwargs:
:return:
"""
project_id = request.GET.get('project_id')
if not project_id:
return response_success(data=[])
services = Service.objects.filter(project_id=project_id)
ret = []
for item in services:
ret.append(model_to_dict(item))
return response_success(data=ret)
def get(self, request, task_id, *args, **kwargs):
"""
获取report列表
:param request:
:param task_id:
:param args:
:param kwargs:
:return:
"""
task_reports_path = os.path.join(settings.BASE_DIR, "task_test",
"reports", str(task_id))
list_name = []
if not os.path.exists(task_reports_path):
return response_success(list_name)
for file in os.listdir(task_reports_path):
if os.path.splitext(file)[1] == '.html':
list_name.append({"name": file})
return response_success(list_name)
def user_logout(request, *args, **kwargs):
"""
注销
:param request:
:param args:
:param kwargs:
:return:
"""
logout(request)
return response_success()
def delete(self, request, case_id, *args, **kwargs):
"""
这个是删除数据
:param request:
:param case_id:
:param args:
:param kwargs:
:return:
"""
TestCase.objects.filter(id=case_id).delete()
return response_success(data=True)
def delete(self, request, project_id, *args, **kwargs):
"""
这个是删除数据
:param request:
:param project_id:
:param args:
:param kwargs:
:return:
"""
Project.objects.filter(id=project_id).delete()
return response_success(data=True)
def post(self, request, task_id, *args, **kwargs):
"""
任务执行
:param request:
:param task_id:
:param args:
:param kwargs:
:return:
"""
run_task_common(task_id)
return response_success()
def get(self, request, service_id, *args, **kwargs):
"""
请求是单个数据
:param request:
:param service_id:
:param args:
:param kwargs:
:return:
"""
service = Service.objects.filter(id=service_id).first()
if not service:
return response_failed(code=ErrorCode.service, message='数据不存在')
service_dict = model_to_dict(service)
return response_success(data=service_dict)
def get(self, request, case_id, *args, **kwargs):
"""
请求是单个数据
:param request:
:param case_id:
:param args:
:param kwargs:
:return:
"""
case = TestCase.objects.filter(id=case_id).first()
if not case:
return response_failed(code=ErrorCode.test_case, message='数据不存在')
ret = test_case_model_to_dict(case)
return response_success(data=ret)
def get(self, request, task_id, *args, **kwargs):
"""
请求是单个数据
:param request:
:param task_id:
:param args:
:param kwargs:
:return:
"""
task = Task.objects.filter(id=task_id).first()
if not task:
return response_failed(code=ErrorCode.task, message='数据不存在')
task_dict = model_to_dict(task)
return response_success(data=task_dict)
def get_user_info(request, *args, **kwargs):
"""
获取已登录的用户信息
:param request:
:param args:
:param kwargs:
:return:
"""
user = request.user # 获取当前用户
if not user:
return response_failed(code=ErrorCode.auth, message='用户未登录')
if user.is_authenticated: # 判断用户是否已经通过校验
return response_success(data={'id': user.id, 'name': user.username})
else:
return response_failed(code=ErrorCode.auth, message='用户未登录')
def get(self, request, project_id, *args, **kwargs):
"""
请求是单个数据
:param request:
:param project_id:
:param args:
:param kwargs:
:return:
"""
project = Project.objects.filter(id=project_id).first()
if not project:
return response_failed(code=ErrorCode.project, message='数据不存在')
project_dict = model_to_dict(project)
project_dict['create_time'] = datetime.datetime.strftime(
project.create_time, '%Y-%m-%d %H:%M')
return response_success(data=project_dict)
def get(self, request, *args, **kwargs):
"""
请求列表数据
:param request:
:param project_id:
:param args:
:param kwargs:
:return:
"""
projects = Project.objects.all()
ret = []
for item in projects:
tmp = model_to_dict(item)
tmp['create_time'] = datetime.datetime.strftime(
item.create_time, '%Y-%m-%d %H:%M')
ret.append(tmp)
return response_success(data=ret)
def post(self, request, *args, **kwargs):
"""
创建数据
:param request:
:param project_id:
:param args:
:param kwargs:
:return:
"""
body = request.body
data = json.loads(body, encoding='utf-8')
if not self.create_schema.is_valid(data):
return response_failed()
data = self.create_schema.validate(data)
service = Service.objects.create(**data)
service_dict = model_to_dict(service)
return response_success(data=service_dict)
class TaskTestCasesView(View):
def get(self, request, task_id, *args, **kwargs):
"""
请求任务的用例列表数据
:param request:
:param args:
:param task_id:
:param kwargs:
:return:
"""
task_cases = TaskTestCase.objects.filter(task_id=task_id)
ret = []
for item in task_cases:
case = TestCase.objects.get(id=item.test_case_id)
tmp = test_case_model_to_dict(case)
tmp['task_test_case_id'] = item.id
ret.append(tmp)
return response_success(data=ret)
def post(self, request, task_id, *args, **kwargs):
"""
创建数据
:param request:
:param task_id:
:param args:
:param kwargs:
:return:
"""
create_schema = Schema({'test_case_ids': list})
body = request.body
data = json.loads(body, encoding='utf-8')
if not create_schema.is_valid(data):
return response_failed()
data = create_schema.validate(data)
test_case_ids = data['test_case_ids']
for item in test_case_ids:
TaskTestCase.objects.create(task_id=task_id, test_case_id=item)
return response_success()
def post(self, request, *args, **kwargs):
"""
创建数据
:param request:
:param project_id:
:param args:
:param kwargs:
:return:
"""
body = request.body
data = json.loads(body, encoding='utf-8')
if not self.debug_schema.is_valid(data):
return response_failed()
data = self.debug_schema.validate(data)
if data.get('request_body'):
data['request_body'] = json.dumps(data['request_body'])
response = HttpRequest.send_request(
data['url'], data['method'], data.get('request_body', {}),
data['request_type']) # 4. 进行http请求，获取响应
return response_success(data=response)
def post(self, request, task_id, *args, **kwargs):
"""
任务循环执行
:param request:
:param task_id:
:param args:
:param kwargs:
:return:
"""
task = Task.objects.filter(id=task_id).first()
if not task:
return response_failed(code=ErrorCode.task, message='数据不存在')
body = request.body
data = json.loads(body, encoding='utf-8')
if not self.update_schema.is_valid(data):
return response_failed()
data = self.update_schema.validate(data)
if not data: # 如果没有传数据，就不需要处理
pass
else:
data['interval_switch'] = True
Task.objects.filter(id=task_id).update(**data)
job = scheduler.get_job("task" + str(task_id))
if job:
scheduler.remove_job("task" + str(task_id))
scheduler.add_job(run_task_common,
'interval',
args=[task_id],
days=data["days"],
hours=data["hours"],
minutes=data["minutes"],
start_date=data["start_time"],
id="task" + str(task_id))
return response_success()
def user_login(request, *args, **kwargs):
"""
登录
:param request:
:param args:
:param kwargs:
:return:
"""
body = request.body
data = json.loads(body, encoding='utf-8')
if not user_schema.is_valid(data):
return response_failed()
if User.objects.filter(username=data["name"]).exists():
user = authenticate(username=data["name"], password=data["psw"])
else:
user = User.objects.create_user(username=data["name"],
password=data["psw"])
if not user:
return response_failed(code=ErrorCode.auth, message='登录失败')
else:
login(request, user) # 登录持久化
return response_success()
def post(self, request, *args, **kwargs):
"""
创建数据
:param request:
:param project_id:
:param args:
:param kwargs:
:return:
"""
body = request.body
data = json.loads(body, encoding='utf-8')
if not self.create_schema.is_valid(data):
return response_failed()
data = self.create_schema.validate(data)
if data.get('request_body'):
data['request_body'] = json.dumps(data['request_body'])
if data.get('response_assert'):
data['response_assert'] = json.dumps(data['response_assert'])
case = TestCase.objects.create(**data)
case = TestCase.objects.get(id=case.id)
case_dict = test_case_model_to_dict(case)
return response_success(data=case_dict)
