报告的实现

六、报告的实现

先把create_data字典的代码复制到tasks.py的Run类的simple_run方法里，代码如下：

# 创建报告的数据结构
create_data = {
    'response': str(response),
    'case': case_obj,
    'batch': task_id,
    'status': status,
    'duration': 100,
    'user': models.User.objects.get(id=user_id),
    'case_collection': models.CaseCollection.objects.get(id=collection_id) if collection_id else None,
    'reason': reason,
    'params': json.dumps(data),
    'url': host + uri,
    'title': case_obj.title,
    'project': case_obj.project
}

修改代码，把simple_run方法里传入task_id、user_id和collection_id，collection_id默认=None，在run_case方法里，也要传入task_id和user_id，在create_data下面加上models.Report.objects.create(**create_data)，新增代码如下图：

点击用例管理页面的登录用例后的运行按钮，在日志里没有报错，查看report表里多出来一条数据，如下图：

可以看到case_collection_id为空，因为在run_case方法里，没有传collection_id，因此默认就是None，用例的报告实现了

七、更新用例状态

接下来改变用例的状态，在models.Report.objects.create(**create_data)下面增加如下代码：

if collection_id:  # 如果collection_id存在，知道是哪个集合的，如果不存在就是运行的用例
    pass
else:
    models.Case.objects.filter(id=case_id).update(status=status)  # status等于上面create_data里传的status

重启异步任务服务，点击用例管理页面的登录用例后的运行按钮，在日志里没有报错，后台代码没有跑完，刷新页面还是运行中，等代码跑完后再刷新页面，登录用例对应的用例状态从运行中变成了执行完毕，因为case运行是一个异步任务，返回结果的时候case刚运行，运行完了再次刷新的时候状态才能改变，如下图：

接下来实现集合的运行，新增代码如下图：

重启异步任务服务，点击用例集合页面，勾选用例平台回归测试，点击运行按钮，在日志里没有报错，刷新页面，用例平台回归测试对应的集合状态从运行中变成了执行完毕，因为collection也是异步任务，运行完了刷新的时候状态才能改变，如下图：

同时在report表里可以看到多了两条记录，都是一个集合id的，如下图：

接下来执行多用例，勾选两条用例，点击运行按钮，report表里多出三条记录，因为获取项目信息依赖于登录用例，所以登录用例运行两次，但是第二次登录用例和获取项目信息的批次号是一样的，如下图：

同时页面里也显示两条用例都是执行完毕的状态

最后开发查看的功能，查看用例，查看集合的状态，点击登录用例后的查看按钮，在Network的Headers里看到请求的url是http://127.0.0.1:8000/api/case_report?report_batch=3da0f12a-0de1-4ba6-a50e-cc9bc8943e31&id=11，get请求方式，需要传一个report_batch和用例id，现在开发该接口，首先在urls.py里输入path('case_report', views.CaseReportView.as_view())，然后在views.py里输入如下图：

class CaseReportView(View):
    def get(self, request):
        case_id = request.GET.get('id')
        report_batch = request.GET.get('report_batch')
        case = models.Case.objects.get(id=case_id)
        report = models.Report.objects.filter(batch=report_batch, case_id=case.id).first()
        if report:
            data = {
                'title': case.title,
                'run_time': report.create_time,
                'project_name': case.project.name,
                'status': report.status,
                'case_collection': report.case_collection if report.case_collection else '单用例运行',
                'duration': report.duration,
                'run_user': report.user.username,
                'url': report.url,
                'method': case.get_method_display(),
                'check': case.check,
                'reason': report.reason,
                'params': report.params,
                'response': report.response
            }
            return NbResponse(data=data)
        else:
            return NbResponse(-1, msg='用例运行中，请耐心等待..')

点击查看按钮，可以看到测试结果的相关信息，如下图：

但是请求方式是1，不知道是哪种请求方式，于是修改代码views.py里的CaseReportView类里的method字段，将value从case.method改成case.get_method_display()，重启服务再次点击查看，可以看到请求方式变成了POST，如下图：

从上图发现少了一个header字段，要从表结构里加上，接下来开发集合的查看功能，点击用例平台回归测试后的查看按钮，在Network的Headers里看到请求的url是http://127.0.0.1:8000/api/collection_report?id=4&report_batch=31332761-bdee-4cab-8f44-4e64151b5648，get请求方式，需要传一个report_batch和集合id，现在开发该接口，首先在urls.py里输入path('collection_report', views.CollectionReportView.as_view())，然后在views.py里输入如下：

class CollectionReportView(View):
    def get(self, request):
        case_collection_id = request.GET.get('id')  # 获取集合id
        report_batch = request.GET.get('report_batch')
        case_collection = models.CaseCollection.objects.get(id=case_collection_id)
        report = models.Report.objects.filter(batch=report_batch, case_collection=case_collection.id).first()
        fail_count = models.Report.objects.filter(batch=report_batch, case_collection=case_collection.id,
                                                  status=999).count()
        pass_count = models.Report.objects.filter(batch=report_batch, case_collection=case_collection.id,
                                                  status=1).count()
        if report:
            data = {
                'case_collection': case_collection.name,
                'run_time': report.create_time,
                'case_count': case_collection.case.all().count(),
                'pass_count': pass_count,
                'run_user': report.user.username,
                'fail_count': fail_count,
                'duration': 100,
                'report_batch': case_collection.report_batch,
            }
            return NbResponse(data=data)
        else:
            return NbResponse(-1, msg='用例集合运行中，请耐心等待..')

重启服务，刷新页面，点击查看按钮，可以看到集合的报告，如下图：

点击查看详细，在Network的Headers里看到请求的url是http://127.0.0.1:8000/api/report?case_collection=4&batch=cfb093ac-0e47-4207-98bf-78ca1316c447，get请求方式，现在开发该接口，首先在urls.py里输入path('report', views.ReportView.as_view())，然后在views.py里输入如下：

class ReportView(BaseView):
    search_field = ['title']
    filter_field = ['project', 'case_collection', 'batch']
    model_class = models.Report
    exclude_fields = ['is_delete']

    def get(self, request):
        page_data, page_obj = self.get_query_set_page_data()  # 获取分页之后的数据
        data_list = []
        for instance in page_data:  #
            model_dict = model_to_dict(instance, self.fields, self.exclude_fields)  # 转成字典
            model_dict['title'] = instance.case.title
            model_dict['project_name'] = instance.case.project.name
            model_dict['case_collection'] = instance.case_collection.name if instance.case_collection else '单用例运行'
            model_dict['status'] = instance.case.status
            model_dict['run_user'] = instance.user.username
            model_dict['run_time'] = instance.create_time
            model_dict['check'] = instance.case.check
            model_dict['method'] = instance.case.get_method_display()
            data_list.append(model_dict)
        return NbResponse(data=data_list, count=page_obj.count)

重启服务再次刷新页面，点击查看按钮，再点击详细报告，弹出如下图：

点击下拉按钮，可以看到详细的报告，如下图：

把鼠标放到鼠标悬浮显示参数上，可以看到返回的所有参数，如下图：

接收前端的最新代码，在2.0版本里可以看到数据报表，刷新页面，在Network的Headers里看到请求的url是http://127.0.0.1:8000/api/home_page，get请求方式，现在开发该接口，首先在urls.py里输入path('home_page', views.HomePageView.as_view())，然后在models.py里输入如下：

class HomeData(BaseModel):
    date = models.DateField(verbose_name='统计时间', unique=True)
    pass_count = models.IntegerField(verbose_name='成功次数', default=0)
    all_count = models.IntegerField(verbose_name='执行次数', default=0)
    fail_count = models.IntegerField(verbose_name='失败次数', default=0)

    class Meta:
        verbose_name = '首页数据统计'
        verbose_name_plural = verbose_name
        db_table = 'home_data'
        ordering = ['-id']

migrations生成表结构，migrate生成表，在views.py里输入HomePageView类，如下：

class HomePageView(View):
    def get_source_data(self, day):
        pass_count = models.Report.objects.filter(create_time__contains=day, status=1).count()
        fail_count = models.Report.objects.filter(create_time__contains=day, status=999).count()
        all_count = models.Report.objects.filter(create_time__contains=day).count()
        data = {
            "pass_count": pass_count,
            "fail_count": fail_count,
            "all_count": all_count
        }
        return data

    def get(self, request):
        import datetime
        today = datetime.date.today()
        # 统计数据 当天数据
        data = self.get_source_data(today)
        if models.HomeData.objects.filter(date=today).first():
            models.HomeData.objects.filter(date=today).update(**data)
        else:
            data.update({"date": today})
            models.HomeData.objects.create(**data)
        # 昨天数据

        yesterday = today - datetime.timedelta(days=1)
        data = self.get_source_data(yesterday)
        if models.HomeData.objects.filter(date=yesterday).first():
            models.HomeData.objects.filter(date=yesterday).update(**data)
        else:
            data.update({"date": yesterday})
            models.HomeData.objects.create(**data)

        # 最大执行次数和最大成功次数，用于确认页面的y轴数据
        max_all_count = models.Report.objects.all().count()
        max_pass_count = models.Report.objects.filter(status=1).count()

        project_count = models.Project.objects.filter(is_delete=1).count()
        interface_count = models.Interface.objects.filter(is_delete=1).count()
        collection_count = models.CaseCollection.objects.filter(is_delete=1).count()
        case_count = models.Case.objects.filter(is_delete=1).count()
        home_data = models.HomeData.objects.all().values()

        pass_count = qs_to_list(home_data, 'pass_count')
        date = qs_to_list(home_data, 'date')
        all_count = qs_to_list(home_data, 'all_count')
        fail_count = qs_to_list(home_data, 'fail_count')
        data = {
            'project_count': project_count,
            'interface_count': interface_count,
            'collection_count': collection_count,
            'case_count': case_count,
            'pass_count': pass_count,
            'date': date,
            'all_count': all_count,
            'fail_count': fail_count,
            'max_all_count': max_all_count,
            'max_pass_count': max_pass_count
        }
        return NbResponse(data=data)

还要导入from utils.tools import qs_to_list，在utils目录下的tools.py里输入如下：

def qs_to_list(d, f):
    """
    根据传入的queryset，将qs转成列表
    :param d:
    :param f:
    :return:
    """
    lis = []
    for item in d:
        if isinstance(item[f], datetime.date):
            value = item[f].strftime('%Y-%m-%d')
            lis.append(value)
        else:
            lis.append(item[f])
    return lis

重启服务，刷新数据报表页面，可以看到项目数量、接口数量、用例集合和用例数量以及昨天和今天执行用例数、通过用例数和失败用例数，运行用例或用例集合，可以看到图表上变化的用例数，在home_data表里可以看到如下统计：